From cc33a2fb3db549660ed8a286f18af3ea4954c77a Mon Sep 17 00:00:00 2001 From: Scott Richmond Date: Thu, 6 Jun 2024 18:47:04 -0400 Subject: [PATCH] complete fucking draft of janet/wasm interpreter --- .gitignore | 2 +- CHANGELOG.md | 24 - TODO.xit | 55 - assets/index.html | 8 - build/driver.cpp | 143 + build/janet.c | 51563 +++++++++++++++++++++++++++ build/janet.h | 2277 ++ build/justfile | 15 + build/ludus.jimage | Bin 0 -> 433427 bytes build/ludus.mjs | 8 + build/out.mjs | 7170 ++++ build/out.wasm | Bin 0 -> 1581475 bytes build/test.mjs | 11 + clj_to_janet.md | 42 - computer_class.md | 10 - deps.edn | 17 - foo.ld | 2 - graal-compile.sh | 7 - justfile | 4 - ludus.sublime-project | 19 - package.json | 14 +- janet/postlude.ld => postlude.ld | 0 janet/prelude.ld => prelude.ld | 0 project.clj | 14 - sandbox.ld | 111 - shadow-cljs.edn | 18 - {janet => src}/base.janet | 24 + {janet => src}/errors.janet | 4 +- {janet => src}/interpreter.janet | 53 +- {janet => src}/judge | 0 {janet => src}/judgy.fish | 0 {janet => src}/language.test.janet | 0 {janet => src}/ludus.janet | 25 +- src/ludus/ast.cljc | 2 - src/ludus/base.cljc | 434 - src/ludus/collections.cljc | 1 - src/ludus/core.clj | 38 - src/ludus/data.cljc | 2 - src/ludus/doc.cljc | 126 - src/ludus/draw.cljs | 15 - src/ludus/error.cljc | 46 - src/ludus/grammar.cljc | 273 - src/ludus/grammar.janet | 273 - src/ludus/interpreter.cljc | 1072 - src/ludus/loader.clj | 16 - src/ludus/node.cljc | 79 - src/ludus/parser.cljc | 316 - src/ludus/postlude.ld | 25 - src/ludus/prelude.cljc | 15 - src/ludus/prelude.ld | 1303 - src/ludus/repl.clj | 118 - src/ludus/scanner.cljc | 336 - src/ludus/show.cljc | 122 - src/ludus/token.cljc | 11 - src/ludus/web.cljs | 44 - {janet => src}/parser.janet | 3 +- {janet => src}/prelude.janet | 13 +- {janet => src}/prelude.test.janet | 0 {janet => src}/project.janet | 4 + {janet => src}/scanner.janet | 6 - {janet => src}/validate.janet | 0 {janet => src}/watchy.fish | 0 test/cases/if.ld | 7 - test/cases/list_atoms.ld | 2 - test/cases/single_float.ld | 2 - test/cases/single_int.ld | 2 - test/cases/single_string.ld | 2 - test/cases/tuple_keywords.ld | 2 - test/ludus/core_test.clj | 7 - test/run_tests.js | 30 - tokens | 47 - 71 files changed, 61269 insertions(+), 5165 deletions(-) delete mode 100644 CHANGELOG.md delete mode 100644 TODO.xit delete mode 100644 assets/index.html create mode 100644 build/driver.cpp create mode 100644 build/janet.c create mode 100644 build/janet.h create mode 100644 build/justfile create mode 100644 build/ludus.jimage create mode 100644 build/ludus.mjs create mode 100644 build/out.mjs create mode 100755 build/out.wasm create mode 100644 build/test.mjs delete mode 100644 clj_to_janet.md delete mode 100644 computer_class.md delete mode 100644 deps.edn delete mode 100644 foo.ld delete mode 100755 graal-compile.sh delete mode 100644 ludus.sublime-project rename janet/postlude.ld => postlude.ld (100%) rename janet/prelude.ld => prelude.ld (100%) delete mode 100644 project.clj delete mode 100644 sandbox.ld delete mode 100644 shadow-cljs.edn rename {janet => src}/base.janet (90%) rename {janet => src}/errors.janet (96%) rename {janet => src}/interpreter.janet (95%) rename {janet => src}/judge (100%) rename {janet => src}/judgy.fish (100%) rename {janet => src}/language.test.janet (100%) rename {janet => src}/ludus.janet (77%) delete mode 100644 src/ludus/ast.cljc delete mode 100644 src/ludus/base.cljc delete mode 100644 src/ludus/collections.cljc delete mode 100644 src/ludus/core.clj delete mode 100644 src/ludus/data.cljc delete mode 100644 src/ludus/doc.cljc delete mode 100644 src/ludus/draw.cljs delete mode 100644 src/ludus/error.cljc delete mode 100644 src/ludus/grammar.cljc delete mode 100644 src/ludus/grammar.janet delete mode 100644 src/ludus/interpreter.cljc delete mode 100644 src/ludus/loader.clj delete mode 100644 src/ludus/node.cljc delete mode 100644 src/ludus/parser.cljc delete mode 100644 src/ludus/postlude.ld delete mode 100644 src/ludus/prelude.cljc delete mode 100644 src/ludus/prelude.ld delete mode 100644 src/ludus/repl.clj delete mode 100644 src/ludus/scanner.cljc delete mode 100644 src/ludus/show.cljc delete mode 100644 src/ludus/token.cljc delete mode 100644 src/ludus/web.cljs rename {janet => src}/parser.janet (99%) rename {janet => src}/prelude.janet (88%) rename {janet => src}/prelude.test.janet (100%) rename {janet => src}/project.janet (54%) rename {janet => src}/scanner.janet (99%) rename {janet => src}/validate.janet (100%) rename {janet => src}/watchy.fish (100%) delete mode 100644 test/cases/if.ld delete mode 100644 test/cases/list_atoms.ld delete mode 100644 test/cases/single_float.ld delete mode 100644 test/cases/single_int.ld delete mode 100644 test/cases/single_string.ld delete mode 100644 test/cases/tuple_keywords.ld delete mode 100644 test/ludus/core_test.clj delete mode 100644 test/run_tests.js delete mode 100644 tokens diff --git a/.gitignore b/.gitignore index ab9afee..227ed6d 100644 --- a/.gitignore +++ b/.gitignore @@ -32,4 +32,4 @@ target/repl-port .repl-buffer .repl-buffer.janet .env -janet/jpm_tree +src/jpm_tree diff --git a/CHANGELOG.md b/CHANGELOG.md deleted file mode 100644 index 12756d5..0000000 --- a/CHANGELOG.md +++ /dev/null @@ -1,24 +0,0 @@ -# Change Log -All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/). - -## [Unreleased] -### Changed -- Add a new arity to `make-widget-async` to provide a different widget shape. - -## [0.1.1] - 2021-10-23 -### Changed -- Documentation on how to make the widgets. - -### Removed -- `make-widget-sync` - we're all async, all the time. - -### Fixed -- Fixed widget maker to keep working when daylight savings switches over. - -## 0.1.0 - 2021-10-23 -### Added -- Files from the new template. -- Widget maker public API - `make-widget-sync`. - -[Unreleased]: https://sourcehost.site/your-name/cludus/compare/0.1.1...HEAD -[0.1.1]: https://sourcehost.site/your-name/cludus/compare/0.1.0...0.1.1 diff --git a/TODO.xit b/TODO.xit deleted file mode 100644 index 1d34726..0000000 --- a/TODO.xit +++ /dev/null @@ -1,55 +0,0 @@ - -[x] Fix recursive definition problems in grammar.clj - -TODOS for parser -[ ] Make parser errors pretty -[ ] Use synchronization to make parsing more robust -[ ] Decide on synchronization tokens: [then else ] ) } , ; \n] - -TODOS from interpreter -[x] implement tuple splat patterns -[x] update match-list to use new AST representation -[x] fix length comparison when pattern includes splats -[x] update match-dict to use new AST representation -[x] update match-struct to use new AST representation -[ ] update interpret-receive to use new AST representation -[ ] Check interpret-fn-inner ctx for cycles/bugs - -Re-add processes to the language -[ ] Write send as function -[ ] update interpret-spawn to use new AST representation -[ ] ---- Investigate weird timing issue in current send implementation -[ ] Investigate `with-bindings` and virtual threads - -Finish interpreter -[x] Wire up new interpreter to repl, script situation -[x] Merge new interpreter - -Conditionals -[ ] Fix let bindings/scope in `if` expressions -[ ] Make `and` and `or` special forms -[ ] ---- `if and (let x ...)` pattern -[ ] ---- arguments are lazily, not eagerly, executed - -Write a compiler: desugaring -[~] `...` to `..._` in tuple & list patterns -[ ] placeholder partial application to anonymous lambda -[ ] word -> :[word] word in pairs (patterns & expressions) - -Write a compiler: correctness -[ ] check for unbound names -[ ] check for re-binding names -[ ] check that recur is in tail position -[ ] check that recur is only called inside loop or fn forms -[ ] check ns accesses -[ ] prevent import cycles -[ ] splattern is last member in a pattern -[ ] -----List/Tuple -[ ] -----Dict/Struct/Set - -Write a compiler: optimization -[ ] devise tail call optimization - -Next steps -[ ] Get drawing working? -[ ] Add stack traces for panics diff --git a/assets/index.html b/assets/index.html deleted file mode 100644 index bc46333..0000000 --- a/assets/index.html +++ /dev/null @@ -1,8 +0,0 @@ - - - Hello, world! - - - - - \ No newline at end of file diff --git a/build/driver.cpp b/build/driver.cpp new file mode 100644 index 0000000..83dff79 --- /dev/null +++ b/build/driver.cpp @@ -0,0 +1,143 @@ +#include +#include +#include +#include +#include +#include "janet.h" + +using std::string; + +// set all our exported Janet functions as null pointers +static JanetFunction *janet_ludus = NULL; +static JanetFunction *janet_hello = NULL; + +// these let us look up functions +Janet env_lookup(JanetTable *env, const char *name) { + Janet out; + janet_resolve(env, janet_csymbol(name), &out); + return out; +} + +JanetFunction *env_lookup_function(JanetTable *env, const char *name) { + Janet value = env_lookup(env, name); + if (!janet_checktype(value, JANET_FUNCTION)) { + janet_panicf("expected %s to be a function, got %q\n", name, value); + } + return janet_unwrap_function(value); +} + +// this lets us call a function +bool call_fn(JanetFunction *fn, int argc, const Janet *argv, Janet *out) { + JanetFiber *fiber = NULL; + if (janet_pcall(fn, argc, argv, out, &fiber) == JANET_SIGNAL_OK) { + return true; + } else { + janet_stacktrace(fiber, *out); + return false; + } +} + +// this is darkish magic, reads an embedded file +// do not fuck with this, fellas +unsigned char *read_file(const char *filename, size_t *length) { + size_t capacity = 2 << 17; + unsigned char *src = (unsigned char *)malloc(capacity * sizeof(unsigned char)); + assert(src); + size_t total_bytes_read = 0; + FILE *file = fopen(filename, "r"); + assert(file); + size_t bytes_read; + do { + size_t remaining_capacity = capacity - total_bytes_read; + if (remaining_capacity == 0) { + capacity <<= 1; + src = (unsigned char*)realloc(src, capacity * sizeof(unsigned char)); + assert(src); + remaining_capacity = capacity - total_bytes_read; + } + + bytes_read = fread(&src[total_bytes_read], sizeof(unsigned char), remaining_capacity, file); + total_bytes_read += bytes_read; + } while (bytes_read > 0); + + fclose(file); + *length = total_bytes_read; + return src; +} + +// these are the C++ functions that wrap our Janet functions +// simplest case: takes nothing, returns nothing +void hello() { + Janet result; // we need a place to put the result + // args are: fn ptr, argc, argv, result + call_fn(janet_hello, 0, {}, &result); +} + +// finally, getting a string back +// this is our result type +struct StringResult { + string value; +}; + +// this is our result constructor +// Janet's getcstring resturns const char* +StringResult string_result(const char* cstr) { + // ...which we have to cast to a std::string + return (StringResult) {.value = (string) cstr }; +} + +// and this is a function that takes and returns a string +// it returns a StringResult, tho +StringResult ludus(string source) { + Janet result; + const Janet args[1] = {janet_cstringv(source.c_str())}; + call_fn(janet_ludus, 1, args, &result); + // get the cstring in the result + // the 0 passed here is the index in the result of the string + const char* cstr = janet_getcstring(&result, 0); + // return a constructed StringResult + return string_result(cstr); +} + +// This function sets up our Janet interpreter, and fixes the null pointers +EMSCRIPTEN_KEEPALIVE +int main() { + janet_init(); // start the interpreter + JanetTable *core_env = janet_core_env(NULL); // get a core env + JanetTable *lookup = janet_env_lookup(core_env); // and get an env table + + // load the janet image into memory + // note that the image is hardcoded here + size_t image_length; + unsigned char *image = read_file("ludus.jimage", &image_length); + + // load the image into the Janet environment + Janet env = janet_unmarshal(image, image_length, 0, lookup, NULL); + + if(!janet_checktype(env, JANET_TABLE)) { + janet_panicf("invalid image %q", env); + } + + // fix the null pointers, as above + // note that the bound symbols are just the normal fn names + // no namespacing + janet_ludus = env_lookup_function(janet_unwrap_table(env), "ludus"); + janet_gcroot(janet_wrap_function(janet_ludus)); + + janet_hello = env_lookup_function(janet_unwrap_table(env), "hello"); + janet_gcroot(janet_wrap_function(janet_hello)); +} + +// these bindings are exported into javascript +EMSCRIPTEN_BINDINGS(module) { + using namespace emscripten; + + // these are the functions that will be available + function("ludus", &ludus, allow_raw_pointers()); + function("hello", &hello, allow_raw_pointers()); + + // we also want a wrapper for our StringResult + // we won't access it directly, but emcc makes it nice + value_object("StringResult") + .field("value", &StringResult::value); +} diff --git a/build/janet.c b/build/janet.c new file mode 100644 index 0000000..ba7419c --- /dev/null +++ b/build/janet.c @@ -0,0 +1,51563 @@ +/* Amalgamated build - DO NOT EDIT */ +/* Generated from janet version 1.34.0-f92f3eb */ +#define JANET_BUILD "f92f3eb" +#define JANET_AMALG + +/* src/core/features.h */ +#line 0 "src/core/features.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +/* Feature test macros */ + +#ifndef JANET_FEATURES_H_defined +#define JANET_FEATURES_H_defined + +#if defined(__NetBSD__) || defined(__APPLE__) || defined(__OpenBSD__) \ + || defined(__bsdi__) || defined(__DragonFly__) || defined(__FreeBSD__) +/* Use BSD source on any BSD systems, include OSX */ +# define _BSD_SOURCE +# define _POSIX_C_SOURCE 200809L +#else +/* Use POSIX feature flags */ +# ifndef _POSIX_C_SOURCE +# define _POSIX_C_SOURCE 200809L +# endif +#endif + +#if defined(__APPLE__) +#define _DARWIN_C_SOURCE +#endif + +/* Needed for sched.h for cpu count */ +#ifdef __linux__ +#define _GNU_SOURCE +#endif + +#if defined(WIN32) || defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#endif + +/* needed for inet_pton and InitializeSRWLock */ +#ifdef __MINGW32__ +#define _WIN32_WINNT _WIN32_WINNT_VISTA +#endif + +/* Needed for realpath on linux, as well as pthread rwlocks. */ +#ifndef _XOPEN_SOURCE +#define _XOPEN_SOURCE 600 +#endif +#if _XOPEN_SOURCE < 600 +#undef _XOPEN_SOURCE +#define _XOPEN_SOURCE 600 +#endif + +/* Needed for timegm and other extensions when building with -std=c99. + * It also defines realpath, etc, which would normally require + * _XOPEN_SOURCE >= 500. */ +#if !defined(_NETBSD_SOURCE) && defined(__NetBSD__) +#define _NETBSD_SOURCE +#endif + +/* Needed for several things when building with -std=c99. */ +#if !__BSD_VISIBLE && (defined(__DragonFly__) || defined(__FreeBSD__)) +#define __BSD_VISIBLE 1 +#endif + +#endif + +#include "janet.h" + +/* src/core/state.h */ +#line 0 "src/core/state.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_STATE_H_defined +#define JANET_STATE_H_defined + +#include "janet.h" +#include + +#ifdef JANET_EV +#ifndef JANET_WINDOWS +#include +#endif +#endif + +typedef int64_t JanetTimestamp; + +typedef struct JanetScratch { + JanetScratchFinalizer finalize; + long long mem[]; /* for proper alignment */ +} JanetScratch; + +typedef struct { + JanetGCObject *self; + JanetGCObject *other; + int32_t index; + int32_t index2; +} JanetTraversalNode; + +typedef struct { + int32_t capacity; + int32_t head; + int32_t tail; + void *data; +} JanetQueue; + +typedef struct { + JanetTimestamp when; + JanetFiber *fiber; + JanetFiber *curr_fiber; + uint32_t sched_id; + int is_error; +} JanetTimeout; + +/* Registry table for C functions - contains metadata that can + * be looked up by cfunction pointer. All strings here are pointing to + * static memory not managed by Janet. */ +typedef struct { + JanetCFunction cfun; + const char *name; + const char *name_prefix; + const char *source_file; + int32_t source_line; + /* int32_t min_arity; */ + /* int32_t max_arity; */ +} JanetCFunRegistry; + +struct JanetVM { + /* Place for user data */ + void *user; + + /* Top level dynamic bindings */ + JanetTable *top_dyns; + + /* Cache the core environment */ + JanetTable *core_env; + + /* How many VM stacks have been entered */ + int stackn; + + /* If this flag is true, suspend on function calls and backwards jumps. + * When this occurs, this flag will be reset to 0. */ + volatile JanetAtomicInt auto_suspend; + + /* The current running fiber on the current thread. + * Set and unset by functions in vm.c */ + JanetFiber *fiber; + JanetFiber *root_fiber; + + /* The current pointer to the inner most jmp_buf. The current + * return point for panics. */ + jmp_buf *signal_buf; + Janet *return_reg; + + /* The global registry for c functions. Used to store meta-data + * along with otherwise bare c function pointers. */ + JanetCFunRegistry *registry; + size_t registry_cap; + size_t registry_count; + int registry_dirty; + + /* Registry for abstract types that can be marshalled. + * We need this to look up the constructors when unmarshalling. */ + JanetTable *abstract_registry; + + /* Immutable value cache */ + const uint8_t **cache; + uint32_t cache_capacity; + uint32_t cache_count; + uint32_t cache_deleted; + uint8_t gensym_counter[8]; + + /* Garbage collection */ + void *blocks; + void *weak_blocks; + size_t gc_interval; + size_t next_collection; + size_t block_count; + int gc_suspend; + int gc_mark_phase; + + /* GC roots */ + Janet *roots; + size_t root_count; + size_t root_capacity; + + /* Scratch memory */ + JanetScratch **scratch_mem; + size_t scratch_cap; + size_t scratch_len; + + /* Sandbox flags */ + uint32_t sandbox_flags; + + /* Random number generator */ + JanetRNG rng; + + /* Traversal pointers */ + JanetTraversalNode *traversal; + JanetTraversalNode *traversal_top; + JanetTraversalNode *traversal_base; + + /* Event loop and scheduler globals */ +#ifdef JANET_EV + size_t tq_count; + size_t tq_capacity; + JanetQueue spawn; + JanetTimeout *tq; + JanetRNG ev_rng; + volatile JanetAtomicInt listener_count; /* used in signal handler, must be volatile */ + JanetTable threaded_abstracts; /* All abstract types that can be shared between threads (used in this thread) */ + JanetTable active_tasks; /* All possibly live task fibers - used just for tracking */ + JanetTable signal_handlers; +#ifdef JANET_WINDOWS + void **iocp; +#elif defined(JANET_EV_EPOLL) + pthread_attr_t new_thread_attr; + JanetHandle selfpipe[2]; + int epoll; + int timerfd; + int timer_enabled; +#elif defined(JANET_EV_KQUEUE) + pthread_attr_t new_thread_attr; + JanetHandle selfpipe[2]; + int kq; + int timer; + int timer_enabled; +#else + JanetStream **streams; + size_t stream_count; + size_t stream_capacity; + pthread_attr_t new_thread_attr; + JanetHandle selfpipe[2]; + struct pollfd *fds; +#endif +#endif + +}; + +extern JANET_THREAD_LOCAL JanetVM janet_vm; + +#ifdef JANET_NET +void janet_net_init(void); +void janet_net_deinit(void); +#endif + +#ifdef JANET_EV +void janet_ev_init(void); +void janet_ev_deinit(void); +#endif + +#endif /* JANET_STATE_H_defined */ + + +/* src/core/util.h */ +#line 0 "src/core/util.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_UTIL_H_defined +#define JANET_UTIL_H_defined + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#endif + +#include +#include +#include +#include + +#ifdef JANET_EV +#ifndef JANET_WINDOWS +#include +#endif +#endif + +#if !defined(JANET_REDUCED_OS) || !defined(JANET_SINGLE_THREADED) +#include +#define JANET_GETTIME +#endif + +/* Handle runtime errors */ +#ifndef JANET_EXIT +#include +#define JANET_EXIT(m) do { \ + fprintf(stderr, "janet internal error at line %d in file %s: %s\n",\ + __LINE__,\ + __FILE__,\ + (m));\ + abort();\ +} while (0) +#endif + +#define JANET_MARSHAL_DECREF 0x40000 + +#define janet_assert(c, m) do { \ + if (!(c)) JANET_EXIT((m)); \ +} while (0) + +/* Utils */ +uint32_t janet_hash_mix(uint32_t input, uint32_t more); +#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) +int janet_valid_utf8(const uint8_t *str, int32_t len); +int janet_is_symbol_char(uint8_t c); +extern const char janet_base64[65]; +int32_t janet_array_calchash(const Janet *array, int32_t len); +int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len); +int32_t janet_string_calchash(const uint8_t *str, int32_t len); +int32_t janet_tablen(int32_t n); +void safe_memcpy(void *dest, const void *src, size_t len); +void janet_buffer_push_types(JanetBuffer *buffer, int types); +const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key); +void janet_memempty(JanetKV *mem, int32_t count); +void *janet_memalloc_empty(int32_t count); +JanetTable *janet_get_core_table(const char *name); +void janet_def_addflags(JanetFuncDef *def); +const void *janet_strbinsearch( + const void *tab, + size_t tabcount, + size_t itemsize, + const uint8_t *key); +void janet_buffer_format( + JanetBuffer *b, + const char *strfrmt, + int32_t argstart, + int32_t argc, + Janet *argv); +Janet janet_next_impl(Janet ds, Janet key, int is_interpreter); +JanetBinding janet_binding_from_entry(Janet entry); +JanetByteView janet_text_substitution( + Janet *subst, + const uint8_t *bytes, + uint32_t len, + JanetArray *extra_args); + +/* Registry functions */ +void janet_registry_put( + JanetCFunction key, + const char *name, + const char *name_prefix, + const char *source_file, + int32_t source_line); +JanetCFunRegistry *janet_registry_get(JanetCFunction key); + +/* Inside the janet core, defining globals is different + * at bootstrap time and normal runtime */ +#ifdef JANET_BOOTSTRAP +#define JANET_CORE_REG JANET_REG +#define JANET_CORE_FN JANET_FN +#define JANET_CORE_DEF JANET_DEF +#define janet_core_def_sm janet_def_sm +#define janet_core_cfuns_ext janet_cfuns_ext +#else +#define JANET_CORE_REG JANET_REG_S +#define JANET_CORE_FN JANET_FN_S +#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) +void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl); +void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns); +#endif + +/* Clock gettime */ +#ifdef JANET_GETTIME +enum JanetTimeSource { + JANET_TIME_REALTIME, + JANET_TIME_MONOTONIC, + JANET_TIME_CPUTIME +}; +int janet_gettime(struct timespec *spec, enum JanetTimeSource source); +#endif + +/* strdup */ +#ifdef JANET_WINDOWS +#define strdup(x) _strdup(x) +#endif + +/* Use LoadLibrary on windows or dlopen on posix to load dynamic libaries + * with native code. */ +#if defined(JANET_NO_DYNAMIC_MODULES) +typedef int Clib; +#define load_clib(name) ((void) name, 0) +#define symbol_clib(lib, sym) ((void) lib, (void) sym, NULL) +const char *error_clib(void); +#define free_clib(c) ((void) (c), 0) +#elif defined(JANET_WINDOWS) +#include +typedef HINSTANCE Clib; +void *symbol_clib(Clib clib, const char *sym); +void free_clib(Clib clib); +Clib load_clib(const char *name); +char *error_clib(void); +#else +#include +typedef void *Clib; +#define load_clib(name) dlopen((name), RTLD_NOW) +#define free_clib(lib) dlclose((lib)) +#define symbol_clib(lib, sym) dlsym((lib), (sym)) +#define error_clib dlerror +#endif +char *get_processed_name(const char *name); + +#define RETRY_EINTR(RC, CALL) do { (RC) = CALL; } while((RC) < 0 && errno == EINTR) + +/* Initialize builtin libraries */ +void janet_lib_io(JanetTable *env); +void janet_lib_math(JanetTable *env); +void janet_lib_array(JanetTable *env); +void janet_lib_tuple(JanetTable *env); +void janet_lib_buffer(JanetTable *env); +void janet_lib_table(JanetTable *env); +void janet_lib_struct(JanetTable *env); +void janet_lib_fiber(JanetTable *env); +void janet_lib_os(JanetTable *env); +void janet_lib_string(JanetTable *env); +void janet_lib_marsh(JanetTable *env); +void janet_lib_parse(JanetTable *env); +#ifdef JANET_ASSEMBLER +void janet_lib_asm(JanetTable *env); +#endif +void janet_lib_compile(JanetTable *env); +void janet_lib_debug(JanetTable *env); +#ifdef JANET_PEG +void janet_lib_peg(JanetTable *env); +#endif +#ifdef JANET_TYPED_ARRAY +void janet_lib_typed_array(JanetTable *env); +#endif +#ifdef JANET_INT_TYPES +void janet_lib_inttypes(JanetTable *env); +#endif +#ifdef JANET_NET +void janet_lib_net(JanetTable *env); +extern const JanetAbstractType janet_address_type; +#endif +#ifdef JANET_EV +void janet_lib_ev(JanetTable *env); +void janet_ev_mark(void); +int janet_make_pipe(JanetHandle handles[2], int mode); +#endif +#ifdef JANET_FFI +void janet_lib_ffi(JanetTable *env); +#endif + +#endif + + +/* src/core/gc.h */ +#line 0 "src/core/gc.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_GC_H +#define JANET_GC_H + +#ifndef JANET_AMALG +#include "features.h" +#include +#endif + +/* The metadata header associated with an allocated block of memory */ +#define janet_gc_header(mem) ((JanetGCObject *)(mem)) + +#define JANET_MEM_TYPEBITS 0xFF +#define JANET_MEM_REACHABLE 0x100 +#define JANET_MEM_DISABLED 0x200 + +#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) +#define janet_gc_type(m) (janet_gc_header(m)->flags & 0xFF) + +#define janet_gc_mark(m) (janet_gc_header(m)->flags |= JANET_MEM_REACHABLE) +#define janet_gc_reachable(m) (janet_gc_header(m)->flags & JANET_MEM_REACHABLE) + +/* Memory types for the GC. Different from JanetType to include funcenv and funcdef. */ +enum JanetMemoryType { + JANET_MEMORY_NONE, + JANET_MEMORY_STRING, + JANET_MEMORY_SYMBOL, + JANET_MEMORY_ARRAY, + JANET_MEMORY_TUPLE, + JANET_MEMORY_TABLE, + JANET_MEMORY_STRUCT, + JANET_MEMORY_FIBER, + JANET_MEMORY_BUFFER, + JANET_MEMORY_FUNCTION, + JANET_MEMORY_ABSTRACT, + JANET_MEMORY_FUNCENV, + JANET_MEMORY_FUNCDEF, + JANET_MEMORY_THREADED_ABSTRACT, + JANET_MEMORY_TABLE_WEAKK, + JANET_MEMORY_TABLE_WEAKV, + JANET_MEMORY_TABLE_WEAKKV, + JANET_MEMORY_ARRAY_WEAK +}; + +/* To allocate collectable memory, one must call janet_alloc, initialize the memory, + * and then call when janet_enablegc when it is initailize and reachable by the gc (on the JANET stack) */ +void *janet_gcalloc(enum JanetMemoryType type, size_t size); + +#endif + + +/* src/core/vector.h */ +#line 0 "src/core/vector.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_VECTOR_H_defined +#define JANET_VECTOR_H_defined + +#ifndef JANET_AMALG +#include "features.h" +#include +#endif + +/* + * vector code modified from + * https://github.com/nothings/stb/blob/master/stretchy_buffer.h +*/ + +/* This is mainly used code such as the assembler or compiler, which + * need vector like data structures that are only garbage collected in case + * of an error, and normally rely on malloc/free. */ + +#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) +#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) +#define janet_v_pop(v) (janet_v_count(v) ? janet_v__cnt(v)-- : 0) +#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) +#define janet_v_last(v) ((v)[janet_v__cnt(v) - 1]) +#define janet_v_empty(v) (((v) != NULL) ? (janet_v__cnt(v) = 0) : 0) +#define janet_v_flatten(v) (janet_v_flattenmem((v), sizeof(*(v)))) + +#define janet_v__raw(v) ((int32_t *)(v) - 2) +#define janet_v__cap(v) janet_v__raw(v)[0] +#define janet_v__cnt(v) janet_v__raw(v)[1] + +#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) +#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) +#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) + +/* Actual functions defined in vector.c */ +void *janet_v_grow(void *v, int32_t increment, int32_t itemsize); +void *janet_v_flattenmem(void *v, int32_t itemsize); + +#endif + + +/* src/core/fiber.h */ +#line 0 "src/core/fiber.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_FIBER_H_defined +#define JANET_FIBER_H_defined + +#ifndef JANET_AMALG +#include +#endif + +/* Fiber signal masks. */ +#define JANET_FIBER_MASK_ERROR 2 +#define JANET_FIBER_MASK_DEBUG 4 +#define JANET_FIBER_MASK_YIELD 8 + +#define JANET_FIBER_MASK_USER0 (16 << 0) +#define JANET_FIBER_MASK_USER1 (16 << 1) +#define JANET_FIBER_MASK_USER2 (16 << 2) +#define JANET_FIBER_MASK_USER3 (16 << 3) +#define JANET_FIBER_MASK_USER4 (16 << 4) +#define JANET_FIBER_MASK_USER5 (16 << 5) +#define JANET_FIBER_MASK_USER6 (16 << 6) +#define JANET_FIBER_MASK_USER7 (16 << 7) +#define JANET_FIBER_MASK_USER8 (16 << 8) +#define JANET_FIBER_MASK_USER9 (16 << 9) + +#define JANET_FIBER_MASK_USERN(N) (16 << (N)) +#define JANET_FIBER_MASK_USER 0x3FF0 + +#define JANET_FIBER_STATUS_MASK 0x3F0000 +#define JANET_FIBER_RESUME_SIGNAL 0x400000 +#define JANET_FIBER_STATUS_OFFSET 16 + +#define JANET_FIBER_BREAKPOINT 0x1000000 +#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 +#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 +#define JANET_FIBER_DID_LONGJUMP 0x8000000 +#define JANET_FIBER_FLAG_MASK 0xF000000 + +#define JANET_FIBER_EV_FLAG_CANCELED 0x10000 +#define JANET_FIBER_EV_FLAG_SUSPENDED 0x20000 +#define JANET_FIBER_FLAG_ROOT 0x40000 +#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 + +/* used only on windows, should otherwise be unset */ + +#define janet_fiber_set_status(f, s) do {\ + (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ + (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ +} while (0) + +#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) +#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) +void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n); +void janet_fiber_push(JanetFiber *fiber, Janet x); +void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y); +void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z); +void janet_fiber_pushn(JanetFiber *fiber, const Janet *arr, int32_t n); +int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func); +int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func); +void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun); +void janet_fiber_popframe(JanetFiber *fiber); +void janet_env_maybe_detach(JanetFuncEnv *env); +int janet_env_valid(JanetFuncEnv *env); + +#ifdef JANET_EV +void janet_fiber_did_resume(JanetFiber *fiber); +#endif + +#endif + + +/* src/core/regalloc.h */ +#line 0 "src/core/regalloc.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +/* Implements a simple first fit register allocator for the compiler. */ + +#ifndef JANET_REGALLOC_H +#define JANET_REGALLOC_H + +#include + +/* Placeholder for allocating temporary registers */ +typedef enum { + JANETC_REGTEMP_0, + JANETC_REGTEMP_1, + JANETC_REGTEMP_2, + JANETC_REGTEMP_3, + JANETC_REGTEMP_4, + JANETC_REGTEMP_5, + JANETC_REGTEMP_6, + JANETC_REGTEMP_7 +} JanetcRegisterTemp; + +typedef struct { + uint32_t *chunks; + int32_t count; /* number of chunks in chunks */ + int32_t capacity; /* amount allocated for chunks */ + int32_t max; /* The maximum allocated register so far */ + int32_t regtemps; /* Hold which temp. registers are allocated. */ +} JanetcRegisterAllocator; + +void janetc_regalloc_init(JanetcRegisterAllocator *ra); +void janetc_regalloc_deinit(JanetcRegisterAllocator *ra); + +int32_t janetc_regalloc_1(JanetcRegisterAllocator *ra); +void janetc_regalloc_free(JanetcRegisterAllocator *ra, int32_t reg); +int32_t janetc_regalloc_temp(JanetcRegisterAllocator *ra, JanetcRegisterTemp nth); +void janetc_regalloc_freetemp(JanetcRegisterAllocator *ra, int32_t reg, JanetcRegisterTemp nth); +void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocator *src); +void janetc_regalloc_touch(JanetcRegisterAllocator *ra, int32_t reg); +int janetc_regalloc_check(JanetcRegisterAllocator *ra, int32_t reg); + +#endif + + +/* src/core/compile.h */ +#line 0 "src/core/compile.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_COMPILE_H +#define JANET_COMPILE_H + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "regalloc.h" +#endif + +/* Levels for compiler warnings */ +typedef enum { + JANET_C_LINT_RELAXED, + JANET_C_LINT_NORMAL, + JANET_C_LINT_STRICT +} JanetCompileLintLevel; + +/* Tags for some functions for the prepared inliner */ +#define JANET_FUN_DEBUG 1 +#define JANET_FUN_ERROR 2 +#define JANET_FUN_APPLY 3 +#define JANET_FUN_YIELD 4 +#define JANET_FUN_RESUME 5 +#define JANET_FUN_IN 6 +#define JANET_FUN_PUT 7 +#define JANET_FUN_LENGTH 8 +#define JANET_FUN_ADD 9 +#define JANET_FUN_SUBTRACT 10 +#define JANET_FUN_MULTIPLY 11 +#define JANET_FUN_DIVIDE 12 +#define JANET_FUN_BAND 13 +#define JANET_FUN_BOR 14 +#define JANET_FUN_BXOR 15 +#define JANET_FUN_LSHIFT 16 +#define JANET_FUN_RSHIFT 17 +#define JANET_FUN_RSHIFTU 18 +#define JANET_FUN_BNOT 19 +#define JANET_FUN_GT 20 +#define JANET_FUN_LT 21 +#define JANET_FUN_GTE 22 +#define JANET_FUN_LTE 23 +#define JANET_FUN_EQ 24 +#define JANET_FUN_NEQ 25 +#define JANET_FUN_PROP 26 +#define JANET_FUN_GET 27 +#define JANET_FUN_NEXT 28 +#define JANET_FUN_MODULO 29 +#define JANET_FUN_REMAINDER 30 +#define JANET_FUN_CMP 31 +#define JANET_FUN_CANCEL 32 +#define JANET_FUN_DIVIDE_FLOOR 33 + +/* Compiler typedefs */ +typedef struct JanetCompiler JanetCompiler; +typedef struct FormOptions FormOptions; +typedef struct SlotTracker SlotTracker; +typedef struct JanetScope JanetScope; +typedef struct JanetSlot JanetSlot; +typedef struct JanetFopts JanetFopts; +typedef struct JanetFunOptimizer JanetFunOptimizer; +typedef struct JanetSpecial JanetSpecial; + +#define JANET_SLOT_CONSTANT 0x10000 +#define JANET_SLOT_NAMED 0x20000 +#define JANET_SLOT_MUTABLE 0x40000 +#define JANET_SLOT_REF 0x80000 +#define JANET_SLOT_RETURNED 0x100000 +#define JANET_SLOT_DEP_NOTE 0x200000 +#define JANET_SLOT_DEP_WARN 0x400000 +#define JANET_SLOT_DEP_ERROR 0x800000 +#define JANET_SLOT_SPLICED 0x1000000 + +#define JANET_SLOTTYPE_ANY 0xFFFF + +/* A stack slot */ +struct JanetSlot { + Janet constant; /* If the slot has a constant value */ + int32_t index; + int32_t envindex; /* 0 is local, positive number is an upvalue */ + uint32_t flags; +}; + +#define JANET_SCOPE_FUNCTION 1 +#define JANET_SCOPE_ENV 2 +#define JANET_SCOPE_TOP 4 +#define JANET_SCOPE_UNUSED 8 +#define JANET_SCOPE_CLOSURE 16 +#define JANET_SCOPE_WHILE 32 + +/* A symbol and slot pair */ +typedef struct SymPair { + JanetSlot slot; + const uint8_t *sym; + const uint8_t *sym2; + int keep; + uint32_t birth_pc; + uint32_t death_pc; +} SymPair; + +typedef struct JanetEnvRef { + int32_t envindex; + JanetScope *scope; +} JanetEnvRef; + +/* A lexical scope during compilation */ +struct JanetScope { + + /* For debugging the compiler */ + const char *name; + + /* Scopes are doubly linked list */ + JanetScope *parent; + JanetScope *child; + + /* Constants for this funcdef */ + Janet *consts; + + /* Map of symbols to slots. Use a simple linear scan for symbols. */ + SymPair *syms; + + /* FuncDefs */ + JanetFuncDef **defs; + + /* Register allocator */ + JanetcRegisterAllocator ra; + + /* Upvalue allocator */ + JanetcRegisterAllocator ua; + + /* Referenced closure environments. The values at each index correspond + * to which index to get the environment from in the parent. The environment + * that corresponds to the direct parent's stack will always have value 0. */ + JanetEnvRef *envs; + + int32_t bytecode_start; + int flags; +}; + +/* Compilation state */ +struct JanetCompiler { + + /* Pointer to current scope */ + JanetScope *scope; + + uint32_t *buffer; + JanetSourceMapping *mapbuffer; + + /* Hold the environment */ + JanetTable *env; + + /* Name of source to attach to generated functions */ + const uint8_t *source; + + /* The result of compilation */ + JanetCompileResult result; + + /* Keep track of where we are in the source */ + JanetSourceMapping current_mapping; + + /* Prevent unbounded recursion */ + int recursion_guard; + + /* Collect linting results */ + JanetArray *lints; +}; + +#define JANET_FOPTS_TAIL 0x10000 +#define JANET_FOPTS_HINT 0x20000 +#define JANET_FOPTS_DROP 0x40000 +#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 + +/* Options for compiling a single form */ +struct JanetFopts { + JanetCompiler *compiler; + JanetSlot hint; + uint32_t flags; /* bit set of accepted primitive types */ +}; + +/* Get the default form options */ +JanetFopts janetc_fopts_default(JanetCompiler *c); + +/* For optimizing builtin normal functions. */ +struct JanetFunOptimizer { + int (*can_optimize)(JanetFopts opts, JanetSlot *args); + JanetSlot(*optimize)(JanetFopts opts, JanetSlot *args); +}; + +/* A grouping of a named special and the corresponding compiler fragment */ +struct JanetSpecial { + const char *name; + JanetSlot(*compile)(JanetFopts opts, int32_t argn, const Janet *argv); +}; + +/****************************************************/ + +/* Get an optimizer if it exists, otherwise NULL */ +const JanetFunOptimizer *janetc_funopt(uint32_t flags); + +/* Get a special. Return NULL if none exists */ +const JanetSpecial *janetc_special(const uint8_t *name); + +void janetc_freeslot(JanetCompiler *c, JanetSlot s); +void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s); +JanetSlot janetc_farslot(JanetCompiler *c); + +/* Throw away some code after checking that it is well formed. */ +void janetc_throwaway(JanetFopts opts, Janet x); + +/* Get a target slot for emitting an instruction. Will always return + * a local slot. */ +JanetSlot janetc_gettarget(JanetFopts opts); + +/* Get a bunch of slots for function arguments */ +JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len); + +/* Get a bunch of slots for function arguments */ +JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds); + +/* Push slots loaded via janetc_toslots. */ +int32_t janetc_pushslots(JanetCompiler *c, JanetSlot *slots); + +/* Free slots loaded via janetc_toslots */ +void janetc_freeslots(JanetCompiler *c, JanetSlot *slots); + +/* Generate the return instruction for a slot. */ +JanetSlot janetc_return(JanetCompiler *c, JanetSlot s); + +/* Store an error */ +void janetc_error(JanetCompiler *c, const uint8_t *m); +void janetc_cerror(JanetCompiler *c, const char *m); + +/* Linting */ +void janetc_lintf(JanetCompiler *C, JanetCompileLintLevel level, const char *format, ...); + +/* Dispatch to correct form compiler */ +JanetSlot janetc_value(JanetFopts opts, Janet x); + +/* Push and pop from the scope stack */ +void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name); +void janetc_popscope(JanetCompiler *c); +void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot); +JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c); + +/* Create a destory slots */ +JanetSlot janetc_cslot(Janet x); + +/* Search for a symbol */ +JanetSlot janetc_resolve(JanetCompiler *c, const uint8_t *sym); + +/* Bytecode optimization */ +void janet_bytecode_movopt(JanetFuncDef *def); +void janet_bytecode_remove_noops(JanetFuncDef *def); + +#endif + + +/* src/core/emit.h */ +#line 0 "src/core/emit.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_EMIT_H +#define JANET_EMIT_H + +#ifndef JANET_AMALG +#include "compile.h" +#endif + +void janetc_emit(JanetCompiler *c, uint32_t instr); + +int32_t janetc_allocfar(JanetCompiler *c); +int32_t janetc_allocnear(JanetCompiler *c, JanetcRegisterTemp); + +int32_t janetc_emit_s(JanetCompiler *c, uint8_t op, JanetSlot s, int wr); +int32_t janetc_emit_sl(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t label); +int32_t janetc_emit_st(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t tflags); +int32_t janetc_emit_si(JanetCompiler *c, uint8_t op, JanetSlot s, int16_t immediate, int wr); +int32_t janetc_emit_su(JanetCompiler *c, uint8_t op, JanetSlot s, uint16_t immediate, int wr); +int32_t janetc_emit_ss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int wr); +int32_t janetc_emit_ssi(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int8_t immediate, int wr); +int32_t janetc_emit_ssu(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, uint8_t immediate, int wr); +int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, JanetSlot s3, int wr); + +/* Check if two slots are equivalent */ +int janetc_sequal(JanetSlot x, JanetSlot y); + +/* Move value from one slot to another. Cannot copy to constant slots. */ +void janetc_copy(JanetCompiler *c, JanetSlot dest, JanetSlot src); + +#endif + + +/* src/core/symcache.h */ +#line 0 "src/core/symcache.h" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_SYMCACHE_H_defined +#define JANET_SYMCACHE_H_defined + +#ifndef JANET_AMALG +#include "features.h" +#include +#endif + +/* Initialize the cache (allocate cache memory) */ +void janet_symcache_init(void); +void janet_symcache_deinit(void); +void janet_symbol_deinit(const uint8_t *sym); + +#endif + + +/* Windows work around - winsock2 must be included before windows.h, especially in amalgamated build */ +#if defined(JANET_WINDOWS) && defined(JANET_NET) +#include +#endif + + +/* src/core/abstract.c */ +#line 0 "src/core/abstract.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "gc.h" +#include "state.h" +#endif + +#ifdef JANET_EV +#ifdef JANET_WINDOWS +#include +#endif +#endif + +/* Create new userdata */ +void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { + JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, + sizeof(JanetAbstractHead) + size); + header->size = size; + header->type = atype; + return (void *) & (header->data); +} + +void *janet_abstract_end(void *x) { + janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); + return x; +} + +void *janet_abstract(const JanetAbstractType *atype, size_t size) { + return janet_abstract_end(janet_abstract_begin(atype, size)); +} + +#ifdef JANET_EV + +/* + * Threaded abstracts + */ + +void *janet_abstract_begin_threaded(const JanetAbstractType *atype, size_t size) { + JanetAbstractHead *header = janet_malloc(sizeof(JanetAbstractHead) + size); + if (NULL == header) { + JANET_OUT_OF_MEMORY; + } + janet_vm.next_collection += size + sizeof(JanetAbstractHead); + header->gc.flags = JANET_MEMORY_THREADED_ABSTRACT; + header->gc.data.next = NULL; /* Clear memory for address sanitizers */ + header->gc.data.refcount = 1; + header->size = size; + header->type = atype; + void *abstract = (void *) & (header->data); + janet_table_put(&janet_vm.threaded_abstracts, janet_wrap_abstract(abstract), janet_wrap_false()); + return abstract; +} + +void *janet_abstract_end_threaded(void *x) { + janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_THREADED_ABSTRACT); + return x; +} + +void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) { + return janet_abstract_end_threaded(janet_abstract_begin_threaded(atype, size)); +} + +/* Refcounting primitives and sync primitives */ + +#ifdef JANET_WINDOWS + +size_t janet_os_mutex_size(void) { + return sizeof(CRITICAL_SECTION); +} + +size_t janet_os_rwlock_size(void) { + return sizeof(void *); +} + +void janet_os_mutex_init(JanetOSMutex *mutex) { + InitializeCriticalSection((CRITICAL_SECTION *) mutex); +} + +void janet_os_mutex_deinit(JanetOSMutex *mutex) { + DeleteCriticalSection((CRITICAL_SECTION *) mutex); +} + +void janet_os_mutex_lock(JanetOSMutex *mutex) { + EnterCriticalSection((CRITICAL_SECTION *) mutex); +} + +void janet_os_mutex_unlock(JanetOSMutex *mutex) { + /* error handling? May want to keep counter */ + LeaveCriticalSection((CRITICAL_SECTION *) mutex); +} + +void janet_os_rwlock_init(JanetOSRWLock *rwlock) { + InitializeSRWLock((PSRWLOCK) rwlock); +} + +void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) { + /* no op? */ + (void) rwlock; +} + +void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) { + AcquireSRWLockShared((PSRWLOCK) rwlock); +} + +void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) { + AcquireSRWLockExclusive((PSRWLOCK) rwlock); +} + +void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) { + ReleaseSRWLockShared((PSRWLOCK) rwlock); +} + +void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) { + ReleaseSRWLockExclusive((PSRWLOCK) rwlock); +} + +#else + +size_t janet_os_mutex_size(void) { + return sizeof(pthread_mutex_t); +} + +size_t janet_os_rwlock_size(void) { + return sizeof(pthread_rwlock_t); +} + +void janet_os_mutex_init(JanetOSMutex *mutex) { + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init((pthread_mutex_t *) mutex, &attr); +} + +void janet_os_mutex_deinit(JanetOSMutex *mutex) { + pthread_mutex_destroy((pthread_mutex_t *) mutex); +} + +void janet_os_mutex_lock(JanetOSMutex *mutex) { + pthread_mutex_lock((pthread_mutex_t *) mutex); +} + +void janet_os_mutex_unlock(JanetOSMutex *mutex) { + int ret = pthread_mutex_unlock((pthread_mutex_t *) mutex); + if (ret) janet_panic("cannot release lock"); +} + +void janet_os_rwlock_init(JanetOSRWLock *rwlock) { + pthread_rwlock_init((pthread_rwlock_t *) rwlock, NULL); +} + +void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) { + pthread_rwlock_destroy((pthread_rwlock_t *) rwlock); +} + +void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) { + pthread_rwlock_rdlock((pthread_rwlock_t *) rwlock); +} + +void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) { + pthread_rwlock_wrlock((pthread_rwlock_t *) rwlock); +} + +void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) { + pthread_rwlock_unlock((pthread_rwlock_t *) rwlock); +} + +void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) { + pthread_rwlock_unlock((pthread_rwlock_t *) rwlock); +} + +#endif + +int32_t janet_abstract_incref(void *abst) { + return janet_atomic_inc(&janet_abstract_head(abst)->gc.data.refcount); +} + +int32_t janet_abstract_decref(void *abst) { + return janet_atomic_dec(&janet_abstract_head(abst)->gc.data.refcount); +} + +#endif + + +/* src/core/array.c */ +#line 0 "src/core/array.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include "state.h" +#endif + +#include + +static void janet_array_impl(JanetArray *array, int32_t capacity) { + Janet *data = NULL; + if (capacity > 0) { + janet_vm.next_collection += capacity * sizeof(Janet); + data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity); + if (NULL == data) { + JANET_OUT_OF_MEMORY; + } + } + array->count = 0; + array->capacity = capacity; + array->data = data; +} + +/* Creates a new array */ +JanetArray *janet_array(int32_t capacity) { + JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); + janet_array_impl(array, capacity); + return array; +} + +/* Creates a new array with weak references */ +JanetArray *janet_array_weak(int32_t capacity) { + JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray)); + janet_array_impl(array, capacity); + return array; +} + +/* Creates a new array from n elements. */ +JanetArray *janet_array_n(const Janet *elements, int32_t n) { + JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); + array->capacity = n; + array->count = n; + array->data = janet_malloc(sizeof(Janet) * (size_t) n); + if (!array->data) { + JANET_OUT_OF_MEMORY; + } + safe_memcpy(array->data, elements, sizeof(Janet) * n); + return array; +} + +/* Ensure the array has enough capacity for elements */ +void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) { + Janet *newData; + Janet *old = array->data; + if (capacity <= array->capacity) return; + int64_t new_capacity = ((int64_t) capacity) * growth; + if (new_capacity > INT32_MAX) new_capacity = INT32_MAX; + capacity = (int32_t) new_capacity; + newData = janet_realloc(old, capacity * sizeof(Janet)); + if (NULL == newData) { + JANET_OUT_OF_MEMORY; + } + janet_vm.next_collection += (capacity - array->capacity) * sizeof(Janet); + array->data = newData; + array->capacity = capacity; +} + +/* Set the count of an array. Extend with nil if needed. */ +void janet_array_setcount(JanetArray *array, int32_t count) { + if (count < 0) + return; + if (count > array->count) { + int32_t i; + janet_array_ensure(array, count, 1); + for (i = array->count; i < count; i++) { + array->data[i] = janet_wrap_nil(); + } + } + array->count = count; +} + +/* Push a value to the top of the array */ +void janet_array_push(JanetArray *array, Janet x) { + if (array->count == INT32_MAX) { + janet_panic("array overflow"); + } + int32_t newcount = array->count + 1; + janet_array_ensure(array, newcount, 2); + array->data[array->count] = x; + array->count = newcount; +} + +/* Pop a value from the top of the array */ +Janet janet_array_pop(JanetArray *array) { + if (array->count) { + return array->data[--array->count]; + } else { + return janet_wrap_nil(); + } +} + +/* Look at the last value in the array */ +Janet janet_array_peek(JanetArray *array) { + if (array->count) { + return array->data[array->count - 1]; + } else { + return janet_wrap_nil(); + } +} + +/* C Functions */ + +JANET_CORE_FN(cfun_array_new, + "(array/new capacity)", + "Creates a new empty array with a pre-allocated capacity. The same as " + "`(array)` but can be more efficient if the maximum size of an array is known.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getinteger(argv, 0); + JanetArray *array = janet_array(cap); + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_array_weak, + "(array/weak capacity)", + "Creates a new empty array with a pre-allocated capacity and support for weak references. Similar to `array/new`.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getinteger(argv, 0); + JanetArray *array = janet_array_weak(cap); + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_array_new_filled, + "(array/new-filled count &opt value)", + "Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.") { + janet_arity(argc, 1, 2); + int32_t count = janet_getnat(argv, 0); + Janet x = (argc == 2) ? argv[1] : janet_wrap_nil(); + JanetArray *array = janet_array(count); + for (int32_t i = 0; i < count; i++) { + array->data[i] = x; + } + array->count = count; + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_array_fill, + "(array/fill arr &opt value)", + "Replace all elements of an array with `value` (defaulting to nil) without changing the length of the array. " + "Returns the modified array.") { + janet_arity(argc, 1, 2); + JanetArray *array = janet_getarray(argv, 0); + Janet x = (argc == 2) ? argv[1] : janet_wrap_nil(); + for (int32_t i = 0; i < array->count; i++) { + array->data[i] = x; + } + return argv[0]; +} + +JANET_CORE_FN(cfun_array_pop, + "(array/pop arr)", + "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies " + "the input array.") { + janet_fixarity(argc, 1); + JanetArray *array = janet_getarray(argv, 0); + return janet_array_pop(array); +} + +JANET_CORE_FN(cfun_array_peek, + "(array/peek arr)", + "Returns the last element of the array. Does not modify the array.") { + janet_fixarity(argc, 1); + JanetArray *array = janet_getarray(argv, 0); + return janet_array_peek(array); +} + +JANET_CORE_FN(cfun_array_push, + "(array/push arr & xs)", + "Push all the elements of xs to the end of an array. Modifies the input array and returns it.") { + janet_arity(argc, 1, -1); + JanetArray *array = janet_getarray(argv, 0); + if (INT32_MAX - argc + 1 <= array->count) { + janet_panic("array overflow"); + } + int32_t newcount = array->count - 1 + argc; + janet_array_ensure(array, newcount, 2); + if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet)); + array->count = newcount; + return argv[0]; +} + +JANET_CORE_FN(cfun_array_ensure, + "(array/ensure arr capacity growth)", + "Ensures that the memory backing the array is large enough for `capacity` " + "items at the given rate of growth. `capacity` and `growth` must be integers. " + "If the backing capacity is already enough, then this function does nothing. " + "Otherwise, the backing memory will be reallocated so that there is enough space.") { + janet_fixarity(argc, 3); + JanetArray *array = janet_getarray(argv, 0); + int32_t newcount = janet_getinteger(argv, 1); + int32_t growth = janet_getinteger(argv, 2); + if (newcount < 1) janet_panic("expected positive integer"); + janet_array_ensure(array, newcount, growth); + return argv[0]; +} + +JANET_CORE_FN(cfun_array_slice, + "(array/slice arrtup &opt start end)", + "Takes a slice of array or tuple from `start` to `end`. The range is half open, " + "[start, end). Indexes can also be negative, indicating indexing from the " + "end of the array. By default, `start` is 0 and `end` is the length of the array. " + "Note that if the range is negative, it is taken as (start, end] to allow a full " + "negative slice range. Returns a new array.") { + JanetView view = janet_getindexed(argv, 0); + JanetRange range = janet_getslice(argc, argv); + JanetArray *array = janet_array(range.end - range.start); + if (array->data) + memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start)); + array->count = range.end - range.start; + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_array_concat, + "(array/concat arr & parts)", + "Concatenates a variable number of arrays (and tuples) into the first argument, " + "which must be an array. If any of the parts are arrays or tuples, their elements will " + "be inserted into the array. Otherwise, each part in `parts` will be appended to `arr` in order. " + "Return the modified array `arr`.") { + int32_t i; + janet_arity(argc, 1, -1); + JanetArray *array = janet_getarray(argv, 0); + for (i = 1; i < argc; i++) { + switch (janet_type(argv[i])) { + default: + janet_array_push(array, argv[i]); + break; + case JANET_ARRAY: + case JANET_TUPLE: { + int32_t j, len = 0; + const Janet *vals = NULL; + janet_indexed_view(argv[i], &vals, &len); + if (array->data == vals) { + int32_t newcount = array->count + len; + janet_array_ensure(array, newcount, 2); + janet_indexed_view(argv[i], &vals, &len); + } + for (j = 0; j < len; j++) + janet_array_push(array, vals[j]); + } + break; + } + } + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_array_insert, + "(array/insert arr at & xs)", + "Insert all `xs` into array `arr` at index `at`. `at` should be an integer between " + "0 and the length of the array. A negative value for `at` will index backwards from " + "the end of the array, inserting after the index such that inserting at -1 appends to " + "the array. Returns the array.") { + size_t chunksize, restsize; + janet_arity(argc, 2, -1); + JanetArray *array = janet_getarray(argv, 0); + int32_t at = janet_getinteger(argv, 1); + if (at < 0) { + at = array->count + at + 1; + } + if (at < 0 || at > array->count) + janet_panicf("insertion index %d out of range [0,%d]", at, array->count); + chunksize = (argc - 2) * sizeof(Janet); + restsize = (array->count - at) * sizeof(Janet); + if (INT32_MAX - (argc - 2) < array->count) { + janet_panic("array overflow"); + } + janet_array_ensure(array, array->count + argc - 2, 2); + if (restsize) { + memmove(array->data + at + argc - 2, + array->data + at, + restsize); + } + safe_memcpy(array->data + at, argv + 2, chunksize); + array->count += (argc - 2); + return argv[0]; +} + +JANET_CORE_FN(cfun_array_remove, + "(array/remove arr at &opt n)", + "Remove up to `n` elements starting at index `at` in array `arr`. `at` can index from " + "the end of the array with a negative index, and `n` must be a non-negative integer. " + "By default, `n` is 1. " + "Returns the array.") { + janet_arity(argc, 2, 3); + JanetArray *array = janet_getarray(argv, 0); + int32_t at = janet_getinteger(argv, 1); + int32_t n = 1; + if (at < 0) { + at = array->count + at; + } + if (at < 0 || at > array->count) + janet_panicf("removal index %d out of range [0,%d]", at, array->count); + if (argc == 3) { + n = janet_getinteger(argv, 2); + if (n < 0) + janet_panicf("expected non-negative integer for argument n, got %v", argv[2]); + } + if (at + n > array->count) { + n = array->count - at; + } + memmove(array->data + at, + array->data + at + n, + (array->count - at - n) * sizeof(Janet)); + array->count -= n; + return argv[0]; +} + +JANET_CORE_FN(cfun_array_trim, + "(array/trim arr)", + "Set the backing capacity of an array to its current length. Returns the modified array.") { + janet_fixarity(argc, 1); + JanetArray *array = janet_getarray(argv, 0); + if (array->count) { + if (array->count < array->capacity) { + Janet *newData = janet_realloc(array->data, array->count * sizeof(Janet)); + if (NULL == newData) { + JANET_OUT_OF_MEMORY; + } + array->data = newData; + array->capacity = array->count; + } + } else { + array->capacity = 0; + janet_free(array->data); + array->data = NULL; + } + return argv[0]; +} + +JANET_CORE_FN(cfun_array_clear, + "(array/clear arr)", + "Empties an array, setting it's count to 0 but does not free the backing capacity. " + "Returns the modified array.") { + janet_fixarity(argc, 1); + JanetArray *array = janet_getarray(argv, 0); + array->count = 0; + return argv[0]; +} + +/* Load the array module */ +void janet_lib_array(JanetTable *env) { + JanetRegExt array_cfuns[] = { + JANET_CORE_REG("array/new", cfun_array_new), + JANET_CORE_REG("array/weak", cfun_array_weak), + JANET_CORE_REG("array/new-filled", cfun_array_new_filled), + JANET_CORE_REG("array/fill", cfun_array_fill), + JANET_CORE_REG("array/pop", cfun_array_pop), + JANET_CORE_REG("array/peek", cfun_array_peek), + JANET_CORE_REG("array/push", cfun_array_push), + JANET_CORE_REG("array/ensure", cfun_array_ensure), + JANET_CORE_REG("array/slice", cfun_array_slice), + JANET_CORE_REG("array/concat", cfun_array_concat), + JANET_CORE_REG("array/insert", cfun_array_insert), + JANET_CORE_REG("array/remove", cfun_array_remove), + JANET_CORE_REG("array/trim", cfun_array_trim), + JANET_CORE_REG("array/clear", cfun_array_clear), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, array_cfuns); +} + + +/* src/core/asm.c */ +#line 0 "src/core/asm.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#endif + +#include + +/* Conditionally compile this file */ +#ifdef JANET_ASSEMBLER + +/* Definition for an instruction in the assembler */ +typedef struct JanetInstructionDef JanetInstructionDef; +struct JanetInstructionDef { + const char *name; + enum JanetOpCode opcode; +}; + +/* Hold all state needed during assembly */ +typedef struct JanetAssembler JanetAssembler; +struct JanetAssembler { + JanetAssembler *parent; + JanetFuncDef *def; + jmp_buf on_error; + const uint8_t *errmessage; + int32_t errindex; + + int32_t environments_capacity; + int32_t defs_capacity; + int32_t bytecode_count; /* Used for calculating labels */ + + Janet name; + JanetTable labels; /* keyword -> bytecode index */ + JanetTable slots; /* symbol -> slot index */ + JanetTable envs; /* symbol -> environment index */ + JanetTable defs; /* symbol -> funcdefs index */ +}; + +/* Janet opcode descriptions in lexicographic order. This + * allows a binary search over the elements to find the + * correct opcode given a name. This works in reasonable + * time and is easier to setup statically than a hash table or + * prefix tree. */ +static const JanetInstructionDef janet_ops[] = { + {"add", JOP_ADD}, + {"addim", JOP_ADD_IMMEDIATE}, + {"band", JOP_BAND}, + {"bnot", JOP_BNOT}, + {"bor", JOP_BOR}, + {"bxor", JOP_BXOR}, + {"call", JOP_CALL}, + {"clo", JOP_CLOSURE}, + {"cmp", JOP_COMPARE}, + {"cncl", JOP_CANCEL}, + {"div", JOP_DIVIDE}, + {"divf", JOP_DIVIDE_FLOOR}, + {"divim", JOP_DIVIDE_IMMEDIATE}, + {"eq", JOP_EQUALS}, + {"eqim", JOP_EQUALS_IMMEDIATE}, + {"err", JOP_ERROR}, + {"get", JOP_GET}, + {"geti", JOP_GET_INDEX}, + {"gt", JOP_GREATER_THAN}, + {"gte", JOP_GREATER_THAN_EQUAL}, + {"gtim", JOP_GREATER_THAN_IMMEDIATE}, + {"in", JOP_IN}, + {"jmp", JOP_JUMP}, + {"jmpif", JOP_JUMP_IF}, + {"jmpni", JOP_JUMP_IF_NIL}, + {"jmpnn", JOP_JUMP_IF_NOT_NIL}, + {"jmpno", JOP_JUMP_IF_NOT}, + {"ldc", JOP_LOAD_CONSTANT}, + {"ldf", JOP_LOAD_FALSE}, + {"ldi", JOP_LOAD_INTEGER}, + {"ldn", JOP_LOAD_NIL}, + {"lds", JOP_LOAD_SELF}, + {"ldt", JOP_LOAD_TRUE}, + {"ldu", JOP_LOAD_UPVALUE}, + {"len", JOP_LENGTH}, + {"lt", JOP_LESS_THAN}, + {"lte", JOP_LESS_THAN_EQUAL}, + {"ltim", JOP_LESS_THAN_IMMEDIATE}, + {"mkarr", JOP_MAKE_ARRAY}, + {"mkbtp", JOP_MAKE_BRACKET_TUPLE}, + {"mkbuf", JOP_MAKE_BUFFER}, + {"mkstr", JOP_MAKE_STRING}, + {"mkstu", JOP_MAKE_STRUCT}, + {"mktab", JOP_MAKE_TABLE}, + {"mktup", JOP_MAKE_TUPLE}, + {"mod", JOP_MODULO}, + {"movf", JOP_MOVE_FAR}, + {"movn", JOP_MOVE_NEAR}, + {"mul", JOP_MULTIPLY}, + {"mulim", JOP_MULTIPLY_IMMEDIATE}, + {"neq", JOP_NOT_EQUALS}, + {"neqim", JOP_NOT_EQUALS_IMMEDIATE}, + {"next", JOP_NEXT}, + {"noop", JOP_NOOP}, + {"prop", JOP_PROPAGATE}, + {"push", JOP_PUSH}, + {"push2", JOP_PUSH_2}, + {"push3", JOP_PUSH_3}, + {"pusha", JOP_PUSH_ARRAY}, + {"put", JOP_PUT}, + {"puti", JOP_PUT_INDEX}, + {"rem", JOP_REMAINDER}, + {"res", JOP_RESUME}, + {"ret", JOP_RETURN}, + {"retn", JOP_RETURN_NIL}, + {"setu", JOP_SET_UPVALUE}, + {"sig", JOP_SIGNAL}, + {"sl", JOP_SHIFT_LEFT}, + {"slim", JOP_SHIFT_LEFT_IMMEDIATE}, + {"sr", JOP_SHIFT_RIGHT}, + {"srim", JOP_SHIFT_RIGHT_IMMEDIATE}, + {"sru", JOP_SHIFT_RIGHT_UNSIGNED}, + {"sruim", JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE}, + {"sub", JOP_SUBTRACT}, + {"subim", JOP_SUBTRACT_IMMEDIATE}, + {"tcall", JOP_TAILCALL}, + {"tchck", JOP_TYPECHECK} +}; + +/* Typename aliases for tchck instruction */ +typedef struct TypeAlias { + const char *name; + int32_t mask; +} TypeAlias; + +static const TypeAlias type_aliases[] = { + {"abstract", JANET_TFLAG_ABSTRACT}, + {"array", JANET_TFLAG_ARRAY}, + {"boolean", JANET_TFLAG_BOOLEAN}, + {"buffer", JANET_TFLAG_BUFFER}, + {"callable", JANET_TFLAG_CALLABLE}, + {"cfunction", JANET_TFLAG_CFUNCTION}, + {"dictionary", JANET_TFLAG_DICTIONARY}, + {"fiber", JANET_TFLAG_FIBER}, + {"function", JANET_TFLAG_FUNCTION}, + {"indexed", JANET_TFLAG_INDEXED}, + {"keyword", JANET_TFLAG_KEYWORD}, + {"nil", JANET_TFLAG_NIL}, + {"number", JANET_TFLAG_NUMBER}, + {"pointer", JANET_TFLAG_POINTER}, + {"string", JANET_TFLAG_STRING}, + {"struct", JANET_TFLAG_STRUCT}, + {"symbol", JANET_TFLAG_SYMBOL}, + {"table", JANET_TFLAG_TABLE}, + {"tuple", JANET_TFLAG_TUPLE} +}; + +/* Deinitialize an Assembler. Does not deinitialize the parents. */ +static void janet_asm_deinit(JanetAssembler *a) { + janet_table_deinit(&a->slots); + janet_table_deinit(&a->labels); + janet_table_deinit(&a->envs); + janet_table_deinit(&a->defs); +} + +static void janet_asm_longjmp(JanetAssembler *a) { +#if defined(JANET_BSD) || defined(JANET_APPLE) + _longjmp(a->on_error, 1); +#else + longjmp(a->on_error, 1); +#endif +} + +/* Throw some kind of assembly error */ +static void janet_asm_error(JanetAssembler *a, const char *message) { + if (a->errindex < 0) { + a->errmessage = janet_formatc("%s", message); + } else { + a->errmessage = janet_formatc("%s, instruction %d", message, a->errindex); + } + janet_asm_longjmp(a); +} +#define janet_asm_assert(a, c, m) do { if (!(c)) janet_asm_error((a), (m)); } while (0) + +/* Throw some kind of assembly error */ +static void janet_asm_errorv(JanetAssembler *a, const uint8_t *m) { + a->errmessage = m; + janet_asm_longjmp(a); +} + +/* Add a closure environment to the assembler. Sub funcdefs may need + * to reference outer function environments, and may change the outer environment. + * Returns the index of the environment in the assembler's environments, or -1 + * if not found. */ +static int32_t janet_asm_addenv(JanetAssembler *a, Janet envname) { + Janet check; + JanetFuncDef *def = a->def; + int32_t envindex; + int32_t res; + if (janet_equals(a->name, envname)) { + return -1; + } + /* Check for memoized value */ + check = janet_table_get(&a->envs, envname); + if (janet_checktype(check, JANET_NUMBER)) { + return (int32_t) janet_unwrap_number(check); + } + if (NULL == a->parent) return -2; + res = janet_asm_addenv(a->parent, envname); + if (res < -1) { + return res; + } + envindex = def->environments_length; + janet_table_put(&a->envs, envname, janet_wrap_number(envindex)); + if (envindex >= a->environments_capacity) { + int32_t newcap = 2 * envindex; + def->environments = janet_realloc(def->environments, newcap * sizeof(int32_t)); + if (NULL == def->environments) { + JANET_OUT_OF_MEMORY; + } + a->environments_capacity = newcap; + } + def->environments[envindex] = (int32_t) res; + def->environments_length = envindex + 1; + return envindex; +} + +/* Parse an argument to an assembly instruction, and return the result as an + * integer. This integer will need to be bounds checked. */ +static int32_t doarg_1( + JanetAssembler *a, + enum JanetOpArgType argtype, + Janet x) { + int32_t ret = -1; + JanetTable *c; + switch (argtype) { + default: + c = NULL; + break; + case JANET_OAT_SLOT: + c = &a->slots; + break; + case JANET_OAT_ENVIRONMENT: + c = &a->envs; + break; + case JANET_OAT_LABEL: + c = &a->labels; + break; + case JANET_OAT_FUNCDEF: + c = &a->defs; + break; + } + switch (janet_type(x)) { + default: + goto error; + break; + case JANET_NUMBER: { + double y = janet_unwrap_number(x); + if (janet_checkintrange(y)) { + ret = (int32_t) y; + } else { + goto error; + } + break; + } + case JANET_TUPLE: { + const Janet *t = janet_unwrap_tuple(x); + if (argtype == JANET_OAT_TYPE) { + int32_t i = 0; + ret = 0; + for (i = 0; i < janet_tuple_length(t); i++) { + ret |= doarg_1(a, JANET_OAT_SIMPLETYPE, t[i]); + } + } else { + goto error; + } + break; + } + case JANET_KEYWORD: { + if (NULL != c && argtype == JANET_OAT_LABEL) { + Janet result = janet_table_get(c, x); + if (janet_checktype(result, JANET_NUMBER)) { + ret = janet_unwrap_integer(result) - a->bytecode_count; + } else { + goto error; + } + } else if (argtype == JANET_OAT_TYPE || argtype == JANET_OAT_SIMPLETYPE) { + const TypeAlias *alias = janet_strbinsearch( + &type_aliases, + sizeof(type_aliases) / sizeof(TypeAlias), + sizeof(TypeAlias), + janet_unwrap_keyword(x)); + if (alias) { + ret = alias->mask; + } else { + janet_asm_errorv(a, janet_formatc("unknown type %v", x)); + } + } else { + goto error; + } + break; + } + case JANET_SYMBOL: { + if (NULL != c) { + Janet result = janet_table_get(c, x); + if (janet_checktype(result, JANET_NUMBER)) { + ret = (int32_t) janet_unwrap_number(result); + } else { + janet_asm_errorv(a, janet_formatc("unknown name %v", x)); + } + } else { + goto error; + } + if (argtype == JANET_OAT_ENVIRONMENT && ret == -1) { + /* Add a new env */ + ret = janet_asm_addenv(a, x); + if (ret < -1) { + janet_asm_errorv(a, janet_formatc("unknown environment %v", x)); + } + } + break; + } + } + if (argtype == JANET_OAT_SLOT && ret >= a->def->slotcount) + a->def->slotcount = (int32_t) ret + 1; + return ret; + +error: + janet_asm_errorv(a, janet_formatc("error parsing instruction argument %v", x)); + return 0; +} + +/* Parse a single argument to an instruction. Trims it as well as + * try to convert arguments to bit patterns */ +static uint32_t doarg( + JanetAssembler *a, + enum JanetOpArgType argtype, + int nth, + int nbytes, + int hassign, + Janet x) { + int32_t arg = doarg_1(a, argtype, x); + /* Calculate the min and max values that can be stored given + * nbytes, and whether or not the storage is signed */ + int32_t max = (1 << ((nbytes << 3) - hassign)) - 1; + int32_t min = hassign ? -max - 1 : 0; + if (arg < min) + janet_asm_errorv(a, janet_formatc("instruction argument %v is too small, must be %d byte%s", + x, nbytes, nbytes > 1 ? "s" : "")); + if (arg > max) + janet_asm_errorv(a, janet_formatc("instruction argument %v is too large, must be %d byte%s", + x, nbytes, nbytes > 1 ? "s" : "")); + return ((uint32_t) arg) << (nth << 3); +} + +/* Provide parsing methods for the different kinds of arguments */ +static uint32_t read_instruction( + JanetAssembler *a, + const JanetInstructionDef *idef, + const Janet *argt) { + uint32_t instr = idef->opcode; + enum JanetInstructionType type = janet_instructions[idef->opcode]; + switch (type) { + case JINT_0: { + if (janet_tuple_length(argt) != 1) + janet_asm_error(a, "expected 0 arguments: (op)"); + break; + } + case JINT_S: { + if (janet_tuple_length(argt) != 2) + janet_asm_error(a, "expected 1 argument: (op, slot)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 2, 0, argt[1]); + break; + } + case JINT_L: { + if (janet_tuple_length(argt) != 2) + janet_asm_error(a, "expected 1 argument: (op, label)"); + instr |= doarg(a, JANET_OAT_LABEL, 1, 3, 1, argt[1]); + break; + } + case JINT_SS: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, slot)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_SLOT, 2, 2, 0, argt[2]); + break; + } + case JINT_SL: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, label)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_LABEL, 2, 2, 1, argt[2]); + break; + } + case JINT_ST: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, type)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_TYPE, 2, 2, 0, argt[2]); + break; + } + case JINT_SI: + case JINT_SU: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, integer)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_INTEGER, 2, 2, type == JINT_SI, argt[2]); + break; + } + case JINT_SD: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, funcdef)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_FUNCDEF, 2, 2, 0, argt[2]); + break; + } + case JINT_SSS: { + if (janet_tuple_length(argt) != 4) + janet_asm_error(a, "expected 3 arguments: (op, slot, slot, slot)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_SLOT, 2, 1, 0, argt[2]); + instr |= doarg(a, JANET_OAT_SLOT, 3, 1, 0, argt[3]); + break; + } + case JINT_SSI: + case JINT_SSU: { + if (janet_tuple_length(argt) != 4) + janet_asm_error(a, "expected 3 arguments: (op, slot, slot, integer)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_SLOT, 2, 1, 0, argt[2]); + instr |= doarg(a, JANET_OAT_INTEGER, 3, 1, type == JINT_SSI, argt[3]); + break; + } + case JINT_SES: { + JanetAssembler *b = a; + uint32_t env; + if (janet_tuple_length(argt) != 4) + janet_asm_error(a, "expected 3 arguments: (op, slot, environment, envslot)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + env = doarg(a, JANET_OAT_ENVIRONMENT, 0, 1, 0, argt[2]); + instr |= env << 16; + for (env += 1; env > 0; env--) { + b = b->parent; + if (NULL == b) + janet_asm_error(a, "invalid environment index"); + } + instr |= doarg(b, JANET_OAT_SLOT, 3, 1, 0, argt[3]); + break; + } + case JINT_SC: { + if (janet_tuple_length(argt) != 3) + janet_asm_error(a, "expected 2 arguments: (op, slot, constant)"); + instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]); + instr |= doarg(a, JANET_OAT_CONSTANT, 2, 2, 0, argt[2]); + break; + } + } + return instr; +} + +/* Helper to get from a structure */ +static Janet janet_get1(Janet ds, Janet key) { + switch (janet_type(ds)) { + default: + return janet_wrap_nil(); + case JANET_TABLE: + return janet_table_get(janet_unwrap_table(ds), key); + case JANET_STRUCT: + return janet_struct_get(janet_unwrap_struct(ds), key); + } +} + +/* Helper to assembly. Return the assembly result */ +static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int flags) { + JanetAssembleResult result; + JanetAssembler a; + Janet s = source; + JanetFuncDef *def; + int32_t count, i; + const Janet *arr; + Janet x; + (void) flags; + + /* Initialize funcdef */ + def = janet_funcdef_alloc(); + + /* Initialize Assembler */ + a.def = def; + a.parent = parent; + a.errmessage = NULL; + a.errindex = 0; + a.environments_capacity = 0; + a.bytecode_count = 0; + a.defs_capacity = 0; + a.name = janet_wrap_nil(); + janet_table_init(&a.labels, 0); + janet_table_init(&a.slots, 0); + janet_table_init(&a.envs, 0); + janet_table_init(&a.defs, 0); + + /* Set error jump */ +#if defined(JANET_BSD) || defined(JANET_APPLE) + if (_setjmp(a.on_error)) { +#else + if (setjmp(a.on_error)) { +#endif + if (NULL != a.parent) { + janet_asm_deinit(&a); + a.parent->errmessage = a.errmessage; + janet_asm_longjmp(a.parent); + } + result.funcdef = NULL; + result.error = a.errmessage; + result.status = JANET_ASSEMBLE_ERROR; + janet_asm_deinit(&a); + return result; + } + + janet_asm_assert(&a, + janet_checktype(s, JANET_STRUCT) || + janet_checktype(s, JANET_TABLE), + "expected struct or table for assembly source"); + + /* Check for function name */ + a.name = janet_get1(s, janet_ckeywordv("name")); + if (!janet_checktype(a.name, JANET_NIL)) { + def->name = janet_to_string(a.name); + } + + /* Set function arity */ + x = janet_get1(s, janet_ckeywordv("arity")); + def->arity = janet_checkint(x) ? janet_unwrap_integer(x) : 0; + janet_asm_assert(&a, def->arity >= 0, "arity must be non-negative"); + + x = janet_get1(s, janet_ckeywordv("max-arity")); + def->max_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity; + janet_asm_assert(&a, def->max_arity >= def->arity, "max-arity must be greater than or equal to arity"); + + x = janet_get1(s, janet_ckeywordv("min-arity")); + def->min_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity; + janet_asm_assert(&a, def->min_arity <= def->arity, "min-arity must be less than or equal to arity"); + + /* Check vararg */ + x = janet_get1(s, janet_ckeywordv("vararg")); + if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_VARARG; + + /* Initialize slotcount */ + def->slotcount = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG) + def->arity; + + /* Check structarg */ + x = janet_get1(s, janet_ckeywordv("structarg")); + if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG; + + /* Check source */ + x = janet_get1(s, janet_ckeywordv("source")); + if (janet_checktype(x, JANET_STRING)) def->source = janet_unwrap_string(x); + + /* Create slot aliases */ + x = janet_get1(s, janet_ckeywordv("slots")); + if (janet_indexed_view(x, &arr, &count)) { + for (i = 0; i < count; i++) { + Janet v = arr[i]; + if (janet_checktype(v, JANET_TUPLE)) { + const Janet *t = janet_unwrap_tuple(v); + int32_t j; + for (j = 0; j < janet_tuple_length(t); j++) { + if (!janet_checktype(t[j], JANET_SYMBOL)) + janet_asm_error(&a, "slot names must be symbols"); + janet_table_put(&a.slots, t[j], janet_wrap_integer(i)); + } + } else if (janet_checktype(v, JANET_SYMBOL)) { + janet_table_put(&a.slots, v, janet_wrap_integer(i)); + } else { + janet_asm_error(&a, "slot names must be symbols or tuple of symbols"); + } + } + } + + /* Parse constants */ + x = janet_get1(s, janet_ckeywordv("constants")); + if (janet_indexed_view(x, &arr, &count)) { + def->constants_length = count; + def->constants = janet_malloc(sizeof(Janet) * (size_t) count); + if (NULL == def->constants) { + JANET_OUT_OF_MEMORY; + } + for (i = 0; i < count; i++) { + Janet ct = arr[i]; + def->constants[i] = ct; + } + } else { + def->constants = NULL; + def->constants_length = 0; + } + + /* Parse sub funcdefs */ + x = janet_get1(s, janet_ckeywordv("closures")); + if (janet_checktype(x, JANET_NIL)) { + x = janet_get1(s, janet_ckeywordv("defs")); + } + if (janet_indexed_view(x, &arr, &count)) { + int32_t i; + for (i = 0; i < count; i++) { + JanetAssembleResult subres; + Janet subname; + int32_t newlen; + subres = janet_asm1(&a, arr[i], flags); + if (subres.status != JANET_ASSEMBLE_OK) { + janet_asm_errorv(&a, subres.error); + } + subname = janet_get1(arr[i], janet_ckeywordv("name")); + if (!janet_checktype(subname, JANET_NIL)) { + janet_table_put(&a.defs, subname, janet_wrap_integer(def->defs_length)); + } + newlen = def->defs_length + 1; + if (a.defs_capacity < newlen) { + int32_t newcap = newlen; + def->defs = janet_realloc(def->defs, newcap * sizeof(JanetFuncDef *)); + if (NULL == def->defs) { + JANET_OUT_OF_MEMORY; + } + a.defs_capacity = newcap; + } + def->defs[def->defs_length] = subres.funcdef; + def->defs_length = newlen; + } + } + + /* Parse bytecode and labels */ + x = janet_get1(s, janet_ckeywordv("bytecode")); + if (janet_indexed_view(x, &arr, &count)) { + /* Do labels and find length */ + int32_t blength = 0; + for (i = 0; i < count; ++i) { + Janet instr = arr[i]; + if (janet_checktype(instr, JANET_KEYWORD)) { + janet_table_put(&a.labels, instr, janet_wrap_integer(blength)); + } else if (janet_checktype(instr, JANET_TUPLE)) { + blength++; + } else { + a.errindex = i; + janet_asm_error(&a, "expected assembly instruction"); + } + } + /* Allocate bytecode array */ + def->bytecode_length = blength; + def->bytecode = janet_malloc(sizeof(uint32_t) * (size_t) blength); + if (NULL == def->bytecode) { + JANET_OUT_OF_MEMORY; + } + /* Do bytecode */ + for (i = 0; i < count; ++i) { + Janet instr = arr[i]; + if (janet_checktype(instr, JANET_KEYWORD)) { + continue; + } else { + uint32_t op; + const JanetInstructionDef *idef; + const Janet *t; + a.errindex = i; + janet_asm_assert(&a, janet_checktype(instr, JANET_TUPLE), "expected tuple"); + t = janet_unwrap_tuple(instr); + if (janet_tuple_length(t) == 0) { + op = 0; + } else { + janet_asm_assert(&a, janet_checktype(t[0], JANET_SYMBOL), + "expected symbol in assembly instruction"); + idef = janet_strbinsearch( + &janet_ops, + sizeof(janet_ops) / sizeof(JanetInstructionDef), + sizeof(JanetInstructionDef), + janet_unwrap_symbol(t[0])); + if (NULL == idef) + janet_asm_errorv(&a, janet_formatc("unknown instruction %v", t[0])); + op = read_instruction(&a, idef, t); + } + def->bytecode[a.bytecode_count++] = op; + } + } + } else { + janet_asm_error(&a, "bytecode expected"); + } + a.errindex = -1; + + /* Check for source mapping */ + x = janet_get1(s, janet_ckeywordv("sourcemap")); + if (janet_indexed_view(x, &arr, &count)) { + janet_asm_assert(&a, count == def->bytecode_length, "sourcemap must have the same length as the bytecode"); + def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) count); + if (NULL == def->sourcemap) { + JANET_OUT_OF_MEMORY; + } + for (i = 0; i < count; i++) { + const Janet *tup; + Janet entry = arr[i]; + JanetSourceMapping mapping; + if (!janet_checktype(entry, JANET_TUPLE)) { + janet_asm_error(&a, "expected tuple"); + } + tup = janet_unwrap_tuple(entry); + if (!janet_checkint(tup[0])) { + janet_asm_error(&a, "expected integer"); + } + if (!janet_checkint(tup[1])) { + janet_asm_error(&a, "expected integer"); + } + mapping.line = janet_unwrap_integer(tup[0]); + mapping.column = janet_unwrap_integer(tup[1]); + def->sourcemap[i] = mapping; + } + } + + /* Set symbolmap */ + def->symbolmap = NULL; + def->symbolmap_length = 0; + x = janet_get1(s, janet_ckeywordv("symbolmap")); + if (janet_indexed_view(x, &arr, &count)) { + def->symbolmap_length = count; + def->symbolmap = janet_malloc(sizeof(JanetSymbolMap) * (size_t)count); + if (NULL == def->symbolmap) { + JANET_OUT_OF_MEMORY; + } + for (i = 0; i < count; i++) { + const Janet *tup; + Janet entry = arr[i]; + JanetSymbolMap ss; + if (!janet_checktype(entry, JANET_TUPLE)) { + janet_asm_error(&a, "expected tuple"); + } + tup = janet_unwrap_tuple(entry); + if (janet_keyeq(tup[0], "upvalue")) { + ss.birth_pc = UINT32_MAX; + } else if (!janet_checkint(tup[0])) { + janet_asm_error(&a, "expected integer"); + } else { + ss.birth_pc = janet_unwrap_integer(tup[0]); + } + if (!janet_checkint(tup[1])) { + janet_asm_error(&a, "expected integer"); + } + if (!janet_checkint(tup[2])) { + janet_asm_error(&a, "expected integer"); + } + if (!janet_checktype(tup[3], JANET_SYMBOL)) { + janet_asm_error(&a, "expected symbol"); + } + ss.death_pc = janet_unwrap_integer(tup[1]); + ss.slot_index = janet_unwrap_integer(tup[2]); + ss.symbol = janet_unwrap_symbol(tup[3]); + def->symbolmap[i] = ss; + } + } + if (def->symbolmap_length) def->flags |= JANET_FUNCDEF_FLAG_HASSYMBOLMAP; + + /* Set environments */ + x = janet_get1(s, janet_ckeywordv("environments")); + if (janet_indexed_view(x, &arr, &count)) { + def->environments_length = count; + if (def->environments_length) { + def->environments = janet_realloc(def->environments, def->environments_length * sizeof(int32_t)); + } + for (int32_t i = 0; i < count; i++) { + if (!janet_checkint(arr[i])) { + janet_asm_error(&a, "expected integer"); + } + def->environments[i] = janet_unwrap_integer(arr[i]); + } + } + if (def->environments_length && NULL == def->environments) { + JANET_OUT_OF_MEMORY; + } + + /* Verify the func def */ + int verify_status = janet_verify(def); + if (verify_status) { + janet_asm_errorv(&a, janet_formatc("invalid assembly (%d)", verify_status)); + } + + /* Add final flags */ + janet_def_addflags(def); + + /* Finish everything and return funcdef */ + janet_asm_deinit(&a); + result.error = NULL; + result.funcdef = def; + result.status = JANET_ASSEMBLE_OK; + return result; +} + +/* Assemble a function */ +JanetAssembleResult janet_asm(Janet source, int flags) { + return janet_asm1(NULL, source, flags); +} + +/* Disassembly */ + +/* Find the definition of an instruction given the instruction word. Return + * NULL if not found. */ +static const JanetInstructionDef *janet_asm_reverse_lookup(uint32_t instr) { + size_t i; + uint32_t opcode = instr & 0x7F; + for (i = 0; i < sizeof(janet_ops) / sizeof(JanetInstructionDef); i++) { + const JanetInstructionDef *def = janet_ops + i; + if (def->opcode == opcode) + return def; + } + return NULL; +} + +/* Create some constant sized tuples */ +static const Janet *tup1(Janet x) { + Janet *tup = janet_tuple_begin(1); + tup[0] = x; + return janet_tuple_end(tup); +} +static const Janet *tup2(Janet x, Janet y) { + Janet *tup = janet_tuple_begin(2); + tup[0] = x; + tup[1] = y; + return janet_tuple_end(tup); +} +static const Janet *tup3(Janet x, Janet y, Janet z) { + Janet *tup = janet_tuple_begin(3); + tup[0] = x; + tup[1] = y; + tup[2] = z; + return janet_tuple_end(tup); +} +static const Janet *tup4(Janet w, Janet x, Janet y, Janet z) { + Janet *tup = janet_tuple_begin(4); + tup[0] = w; + tup[1] = x; + tup[2] = y; + tup[3] = z; + return janet_tuple_end(tup); +} + +/* Given an argument, convert it to the appropriate integer or symbol */ +Janet janet_asm_decode_instruction(uint32_t instr) { + const JanetInstructionDef *def = janet_asm_reverse_lookup(instr); + Janet name; + if (NULL == def) { + return janet_wrap_integer((int32_t)instr); + } + name = janet_csymbolv(def->name); + const Janet *ret = NULL; +#define oparg(shift, mask) ((instr >> ((shift) << 3)) & (mask)) + switch (janet_instructions[def->opcode]) { + case JINT_0: + ret = tup1(name); + break; + case JINT_S: + ret = tup2(name, janet_wrap_integer(oparg(1, 0xFFFFFF))); + break; + case JINT_L: + ret = tup2(name, janet_wrap_integer((int32_t)instr >> 8)); + break; + case JINT_SS: + case JINT_ST: + case JINT_SC: + case JINT_SU: + case JINT_SD: + ret = tup3(name, + janet_wrap_integer(oparg(1, 0xFF)), + janet_wrap_integer(oparg(2, 0xFFFF))); + break; + case JINT_SI: + case JINT_SL: + ret = tup3(name, + janet_wrap_integer(oparg(1, 0xFF)), + janet_wrap_integer((int32_t)instr >> 16)); + break; + case JINT_SSS: + case JINT_SES: + case JINT_SSU: + ret = tup4(name, + janet_wrap_integer(oparg(1, 0xFF)), + janet_wrap_integer(oparg(2, 0xFF)), + janet_wrap_integer(oparg(3, 0xFF))); + break; + case JINT_SSI: + ret = tup4(name, + janet_wrap_integer(oparg(1, 0xFF)), + janet_wrap_integer(oparg(2, 0xFF)), + janet_wrap_integer((int32_t)instr >> 24)); + break; + } +#undef oparg + if (ret) { + /* Check if break point set */ + if (instr & 0x80) { + janet_tuple_flag(ret) |= JANET_TUPLE_FLAG_BRACKETCTOR; + } + return janet_wrap_tuple(ret); + } + return janet_wrap_nil(); +} + +/* + * Disasm sections + */ + +static Janet janet_disasm_arity(JanetFuncDef *def) { + return janet_wrap_integer(def->arity); +} + +static Janet janet_disasm_min_arity(JanetFuncDef *def) { + return janet_wrap_integer(def->min_arity); +} + +static Janet janet_disasm_max_arity(JanetFuncDef *def) { + return janet_wrap_integer(def->max_arity); +} + +static Janet janet_disasm_slotcount(JanetFuncDef *def) { + return janet_wrap_integer(def->slotcount); +} + +static Janet janet_disasm_symbolslots(JanetFuncDef *def) { + if (def->symbolmap == NULL) { + return janet_wrap_nil(); + } + JanetArray *symbolslots = janet_array(def->symbolmap_length); + Janet upvaluekw = janet_ckeywordv("upvalue"); + for (int32_t i = 0; i < def->symbolmap_length; i++) { + JanetSymbolMap ss = def->symbolmap[i]; + Janet *t = janet_tuple_begin(4); + if (ss.birth_pc == UINT32_MAX) { + t[0] = upvaluekw; + } else { + t[0] = janet_wrap_integer(ss.birth_pc); + } + t[1] = janet_wrap_integer(ss.death_pc); + t[2] = janet_wrap_integer(ss.slot_index); + t[3] = janet_wrap_symbol(ss.symbol); + symbolslots->data[i] = janet_wrap_tuple(janet_tuple_end(t)); + } + symbolslots->count = def->symbolmap_length; + return janet_wrap_array(symbolslots); +} + +static Janet janet_disasm_bytecode(JanetFuncDef *def) { + JanetArray *bcode = janet_array(def->bytecode_length); + for (int32_t i = 0; i < def->bytecode_length; i++) { + bcode->data[i] = janet_asm_decode_instruction(def->bytecode[i]); + } + bcode->count = def->bytecode_length; + return janet_wrap_array(bcode); +} + +static Janet janet_disasm_source(JanetFuncDef *def) { + if (def->source != NULL) return janet_wrap_string(def->source); + return janet_wrap_nil(); +} + +static Janet janet_disasm_name(JanetFuncDef *def) { + if (def->name != NULL) return janet_wrap_string(def->name); + return janet_wrap_nil(); +} + +static Janet janet_disasm_vararg(JanetFuncDef *def) { + return janet_wrap_boolean(def->flags & JANET_FUNCDEF_FLAG_VARARG); +} + +static Janet janet_disasm_structarg(JanetFuncDef *def) { + return janet_wrap_boolean(def->flags & JANET_FUNCDEF_FLAG_STRUCTARG); +} + +static Janet janet_disasm_constants(JanetFuncDef *def) { + JanetArray *constants = janet_array(def->constants_length); + for (int32_t i = 0; i < def->constants_length; i++) { + constants->data[i] = def->constants[i]; + } + constants->count = def->constants_length; + return janet_wrap_array(constants); +} + +static Janet janet_disasm_sourcemap(JanetFuncDef *def) { + if (NULL == def->sourcemap) return janet_wrap_nil(); + JanetArray *sourcemap = janet_array(def->bytecode_length); + for (int32_t i = 0; i < def->bytecode_length; i++) { + Janet *t = janet_tuple_begin(2); + JanetSourceMapping mapping = def->sourcemap[i]; + t[0] = janet_wrap_integer(mapping.line); + t[1] = janet_wrap_integer(mapping.column); + sourcemap->data[i] = janet_wrap_tuple(janet_tuple_end(t)); + } + sourcemap->count = def->bytecode_length; + return janet_wrap_array(sourcemap); +} + +static Janet janet_disasm_environments(JanetFuncDef *def) { + JanetArray *envs = janet_array(def->environments_length); + for (int32_t i = 0; i < def->environments_length; i++) { + envs->data[i] = janet_wrap_integer(def->environments[i]); + } + envs->count = def->environments_length; + return janet_wrap_array(envs); +} + +static Janet janet_disasm_defs(JanetFuncDef *def) { + JanetArray *defs = janet_array(def->defs_length); + for (int32_t i = 0; i < def->defs_length; i++) { + defs->data[i] = janet_disasm(def->defs[i]); + } + defs->count = def->defs_length; + return janet_wrap_array(defs); +} + +Janet janet_disasm(JanetFuncDef *def) { + JanetTable *ret = janet_table(10); + janet_table_put(ret, janet_ckeywordv("arity"), janet_disasm_arity(def)); + janet_table_put(ret, janet_ckeywordv("min-arity"), janet_disasm_min_arity(def)); + janet_table_put(ret, janet_ckeywordv("max-arity"), janet_disasm_max_arity(def)); + janet_table_put(ret, janet_ckeywordv("bytecode"), janet_disasm_bytecode(def)); + janet_table_put(ret, janet_ckeywordv("source"), janet_disasm_source(def)); + janet_table_put(ret, janet_ckeywordv("vararg"), janet_disasm_vararg(def)); + janet_table_put(ret, janet_ckeywordv("structarg"), janet_disasm_structarg(def)); + janet_table_put(ret, janet_ckeywordv("name"), janet_disasm_name(def)); + janet_table_put(ret, janet_ckeywordv("slotcount"), janet_disasm_slotcount(def)); + janet_table_put(ret, janet_ckeywordv("symbolmap"), janet_disasm_symbolslots(def)); + janet_table_put(ret, janet_ckeywordv("constants"), janet_disasm_constants(def)); + janet_table_put(ret, janet_ckeywordv("sourcemap"), janet_disasm_sourcemap(def)); + janet_table_put(ret, janet_ckeywordv("environments"), janet_disasm_environments(def)); + janet_table_put(ret, janet_ckeywordv("defs"), janet_disasm_defs(def)); + return janet_wrap_struct(janet_table_to_struct(ret)); +} + +JANET_CORE_FN(cfun_asm, + "(asm assembly)", + "Returns a new function that is the compiled result of the assembly.\n" + "The syntax for the assembly can be found on the Janet website, and should correspond\n" + "to the return value of disasm. Will throw an\n" + "error on invalid assembly.") { + janet_fixarity(argc, 1); + JanetAssembleResult res; + res = janet_asm(argv[0], 0); + if (res.status != JANET_ASSEMBLE_OK) { + janet_panics(res.error ? res.error : janet_cstring("invalid assembly")); + } + return janet_wrap_function(janet_thunk(res.funcdef)); +} + +JANET_CORE_FN(cfun_disasm, + "(disasm func &opt field)", + "Returns assembly that could be used to compile the given function. " + "func must be a function, not a c function. Will throw on error on a badly " + "typed argument. If given a field name, will only return that part of the function assembly. " + "Possible fields are:\n\n" + "* :arity - number of required and optional arguments.\n" + "* :min-arity - minimum number of arguments function can be called with.\n" + "* :max-arity - maximum number of arguments function can be called with.\n" + "* :vararg - true if function can take a variable number of arguments.\n" + "* :bytecode - array of parsed bytecode instructions. Each instruction is a tuple.\n" + "* :source - name of source file that this function was compiled from.\n" + "* :name - name of function.\n" + "* :slotcount - how many virtual registers, or slots, this function uses. Corresponds to stack space used by function.\n" + "* :symbolmap - all symbols and their slots.\n" + "* :constants - an array of constants referenced by this function.\n" + "* :sourcemap - a mapping of each bytecode instruction to a line and column in the source file.\n" + "* :environments - an internal mapping of which enclosing functions are referenced for bindings.\n" + "* :defs - other function definitions that this function may instantiate.\n") { + janet_arity(argc, 1, 2); + JanetFunction *f = janet_getfunction(argv, 0); + if (argc == 2) { + JanetKeyword kw = janet_getkeyword(argv, 1); + if (!janet_cstrcmp(kw, "arity")) return janet_disasm_arity(f->def); + if (!janet_cstrcmp(kw, "min-arity")) return janet_disasm_min_arity(f->def); + if (!janet_cstrcmp(kw, "max-arity")) return janet_disasm_max_arity(f->def); + if (!janet_cstrcmp(kw, "bytecode")) return janet_disasm_bytecode(f->def); + if (!janet_cstrcmp(kw, "source")) return janet_disasm_source(f->def); + if (!janet_cstrcmp(kw, "name")) return janet_disasm_name(f->def); + if (!janet_cstrcmp(kw, "vararg")) return janet_disasm_vararg(f->def); + if (!janet_cstrcmp(kw, "structarg")) return janet_disasm_structarg(f->def); + if (!janet_cstrcmp(kw, "slotcount")) return janet_disasm_slotcount(f->def); + if (!janet_cstrcmp(kw, "constants")) return janet_disasm_constants(f->def); + if (!janet_cstrcmp(kw, "sourcemap")) return janet_disasm_sourcemap(f->def); + if (!janet_cstrcmp(kw, "environments")) return janet_disasm_environments(f->def); + if (!janet_cstrcmp(kw, "defs")) return janet_disasm_defs(f->def); + janet_panicf("unknown disasm key %v", argv[1]); + } else { + return janet_disasm(f->def); + } +} + +/* Load the library */ +void janet_lib_asm(JanetTable *env) { + JanetRegExt asm_cfuns[] = { + JANET_CORE_REG("asm", cfun_asm), + JANET_CORE_REG("disasm", cfun_disasm), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, asm_cfuns); +} + +#endif + + +/* src/core/buffer.c */ +#line 0 "src/core/buffer.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include "state.h" +#endif + +/* Allow for managed buffers that cannot realloc/free their backing memory */ +static void janet_buffer_can_realloc(JanetBuffer *buffer) { + if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { + janet_panic("buffer cannot reallocate foreign memory"); + } +} + +/* Initialize a buffer */ +static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { + uint8_t *data = NULL; + if (capacity < 4) capacity = 4; + janet_gcpressure(capacity); + data = janet_malloc(sizeof(uint8_t) * (size_t) capacity); + if (NULL == data) { + JANET_OUT_OF_MEMORY; + } + buffer->count = 0; + buffer->capacity = capacity; + buffer->data = data; + return buffer; +} + +/* Initialize a buffer */ +JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { + janet_buffer_init_impl(buffer, capacity); + buffer->gc.data.next = NULL; + buffer->gc.flags = JANET_MEM_DISABLED; + return buffer; +} + +/* Initialize an unmanaged buffer */ +JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count) { + if (count < 0) janet_panic("count < 0"); + if (capacity < count) janet_panic("capacity < count"); + JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); + buffer->gc.flags |= JANET_BUFFER_FLAG_NO_REALLOC; + buffer->capacity = capacity; + buffer->count = count; + buffer->data = (uint8_t *) memory; + return buffer; +} + +/* Deinitialize a buffer (free data memory) */ +void janet_buffer_deinit(JanetBuffer *buffer) { + if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { + janet_free(buffer->data); + } +} + +/* Initialize a buffer */ +JanetBuffer *janet_buffer(int32_t capacity) { + JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); + return janet_buffer_init_impl(buffer, capacity); +} + +/* Ensure that the buffer has enough internal capacity */ +void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) { + uint8_t *new_data; + uint8_t *old = buffer->data; + if (capacity <= buffer->capacity) return; + janet_buffer_can_realloc(buffer); + int64_t big_capacity = ((int64_t) capacity) * growth; + capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity; + janet_gcpressure(capacity - buffer->capacity); + new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t)); + if (NULL == new_data) { + JANET_OUT_OF_MEMORY; + } + buffer->data = new_data; + buffer->capacity = capacity; +} + +/* Ensure that the buffer has enough internal capacity */ +void janet_buffer_setcount(JanetBuffer *buffer, int32_t count) { + if (count < 0) + return; + if (count > buffer->count) { + int32_t oldcount = buffer->count; + janet_buffer_ensure(buffer, count, 1); + memset(buffer->data + oldcount, 0, count - oldcount); + } + buffer->count = count; +} + +/* Adds capacity for enough extra bytes to the buffer. Ensures that the + * next n bytes pushed to the buffer will not cause a reallocation */ +void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { + /* Check for buffer overflow */ + if ((int64_t)n + buffer->count > INT32_MAX) { + janet_panic("buffer overflow"); + } + int32_t new_size = buffer->count + n; + if (new_size > buffer->capacity) { + janet_buffer_can_realloc(buffer); + int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); + uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); + janet_gcpressure(new_capacity - buffer->capacity); + if (NULL == new_data) { + JANET_OUT_OF_MEMORY; + } + buffer->data = new_data; + buffer->capacity = new_capacity; + } +} + +/* Push a cstring to buffer */ +void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { + int32_t len = (int32_t) strlen(cstring); + janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); +} + +/* Push multiple bytes into the buffer */ +void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { + if (0 == length) return; + janet_buffer_extra(buffer, length); + memcpy(buffer->data + buffer->count, string, length); + buffer->count += length; +} + +void janet_buffer_push_string(JanetBuffer *buffer, const uint8_t *string) { + janet_buffer_push_bytes(buffer, string, janet_string_length(string)); +} + +/* Push a single byte to the buffer */ +void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { + janet_buffer_extra(buffer, 1); + buffer->data[buffer->count] = byte; + buffer->count++; +} + +/* Push a 16 bit unsigned integer to the buffer */ +void janet_buffer_push_u16(JanetBuffer *buffer, uint16_t x) { + janet_buffer_extra(buffer, 2); + buffer->data[buffer->count] = x & 0xFF; + buffer->data[buffer->count + 1] = (x >> 8) & 0xFF; + buffer->count += 2; +} + +/* Push a 32 bit unsigned integer to the buffer */ +void janet_buffer_push_u32(JanetBuffer *buffer, uint32_t x) { + janet_buffer_extra(buffer, 4); + buffer->data[buffer->count] = x & 0xFF; + buffer->data[buffer->count + 1] = (x >> 8) & 0xFF; + buffer->data[buffer->count + 2] = (x >> 16) & 0xFF; + buffer->data[buffer->count + 3] = (x >> 24) & 0xFF; + buffer->count += 4; +} + +/* Push a 64 bit unsigned integer to the buffer */ +void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x) { + janet_buffer_extra(buffer, 8); + buffer->data[buffer->count] = x & 0xFF; + buffer->data[buffer->count + 1] = (x >> 8) & 0xFF; + buffer->data[buffer->count + 2] = (x >> 16) & 0xFF; + buffer->data[buffer->count + 3] = (x >> 24) & 0xFF; + buffer->data[buffer->count + 4] = (x >> 32) & 0xFF; + buffer->data[buffer->count + 5] = (x >> 40) & 0xFF; + buffer->data[buffer->count + 6] = (x >> 48) & 0xFF; + buffer->data[buffer->count + 7] = (x >> 56) & 0xFF; + buffer->count += 8; +} + +/* C functions */ + +JANET_CORE_FN(cfun_buffer_new, + "(buffer/new capacity)", + "Creates a new, empty buffer with enough backing memory for `capacity` bytes. " + "Returns a new buffer of length 0.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getinteger(argv, 0); + JanetBuffer *buffer = janet_buffer(cap); + return janet_wrap_buffer(buffer); +} + +JANET_CORE_FN(cfun_buffer_new_filled, + "(buffer/new-filled count &opt byte)", + "Creates a new buffer of length `count` filled with `byte`. By default, `byte` is 0. " + "Returns the new buffer.") { + janet_arity(argc, 1, 2); + int32_t count = janet_getinteger(argv, 0); + if (count < 0) count = 0; + int32_t byte = 0; + if (argc == 2) { + byte = janet_getinteger(argv, 1) & 0xFF; + } + JanetBuffer *buffer = janet_buffer(count); + if (buffer->data && count > 0) + memset(buffer->data, byte, count); + buffer->count = count; + return janet_wrap_buffer(buffer); +} + +JANET_CORE_FN(cfun_buffer_frombytes, + "(buffer/from-bytes & byte-vals)", + "Creates a buffer from integer parameters with byte values. All integers " + "will be coerced to the range of 1 byte 0-255.") { + int32_t i; + JanetBuffer *buffer = janet_buffer(argc); + for (i = 0; i < argc; i++) { + int32_t c = janet_getinteger(argv, i); + buffer->data[i] = c & 0xFF; + } + buffer->count = argc; + return janet_wrap_buffer(buffer); +} + +JANET_CORE_FN(cfun_buffer_fill, + "(buffer/fill buffer &opt byte)", + "Fill up a buffer with bytes, defaulting to 0s. Does not change the buffer's length. " + "Returns the modified buffer.") { + janet_arity(argc, 1, 2); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int32_t byte = 0; + if (argc == 2) { + byte = janet_getinteger(argv, 1) & 0xFF; + } + if (buffer->count) { + memset(buffer->data, byte, buffer->count); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_trim, + "(buffer/trim buffer)", + "Set the backing capacity of the buffer to the current length of the buffer. Returns the " + "modified buffer.") { + janet_fixarity(argc, 1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + janet_buffer_can_realloc(buffer); + if (buffer->count < buffer->capacity) { + int32_t newcap = buffer->count > 4 ? buffer->count : 4; + uint8_t *newData = janet_realloc(buffer->data, newcap); + if (NULL == newData) { + JANET_OUT_OF_MEMORY; + } + buffer->data = newData; + buffer->capacity = newcap; + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_u8, + "(buffer/push-byte buffer & xs)", + "Append bytes to a buffer. Will expand the buffer as necessary. " + "Returns the modified buffer. Will throw an error if the buffer overflows.") { + int32_t i; + janet_arity(argc, 1, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + for (i = 1; i < argc; i++) { + janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF)); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_word, + "(buffer/push-word buffer & xs)", + "Append machine words to a buffer. The 4 bytes of the integer are appended " + "in twos complement, little endian order, unsigned for all x. Returns the modified buffer. Will " + "throw an error if the buffer overflows.") { + int32_t i; + janet_arity(argc, 1, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + for (i = 1; i < argc; i++) { + double number = janet_getnumber(argv, i); + uint32_t word = (uint32_t) number; + if (word != number) + janet_panicf("cannot convert %v to machine word", argv[i]); + janet_buffer_push_u32(buffer, word); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_chars, + "(buffer/push-string buffer & xs)", + "Push byte sequences onto the end of a buffer. " + "Will accept any of strings, keywords, symbols, and buffers. " + "Returns the modified buffer. " + "Will throw an error if the buffer overflows.") { + int32_t i; + janet_arity(argc, 1, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + for (i = 1; i < argc; i++) { + JanetByteView view = janet_getbytes(argv, i); + if (view.bytes == buffer->data) { + janet_buffer_ensure(buffer, buffer->count + view.len, 2); + view.bytes = buffer->data; + } + janet_buffer_push_bytes(buffer, view.bytes, view.len); + } + return argv[0]; +} + +static int should_reverse_bytes(const Janet *argv, int32_t argc) { + JanetKeyword order_kw = janet_getkeyword(argv, argc); + if (!janet_cstrcmp(order_kw, "le")) { +#if JANET_BIG_ENDIAN + return 1; +#endif + } else if (!janet_cstrcmp(order_kw, "be")) { +#if JANET_LITTLE_ENDIAN + return 1; +#endif + } else if (!janet_cstrcmp(order_kw, "native")) { + return 0; + } else { + janet_panicf("expected endianness :le, :be or :native, got %v", argv[1]); + } + return 0; +} + +static void reverse_u32(uint8_t bytes[4]) { + uint8_t temp; + temp = bytes[3]; + bytes[3] = bytes[0]; + bytes[0] = temp; + temp = bytes[2]; + bytes[2] = bytes[1]; + bytes[1] = temp; +} + +static void reverse_u64(uint8_t bytes[8]) { + uint8_t temp; + temp = bytes[7]; + bytes[7] = bytes[0]; + bytes[0] = temp; + temp = bytes[6]; + bytes[6] = bytes[1]; + bytes[1] = temp; + temp = bytes[5]; + bytes[5] = bytes[2]; + bytes[2] = temp; + temp = bytes[4]; + bytes[4] = bytes[3]; + bytes[3] = temp; +} + +JANET_CORE_FN(cfun_buffer_push_uint16, + "(buffer/push-uint16 buffer order data)", + "Push a 16 bit unsigned integer data onto the end of the buffer. " + "Returns the modified buffer.") { + janet_fixarity(argc, 3); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int reverse = should_reverse_bytes(argv, 1); + union { + uint16_t data; + uint8_t bytes[2]; + } u; + u.data = (uint16_t) janet_getinteger(argv, 2); + if (reverse) { + uint8_t temp = u.bytes[1]; + u.bytes[1] = u.bytes[0]; + u.bytes[0] = temp; + } + janet_buffer_push_u16(buffer, *(uint16_t *) u.bytes); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_push_uint32, + "(buffer/push-uint32 buffer order data)", + "Push a 32 bit unsigned integer data onto the end of the buffer. " + "Returns the modified buffer.") { + janet_fixarity(argc, 3); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int reverse = should_reverse_bytes(argv, 1); + union { + uint32_t data; + uint8_t bytes[4]; + } u; + u.data = (uint32_t) janet_getinteger(argv, 2); + if (reverse) + reverse_u32(u.bytes); + janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_push_uint64, + "(buffer/push-uint64 buffer order data)", + "Push a 64 bit unsigned integer data onto the end of the buffer. " + "Returns the modified buffer.") { + janet_fixarity(argc, 3); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int reverse = should_reverse_bytes(argv, 1); + union { + uint64_t data; + uint8_t bytes[8]; + } u; + u.data = (uint64_t) janet_getuinteger64(argv, 2); + if (reverse) + reverse_u64(u.bytes); + janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_push_float32, + "(buffer/push-float32 buffer order data)", + "Push the underlying bytes of a 32 bit float data onto the end of the buffer. " + "Returns the modified buffer.") { + janet_fixarity(argc, 3); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int reverse = should_reverse_bytes(argv, 1); + union { + float data; + uint8_t bytes[4]; + } u; + u.data = (float) janet_getnumber(argv, 2); + if (reverse) + reverse_u32(u.bytes); + janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_push_float64, + "(buffer/push-float64 buffer order data)", + "Push the underlying bytes of a 64 bit float data onto the end of the buffer. " + "Returns the modified buffer.") { + janet_fixarity(argc, 3); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int reverse = should_reverse_bytes(argv, 1); + union { + double data; + uint8_t bytes[8]; + } u; + u.data = janet_getnumber(argv, 2); + if (reverse) + reverse_u64(u.bytes); + janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes); + return argv[0]; +} + +static void buffer_push_impl(JanetBuffer *buffer, Janet *argv, int32_t argc_offset, int32_t argc) { + for (int32_t i = argc_offset; i < argc; i++) { + if (janet_checktype(argv[i], JANET_NUMBER)) { + janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF)); + } else { + JanetByteView view = janet_getbytes(argv, i); + if (view.bytes == buffer->data) { + janet_buffer_ensure(buffer, buffer->count + view.len, 2); + view.bytes = buffer->data; + } + janet_buffer_push_bytes(buffer, view.bytes, view.len); + } + } +} + +JANET_CORE_FN(cfun_buffer_push_at, + "(buffer/push-at buffer index & xs)", + "Same as buffer/push, but copies the new data into the buffer " + " at index `index`.") { + janet_arity(argc, 2, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int32_t index = janet_getinteger(argv, 1); + int32_t old_count = buffer->count; + if (index < 0 || index > old_count) { + janet_panicf("index out of range [0, %d)", old_count); + } + buffer->count = index; + buffer_push_impl(buffer, argv, 2, argc); + if (buffer->count < old_count) { + buffer->count = old_count; + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_push, + "(buffer/push buffer & xs)", + "Push both individual bytes and byte sequences to a buffer. For each x in xs, " + "push the byte if x is an integer, otherwise push the bytesequence to the buffer. " + "Thus, this function behaves like both `buffer/push-string` and `buffer/push-byte`. " + "Returns the modified buffer. " + "Will throw an error if the buffer overflows.") { + janet_arity(argc, 1, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + buffer_push_impl(buffer, argv, 1, argc); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_clear, + "(buffer/clear buffer)", + "Sets the size of a buffer to 0 and empties it. The buffer retains " + "its memory so it can be efficiently refilled. Returns the modified buffer.") { + janet_fixarity(argc, 1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + buffer->count = 0; + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_popn, + "(buffer/popn buffer n)", + "Removes the last `n` bytes from the buffer. Returns the modified buffer.") { + janet_fixarity(argc, 2); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + int32_t n = janet_getinteger(argv, 1); + if (n < 0) janet_panic("n must be non-negative"); + if (buffer->count < n) { + buffer->count = 0; + } else { + buffer->count -= n; + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_slice, + "(buffer/slice bytes &opt start end)", + "Takes a slice of a byte sequence from `start` to `end`. The range is half open, " + "[start, end). Indexes can also be negative, indicating indexing from the end of the " + "end of the array. By default, `start` is 0 and `end` is the length of the buffer. " + "Returns a new buffer.") { + JanetByteView view = janet_getbytes(argv, 0); + JanetRange range = janet_getslice(argc, argv); + JanetBuffer *buffer = janet_buffer(range.end - range.start); + if (buffer->data) + memcpy(buffer->data, view.bytes + range.start, range.end - range.start); + buffer->count = range.end - range.start; + return janet_wrap_buffer(buffer); +} + +static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, int32_t *index, int *bit) { + janet_fixarity(argc, 2); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + double x = janet_getnumber(argv, 1); + int64_t bitindex = (int64_t) x; + int64_t byteindex = bitindex >> 3; + int which_bit = bitindex & 7; + if (bitindex != x || bitindex < 0 || byteindex >= buffer->count) + janet_panicf("invalid bit index %v", argv[1]); + *b = buffer; + *index = (int32_t) byteindex; + *bit = which_bit; +} + +JANET_CORE_FN(cfun_buffer_bitset, + "(buffer/bit-set buffer index)", + "Sets the bit at the given bit-index. Returns the buffer.") { + int bit; + int32_t index; + JanetBuffer *buffer; + bitloc(argc, argv, &buffer, &index, &bit); + buffer->data[index] |= 1 << bit; + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_bitclear, + "(buffer/bit-clear buffer index)", + "Clears the bit at the given bit-index. Returns the buffer.") { + int bit; + int32_t index; + JanetBuffer *buffer; + bitloc(argc, argv, &buffer, &index, &bit); + buffer->data[index] &= ~(1 << bit); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_bitget, + "(buffer/bit buffer index)", + "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.") { + int bit; + int32_t index; + JanetBuffer *buffer; + bitloc(argc, argv, &buffer, &index, &bit); + return janet_wrap_boolean(buffer->data[index] & (1 << bit)); +} + +JANET_CORE_FN(cfun_buffer_bittoggle, + "(buffer/bit-toggle buffer index)", + "Toggles the bit at the given bit index in buffer. Returns the buffer.") { + int bit; + int32_t index; + JanetBuffer *buffer; + bitloc(argc, argv, &buffer, &index, &bit); + buffer->data[index] ^= (1 << bit); + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_blit, + "(buffer/blit dest src &opt dest-start src-start src-end)", + "Insert the contents of `src` into `dest`. Can optionally take indices that " + "indicate which part of `src` to copy into which part of `dest`. Indices can be " + "negative in order to index from the end of `src` or `dest`. Returns `dest`.") { + janet_arity(argc, 2, 5); + JanetBuffer *dest = janet_getbuffer(argv, 0); + JanetByteView src = janet_getbytes(argv, 1); + int same_buf = src.bytes == dest->data; + int32_t offset_dest = 0; + int32_t offset_src = 0; + if (argc > 2 && !janet_checktype(argv[2], JANET_NIL)) + offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start"); + if (argc > 3 && !janet_checktype(argv[3], JANET_NIL)) + offset_src = janet_gethalfrange(argv, 3, src.len, "src-start"); + int32_t length_src; + if (argc > 4) { + int32_t src_end = src.len; + if (!janet_checktype(argv[4], JANET_NIL)) + src_end = janet_gethalfrange(argv, 4, src.len, "src-end"); + length_src = src_end - offset_src; + if (length_src < 0) length_src = 0; + } else { + length_src = src.len - offset_src; + } + int64_t last = (int64_t) offset_dest + length_src; + if (last > INT32_MAX) + janet_panic("buffer blit out of range"); + int32_t last32 = (int32_t) last; + janet_buffer_ensure(dest, last32, 2); + if (last32 > dest->count) dest->count = last32; + if (length_src) { + if (same_buf) { + /* janet_buffer_ensure may have invalidated src */ + src.bytes = dest->data; + memmove(dest->data + offset_dest, src.bytes + offset_src, length_src); + } else { + memcpy(dest->data + offset_dest, src.bytes + offset_src, length_src); + } + } + return argv[0]; +} + +JANET_CORE_FN(cfun_buffer_format, + "(buffer/format buffer format & args)", + "Snprintf like functionality for printing values into a buffer. Returns " + "the modified buffer.") { + janet_arity(argc, 2, -1); + JanetBuffer *buffer = janet_getbuffer(argv, 0); + const char *strfrmt = (const char *) janet_getstring(argv, 1); + janet_buffer_format(buffer, strfrmt, 1, argc, argv); + return argv[0]; +} + +void janet_lib_buffer(JanetTable *env) { + JanetRegExt buffer_cfuns[] = { + JANET_CORE_REG("buffer/new", cfun_buffer_new), + JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), + JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), + JANET_CORE_REG("buffer/fill", cfun_buffer_fill), + JANET_CORE_REG("buffer/trim", cfun_buffer_trim), + JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), + JANET_CORE_REG("buffer/push-word", cfun_buffer_word), + JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), + JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), + JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), + JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), + JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), + JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), + JANET_CORE_REG("buffer/push", cfun_buffer_push), + JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), + JANET_CORE_REG("buffer/popn", cfun_buffer_popn), + JANET_CORE_REG("buffer/clear", cfun_buffer_clear), + JANET_CORE_REG("buffer/slice", cfun_buffer_slice), + JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), + JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), + JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), + JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), + JANET_CORE_REG("buffer/blit", cfun_buffer_blit), + JANET_CORE_REG("buffer/format", cfun_buffer_format), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, buffer_cfuns); +} + + +/* src/core/bytecode.c */ +#line 0 "src/core/bytecode.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include "regalloc.h" +#endif + +/* Look up table for instructions */ +enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = { + JINT_0, /* JOP_NOOP, */ + JINT_S, /* JOP_ERROR, */ + JINT_ST, /* JOP_TYPECHECK, */ + JINT_S, /* JOP_RETURN, */ + JINT_0, /* JOP_RETURN_NIL, */ + JINT_SSI, /* JOP_ADD_IMMEDIATE, */ + JINT_SSS, /* JOP_ADD, */ + JINT_SSI, /* JOP_SUBTRACT_IMMEDIATE, */ + JINT_SSS, /* JOP_SUBTRACT, */ + JINT_SSI, /* JOP_MULTIPLY_IMMEDIATE, */ + JINT_SSS, /* JOP_MULTIPLY, */ + JINT_SSI, /* JOP_DIVIDE_IMMEDIATE, */ + JINT_SSS, /* JOP_DIVIDE, */ + JINT_SSS, /* JOP_DIVIDE_FLOOR */ + JINT_SSS, /* JOP_MODULO, */ + JINT_SSS, /* JOP_REMAINDER, */ + JINT_SSS, /* JOP_BAND, */ + JINT_SSS, /* JOP_BOR, */ + JINT_SSS, /* JOP_BXOR, */ + JINT_SS, /* JOP_BNOT, */ + JINT_SSS, /* JOP_SHIFT_LEFT, */ + JINT_SSI, /* JOP_SHIFT_LEFT_IMMEDIATE, */ + JINT_SSS, /* JOP_SHIFT_RIGHT, */ + JINT_SSI, /* JOP_SHIFT_RIGHT_IMMEDIATE, */ + JINT_SSS, /* JOP_SHIFT_RIGHT_UNSIGNED, */ + JINT_SSU, /* JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, */ + JINT_SS, /* JOP_MOVE_FAR, */ + JINT_SS, /* JOP_MOVE_NEAR, */ + JINT_L, /* JOP_JUMP, */ + JINT_SL, /* JOP_JUMP_IF, */ + JINT_SL, /* JOP_JUMP_IF_NOT, */ + JINT_SL, /* JOP_JUMP_IF_NIL, */ + JINT_SL, /* JOP_JUMP_IF_NOT_NIL, */ + JINT_SSS, /* JOP_GREATER_THAN, */ + JINT_SSI, /* JOP_GREATER_THAN_IMMEDIATE, */ + JINT_SSS, /* JOP_LESS_THAN, */ + JINT_SSI, /* JOP_LESS_THAN_IMMEDIATE, */ + JINT_SSS, /* JOP_EQUALS, */ + JINT_SSI, /* JOP_EQUALS_IMMEDIATE, */ + JINT_SSS, /* JOP_COMPARE, */ + JINT_S, /* JOP_LOAD_NIL, */ + JINT_S, /* JOP_LOAD_TRUE, */ + JINT_S, /* JOP_LOAD_FALSE, */ + JINT_SI, /* JOP_LOAD_INTEGER, */ + JINT_SC, /* JOP_LOAD_CONSTANT, */ + JINT_SES, /* JOP_LOAD_UPVALUE, */ + JINT_S, /* JOP_LOAD_SELF, */ + JINT_SES, /* JOP_SET_UPVALUE, */ + JINT_SD, /* JOP_CLOSURE, */ + JINT_S, /* JOP_PUSH, */ + JINT_SS, /* JOP_PUSH_2, */ + JINT_SSS, /* JOP_PUSH_3, */ + JINT_S, /* JOP_PUSH_ARRAY, */ + JINT_SS, /* JOP_CALL, */ + JINT_S, /* JOP_TAILCALL, */ + JINT_SSS, /* JOP_RESUME, */ + JINT_SSU, /* JOP_SIGNAL, */ + JINT_SSS, /* JOP_PROPAGATE */ + JINT_SSS, /* JOP_IN, */ + JINT_SSS, /* JOP_GET, */ + JINT_SSS, /* JOP_PUT, */ + JINT_SSU, /* JOP_GET_INDEX, */ + JINT_SSU, /* JOP_PUT_INDEX, */ + JINT_SS, /* JOP_LENGTH */ + JINT_S, /* JOP_MAKE_ARRAY */ + JINT_S, /* JOP_MAKE_BUFFER */ + JINT_S, /* JOP_MAKE_STRING */ + JINT_S, /* JOP_MAKE_STRUCT */ + JINT_S, /* JOP_MAKE_TABLE */ + JINT_S, /* JOP_MAKE_TUPLE */ + JINT_S, /* JOP_MAKE_BRACKET_TUPLE */ + JINT_SSS, /* JOP_GREATER_THAN_EQUAL */ + JINT_SSS, /* JOP_LESS_THAN_EQUAL */ + JINT_SSS, /* JOP_NEXT */ + JINT_SSS, /* JOP_NOT_EQUALS, */ + JINT_SSI, /* JOP_NOT_EQUALS_IMMEDIATE, */ + JINT_SSS /* JOP_CANCEL, */ +}; + +/* Remove all noops while preserving jumps and debugging information. + * Useful as part of a filtering compiler pass. */ +void janet_bytecode_remove_noops(JanetFuncDef *def) { + + /* Get an instruction rewrite map so we can rewrite jumps */ + uint32_t *pc_map = janet_smalloc(sizeof(uint32_t) * (1 + def->bytecode_length)); + uint32_t new_bytecode_length = 0; + for (int32_t i = 0; i < def->bytecode_length; i++) { + uint32_t instr = def->bytecode[i]; + uint32_t opcode = instr & 0x7F; + pc_map[i] = new_bytecode_length; + if (opcode != JOP_NOOP) { + new_bytecode_length++; + } + } + pc_map[def->bytecode_length] = new_bytecode_length; + + /* Linear scan rewrite bytecode and sourcemap. Also fix jumps. */ + int32_t j = 0; + for (int32_t i = 0; i < def->bytecode_length; i++) { + uint32_t instr = def->bytecode[i]; + uint32_t opcode = instr & 0x7F; + int32_t old_jump_target = 0; + int32_t new_jump_target = 0; + switch (opcode) { + case JOP_NOOP: + continue; + case JOP_JUMP: + /* relative pc is in DS field of instruction */ + old_jump_target = i + (((int32_t)instr) >> 8); + new_jump_target = pc_map[old_jump_target]; + instr += (new_jump_target - old_jump_target + (i - j)) << 8; + break; + case JOP_JUMP_IF: + case JOP_JUMP_IF_NIL: + case JOP_JUMP_IF_NOT: + case JOP_JUMP_IF_NOT_NIL: + /* relative pc is in ES field of instruction */ + old_jump_target = i + (((int32_t)instr) >> 16); + new_jump_target = pc_map[old_jump_target]; + instr += (new_jump_target - old_jump_target + (i - j)) << 16; + break; + default: + break; + } + def->bytecode[j] = instr; + if (def->sourcemap != NULL) { + def->sourcemap[j] = def->sourcemap[i]; + } + j++; + } + + /* Rewrite symbolmap */ + for (int32_t i = 0; i < def->symbolmap_length; i++) { + JanetSymbolMap *sm = def->symbolmap + i; + /* Don't rewrite upvalue mappings */ + if (sm->birth_pc < UINT32_MAX) { + sm->birth_pc = pc_map[sm->birth_pc]; + sm->death_pc = pc_map[sm->death_pc]; + } + } + + def->bytecode_length = new_bytecode_length; + def->bytecode = janet_realloc(def->bytecode, def->bytecode_length * sizeof(uint32_t)); + janet_sfree(pc_map); +} + +/* Remove redundant loads, moves and other instructions if possible and convert them to + * noops. Input is assumed valid bytecode. */ +void janet_bytecode_movopt(JanetFuncDef *def) { + JanetcRegisterAllocator ra; + int recur = 1; + + /* Iterate this until no more instructions can be removed. */ + while (recur) { + janetc_regalloc_init(&ra); + + /* Look for slots that have writes but no reads (and aren't in the closure bitset). */ + if (def->closure_bitset != NULL) { + for (int32_t i = 0; i < def->slotcount; i++) { + int32_t index = i >> 5; + uint32_t mask = 1U << (((uint32_t) i) & 31); + if (def->closure_bitset[index] & mask) { + janetc_regalloc_touch(&ra, i); + } + } + } + +#define AA ((instr >> 8) & 0xFF) +#define BB ((instr >> 16) & 0xFF) +#define CC (instr >> 24) +#define DD (instr >> 8) +#define EE (instr >> 16) + + /* Check reads and writes */ + for (int32_t i = 0; i < def->bytecode_length; i++) { + uint32_t instr = def->bytecode[i]; + switch (instr & 0x7F) { + + /* Group instructions my how they read from slots */ + + /* No reads or writes */ + default: + janet_assert(0, "unhandled instruction"); + case JOP_JUMP: + case JOP_NOOP: + case JOP_RETURN_NIL: + /* Write A */ + case JOP_LOAD_INTEGER: + case JOP_LOAD_CONSTANT: + case JOP_LOAD_UPVALUE: + case JOP_CLOSURE: + /* Write D */ + case JOP_LOAD_NIL: + case JOP_LOAD_TRUE: + case JOP_LOAD_FALSE: + case JOP_LOAD_SELF: + break; + case JOP_MAKE_ARRAY: + case JOP_MAKE_BUFFER: + case JOP_MAKE_STRING: + case JOP_MAKE_STRUCT: + case JOP_MAKE_TABLE: + case JOP_MAKE_TUPLE: + case JOP_MAKE_BRACKET_TUPLE: + /* Reads from the stack, don't remove */ + janetc_regalloc_touch(&ra, DD); + break; + + /* Read A */ + case JOP_ERROR: + case JOP_TYPECHECK: + case JOP_JUMP_IF: + case JOP_JUMP_IF_NOT: + case JOP_JUMP_IF_NIL: + case JOP_JUMP_IF_NOT_NIL: + case JOP_SET_UPVALUE: + /* Write E, Read A */ + case JOP_MOVE_FAR: + janetc_regalloc_touch(&ra, AA); + break; + + /* Read B */ + case JOP_SIGNAL: + /* Write A, Read B */ + case JOP_ADD_IMMEDIATE: + case JOP_SUBTRACT_IMMEDIATE: + case JOP_MULTIPLY_IMMEDIATE: + case JOP_DIVIDE_IMMEDIATE: + case JOP_SHIFT_LEFT_IMMEDIATE: + case JOP_SHIFT_RIGHT_IMMEDIATE: + case JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE: + case JOP_GREATER_THAN_IMMEDIATE: + case JOP_LESS_THAN_IMMEDIATE: + case JOP_EQUALS_IMMEDIATE: + case JOP_NOT_EQUALS_IMMEDIATE: + case JOP_GET_INDEX: + janetc_regalloc_touch(&ra, BB); + break; + + /* Read D */ + case JOP_RETURN: + case JOP_PUSH: + case JOP_PUSH_ARRAY: + case JOP_TAILCALL: + janetc_regalloc_touch(&ra, DD); + break; + + /* Write A, Read E */ + case JOP_MOVE_NEAR: + case JOP_LENGTH: + case JOP_BNOT: + case JOP_CALL: + janetc_regalloc_touch(&ra, EE); + break; + + /* Read A, B */ + case JOP_PUT_INDEX: + janetc_regalloc_touch(&ra, AA); + janetc_regalloc_touch(&ra, BB); + break; + + /* Read A, E */ + case JOP_PUSH_2: + janetc_regalloc_touch(&ra, AA); + janetc_regalloc_touch(&ra, EE); + break; + + /* Read B, C */ + case JOP_PROPAGATE: + /* Write A, Read B and C */ + case JOP_BAND: + case JOP_BOR: + case JOP_BXOR: + case JOP_ADD: + case JOP_SUBTRACT: + case JOP_MULTIPLY: + case JOP_DIVIDE: + case JOP_DIVIDE_FLOOR: + case JOP_MODULO: + case JOP_REMAINDER: + case JOP_SHIFT_LEFT: + case JOP_SHIFT_RIGHT: + case JOP_SHIFT_RIGHT_UNSIGNED: + case JOP_GREATER_THAN: + case JOP_LESS_THAN: + case JOP_EQUALS: + case JOP_COMPARE: + case JOP_IN: + case JOP_GET: + case JOP_GREATER_THAN_EQUAL: + case JOP_LESS_THAN_EQUAL: + case JOP_NOT_EQUALS: + case JOP_CANCEL: + case JOP_RESUME: + case JOP_NEXT: + janetc_regalloc_touch(&ra, BB); + janetc_regalloc_touch(&ra, CC); + break; + + /* Read A, B, C */ + case JOP_PUT: + case JOP_PUSH_3: + janetc_regalloc_touch(&ra, AA); + janetc_regalloc_touch(&ra, BB); + janetc_regalloc_touch(&ra, CC); + break; + } + } + + /* Iterate and set noops on instructions that make writes that no one ever reads. + * Only set noops for instructions with no side effects - moves, loads, etc. that can't + * raise errors (outside of systemic errors like oom or stack overflow). */ + recur = 0; + for (int32_t i = 0; i < def->bytecode_length; i++) { + uint32_t instr = def->bytecode[i]; + switch (instr & 0x7F) { + default: + break; + /* Write D */ + case JOP_LOAD_NIL: + case JOP_LOAD_TRUE: + case JOP_LOAD_FALSE: + case JOP_LOAD_SELF: + case JOP_MAKE_ARRAY: + case JOP_MAKE_TUPLE: + case JOP_MAKE_BRACKET_TUPLE: { + if (!janetc_regalloc_check(&ra, DD)) { + def->bytecode[i] = JOP_NOOP; + recur = 1; + } + } + break; + /* Write E, Read A */ + case JOP_MOVE_FAR: { + if (!janetc_regalloc_check(&ra, EE)) { + def->bytecode[i] = JOP_NOOP; + recur = 1; + } + } + break; + /* Write A, Read E */ + case JOP_MOVE_NEAR: + /* Write A, Read B */ + case JOP_GET_INDEX: + /* Write A */ + case JOP_LOAD_INTEGER: + case JOP_LOAD_CONSTANT: + case JOP_LOAD_UPVALUE: + case JOP_CLOSURE: { + if (!janetc_regalloc_check(&ra, AA)) { + def->bytecode[i] = JOP_NOOP; + recur = 1; + } + } + break; + } + } + + janetc_regalloc_deinit(&ra); +#undef AA +#undef BB +#undef CC +#undef DD +#undef EE + } +} + +/* Verify some bytecode */ +int janet_verify(JanetFuncDef *def) { + int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); + int32_t i; + int32_t maxslot = def->arity + vargs; + int32_t sc = def->slotcount; + + if (def->bytecode_length == 0) return 1; + + if (maxslot > sc) return 2; + + /* Verify each instruction */ + for (i = 0; i < def->bytecode_length; i++) { + uint32_t instr = def->bytecode[i]; + /* Check for invalid instructions */ + if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { + return 3; + } + enum JanetInstructionType type = janet_instructions[instr & 0x7F]; + switch (type) { + case JINT_0: + continue; + case JINT_S: { + if ((int32_t)(instr >> 8) >= sc) return 4; + continue; + } + case JINT_SI: + case JINT_SU: + case JINT_ST: { + if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; + continue; + } + case JINT_L: { + int32_t jumpdest = i + (((int32_t)instr) >> 8); + if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; + continue; + } + case JINT_SS: { + if ((int32_t)((instr >> 8) & 0xFF) >= sc || + (int32_t)(instr >> 16) >= sc) return 4; + continue; + } + case JINT_SSI: + case JINT_SSU: { + if ((int32_t)((instr >> 8) & 0xFF) >= sc || + (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; + continue; + } + case JINT_SL: { + int32_t jumpdest = i + (((int32_t)instr) >> 16); + if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; + if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; + continue; + } + case JINT_SSS: { + if (((int32_t)(instr >> 8) & 0xFF) >= sc || + ((int32_t)(instr >> 16) & 0xFF) >= sc || + ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; + continue; + } + case JINT_SD: { + if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; + if ((int32_t)(instr >> 16) >= def->defs_length) return 6; + continue; + } + case JINT_SC: { + if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; + if ((int32_t)(instr >> 16) >= def->constants_length) return 7; + continue; + } + case JINT_SES: { + /* How can we check the last slot index? We need info parent funcdefs. Resort + * to runtime checks for now. Maybe invalid upvalue references could be defaulted + * to nil? (don't commit to this in the long term, though) */ + if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; + if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; + continue; + } + } + } + + /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, + * some real flow analysis would be ideal, but this should be very effective. Will completely + * prevent running over the end of bytecode. However, valid functions with dead code will + * be rejected. */ + { + uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; + switch (lastop) { + default: + return 9; + case JOP_RETURN: + case JOP_RETURN_NIL: + case JOP_JUMP: + case JOP_ERROR: + case JOP_TAILCALL: + break; + } + } + + return 0; +} + +/* Allocate an empty funcdef. This function may have added functionality + * as commonalities between asm and compile arise. */ +JanetFuncDef *janet_funcdef_alloc(void) { + JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); + def->environments = NULL; + def->constants = NULL; + def->bytecode = NULL; + def->closure_bitset = NULL; + def->flags = 0; + def->slotcount = 0; + def->symbolmap = NULL; + def->arity = 0; + def->min_arity = 0; + def->max_arity = INT32_MAX; + def->source = NULL; + def->sourcemap = NULL; + def->name = NULL; + def->defs = NULL; + def->defs_length = 0; + def->constants_length = 0; + def->bytecode_length = 0; + def->environments_length = 0; + def->symbolmap_length = 0; + return def; +} + +/* Create a simple closure from a funcdef */ +JanetFunction *janet_thunk(JanetFuncDef *def) { + JanetFunction *func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction)); + func->def = def; + janet_assert(def->environments_length == 0, "tried to create thunk that needs upvalues"); + return func; +} + + +/* src/core/capi.c */ +#line 0 "src/core/capi.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "fiber.h" +#endif + +#ifndef JANET_SINGLE_THREADED +#ifndef JANET_WINDOWS +#include +#else +#include +#endif +#endif + +#ifdef JANET_USE_STDATOMIC +#include +/* We don't need stdatomic on most compilers since we use compiler builtins for atomic operations. + * Some (TCC), explicitly require using stdatomic.h and don't have any exposed builtins (that I know of). + * For TCC and similar compilers, one would need -std=c11 or similar then to get access. */ +#endif + +JANET_NO_RETURN static void janet_top_level_signal(const char *msg) { +#ifdef JANET_TOP_LEVEL_SIGNAL + JANET_TOP_LEVEL_SIGNAL(msg); +#else + fputs(msg, stdout); +# ifdef JANET_SINGLE_THREADED + exit(-1); +# elif defined(JANET_WINDOWS) + ExitThread(-1); +# else + pthread_exit(NULL); +# endif +#endif +} + +void janet_signalv(JanetSignal sig, Janet message) { + if (janet_vm.return_reg != NULL) { + *janet_vm.return_reg = message; + if (NULL != janet_vm.fiber) { + janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP; + } +#if defined(JANET_BSD) || defined(JANET_APPLE) + _longjmp(*janet_vm.signal_buf, sig); +#else + longjmp(*janet_vm.signal_buf, sig); +#endif + } else { + const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message); + janet_top_level_signal(str); + } +} + +void janet_panicv(Janet message) { + janet_signalv(JANET_SIGNAL_ERROR, message); +} + +void janet_panicf(const char *format, ...) { + va_list args; + const uint8_t *ret; + JanetBuffer buffer; + int32_t len = 0; + while (format[len]) len++; + janet_buffer_init(&buffer, len); + va_start(args, format); + janet_formatbv(&buffer, format, args); + va_end(args); + ret = janet_string(buffer.data, buffer.count); + janet_buffer_deinit(&buffer); + janet_panics(ret); +} + +void janet_panic(const char *message) { + janet_panicv(janet_cstringv(message)); +} + +void janet_panics(const uint8_t *message) { + janet_panicv(janet_wrap_string(message)); +} + +void janet_panic_type(Janet x, int32_t n, int expected) { + janet_panicf("bad slot #%d, expected %T, got %v", n, expected, x); +} + +void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at) { + janet_panicf("bad slot #%d, expected %s, got %v", n, at->name, x); +} + +void janet_fixarity(int32_t arity, int32_t fix) { + if (arity != fix) + janet_panicf("arity mismatch, expected %d, got %d", fix, arity); +} + +void janet_arity(int32_t arity, int32_t min, int32_t max) { + if (min >= 0 && arity < min) + janet_panicf("arity mismatch, expected at least %d, got %d", min, arity); + if (max >= 0 && arity > max) + janet_panicf("arity mismatch, expected at most %d, got %d", max, arity); +} + +#define DEFINE_GETTER(name, NAME, type) \ +type janet_get##name(const Janet *argv, int32_t n) { \ + Janet x = argv[n]; \ + if (!janet_checktype(x, JANET_##NAME)) { \ + janet_panic_type(x, n, JANET_TFLAG_##NAME); \ + } \ + return janet_unwrap_##name(x); \ +} + +#define DEFINE_OPT(name, NAME, type) \ +type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, type dflt) { \ + if (n >= argc) return dflt; \ + if (janet_checktype(argv[n], JANET_NIL)) return dflt; \ + return janet_get##name(argv, n); \ +} + +#define DEFINE_OPTLEN(name, NAME, type) \ +type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len) { \ + if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {\ + return janet_##name(dflt_len); \ + }\ + return janet_get##name(argv, n); \ +} + +int janet_getmethod(const uint8_t *method, const JanetMethod *methods, Janet *out) { + while (methods->name) { + if (!janet_cstrcmp(method, methods->name)) { + *out = janet_wrap_cfunction(methods->cfun); + return 1; + } + methods++; + } + return 0; +} + +Janet janet_nextmethod(const JanetMethod *methods, Janet key) { + if (!janet_checktype(key, JANET_NIL)) { + while (methods->name) { + if (janet_keyeq(key, methods->name)) { + methods++; + break; + } + methods++; + } + } + if (methods->name) { + return janet_ckeywordv(methods->name); + } else { + return janet_wrap_nil(); + } +} + +DEFINE_GETTER(number, NUMBER, double) +DEFINE_GETTER(array, ARRAY, JanetArray *) +DEFINE_GETTER(tuple, TUPLE, const Janet *) +DEFINE_GETTER(table, TABLE, JanetTable *) +DEFINE_GETTER(struct, STRUCT, const JanetKV *) +DEFINE_GETTER(string, STRING, const uint8_t *) +DEFINE_GETTER(keyword, KEYWORD, const uint8_t *) +DEFINE_GETTER(symbol, SYMBOL, const uint8_t *) +DEFINE_GETTER(buffer, BUFFER, JanetBuffer *) +DEFINE_GETTER(fiber, FIBER, JanetFiber *) +DEFINE_GETTER(function, FUNCTION, JanetFunction *) +DEFINE_GETTER(cfunction, CFUNCTION, JanetCFunction) +DEFINE_GETTER(boolean, BOOLEAN, int) +DEFINE_GETTER(pointer, POINTER, void *) + +DEFINE_OPT(number, NUMBER, double) +DEFINE_OPT(tuple, TUPLE, const Janet *) +DEFINE_OPT(struct, STRUCT, const JanetKV *) +DEFINE_OPT(string, STRING, const uint8_t *) +DEFINE_OPT(keyword, KEYWORD, const uint8_t *) +DEFINE_OPT(symbol, SYMBOL, const uint8_t *) +DEFINE_OPT(fiber, FIBER, JanetFiber *) +DEFINE_OPT(function, FUNCTION, JanetFunction *) +DEFINE_OPT(cfunction, CFUNCTION, JanetCFunction) +DEFINE_OPT(boolean, BOOLEAN, int) +DEFINE_OPT(pointer, POINTER, void *) + +DEFINE_OPTLEN(buffer, BUFFER, JanetBuffer *) +DEFINE_OPTLEN(table, TABLE, JanetTable *) +DEFINE_OPTLEN(array, ARRAY, JanetArray *) + +const char *janet_optcstring(const Janet *argv, int32_t argc, int32_t n, const char *dflt) { + if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { + return dflt; + } + return janet_getcstring(argv, n); +} + +#undef DEFINE_GETTER +#undef DEFINE_OPT +#undef DEFINE_OPTLEN + +const char *janet_getcstring(const Janet *argv, int32_t n) { + if (!janet_checktype(argv[n], JANET_STRING)) { + janet_panic_type(argv[n], n, JANET_TFLAG_STRING); + } + return janet_getcbytes(argv, n); +} + +const char *janet_getcbytes(const Janet *argv, int32_t n) { + /* Ensure buffer 0-padded */ + if (janet_checktype(argv[n], JANET_BUFFER)) { + JanetBuffer *b = janet_unwrap_buffer(argv[n]); + if ((b->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) && b->count == b->capacity) { + /* Make a copy with janet_smalloc in the rare case we have a buffer that + * cannot be realloced and pushing a 0 byte would panic. */ + char *new_string = janet_smalloc(b->count + 1); + memcpy(new_string, b->data, b->count); + new_string[b->count] = 0; + if (strlen(new_string) != (size_t) b->count) goto badzeros; + return new_string; + } else { + /* Ensure trailing 0 */ + janet_buffer_push_u8(b, 0); + b->count--; + if (strlen((char *)b->data) != (size_t) b->count) goto badzeros; + return (const char *) b->data; + } + } + JanetByteView view = janet_getbytes(argv, n); + const char *cstr = (const char *)view.bytes; + if (strlen(cstr) != (size_t) view.len) goto badzeros; + return cstr; + +badzeros: + janet_panic("bytes contain embedded 0s"); +} + +const char *janet_optcbytes(const Janet *argv, int32_t argc, int32_t n, const char *dflt) { + if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { + return dflt; + } + return janet_getcbytes(argv, n); +} + +int32_t janet_getnat(const Janet *argv, int32_t n) { + Janet x = argv[n]; + if (!janet_checkint(x)) goto bad; + int32_t ret = janet_unwrap_integer(x); + if (ret < 0) goto bad; + return ret; +bad: + janet_panicf("bad slot #%d, expected non-negative 32 bit signed integer, got %v", n, x); +} + +JanetAbstract janet_checkabstract(Janet x, const JanetAbstractType *at) { + if (!janet_checktype(x, JANET_ABSTRACT)) return NULL; + JanetAbstract a = janet_unwrap_abstract(x); + if (janet_abstract_type(a) != at) return NULL; + return a; +} + +static int janet_strlike_cmp(JanetType type, Janet x, const char *cstring) { + if (janet_type(x) != type) return 0; + return !janet_cstrcmp(janet_unwrap_string(x), cstring); +} + +int janet_keyeq(Janet x, const char *cstring) { + return janet_strlike_cmp(JANET_KEYWORD, x, cstring); +} + +int janet_streq(Janet x, const char *cstring) { + return janet_strlike_cmp(JANET_STRING, x, cstring); +} + +int janet_symeq(Janet x, const char *cstring) { + return janet_strlike_cmp(JANET_SYMBOL, x, cstring); +} + +int32_t janet_getinteger(const Janet *argv, int32_t n) { + Janet x = argv[n]; + if (!janet_checkint(x)) { + janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x); + } + return janet_unwrap_integer(x); +} + +uint32_t janet_getuinteger(const Janet *argv, int32_t n) { + Janet x = argv[n]; + if (!janet_checkuint(x)) { + janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x); + } + return janet_unwrap_integer(x); +} + +int64_t janet_getinteger64(const Janet *argv, int32_t n) { +#ifdef JANET_INT_TYPES + return janet_unwrap_s64(argv[n]); +#else + Janet x = argv[n]; + if (!janet_checkint64(x)) { + janet_panicf("bad slot #%d, expected 64 bit signed integer, got %v", n, x); + } + return (int64_t) janet_unwrap_number(x); +#endif +} + +uint64_t janet_getuinteger64(const Janet *argv, int32_t n) { +#ifdef JANET_INT_TYPES + return janet_unwrap_u64(argv[n]); +#else + Janet x = argv[n]; + if (!janet_checkuint64(x)) { + janet_panicf("bad slot #%d, expected 64 bit unsigned integer, got %v", n, x); + } + return (uint64_t) janet_unwrap_number(x); +#endif +} + +size_t janet_getsize(const Janet *argv, int32_t n) { + Janet x = argv[n]; + if (!janet_checksize(x)) { + janet_panicf("bad slot #%d, expected size, got %v", n, x); + } + return (size_t) janet_unwrap_number(x); +} + +int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) { + int32_t raw = janet_getinteger(argv, n); + int32_t not_raw = raw; + if (not_raw < 0) not_raw += length + 1; + if (not_raw < 0 || not_raw > length) + janet_panicf("%s index %d out of range [%d,%d]", which, (int64_t) raw, -(int64_t)length - 1, (int64_t) length); + return not_raw; +} + +int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) { + if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { + return 0; + } + return janet_gethalfrange(argv, n, length, "start"); +} + +int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) { + if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { + return length; + } + return janet_gethalfrange(argv, n, length, "end"); +} + +int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which) { + int32_t raw = janet_getinteger(argv, n); + int32_t not_raw = raw; + if (not_raw < 0) not_raw += length; + if (not_raw < 0 || not_raw > length) + janet_panicf("%s index %d out of range [%d,%d)", which, (int64_t)raw, -(int64_t)length, (int64_t)length); + return not_raw; +} + +JanetView janet_getindexed(const Janet *argv, int32_t n) { + Janet x = argv[n]; + JanetView view; + if (!janet_indexed_view(x, &view.items, &view.len)) { + janet_panic_type(x, n, JANET_TFLAG_INDEXED); + } + return view; +} + +JanetByteView janet_getbytes(const Janet *argv, int32_t n) { + Janet x = argv[n]; + JanetByteView view; + if (!janet_bytes_view(x, &view.bytes, &view.len)) { + janet_panic_type(x, n, JANET_TFLAG_BYTES); + } + return view; +} + +JanetDictView janet_getdictionary(const Janet *argv, int32_t n) { + Janet x = argv[n]; + JanetDictView view; + if (!janet_dictionary_view(x, &view.kvs, &view.len, &view.cap)) { + janet_panic_type(x, n, JANET_TFLAG_DICTIONARY); + } + return view; +} + +void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *at) { + Janet x = argv[n]; + if (!janet_checktype(x, JANET_ABSTRACT)) { + janet_panic_abstract(x, n, at); + } + void *abstractx = janet_unwrap_abstract(x); + if (janet_abstract_type(abstractx) != at) { + janet_panic_abstract(x, n, at); + } + return abstractx; +} + +JanetRange janet_getslice(int32_t argc, const Janet *argv) { + janet_arity(argc, 1, 3); + JanetRange range; + int32_t length = janet_length(argv[0]); + range.start = janet_getstartrange(argv, argc, 1, length); + range.end = janet_getendrange(argv, argc, 2, length); + if (range.end < range.start) + range.end = range.start; + return range; +} + +Janet janet_dyn(const char *name) { + if (!janet_vm.fiber) { + if (!janet_vm.top_dyns) return janet_wrap_nil(); + return janet_table_get(janet_vm.top_dyns, janet_ckeywordv(name)); + } + if (janet_vm.fiber->env) { + return janet_table_get(janet_vm.fiber->env, janet_ckeywordv(name)); + } else { + return janet_wrap_nil(); + } +} + +void janet_setdyn(const char *name, Janet value) { + if (!janet_vm.fiber) { + if (!janet_vm.top_dyns) janet_vm.top_dyns = janet_table(10); + janet_table_put(janet_vm.top_dyns, janet_ckeywordv(name), value); + } else { + if (!janet_vm.fiber->env) { + janet_vm.fiber->env = janet_table(1); + } + janet_table_put(janet_vm.fiber->env, janet_ckeywordv(name), value); + } +} + +uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags) { + uint64_t ret = 0; + const uint8_t *keyw = janet_getkeyword(argv, n); + int32_t klen = janet_string_length(keyw); + int32_t flen = (int32_t) strlen(flags); + if (flen > 64) { + flen = 64; + } + for (int32_t j = 0; j < klen; j++) { + for (int32_t i = 0; i < flen; i++) { + if (((uint8_t) flags[i]) == keyw[j]) { + ret |= 1ULL << i; + goto found; + } + } + janet_panicf("unexpected flag %c, expected one of \"%s\"", (char) keyw[j], flags); + found: + ; + } + return ret; +} + +int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) { + if (argc <= n) return dflt; + if (janet_checktype(argv[n], JANET_NIL)) return dflt; + return janet_getnat(argv, n); +} + +int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) { + if (argc <= n) return dflt; + if (janet_checktype(argv[n], JANET_NIL)) return dflt; + return janet_getinteger(argv, n); +} + +int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt) { + if (argc <= n) return dflt; + if (janet_checktype(argv[n], JANET_NIL)) return dflt; + return janet_getinteger64(argv, n); +} + +size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt) { + if (argc <= n) return dflt; + if (janet_checktype(argv[n], JANET_NIL)) return dflt; + return janet_getsize(argv, n); +} + +void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, void *dflt) { + if (argc <= n) return dflt; + if (janet_checktype(argv[n], JANET_NIL)) return dflt; + return janet_getabstract(argv, n, at); +} + +/* Atomic refcounts */ + +JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) { +#ifdef JANET_WINDOWS + return InterlockedIncrement(x); +#elif defined(JANET_USE_STDATOMIC) + return atomic_fetch_add_explicit(x, 1, memory_order_relaxed) + 1; +#else + return __atomic_add_fetch(x, 1, __ATOMIC_RELAXED); +#endif +} + +JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) { +#ifdef JANET_WINDOWS + return InterlockedDecrement(x); +#elif defined(JANET_USE_STDATOMIC) + return atomic_fetch_add_explicit(x, -1, memory_order_acq_rel) - 1; +#else + return __atomic_add_fetch(x, -1, __ATOMIC_ACQ_REL); +#endif +} + +JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) { +#ifdef JANET_WINDOWS + return InterlockedOr(x, 0); +#elif defined(JANET_USE_STDATOMIC) + return atomic_load_explicit(x, memory_order_acquire); +#else + return __atomic_load_n(x, __ATOMIC_ACQUIRE); +#endif +} + +/* Some definitions for function-like macros */ + +JANET_API JanetStructHead *(janet_struct_head)(JanetStruct st) { + return janet_struct_head(st); +} + +JANET_API JanetAbstractHead *(janet_abstract_head)(const void *abstract) { + return janet_abstract_head(abstract); +} + +JANET_API JanetStringHead *(janet_string_head)(JanetString s) { + return janet_string_head(s); +} + +JANET_API JanetTupleHead *(janet_tuple_head)(JanetTuple tuple) { + return janet_tuple_head(tuple); +} + + +/* src/core/cfuns.c */ +#line 0 "src/core/cfuns.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "compile.h" +#include "emit.h" +#include "vector.h" +#endif + +static int arity1or2(JanetFopts opts, JanetSlot *args) { + (void) opts; + int32_t arity = janet_v_count(args); + return arity == 1 || arity == 2; +} +static int arity2or3(JanetFopts opts, JanetSlot *args) { + (void) opts; + int32_t arity = janet_v_count(args); + return arity == 2 || arity == 3; +} +static int fixarity1(JanetFopts opts, JanetSlot *args) { + (void) opts; + return janet_v_count(args) == 1; +} +static int maxarity1(JanetFopts opts, JanetSlot *args) { + (void) opts; + return janet_v_count(args) <= 1; +} +static int minarity2(JanetFopts opts, JanetSlot *args) { + (void) opts; + return janet_v_count(args) >= 2; +} +static int fixarity2(JanetFopts opts, JanetSlot *args) { + (void) opts; + return janet_v_count(args) == 2; +} +static int fixarity3(JanetFopts opts, JanetSlot *args) { + (void) opts; + return janet_v_count(args) == 3; +} + +/* Generic handling for $A = op $B */ +static JanetSlot genericSS(JanetFopts opts, int op, JanetSlot s) { + JanetSlot target = janetc_gettarget(opts); + janetc_emit_ss(opts.compiler, op, target, s, 1); + return target; +} + +/* Generic handling for $A = $B op I */ +static JanetSlot genericSSI(JanetFopts opts, int op, JanetSlot s, int32_t imm) { + JanetSlot target = janetc_gettarget(opts); + janetc_emit_ssi(opts.compiler, op, target, s, imm, 1); + return target; +} + +/* Emit an insruction that implements a form by itself. */ +static JanetSlot opfunction( + JanetFopts opts, + JanetSlot *args, + int op, + Janet defaultArg2) { + JanetCompiler *c = opts.compiler; + int32_t len; + len = janet_v_count(args); + JanetSlot t; + if (len == 1) { + t = janetc_gettarget(opts); + janetc_emit_sss(c, op, t, args[0], janetc_cslot(defaultArg2), 1); + return t; + } else { + /* len == 2 */ + t = janetc_gettarget(opts); + janetc_emit_sss(c, op, t, args[0], args[1], 1); + } + return t; +} + +/* Check if a value can be coerced to an immediate value */ +static int can_be_imm(Janet x, int8_t *out) { + if (!janet_checkint(x)) return 0; + int32_t integer = janet_unwrap_integer(x); + if (integer > INT8_MAX || integer < INT8_MIN) return 0; + *out = (int8_t) integer; + return 1; +} + +/* Check if a slot can be coerced to an immediate value */ +static int can_slot_be_imm(JanetSlot s, int8_t *out) { + if (!(s.flags & JANET_SLOT_CONSTANT)) return 0; + return can_be_imm(s.constant, out); +} + +/* Emit a series of instructions instead of a function call to a math op */ +static JanetSlot opreduce( + JanetFopts opts, + JanetSlot *args, + int op, + int opim, + Janet nullary, + Janet unary) { + JanetCompiler *c = opts.compiler; + int32_t i, len; + int8_t imm = 0; + len = janet_v_count(args); + JanetSlot t; + if (len == 0) { + return janetc_cslot(nullary); + } else if (len == 1) { + t = janetc_gettarget(opts); + /* Special case subtract to be times -1 */ + if (op == JOP_SUBTRACT) { + janetc_emit_ssi(c, JOP_MULTIPLY_IMMEDIATE, t, args[0], -1, 1); + } else { + janetc_emit_sss(c, op, t, janetc_cslot(unary), args[0], 1); + } + return t; + } + t = janetc_gettarget(opts); + if (opim && can_slot_be_imm(args[1], &imm)) { + janetc_emit_ssi(c, opim, t, args[0], imm, 1); + } else { + janetc_emit_sss(c, op, t, args[0], args[1], 1); + } + for (i = 2; i < len; i++) { + if (opim && can_slot_be_imm(args[i], &imm)) { + janetc_emit_ssi(c, opim, t, t, imm, 1); + } else { + janetc_emit_sss(c, op, t, t, args[i], 1); + } + } + return t; +} + +/* Function optimizers */ + +static JanetSlot do_propagate(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil(), janet_wrap_nil()); +} +static JanetSlot do_error(JanetFopts opts, JanetSlot *args) { + janetc_emit_s(opts.compiler, JOP_ERROR, args[0], 0); + return janetc_cslot(janet_wrap_nil()); +} +static JanetSlot do_debug(JanetFopts opts, JanetSlot *args) { + (void)args; + int32_t len = janet_v_count(args); + JanetSlot t = janetc_gettarget(opts); + janetc_emit_ssu(opts.compiler, JOP_SIGNAL, t, + (len == 1) ? args[0] : janetc_cslot(janet_wrap_nil()), + JANET_SIGNAL_DEBUG, + 1); + return t; +} +static JanetSlot do_in(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil(), janet_wrap_nil()); +} +static JanetSlot do_get(JanetFopts opts, JanetSlot *args) { + if (janet_v_count(args) == 3) { + JanetCompiler *c = opts.compiler; + JanetSlot t = janetc_gettarget(opts); + int target_is_default = janetc_sequal(t, args[2]); + JanetSlot dflt_slot = args[2]; + if (target_is_default) { + dflt_slot = janetc_farslot(c); + janetc_copy(c, dflt_slot, t); + } + janetc_emit_sss(c, JOP_GET, t, args[0], args[1], 1); + int32_t label = janetc_emit_si(c, JOP_JUMP_IF_NOT_NIL, t, 0, 0); + janetc_copy(c, t, dflt_slot); + if (target_is_default) janetc_freeslot(c, dflt_slot); + int32_t current = janet_v_count(c->buffer); + c->buffer[label] |= (current - label) << 16; + return t; + } else { + return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil(), janet_wrap_nil()); + } +} +static JanetSlot do_next(JanetFopts opts, JanetSlot *args) { + return opfunction(opts, args, JOP_NEXT, janet_wrap_nil()); +} +static JanetSlot do_cmp(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_COMPARE, 0, janet_wrap_nil(), janet_wrap_nil()); +} +static JanetSlot do_put(JanetFopts opts, JanetSlot *args) { + if (opts.flags & JANET_FOPTS_DROP) { + janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0); + return janetc_cslot(janet_wrap_nil()); + } else { + JanetSlot t = janetc_gettarget(opts); + janetc_copy(opts.compiler, t, args[0]); + janetc_emit_sss(opts.compiler, JOP_PUT, t, args[1], args[2], 0); + return t; + } +} +static JanetSlot do_length(JanetFopts opts, JanetSlot *args) { + return genericSS(opts, JOP_LENGTH, args[0]); +} +static JanetSlot do_yield(JanetFopts opts, JanetSlot *args) { + if (janet_v_count(args) == 0) { + return genericSSI(opts, JOP_SIGNAL, janetc_cslot(janet_wrap_nil()), 3); + } else { + return genericSSI(opts, JOP_SIGNAL, args[0], 3); + } +} +static JanetSlot do_resume(JanetFopts opts, JanetSlot *args) { + return opfunction(opts, args, JOP_RESUME, janet_wrap_nil()); +} +static JanetSlot do_cancel(JanetFopts opts, JanetSlot *args) { + return opfunction(opts, args, JOP_CANCEL, janet_wrap_nil()); +} +static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) { + /* Push phase */ + JanetCompiler *c = opts.compiler; + int32_t i; + for (i = 1; i < janet_v_count(args) - 3; i += 3) + janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i + 1], args[i + 2], 0); + if (i == janet_v_count(args) - 3) + janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i + 1], 0); + else if (i == janet_v_count(args) - 2) + janetc_emit_s(c, JOP_PUSH, args[i], 0); + /* Push array phase */ + janetc_emit_s(c, JOP_PUSH_ARRAY, janet_v_last(args), 0); + /* Call phase */ + JanetSlot target; + if (opts.flags & JANET_FOPTS_TAIL) { + janetc_emit_s(c, JOP_TAILCALL, args[0], 0); + target = janetc_cslot(janet_wrap_nil()); + target.flags |= JANET_SLOT_RETURNED; + } else { + target = janetc_gettarget(opts); + janetc_emit_ss(c, JOP_CALL, target, args[0], 1); + } + return target; +} + +/* Variadic operators specialization */ + +static JanetSlot do_add(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); +} +static JanetSlot do_sub(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_SUBTRACT, JOP_SUBTRACT_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); +} +static JanetSlot do_mul(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_div(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_divf(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_DIVIDE_FLOOR, 0, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_modulo(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_MODULO, 0, janet_wrap_integer(0), janet_wrap_integer(1)); +} +static JanetSlot do_remainder(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_integer(0), janet_wrap_integer(1)); +} +static JanetSlot do_band(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_BAND, 0, janet_wrap_integer(-1), janet_wrap_integer(-1)); +} +static JanetSlot do_bor(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_BOR, 0, janet_wrap_integer(0), janet_wrap_integer(0)); +} +static JanetSlot do_bxor(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_BXOR, 0, janet_wrap_integer(0), janet_wrap_integer(0)); +} +static JanetSlot do_lshift(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_SHIFT_LEFT, JOP_SHIFT_LEFT_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_rshift(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_SHIFT_RIGHT, JOP_SHIFT_RIGHT_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_rshiftu(JanetFopts opts, JanetSlot *args) { + return opreduce(opts, args, JOP_SHIFT_RIGHT_UNSIGNED, JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); +} +static JanetSlot do_bnot(JanetFopts opts, JanetSlot *args) { + return genericSS(opts, JOP_BNOT, args[0]); +} + +/* Specialization for comparators */ +static JanetSlot compreduce( + JanetFopts opts, + JanetSlot *args, + int op, + int opim, + int invert) { + JanetCompiler *c = opts.compiler; + int32_t i, len; + int8_t imm = 0; + len = janet_v_count(args); + int32_t *labels = NULL; + JanetSlot t; + if (len < 2) { + return invert + ? janetc_cslot(janet_wrap_false()) + : janetc_cslot(janet_wrap_true()); + } + t = janetc_gettarget(opts); + for (i = 1; i < len; i++) { + if (opim && can_slot_be_imm(args[i], &imm)) { + janetc_emit_ssi(c, opim, t, args[i - 1], imm, 1); + } else { + janetc_emit_sss(c, op, t, args[i - 1], args[i], 1); + } + if (i != (len - 1)) { + int32_t label = janetc_emit_si(c, invert ? JOP_JUMP_IF : JOP_JUMP_IF_NOT, t, 0, 1); + janet_v_push(labels, label); + } + } + int32_t end = janet_v_count(c->buffer); + for (i = 0; i < janet_v_count(labels); i++) { + int32_t label = labels[i]; + c->buffer[label] |= ((end - label) << 16); + } + janet_v_free(labels); + return t; +} + +static JanetSlot do_gt(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_GREATER_THAN, JOP_GREATER_THAN_IMMEDIATE, 0); +} +static JanetSlot do_lt(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_LESS_THAN, JOP_LESS_THAN_IMMEDIATE, 0); +} +static JanetSlot do_gte(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_GREATER_THAN_EQUAL, 0, 0); +} +static JanetSlot do_lte(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_LESS_THAN_EQUAL, 0, 0); +} +static JanetSlot do_eq(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_EQUALS, JOP_EQUALS_IMMEDIATE, 0); +} +static JanetSlot do_neq(JanetFopts opts, JanetSlot *args) { + return compreduce(opts, args, JOP_NOT_EQUALS, JOP_NOT_EQUALS_IMMEDIATE, 1); +} + +/* Arranged by tag */ +static const JanetFunOptimizer optimizers[] = { + {maxarity1, do_debug}, + {fixarity1, do_error}, + {minarity2, do_apply}, + {maxarity1, do_yield}, + {arity1or2, do_resume}, + {fixarity2, do_in}, + {fixarity3, do_put}, + {fixarity1, do_length}, + {NULL, do_add}, + {NULL, do_sub}, + {NULL, do_mul}, + {NULL, do_div}, + {NULL, do_band}, + {NULL, do_bor}, + {NULL, do_bxor}, + {NULL, do_lshift}, + {NULL, do_rshift}, + {NULL, do_rshiftu}, + {fixarity1, do_bnot}, + {NULL, do_gt}, + {NULL, do_lt}, + {NULL, do_gte}, + {NULL, do_lte}, + {NULL, do_eq}, + {NULL, do_neq}, + {fixarity2, do_propagate}, + {arity2or3, do_get}, + {arity1or2, do_next}, + {NULL, do_modulo}, + {NULL, do_remainder}, + {fixarity2, do_cmp}, + {fixarity2, do_cancel}, + {NULL, do_divf} +}; + +const JanetFunOptimizer *janetc_funopt(uint32_t flags) { + uint32_t tag = flags & JANET_FUNCDEF_FLAG_TAG; + if (tag == 0) + return NULL; + uint32_t index = tag - 1; + if (index >= (sizeof(optimizers) / sizeof(optimizers[0]))) + return NULL; + return optimizers + index; +} + + + +/* src/core/compile.c */ +#line 0 "src/core/compile.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "compile.h" +#include "emit.h" +#include "vector.h" +#include "util.h" +#include "state.h" +#endif + +JanetFopts janetc_fopts_default(JanetCompiler *c) { + JanetFopts ret; + ret.compiler = c; + ret.flags = 0; + ret.hint = janetc_cslot(janet_wrap_nil()); + return ret; +} + +/* Throw an error with a janet string. */ +void janetc_error(JanetCompiler *c, const uint8_t *m) { + /* Don't override first error */ + if (c->result.status == JANET_COMPILE_ERROR) { + return; + } + c->result.status = JANET_COMPILE_ERROR; + c->result.error = m; +} + +/* Throw an error with a message in a cstring */ +void janetc_cerror(JanetCompiler *c, const char *m) { + janetc_error(c, janet_cstring(m)); +} + +static const char *janet_lint_level_names[] = { + "relaxed", + "normal", + "strict" +}; + +/* Emit compiler linter messages */ +void janetc_lintf(JanetCompiler *c, JanetCompileLintLevel level, const char *format, ...) { + if (NULL != c->lints) { + /* format message */ + va_list args; + JanetBuffer buffer; + int32_t len = 0; + while (format[len]) len++; + janet_buffer_init(&buffer, len); + va_start(args, format); + janet_formatbv(&buffer, format, args); + va_end(args); + const uint8_t *str = janet_string(buffer.data, buffer.count); + janet_buffer_deinit(&buffer); + /* construct linting payload */ + Janet *payload = janet_tuple_begin(4); + payload[0] = janet_ckeywordv(janet_lint_level_names[level]); + payload[1] = c->current_mapping.line == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.line); + payload[2] = c->current_mapping.column == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.column); + payload[3] = janet_wrap_string(str); + janet_array_push(c->lints, janet_wrap_tuple(janet_tuple_end(payload))); + } +} + +/* Free a slot */ +void janetc_freeslot(JanetCompiler *c, JanetSlot s) { + if (s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF | JANET_SLOT_NAMED)) return; + if (s.envindex >= 0) return; + janetc_regalloc_free(&c->scope->ra, s.index); +} + +/* Add a slot to a scope with a symbol associated with it (def or var). */ +void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s) { + SymPair sp; + int32_t cnt = janet_v_count(c->buffer); + sp.sym = sym; + sp.sym2 = sym; + sp.slot = s; + sp.keep = 0; + sp.slot.flags |= JANET_SLOT_NAMED; + sp.birth_pc = cnt ? cnt - 1 : 0; + sp.death_pc = UINT32_MAX; + janet_v_push(c->scope->syms, sp); +} + +/* Create a slot with a constant */ +JanetSlot janetc_cslot(Janet x) { + JanetSlot ret; + ret.flags = (1 << janet_type(x)) | JANET_SLOT_CONSTANT; + ret.index = -1; + ret.constant = x; + ret.envindex = -1; + return ret; +} + +/* Get a local slot */ +JanetSlot janetc_farslot(JanetCompiler *c) { + JanetSlot ret; + ret.flags = JANET_SLOTTYPE_ANY; + ret.index = janetc_allocfar(c); + ret.constant = janet_wrap_nil(); + ret.envindex = -1; + return ret; +} + +/* Enter a new scope */ +void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name) { + JanetScope scope; + scope.name = name; + scope.child = NULL; + scope.consts = NULL; + scope.syms = NULL; + scope.envs = NULL; + scope.defs = NULL; + scope.bytecode_start = janet_v_count(c->buffer); + scope.flags = flags; + scope.parent = c->scope; + janetc_regalloc_init(&scope.ua); + /* Inherit slots */ + if ((!(flags & JANET_SCOPE_FUNCTION)) && c->scope) { + janetc_regalloc_clone(&scope.ra, &(c->scope->ra)); + } else { + janetc_regalloc_init(&scope.ra); + } + /* Link parent and child and update pointer */ + if (c->scope) + c->scope->child = s; + c->scope = s; + *s = scope; +} + +/* Leave a scope. */ +void janetc_popscope(JanetCompiler *c) { + JanetScope *oldscope = c->scope; + JanetScope *newscope = oldscope->parent; + /* Move free slots to parent scope if not a new function. + * We need to know the total number of slots used when compiling the function. */ + if (!(oldscope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_UNUSED)) && newscope) { + /* Parent scopes inherit child's closure flag. Needed + * for while loops. (if a while loop creates a closure, it + * is compiled to a tail recursive iife) */ + if (oldscope->flags & JANET_SCOPE_CLOSURE) { + newscope->flags |= JANET_SCOPE_CLOSURE; + } + if (newscope->ra.max < oldscope->ra.max) { + newscope->ra.max = oldscope->ra.max; + } + + /* Keep upvalue slots and symbols for debugging. */ + for (int32_t i = 0; i < janet_v_count(oldscope->syms); i++) { + SymPair pair = oldscope->syms[i]; + /* The variable should not be lexically accessible */ + pair.sym = NULL; + if (pair.death_pc == UINT32_MAX) { + pair.death_pc = (uint32_t) janet_v_count(c->buffer); + } + if (pair.keep) { + /* The variable should also not be included in the locals */ + pair.sym2 = NULL; + janetc_regalloc_touch(&newscope->ra, pair.slot.index); + } + janet_v_push(newscope->syms, pair); + } + } + + /* Free the old scope */ + janet_v_free(oldscope->consts); + janet_v_free(oldscope->syms); + janet_v_free(oldscope->envs); + janet_v_free(oldscope->defs); + janetc_regalloc_deinit(&oldscope->ra); + janetc_regalloc_deinit(&oldscope->ua); + /* Update pointer */ + if (newscope) + newscope->child = NULL; + c->scope = newscope; +} + +/* Leave a scope but keep a slot allocated. */ +void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot) { + JanetScope *scope; + janetc_popscope(c); + scope = c->scope; + if (scope && retslot.envindex < 0 && retslot.index >= 0) { + janetc_regalloc_touch(&scope->ra, retslot.index); + } +} + +static int lookup_missing( + JanetCompiler *c, + const uint8_t *sym, + JanetFunction *handler, + JanetBinding *out) { + int32_t minar = handler->def->min_arity; + int32_t maxar = handler->def->max_arity; + if (minar > 1 || maxar < 1) { + janetc_error(c, janet_cstring("missing symbol lookup handler must take 1 argument")); + return 0; + } + Janet args[1] = { janet_wrap_symbol(sym) }; + JanetFiber *fiberp = janet_fiber(handler, 64, 1, args); + if (NULL == fiberp) { + janetc_error(c, janet_cstring("failed to call missing symbol lookup handler")); + return 0; + } + fiberp->env = c->env; + int lock = janet_gclock(); + Janet tempOut; + JanetSignal status = janet_continue(fiberp, janet_wrap_nil(), &tempOut); + janet_gcunlock(lock); + if (status != JANET_SIGNAL_OK) { + janetc_error(c, janet_formatc("(lookup) %V", tempOut)); + return 0; + } + + /* Convert return value as entry. */ + /* Alternative could use janet_resolve_ext(c->env, sym) to read result from environment. */ + *out = janet_binding_from_entry(tempOut); + return 1; +} + +/* Allow searching for symbols. Return information about the symbol */ +JanetSlot janetc_resolve( + JanetCompiler *c, + const uint8_t *sym) { + + JanetSlot ret = janetc_cslot(janet_wrap_nil()); + JanetScope *scope = c->scope; + SymPair *pair; + int foundlocal = 1; + int unused = 0; + + /* Search scopes for symbol, starting from top */ + while (scope) { + int32_t i, len; + if (scope->flags & JANET_SCOPE_UNUSED) + unused = 1; + len = janet_v_count(scope->syms); + /* Search in reverse order */ + for (i = len - 1; i >= 0; i--) { + pair = scope->syms + i; + if (pair->sym == sym) { + ret = pair->slot; + goto found; + } + } + if (scope->flags & JANET_SCOPE_FUNCTION) + foundlocal = 0; + scope = scope->parent; + } + + /* Symbol not found - check for global */ + { + JanetBinding binding = janet_resolve_ext(c->env, sym); + if (binding.type == JANET_BINDING_NONE) { + Janet handler = janet_table_get(c->env, janet_ckeywordv("missing-symbol")); + switch (janet_type(handler)) { + case JANET_NIL: + break; + case JANET_FUNCTION: + if (!lookup_missing(c, sym, janet_unwrap_function(handler), &binding)) + return janetc_cslot(janet_wrap_nil()); + break; + default: + janetc_error(c, janet_formatc("invalid lookup handler %V", handler)); + return janetc_cslot(janet_wrap_nil()); + } + } + + switch (binding.type) { + default: + case JANET_BINDING_NONE: + janetc_error(c, janet_formatc("unknown symbol %q", janet_wrap_symbol(sym))); + return janetc_cslot(janet_wrap_nil()); + case JANET_BINDING_DEF: + case JANET_BINDING_MACRO: /* Macro should function like defs when not in calling pos */ + ret = janetc_cslot(binding.value); + break; + case JANET_BINDING_DYNAMIC_DEF: + case JANET_BINDING_DYNAMIC_MACRO: + ret = janetc_cslot(binding.value); + ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOTTYPE_ANY; + ret.flags &= ~JANET_SLOT_CONSTANT; + break; + case JANET_BINDING_VAR: { + ret = janetc_cslot(binding.value); + ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; + ret.flags &= ~JANET_SLOT_CONSTANT; + break; + } + } + JanetCompileLintLevel depLevel = JANET_C_LINT_RELAXED; + switch (binding.deprecation) { + case JANET_BINDING_DEP_NONE: + break; + case JANET_BINDING_DEP_RELAXED: + depLevel = JANET_C_LINT_RELAXED; + break; + case JANET_BINDING_DEP_NORMAL: + depLevel = JANET_C_LINT_NORMAL; + break; + case JANET_BINDING_DEP_STRICT: + depLevel = JANET_C_LINT_STRICT; + break; + } + if (binding.deprecation != JANET_BINDING_DEP_NONE) { + janetc_lintf(c, depLevel, "%q is deprecated", janet_wrap_symbol(sym)); + } + return ret; + } + + /* Symbol was found */ +found: + + /* Constants can be returned immediately (they are stateless) */ + if (ret.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) + return ret; + + /* Unused references and locals shouldn't add captured envs. */ + if (unused || foundlocal) { + ret.envindex = -1; + return ret; + } + + /* non-local scope needs to expose its environment */ + JanetScope *original_scope = scope; + pair->keep = 1; + while (scope && !(scope->flags & JANET_SCOPE_FUNCTION)) + scope = scope->parent; + janet_assert(scope, "invalid scopes"); + scope->flags |= JANET_SCOPE_ENV; + + /* In the function scope, allocate the slot as an upvalue */ + janetc_regalloc_touch(&scope->ua, ret.index); + + /* Iterate through child scopes and make sure environment is propagated */ + scope = scope->child; + + /* Propagate env up to current scope */ + int32_t envindex = -1; + while (scope) { + if (scope->flags & JANET_SCOPE_FUNCTION) { + int32_t j, len; + int scopefound = 0; + /* Check if scope already has env. If so, break */ + len = janet_v_count(scope->envs); + for (j = 0; j < len; j++) { + if (scope->envs[j].envindex == envindex) { + scopefound = 1; + envindex = j; + break; + } + } + /* Add the environment if it is not already referenced */ + if (!scopefound) { + len = janet_v_count(scope->envs); + JanetEnvRef ref; + ref.envindex = envindex; + ref.scope = original_scope; + janet_v_push(scope->envs, ref); + envindex = len; + } + } + scope = scope->child; + } + + ret.envindex = envindex; + return ret; +} + +/* Generate the return instruction for a slot. */ +JanetSlot janetc_return(JanetCompiler *c, JanetSlot s) { + if (!(s.flags & JANET_SLOT_RETURNED)) { + if (s.flags & JANET_SLOT_CONSTANT && janet_checktype(s.constant, JANET_NIL)) + janetc_emit(c, JOP_RETURN_NIL); + else + janetc_emit_s(c, JOP_RETURN, s, 0); + s.flags |= JANET_SLOT_RETURNED; + } + return s; +} + +/* Get a target slot for emitting an instruction. */ +JanetSlot janetc_gettarget(JanetFopts opts) { + JanetSlot slot; + if ((opts.flags & JANET_FOPTS_HINT) && + (opts.hint.envindex < 0) && + (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) { + slot = opts.hint; + } else { + slot.envindex = -1; + slot.constant = janet_wrap_nil(); + slot.flags = 0; + slot.index = janetc_allocfar(opts.compiler); + } + return slot; +} + +/* Get a bunch of slots for function arguments */ +JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len) { + int32_t i; + JanetSlot *ret = NULL; + JanetFopts subopts = janetc_fopts_default(c); + subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; + for (i = 0; i < len; i++) { + janet_v_push(ret, janetc_value(subopts, vals[i])); + } + return ret; +} + +/* Get a bunch of slots for function arguments */ +JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) { + JanetSlot *ret = NULL; + JanetFopts subopts = janetc_fopts_default(c); + subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; + const JanetKV *kvs = NULL; + int32_t cap = 0, len = 0; + janet_dictionary_view(ds, &kvs, &len, &cap); + for (int32_t i = 0; i < cap; i++) { + if (janet_checktype(kvs[i].key, JANET_NIL)) continue; + janet_v_push(ret, janetc_value(subopts, kvs[i].key)); + janet_v_push(ret, janetc_value(subopts, kvs[i].value)); + } + return ret; +} + +/* Push slots loaded via janetc_toslots. Return the minimum number of slots pushed, + * or -1 - min_arity if there is a splice. (if there is no splice, min_arity is also + * the maximum possible arity). */ +int32_t janetc_pushslots(JanetCompiler *c, JanetSlot *slots) { + int32_t i; + int32_t count = janet_v_count(slots); + int32_t min_arity = 0; + int has_splice = 0; + for (i = 0; i < count;) { + if (slots[i].flags & JANET_SLOT_SPLICED) { + janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i], 0); + i++; + has_splice = 1; + } else if (i + 1 == count) { + janetc_emit_s(c, JOP_PUSH, slots[i], 0); + i++; + min_arity++; + } else if (slots[i + 1].flags & JANET_SLOT_SPLICED) { + janetc_emit_s(c, JOP_PUSH, slots[i], 0); + janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 1], 0); + i += 2; + min_arity++; + has_splice = 1; + } else if (i + 2 == count) { + janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0); + i += 2; + min_arity += 2; + } else if (slots[i + 2].flags & JANET_SLOT_SPLICED) { + janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0); + janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 2], 0); + i += 3; + min_arity += 2; + has_splice = 1; + } else { + janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i + 1], slots[i + 2], 0); + i += 3; + min_arity += 3; + } + } + return has_splice ? (-1 - min_arity) : min_arity; +} + +/* Check if a list of slots has any spliced slots */ +static int has_spliced(JanetSlot *slots) { + int32_t i; + for (i = 0; i < janet_v_count(slots); i++) { + if (slots[i].flags & JANET_SLOT_SPLICED) + return 1; + } + return 0; +} + +/* Free slots loaded via janetc_toslots */ +void janetc_freeslots(JanetCompiler *c, JanetSlot *slots) { + int32_t i; + for (i = 0; i < janet_v_count(slots); i++) { + janetc_freeslot(c, slots[i]); + } + janet_v_free(slots); +} + +/* Compile some code that will be thrown away. Used to ensure + * that dead code is well formed without including it in the final + * bytecode. */ +void janetc_throwaway(JanetFopts opts, Janet x) { + JanetCompiler *c = opts.compiler; + JanetScope unusedScope; + int32_t bufstart = janet_v_count(c->buffer); + int32_t mapbufstart = janet_v_count(c->mapbuffer); + janetc_scope(&unusedScope, c, JANET_SCOPE_UNUSED, "unusued"); + janetc_value(opts, x); + janetc_lintf(c, JANET_C_LINT_STRICT, "dead code, consider removing %.2q", x); + janetc_popscope(c); + if (c->buffer) { + janet_v__cnt(c->buffer) = bufstart; + if (c->mapbuffer) + janet_v__cnt(c->mapbuffer) = mapbufstart; + } +} + +/* Compile a call or tailcall instruction */ +static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun) { + JanetSlot retslot; + JanetCompiler *c = opts.compiler; + int specialized = 0; + if (fun.flags & JANET_SLOT_CONSTANT && !has_spliced(slots)) { + if (janet_checktype(fun.constant, JANET_FUNCTION)) { + JanetFunction *f = janet_unwrap_function(fun.constant); + const JanetFunOptimizer *o = janetc_funopt(f->def->flags); + if (o && (!o->can_optimize || o->can_optimize(opts, slots))) { + specialized = 1; + retslot = o->optimize(opts, slots); + } + } + /* TODO janet function inlining (no c functions)*/ + } + if (!specialized) { + int32_t min_arity = janetc_pushslots(c, slots); + /* Check for provably incorrect function calls */ + if (fun.flags & JANET_SLOT_CONSTANT) { + + /* Check for bad arity type if fun is a constant */ + switch (janet_type(fun.constant)) { + case JANET_FUNCTION: { + JanetFunction *f = janet_unwrap_function(fun.constant); + int32_t min = f->def->min_arity; + int32_t max = f->def->max_arity; + if (min_arity < 0) { + /* Call has splices */ + min_arity = -1 - min_arity; + if (min_arity > max && max >= 0) { + const uint8_t *es = janet_formatc( + "%v expects at most %d argument%s, got at least %d", + fun.constant, max, max == 1 ? "" : "s", min_arity); + janetc_error(c, es); + } + } else { + /* Call has no splices */ + if (min_arity > max && max >= 0) { + const uint8_t *es = janet_formatc( + "%v expects at most %d argument%s, got %d", + fun.constant, max, max == 1 ? "" : "s", min_arity); + janetc_error(c, es); + } + if (min_arity < min) { + const uint8_t *es = janet_formatc( + "%v expects at least %d argument%s, got %d", + fun.constant, min, min == 1 ? "" : "s", min_arity); + janetc_error(c, es); + } + } + } + break; + case JANET_CFUNCTION: + case JANET_ABSTRACT: + case JANET_NIL: + break; + case JANET_KEYWORD: + if (min_arity == 0) { + const uint8_t *es = janet_formatc("%v expects at least 1 argument, got 0", + fun.constant); + janetc_error(c, es); + } + break; + default: + if (min_arity > 1 || min_arity == 0) { + const uint8_t *es = janet_formatc("%v expects 1 argument, got %d", + fun.constant, min_arity); + janetc_error(c, es); + } + if (min_arity < -2) { + const uint8_t *es = janet_formatc("%v expects 1 argument, got at least %d", + fun.constant, -1 - min_arity); + janetc_error(c, es); + } + break; + } + } + + if ((opts.flags & JANET_FOPTS_TAIL) && + /* Prevent top level tail calls for better errors */ + !(c->scope->flags & JANET_SCOPE_TOP)) { + janetc_emit_s(c, JOP_TAILCALL, fun, 0); + retslot = janetc_cslot(janet_wrap_nil()); + retslot.flags = JANET_SLOT_RETURNED; + } else { + retslot = janetc_gettarget(opts); + janetc_emit_ss(c, JOP_CALL, retslot, fun, 1); + } + } + janetc_freeslots(c, slots); + return retslot; +} + +static JanetSlot janetc_maker(JanetFopts opts, JanetSlot *slots, int op) { + JanetCompiler *c = opts.compiler; + JanetSlot retslot; + + /* Check if this structure is composed entirely of constants */ + int can_inline = 1; + for (int32_t i = 0; i < janet_v_count(slots); i++) { + if (!(slots[i].flags & JANET_SLOT_CONSTANT) || + (slots[i].flags & JANET_SLOT_SPLICED)) { + can_inline = 0; + break; + } + } + + if (can_inline && (op == JOP_MAKE_STRUCT)) { + JanetKV *st = janet_struct_begin(janet_v_count(slots) / 2); + for (int32_t i = 0; i < janet_v_count(slots); i += 2) { + Janet k = slots[i].constant; + Janet v = slots[i + 1].constant; + janet_struct_put(st, k, v); + } + retslot = janetc_cslot(janet_wrap_struct(janet_struct_end(st))); + janetc_freeslots(c, slots); + } else if (can_inline && (op == JOP_MAKE_TUPLE)) { + Janet *tup = janet_tuple_begin(janet_v_count(slots)); + for (int32_t i = 0; i < janet_v_count(slots); i++) { + tup[i] = slots[i].constant; + } + retslot = janetc_cslot(janet_wrap_tuple(janet_tuple_end(tup))); + janetc_freeslots(c, slots); + } else { + janetc_pushslots(c, slots); + janetc_freeslots(c, slots); + retslot = janetc_gettarget(opts); + janetc_emit_s(c, op, retslot, 1); + } + + return retslot; +} + +static JanetSlot janetc_array(JanetFopts opts, Janet x) { + JanetCompiler *c = opts.compiler; + JanetArray *a = janet_unwrap_array(x); + return janetc_maker(opts, + janetc_toslots(c, a->data, a->count), + JOP_MAKE_ARRAY); +} + +static JanetSlot janetc_tuple(JanetFopts opts, Janet x) { + JanetCompiler *c = opts.compiler; + const Janet *t = janet_unwrap_tuple(x); + return janetc_maker(opts, + janetc_toslots(c, t, janet_tuple_length(t)), + JOP_MAKE_TUPLE); +} + +static JanetSlot janetc_tablector(JanetFopts opts, Janet x, int op) { + JanetCompiler *c = opts.compiler; + return janetc_maker(opts, + janetc_toslotskv(c, x), + op); +} + +static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) { + JanetCompiler *c = opts.compiler; + JanetBuffer *b = janet_unwrap_buffer(x); + Janet onearg = janet_stringv(b->data, b->count); + return janetc_maker(opts, + janetc_toslots(c, &onearg, 1), + JOP_MAKE_BUFFER); +} + +/* Expand a macro one time. Also get the special form compiler if we + * find that instead. */ +static int macroexpand1( + JanetCompiler *c, + Janet x, + Janet *out, + const JanetSpecial **spec) { + if (!janet_checktype(x, JANET_TUPLE)) + return 0; + const Janet *form = janet_unwrap_tuple(x); + if (janet_tuple_length(form) == 0) + return 0; + /* Source map - only set when we get a tuple */ + if (janet_tuple_sm_line(form) >= 0) { + c->current_mapping.line = janet_tuple_sm_line(form); + c->current_mapping.column = janet_tuple_sm_column(form); + } + /* Bracketed tuples are not specials or macros! */ + if (janet_tuple_flag(form) & JANET_TUPLE_FLAG_BRACKETCTOR) + return 0; + if (!janet_checktype(form[0], JANET_SYMBOL)) + return 0; + const uint8_t *name = janet_unwrap_symbol(form[0]); + const JanetSpecial *s = janetc_special(name); + if (s) { + *spec = s; + return 0; + } + Janet macroval; + JanetBindingType btype = janet_resolve(c->env, name, ¯oval); + if (!(btype == JANET_BINDING_MACRO || btype == JANET_BINDING_DYNAMIC_MACRO) || + !janet_checktype(macroval, JANET_FUNCTION)) + return 0; + + /* Evaluate macro */ + JanetFunction *macro = janet_unwrap_function(macroval); + int32_t arity = janet_tuple_length(form) - 1; + JanetFiber *fiberp = janet_fiber(macro, 64, arity, form + 1); + if (NULL == fiberp) { + int32_t minar = macro->def->min_arity; + int32_t maxar = macro->def->max_arity; + const uint8_t *es = NULL; + if (minar >= 0 && arity < minar) + es = janet_formatc("macro arity mismatch, expected at least %d, got %d", minar, arity); + if (maxar >= 0 && arity > maxar) + es = janet_formatc("macro arity mismatch, expected at most %d, got %d", maxar, arity); + c->result.macrofiber = NULL; + janetc_error(c, es); + return 0; + } + /* Set env */ + fiberp->env = c->env; + int lock = janet_gclock(); + Janet mf_kw = janet_ckeywordv("macro-form"); + janet_table_put(c->env, mf_kw, x); + Janet ml_kw = janet_ckeywordv("macro-lints"); + if (c->lints) { + janet_table_put(c->env, ml_kw, janet_wrap_array(c->lints)); + } + Janet tempOut; + JanetSignal status = janet_continue(fiberp, janet_wrap_nil(), &tempOut); + janet_table_put(c->env, mf_kw, janet_wrap_nil()); + janet_table_put(c->env, ml_kw, janet_wrap_nil()); + janet_gcunlock(lock); + if (status != JANET_SIGNAL_OK) { + const uint8_t *es = janet_formatc("(macro) %V", tempOut); + c->result.macrofiber = fiberp; + janetc_error(c, es); + return 0; + } else { + *out = tempOut; + } + + return 1; +} + +/* Compile a single value */ +JanetSlot janetc_value(JanetFopts opts, Janet x) { + JanetSlot ret; + JanetCompiler *c = opts.compiler; + JanetSourceMapping last_mapping = c->current_mapping; + c->recursion_guard--; + + /* Guard against previous errors and unbounded recursion */ + if (c->result.status == JANET_COMPILE_ERROR) return janetc_cslot(janet_wrap_nil()); + if (c->recursion_guard <= 0) { + janetc_cerror(c, "recursed too deeply"); + return janetc_cslot(janet_wrap_nil()); + } + + /* Macro expand. Also gets possible special form and + * refines source mapping cursor if possible. */ + const JanetSpecial *spec = NULL; + int macroi = JANET_MAX_MACRO_EXPAND; + while (macroi && + c->result.status != JANET_COMPILE_ERROR && + macroexpand1(c, x, &x, &spec)) + macroi--; + if (macroi == 0) { + janetc_cerror(c, "recursed too deeply in macro expansion"); + return janetc_cslot(janet_wrap_nil()); + } + + /* Special forms */ + if (spec) { + const Janet *tup = janet_unwrap_tuple(x); + ret = spec->compile(opts, janet_tuple_length(tup) - 1, tup + 1); + } else { + switch (janet_type(x)) { + case JANET_TUPLE: { + JanetFopts subopts = janetc_fopts_default(c); + const Janet *tup = janet_unwrap_tuple(x); + /* Empty tuple is tuple literal */ + if (janet_tuple_length(tup) == 0) { + ret = janetc_cslot(janet_wrap_tuple(janet_tuple_n(NULL, 0))); + } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */ + ret = janetc_tuple(opts, x); + } else { + JanetSlot head = janetc_value(subopts, tup[0]); + subopts.flags = JANET_FUNCTION | JANET_CFUNCTION; + ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head); + janetc_freeslot(c, head); + } + ret.flags &= ~JANET_SLOT_SPLICED; + } + break; + case JANET_SYMBOL: + ret = janetc_resolve(c, janet_unwrap_symbol(x)); + break; + case JANET_ARRAY: + ret = janetc_array(opts, x); + break; + case JANET_STRUCT: + ret = janetc_tablector(opts, x, JOP_MAKE_STRUCT); + break; + case JANET_TABLE: + ret = janetc_tablector(opts, x, JOP_MAKE_TABLE); + break; + case JANET_BUFFER: + ret = janetc_bufferctor(opts, x); + break; + default: + ret = janetc_cslot(x); + break; + } + } + + if (c->result.status == JANET_COMPILE_ERROR) + return janetc_cslot(janet_wrap_nil()); + if (opts.flags & JANET_FOPTS_TAIL) + ret = janetc_return(c, ret); + if (opts.flags & JANET_FOPTS_HINT) { + janetc_copy(c, opts.hint, ret); + ret = opts.hint; + } + c->current_mapping = last_mapping; + c->recursion_guard++; + return ret; +} + +/* Add function flags to janet functions */ +void janet_def_addflags(JanetFuncDef *def) { + int32_t set_flags = 0; + int32_t unset_flags = 0; + /* pos checks */ + if (def->name) set_flags |= JANET_FUNCDEF_FLAG_HASNAME; + if (def->source) set_flags |= JANET_FUNCDEF_FLAG_HASSOURCE; + if (def->defs) set_flags |= JANET_FUNCDEF_FLAG_HASDEFS; + if (def->environments) set_flags |= JANET_FUNCDEF_FLAG_HASENVS; + if (def->sourcemap) set_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP; + if (def->closure_bitset) set_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET; + /* negative checks */ + if (!def->name) unset_flags |= JANET_FUNCDEF_FLAG_HASNAME; + if (!def->source) unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCE; + if (!def->defs) unset_flags |= JANET_FUNCDEF_FLAG_HASDEFS; + if (!def->environments) unset_flags |= JANET_FUNCDEF_FLAG_HASENVS; + if (!def->sourcemap) unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP; + if (!def->closure_bitset) unset_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET; + /* Update flags */ + def->flags |= set_flags; + def->flags &= ~unset_flags; +} + +/* Compile a funcdef */ +/* Once the various other settings of the FuncDef have been tweaked, + * call janet_def_addflags to set the proper flags for the funcdef */ +JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) { + JanetScope *scope = c->scope; + JanetFuncDef *def = janet_funcdef_alloc(); + def->slotcount = scope->ra.max + 1; + + janet_assert(scope->flags & JANET_SCOPE_FUNCTION, "expected function scope"); + + /* Copy envs */ + def->environments_length = janet_v_count(scope->envs); + def->environments = janet_malloc(sizeof(int32_t) * def->environments_length); + for (int32_t i = 0; i < def->environments_length; i++) { + def->environments[i] = scope->envs[i].envindex; + } + + def->constants_length = janet_v_count(scope->consts); + def->constants = janet_v_flatten(scope->consts); + + def->defs_length = janet_v_count(scope->defs); + def->defs = janet_v_flatten(scope->defs); + + /* Copy bytecode (only last chunk) */ + def->bytecode_length = janet_v_count(c->buffer) - scope->bytecode_start; + if (def->bytecode_length) { + size_t s = sizeof(int32_t) * (size_t) def->bytecode_length; + def->bytecode = janet_malloc(s); + if (NULL == def->bytecode) { + JANET_OUT_OF_MEMORY; + } + safe_memcpy(def->bytecode, c->buffer + scope->bytecode_start, s); + janet_v__cnt(c->buffer) = scope->bytecode_start; + if (NULL != c->mapbuffer && c->source) { + size_t s = sizeof(JanetSourceMapping) * (size_t) def->bytecode_length; + def->sourcemap = janet_malloc(s); + if (NULL == def->sourcemap) { + JANET_OUT_OF_MEMORY; + } + safe_memcpy(def->sourcemap, c->mapbuffer + scope->bytecode_start, s); + janet_v__cnt(c->mapbuffer) = scope->bytecode_start; + } + } + + /* Get source from parser */ + def->source = c->source; + + def->arity = 0; + def->min_arity = 0; + def->flags = 0; + if (scope->flags & JANET_SCOPE_ENV) { + def->flags |= JANET_FUNCDEF_FLAG_NEEDSENV; + } + + /* Copy upvalue bitset */ + if (scope->ua.count) { + /* Number of u32s we need to create a bitmask for all slots */ + int32_t slotchunks = (def->slotcount + 31) >> 5; + /* numchunks is min of slotchunks and scope->ua.count */ + int32_t numchunks = slotchunks > scope->ua.count ? scope->ua.count : slotchunks; + uint32_t *chunks = janet_calloc(sizeof(uint32_t), slotchunks); + if (NULL == chunks) { + JANET_OUT_OF_MEMORY; + } + memcpy(chunks, scope->ua.chunks, sizeof(uint32_t) * numchunks); + /* Register allocator preallocates some registers [240-255, high 16 bits of chunk index 7], we can ignore those. */ + if (scope->ua.count > 7) chunks[7] &= 0xFFFFU; + def->closure_bitset = chunks; + } + + /* Capture symbol to local mapping */ + JanetSymbolMap *locals = NULL; + + /* Symbol -> upvalue mapping */ + JanetScope *top = c->scope; + while (top->parent) top = top->parent; + for (JanetScope *s = top; s != NULL; s = s->child) { + for (int32_t j = 0; j < janet_v_count(scope->envs); j++) { + JanetEnvRef ref = scope->envs[j]; + JanetScope *upscope = ref.scope; + if (upscope != s) continue; + for (int32_t i = 0; i < janet_v_count(upscope->syms); i++) { + SymPair pair = upscope->syms[i]; + if (pair.sym2) { + JanetSymbolMap jsm; + jsm.birth_pc = UINT32_MAX; + jsm.death_pc = j; + jsm.slot_index = pair.slot.index; + jsm.symbol = pair.sym2; + janet_v_push(locals, jsm); + } + } + } + } + + /* Symbol -> slot mapping */ + for (int32_t i = 0; i < janet_v_count(scope->syms); i++) { + SymPair pair = scope->syms[i]; + if (pair.sym2) { + JanetSymbolMap jsm; + if (pair.death_pc == UINT32_MAX) { + jsm.death_pc = def->bytecode_length; + } else { + jsm.death_pc = pair.death_pc - scope->bytecode_start; + } + /* Handle birth_pc == 0 correctly */ + if ((uint32_t) scope->bytecode_start > pair.birth_pc) { + jsm.birth_pc = 0; + } else { + jsm.birth_pc = pair.birth_pc - scope->bytecode_start; + } + janet_assert(jsm.birth_pc <= jsm.death_pc, "birth pc after death pc"); + janet_assert(jsm.birth_pc < (uint32_t) def->bytecode_length, "bad birth pc"); + janet_assert(jsm.death_pc <= (uint32_t) def->bytecode_length, "bad death pc"); + jsm.slot_index = pair.slot.index; + jsm.symbol = pair.sym2; + janet_v_push(locals, jsm); + } + } + def->symbolmap_length = janet_v_count(locals); + def->symbolmap = janet_v_flatten(locals); + if (def->symbolmap_length) def->flags |= JANET_FUNCDEF_FLAG_HASSYMBOLMAP; + + /* Pop the scope */ + janetc_popscope(c); + + /* Do basic optimization */ + janet_bytecode_movopt(def); + janet_bytecode_remove_noops(def); + + return def; +} + +/* Initialize a compiler */ +static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where, JanetArray *lints) { + c->scope = NULL; + c->buffer = NULL; + c->mapbuffer = NULL; + c->recursion_guard = JANET_RECURSION_GUARD; + c->env = env; + c->source = where; + c->current_mapping.line = -1; + c->current_mapping.column = -1; + c->lints = lints; + /* Init result */ + c->result.error = NULL; + c->result.status = JANET_COMPILE_OK; + c->result.funcdef = NULL; + c->result.macrofiber = NULL; + c->result.error_mapping.line = -1; + c->result.error_mapping.column = -1; +} + +/* Deinitialize a compiler struct */ +static void janetc_deinit(JanetCompiler *c) { + janet_v_free(c->buffer); + janet_v_free(c->mapbuffer); + c->env = NULL; +} + +/* Compile a form. */ +JanetCompileResult janet_compile_lint(Janet source, + JanetTable *env, const uint8_t *where, JanetArray *lints) { + JanetCompiler c; + JanetScope rootscope; + JanetFopts fopts; + + janetc_init(&c, env, where, lints); + + /* Push a function scope */ + janetc_scope(&rootscope, &c, JANET_SCOPE_FUNCTION | JANET_SCOPE_TOP, "root"); + + /* Set initial form options */ + fopts.compiler = &c; + fopts.flags = JANET_FOPTS_TAIL | JANET_SLOTTYPE_ANY; + fopts.hint = janetc_cslot(janet_wrap_nil()); + + /* Compile the value */ + janetc_value(fopts, source); + + if (c.result.status == JANET_COMPILE_OK) { + JanetFuncDef *def = janetc_pop_funcdef(&c); + def->name = janet_cstring("_thunk"); + janet_def_addflags(def); + c.result.funcdef = def; + } else { + c.result.error_mapping = c.current_mapping; + janetc_popscope(&c); + } + + janetc_deinit(&c); + + return c.result; +} + +JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *where) { + return janet_compile_lint(source, env, where, NULL); +} + +/* C Function for compiling */ +JANET_CORE_FN(cfun_compile, + "(compile ast &opt env source lints)", + "Compiles an Abstract Syntax Tree (ast) into a function. " + "Pair the compile function with parsing functionality to implement " + "eval. Returns a new function and does not modify ast. Returns an error " + "struct with keys :line, :column, and :error if compilation fails. " + "If a `lints` array is given, linting messages will be appended to the array. " + "Each message will be a tuple of the form `(level line col message)`.") { + janet_arity(argc, 1, 4); + JanetTable *env = (argc > 1 && !janet_checktype(argv[1], JANET_NIL)) + ? janet_gettable(argv, 1) : janet_vm.fiber->env; + if (NULL == env) { + env = janet_table(0); + janet_vm.fiber->env = env; + } + const uint8_t *source = NULL; + if (argc >= 3) { + Janet x = argv[2]; + if (janet_checktype(x, JANET_STRING)) { + source = janet_unwrap_string(x); + } else if (janet_checktype(x, JANET_KEYWORD)) { + source = janet_unwrap_keyword(x); + } else if (!janet_checktype(x, JANET_NIL)) { + janet_panic_type(x, 2, JANET_TFLAG_STRING | JANET_TFLAG_KEYWORD); + } + } + JanetArray *lints = (argc >= 4 && !janet_checktype(argv[3], JANET_NIL)) + ? janet_getarray(argv, 3) : NULL; + JanetCompileResult res = janet_compile_lint(argv[0], env, source, lints); + if (res.status == JANET_COMPILE_OK) { + return janet_wrap_function(janet_thunk(res.funcdef)); + } else { + JanetTable *t = janet_table(4); + janet_table_put(t, janet_ckeywordv("error"), janet_wrap_string(res.error)); + if (res.error_mapping.line > 0) { + janet_table_put(t, janet_ckeywordv("line"), janet_wrap_integer(res.error_mapping.line)); + } + if (res.error_mapping.column > 0) { + janet_table_put(t, janet_ckeywordv("column"), janet_wrap_integer(res.error_mapping.column)); + } + if (res.macrofiber) { + janet_table_put(t, janet_ckeywordv("fiber"), janet_wrap_fiber(res.macrofiber)); + } + return janet_wrap_table(t); + } +} + +void janet_lib_compile(JanetTable *env) { + JanetRegExt cfuns[] = { + JANET_CORE_REG("compile", cfun_compile), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, cfuns); +} + + +/* src/core/corelib.c */ +#line 0 "src/core/corelib.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include +#include "compile.h" +#include "state.h" +#include "util.h" +#endif + +/* Generated bytes */ +#ifndef JANET_BOOTSTRAP +extern const unsigned char *janet_core_image; +extern size_t janet_core_image_size; +#endif + +/* Docstrings should only exist during bootstrap */ +#ifdef JANET_BOOTSTRAP +#define JDOC(x) (x) +#else +#define JDOC(x) NULL +#endif + +JanetModule janet_native(const char *name, const uint8_t **error) { + janet_sandbox_assert(JANET_SANDBOX_DYNAMIC_MODULES); + char *processed_name = get_processed_name(name); + Clib lib = load_clib(processed_name); + JanetModule init; + JanetModconf getter; + if (name != processed_name) janet_free(processed_name); + if (!lib) { + *error = janet_cstring(error_clib()); + return NULL; + } + init = (JanetModule) symbol_clib(lib, "_janet_init"); + if (!init) { + *error = janet_cstring("could not find the _janet_init symbol"); + return NULL; + } + getter = (JanetModconf) symbol_clib(lib, "_janet_mod_config"); + if (!getter) { + *error = janet_cstring("could not find the _janet_mod_config symbol"); + return NULL; + } + JanetBuildConfig modconf = getter(); + JanetBuildConfig host = janet_config_current(); + if (host.major != modconf.major || + host.minor < modconf.minor || + host.bits != modconf.bits) { + char errbuf[128]; + sprintf(errbuf, "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)", + host.major, + host.minor, + host.patch, + host.bits, + modconf.major, + modconf.minor, + modconf.patch, + modconf.bits); + *error = janet_cstring(errbuf); + return NULL; + } + return init; +} + +static const char *janet_dyncstring(const char *name, const char *dflt) { + Janet x = janet_dyn(name); + if (janet_checktype(x, JANET_NIL)) return dflt; + if (!janet_checktype(x, JANET_STRING)) { + janet_panicf("expected string, got %v", x); + } + const uint8_t *jstr = janet_unwrap_string(x); + const char *cstr = (const char *)jstr; + if (strlen(cstr) != (size_t) janet_string_length(jstr)) { + janet_panicf("string %v contains embedded 0s", x); + } + return cstr; +} + +static int is_path_sep(char c) { +#ifdef JANET_WINDOWS + if (c == '\\') return 1; +#endif + return c == '/'; +} + +/* Used for module system. */ +JANET_CORE_FN(janet_core_expand_path, + "(module/expand-path path template)", + "Expands a path template as found in `module/paths` for `module/find`. " + "This takes in a path (the argument to require) and a template string, " + "to expand the path to a path that can be used for importing files. " + "The replacements are as follows:\n\n" + "* :all: -- the value of path verbatim.\n\n" + "* :@all: -- Same as :all:, but if `path` starts with the @ character, " + "the first path segment is replaced with a dynamic binding " + "`(dyn )`.\n\n" + "* :cur: -- the directory portion, if any, of (dyn :current-file)\n\n" + "* :dir: -- the directory portion, if any, of the path argument\n\n" + "* :name: -- the name component of path, with extension if given\n\n" + "* :native: -- the extension used to load natives, .so or .dll\n\n" + "* :sys: -- the system path, or (dyn :syspath)") { + janet_fixarity(argc, 2); + const char *input = janet_getcstring(argv, 0); + const char *template = janet_getcstring(argv, 1); + const char *curfile = janet_dyncstring("current-file", ""); + const char *syspath = janet_dyncstring("syspath", ""); + JanetBuffer *out = janet_buffer(0); + size_t tlen = strlen(template); + + /* Calculate name */ + const char *name = input + strlen(input); + while (name > input) { + if (is_path_sep(*(name - 1))) break; + name--; + } + + /* Calculate dirpath from current file */ + const char *curname = curfile + strlen(curfile); + while (curname > curfile) { + if (is_path_sep(*curname)) break; + curname--; + } + const char *curdir; + int32_t curlen; + if (curname == curfile) { + /* Current file has one or zero path segments, so + * we are in the . directory. */ + curdir = "."; + curlen = 1; + } else { + /* Current file has 2 or more segments, so we + * can cut off the last segment. */ + curdir = curfile; + curlen = (int32_t)(curname - curfile); + } + + for (size_t i = 0; i < tlen; i++) { + if (template[i] == ':') { + if (strncmp(template + i, ":all:", 5) == 0) { + janet_buffer_push_cstring(out, input); + i += 4; + } else if (strncmp(template + i, ":@all:", 6) == 0) { + if (input[0] == '@') { + const char *p = input; + while (*p && !is_path_sep(*p)) p++; + size_t len = p - input - 1; + char *str = janet_smalloc(len + 1); + memcpy(str, input + 1, len); + str[len] = '\0'; + janet_formatb(out, "%V", janet_dyn(str)); + janet_sfree(str); + janet_buffer_push_cstring(out, p); + } else { + janet_buffer_push_cstring(out, input); + } + i += 5; + } else if (strncmp(template + i, ":cur:", 5) == 0) { + janet_buffer_push_bytes(out, (const uint8_t *)curdir, curlen); + i += 4; + } else if (strncmp(template + i, ":dir:", 5) == 0) { + janet_buffer_push_bytes(out, (const uint8_t *)input, + (int32_t)(name - input)); + i += 4; + } else if (strncmp(template + i, ":sys:", 5) == 0) { + janet_buffer_push_cstring(out, syspath); + i += 4; + } else if (strncmp(template + i, ":name:", 6) == 0) { + janet_buffer_push_cstring(out, name); + i += 5; + } else if (strncmp(template + i, ":native:", 8) == 0) { +#ifdef JANET_WINDOWS + janet_buffer_push_cstring(out, ".dll"); +#else + janet_buffer_push_cstring(out, ".so"); +#endif + i += 7; + } else { + janet_buffer_push_u8(out, (uint8_t) template[i]); + } + } else { + janet_buffer_push_u8(out, (uint8_t) template[i]); + } + } + + /* Normalize */ + uint8_t *scan = out->data; + uint8_t *print = scan; + uint8_t *scanend = scan + out->count; + int normal_section_count = 0; + int dot_count = 0; + while (scan < scanend) { + if (*scan == '.') { + if (dot_count >= 0) { + dot_count++; + } else { + *print++ = '.'; + } + } else if (is_path_sep(*scan)) { + if (dot_count == 1) { + ; + } else if (dot_count == 2) { + if (normal_section_count > 0) { + /* unprint last separator */ + print--; + /* unprint last section */ + while (print > out->data && !is_path_sep(*(print - 1))) + print--; + normal_section_count--; + } else { + *print++ = '.'; + *print++ = '.'; + *print++ = '/'; + } + } else if (scan == out->data || dot_count != 0) { + while (dot_count > 0) { + --dot_count; + *print++ = '.'; + } + if (scan > out->data) { + normal_section_count++; + } + *print++ = '/'; + } + dot_count = 0; + } else { + while (dot_count > 0) { + --dot_count; + *print++ = '.'; + } + dot_count = -1; + *print++ = *scan; + } + scan++; + } + out->count = (int32_t)(print - out->data); + return janet_wrap_buffer(out); +} + +JANET_CORE_FN(janet_core_dyn, + "(dyn key &opt default)", + "Get a dynamic binding. Returns the default value (or nil) if no binding found.") { + janet_arity(argc, 1, 2); + Janet value; + if (janet_vm.fiber->env) { + value = janet_table_get(janet_vm.fiber->env, argv[0]); + } else { + value = janet_wrap_nil(); + } + if (argc == 2 && janet_checktype(value, JANET_NIL)) { + return argv[1]; + } + return value; +} + +JANET_CORE_FN(janet_core_setdyn, + "(setdyn key value)", + "Set a dynamic binding. Returns value.") { + janet_fixarity(argc, 2); + if (!janet_vm.fiber->env) { + janet_vm.fiber->env = janet_table(2); + } + janet_table_put(janet_vm.fiber->env, argv[0], argv[1]); + return argv[1]; +} + +JANET_CORE_FN(janet_core_native, + "(native path &opt env)", + "Load a native module from the given path. The path " + "must be an absolute or relative path on the file system, and is " + "usually a .so file on Unix systems, and a .dll file on Windows. " + "Returns an environment table that contains functions and other values " + "from the native module.") { + JanetModule init; + janet_arity(argc, 1, 2); + const uint8_t *path = janet_getstring(argv, 0); + const uint8_t *error = NULL; + JanetTable *env; + if (argc == 2) { + env = janet_gettable(argv, 1); + } else { + env = janet_table(0); + } + init = janet_native((const char *)path, &error); + if (!init) { + janet_panicf("could not load native %S: %S", path, error); + } + init(env); + janet_table_put(env, janet_ckeywordv("native"), argv[0]); + return janet_wrap_table(env); +} + +JANET_CORE_FN(janet_core_describe, + "(describe x)", + "Returns a string that is a human-readable description of `x`. " + "For recursive data structures, the string returned contains a " + "pointer value from which the identity of `x` " + "can be determined.") { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < argc; ++i) + janet_description_b(b, argv[i]); + return janet_stringv(b->data, b->count); +} + +JANET_CORE_FN(janet_core_string, + "(string & xs)", + "Creates a string by concatenating the elements of `xs` together. If an " + "element is not a byte sequence, it is converted to bytes via `describe`. " + "Returns the new string.") { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < argc; ++i) + janet_to_string_b(b, argv[i]); + return janet_stringv(b->data, b->count); +} + +JANET_CORE_FN(janet_core_symbol, + "(symbol & xs)", + "Creates a symbol by concatenating the elements of `xs` together. If an " + "element is not a byte sequence, it is converted to bytes via `describe`. " + "Returns the new symbol.") { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < argc; ++i) + janet_to_string_b(b, argv[i]); + return janet_symbolv(b->data, b->count); +} + +JANET_CORE_FN(janet_core_keyword, + "(keyword & xs)", + "Creates a keyword by concatenating the elements of `xs` together. If an " + "element is not a byte sequence, it is converted to bytes via `describe`. " + "Returns the new keyword.") { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < argc; ++i) + janet_to_string_b(b, argv[i]); + return janet_keywordv(b->data, b->count); +} + +JANET_CORE_FN(janet_core_buffer, + "(buffer & xs)", + "Creates a buffer by concatenating the elements of `xs` together. If an " + "element is not a byte sequence, it is converted to bytes via `describe`. " + "Returns the new buffer.") { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < argc; ++i) + janet_to_string_b(b, argv[i]); + return janet_wrap_buffer(b); +} + +JANET_CORE_FN(janet_core_is_abstract, + "(abstract? x)", + "Check if x is an abstract type.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(janet_checktype(argv[0], JANET_ABSTRACT)); +} + +JANET_CORE_FN(janet_core_scannumber, + "(scan-number str &opt base)", + "Parse a number from a byte sequence and return that number, either an integer " + "or a real. The number " + "must be in the same format as numbers in janet source code. Will return nil " + "on an invalid number. Optionally provide a base - if a base is provided, no " + "radix specifier is expected at the beginning of the number.") { + double number; + janet_arity(argc, 1, 2); + JanetByteView view = janet_getbytes(argv, 0); + int32_t base = janet_optinteger(argv, argc, 1, 0); + int valid = base == 0 || (base >= 2 && base <= 36); + if (!valid) { + janet_panicf("expected base between 2 and 36, got %d", base); + } + if (janet_scan_number_base(view.bytes, view.len, base, &number)) + return janet_wrap_nil(); + return janet_wrap_number(number); +} + +JANET_CORE_FN(janet_core_tuple, + "(tuple & items)", + "Creates a new tuple that contains items. Returns the new tuple.") { + return janet_wrap_tuple(janet_tuple_n(argv, argc)); +} + +JANET_CORE_FN(janet_core_array, + "(array & items)", + "Create a new array that contains items. Returns the new array.") { + JanetArray *array = janet_array(argc); + array->count = argc; + safe_memcpy(array->data, argv, argc * sizeof(Janet)); + return janet_wrap_array(array); +} + +JANET_CORE_FN(janet_core_slice, + "(slice x &opt start end)", + "Extract a sub-range of an indexed data structure or byte sequence.") { + JanetRange range; + JanetByteView bview; + JanetView iview; + if (janet_bytes_view(argv[0], &bview.bytes, &bview.len)) { + range = janet_getslice(argc, argv); + return janet_stringv(bview.bytes + range.start, range.end - range.start); + } else if (janet_indexed_view(argv[0], &iview.items, &iview.len)) { + range = janet_getslice(argc, argv); + return janet_wrap_tuple(janet_tuple_n(iview.items + range.start, range.end - range.start)); + } else { + janet_panic_type(argv[0], 0, JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED); + } +} + +JANET_CORE_FN(janet_core_range, + "(range & args)", + "Create an array of values [start, end) with a given step. " + "With one argument, returns a range [0, end). With two arguments, returns " + "a range [start, end). With three, returns a range with optional step size.") { + janet_arity(argc, 1, 3); + int32_t start = 0, stop = 0, step = 1, count = 0; + if (argc == 3) { + start = janet_getinteger(argv, 0); + stop = janet_getinteger(argv, 1); + step = janet_getinteger(argv, 2); + count = (step > 0) ? (stop - start - 1) / step + 1 : + ((step < 0) ? (stop - start + 1) / step + 1 : 0); + } else if (argc == 2) { + start = janet_getinteger(argv, 0); + stop = janet_getinteger(argv, 1); + count = stop - start; + } else { + stop = janet_getinteger(argv, 0); + count = stop; + } + count = (count > 0) ? count : 0; + JanetArray *array = janet_array(count); + for (int32_t i = 0; i < count; i++) { + array->data[i] = janet_wrap_number(start + i * step); + } + array->count = count; + return janet_wrap_array(array); +} + +JANET_CORE_FN(janet_core_table, + "(table & kvs)", + "Creates a new table from a variadic number of keys and values. " + "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has " + "an odd number of elements, an error will be thrown. Returns the " + "new table.") { + int32_t i; + if (argc & 1) + janet_panic("expected even number of arguments"); + JanetTable *table = janet_table(argc >> 1); + for (i = 0; i < argc; i += 2) { + janet_table_put(table, argv[i], argv[i + 1]); + } + return janet_wrap_table(table); +} + +JANET_CORE_FN(janet_core_getproto, + "(getproto x)", + "Get the prototype of a table or struct. Will return nil if `x` has no prototype.") { + janet_fixarity(argc, 1); + if (janet_checktype(argv[0], JANET_TABLE)) { + JanetTable *t = janet_unwrap_table(argv[0]); + return t->proto + ? janet_wrap_table(t->proto) + : janet_wrap_nil(); + } + if (janet_checktype(argv[0], JANET_STRUCT)) { + JanetStruct st = janet_unwrap_struct(argv[0]); + return janet_struct_proto(st) + ? janet_wrap_struct(janet_struct_proto(st)) + : janet_wrap_nil(); + } + janet_panicf("expected struct or table, got %v", argv[0]); +} + +JANET_CORE_FN(janet_core_struct, + "(struct & kvs)", + "Create a new struct from a sequence of key value pairs. " + "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has " + "an odd number of elements, an error will be thrown. Returns the " + "new struct.") { + int32_t i; + if (argc & 1) { + janet_panic("expected even number of arguments"); + } + JanetKV *st = janet_struct_begin(argc >> 1); + for (i = 0; i < argc; i += 2) { + janet_struct_put(st, argv[i], argv[i + 1]); + } + return janet_wrap_struct(janet_struct_end(st)); +} + +JANET_CORE_FN(janet_core_gensym, + "(gensym)", + "Returns a new symbol that is unique across the runtime. This means it " + "will not collide with any already created symbols during compilation, so " + "it can be used in macros to generate automatic bindings.") { + (void) argv; + janet_fixarity(argc, 0); + return janet_wrap_symbol(janet_symbol_gen()); +} + +JANET_CORE_FN(janet_core_gccollect, + "(gccollect)", + "Run garbage collection. You should probably not call this manually.") { + (void) argv; + (void) argc; + janet_collect(); + return janet_wrap_nil(); +} + +JANET_CORE_FN(janet_core_gcsetinterval, + "(gcsetinterval interval)", + "Set an integer number of bytes to allocate before running garbage collection. " + "Low values for interval will be slower but use less memory. " + "High values will be faster but use more memory.") { + janet_fixarity(argc, 1); + size_t s = janet_getsize(argv, 0); + /* limit interval to 48 bits */ +#ifdef JANET_64 + if (s >> 48) { + janet_panic("interval too large"); + } +#endif + janet_vm.gc_interval = s; + return janet_wrap_nil(); +} + +JANET_CORE_FN(janet_core_gcinterval, + "(gcinterval)", + "Returns the integer number of bytes to allocate before running an iteration " + "of garbage collection.") { + (void) argv; + janet_fixarity(argc, 0); + return janet_wrap_number((double) janet_vm.gc_interval); +} + +JANET_CORE_FN(janet_core_type, + "(type x)", + "Returns the type of `x` as a keyword. `x` is one of:\n\n" + "* :nil\n\n" + "* :boolean\n\n" + "* :number\n\n" + "* :array\n\n" + "* :tuple\n\n" + "* :table\n\n" + "* :struct\n\n" + "* :string\n\n" + "* :buffer\n\n" + "* :symbol\n\n" + "* :keyword\n\n" + "* :function\n\n" + "* :cfunction\n\n" + "* :fiber\n\n" + "or another keyword for an abstract type.") { + janet_fixarity(argc, 1); + JanetType t = janet_type(argv[0]); + if (t == JANET_ABSTRACT) { + return janet_ckeywordv(janet_abstract_type(janet_unwrap_abstract(argv[0]))->name); + } else { + return janet_ckeywordv(janet_type_names[t]); + } +} + +JANET_CORE_FN(janet_core_hash, + "(hash value)", + "Gets a hash for any value. The hash is an integer can be used " + "as a cheap hash function for all values. If two values are strictly equal, " + "then they will have the same hash value.") { + janet_fixarity(argc, 1); + return janet_wrap_number(janet_hash(argv[0])); +} + +JANET_CORE_FN(janet_core_getline, + "(getline &opt prompt buf env)", + "Reads a line of input into a buffer, including the newline character, using a prompt. " + "An optional environment table can be provided for auto-complete. " + "Returns the modified buffer. " + "Use this function to implement a simple interface for a terminal program.") { + FILE *in = janet_dynfile("in", stdin); + FILE *out = janet_dynfile("out", stdout); + janet_arity(argc, 0, 3); + JanetBuffer *buf = (argc >= 2) ? janet_getbuffer(argv, 1) : janet_buffer(10); + if (argc >= 1) { + const char *prompt = (const char *) janet_getstring(argv, 0); + fprintf(out, "%s", prompt); + fflush(out); + } + { + buf->count = 0; + int c; + for (;;) { + c = fgetc(in); + if (feof(in) || c < 0) { + break; + } + janet_buffer_push_u8(buf, (uint8_t) c); + if (c == '\n') break; + } + } + return janet_wrap_buffer(buf); +} + +JANET_CORE_FN(janet_core_trace, + "(trace func)", + "Enable tracing on a function. Returns the function.") { + janet_fixarity(argc, 1); + JanetFunction *func = janet_getfunction(argv, 0); + func->gc.flags |= JANET_FUNCFLAG_TRACE; + return argv[0]; +} + +JANET_CORE_FN(janet_core_untrace, + "(untrace func)", + "Disables tracing on a function. Returns the function.") { + janet_fixarity(argc, 1); + JanetFunction *func = janet_getfunction(argv, 0); + func->gc.flags &= ~JANET_FUNCFLAG_TRACE; + return argv[0]; +} + +JANET_CORE_FN(janet_core_check_int, + "(int? x)", + "Check if x can be exactly represented as a 32 bit signed two's complement integer.") { + janet_fixarity(argc, 1); + if (!janet_checktype(argv[0], JANET_NUMBER)) goto ret_false; + double num = janet_unwrap_number(argv[0]); + return janet_wrap_boolean(num == (double)((int32_t)num)); +ret_false: + return janet_wrap_false(); +} + +JANET_CORE_FN(janet_core_check_nat, + "(nat? x)", + "Check if x can be exactly represented as a non-negative 32 bit signed two's complement integer.") { + janet_fixarity(argc, 1); + if (!janet_checktype(argv[0], JANET_NUMBER)) goto ret_false; + double num = janet_unwrap_number(argv[0]); + return janet_wrap_boolean(num >= 0 && (num == (double)((int32_t)num))); +ret_false: + return janet_wrap_false(); +} + +JANET_CORE_FN(janet_core_is_bytes, + "(bytes? x)", + "Check if x is a string, symbol, keyword, or buffer.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_BYTES)); +} + +JANET_CORE_FN(janet_core_is_indexed, + "(indexed? x)", + "Check if x is an array or tuple.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_INDEXED)); +} + +JANET_CORE_FN(janet_core_is_dictionary, + "(dictionary? x)", + "Check if x is a table or struct.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_DICTIONARY)); +} + +JANET_CORE_FN(janet_core_is_lengthable, + "(lengthable? x)", + "Check if x is a bytes, indexed, or dictionary.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_LENGTHABLE)); +} + +JANET_CORE_FN(janet_core_signal, + "(signal what x)", + "Raise a signal with payload x. ") { + janet_arity(argc, 1, 2); + Janet payload = argc == 2 ? argv[1] : janet_wrap_nil(); + if (janet_checkint(argv[0])) { + int32_t s = janet_unwrap_integer(argv[0]); + if (s < 0 || s > 9) { + janet_panicf("expected user signal between 0 and 9, got %d", s); + } + janet_signalv(JANET_SIGNAL_USER0 + s, payload); + } else { + JanetKeyword kw = janet_getkeyword(argv, 0); + for (unsigned i = 0; i < sizeof(janet_signal_names) / sizeof(char *); i++) { + if (!janet_cstrcmp(kw, janet_signal_names[i])) { + janet_signalv((JanetSignal) i, payload); + } + } + } + janet_panicf("unknown signal %v", argv[0]); +} + +JANET_CORE_FN(janet_core_memcmp, + "(memcmp a b &opt len offset-a offset-b)", + "Compare memory. Takes two byte sequences `a` and `b`, and " + "return 0 if they have identical contents, a negative integer if a is less than b, " + "and a positive integer if a is greater than b. Optionally take a length and offsets " + "to compare slices of the bytes sequences.") { + janet_arity(argc, 2, 5); + JanetByteView a = janet_getbytes(argv, 0); + JanetByteView b = janet_getbytes(argv, 1); + int32_t len = janet_optnat(argv, argc, 2, a.len < b.len ? a.len : b.len); + int32_t offset_a = janet_optnat(argv, argc, 3, 0); + int32_t offset_b = janet_optnat(argv, argc, 4, 0); + if (offset_a + len > a.len) janet_panicf("invalid offset-a: %d", offset_a); + if (offset_b + len > b.len) janet_panicf("invalid offset-b: %d", offset_b); + return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, (size_t) len)); +} + +typedef struct SandboxOption { + const char *name; + uint32_t flag; +} SandboxOption; + +static const SandboxOption sandbox_options[] = { + {"all", JANET_SANDBOX_ALL}, + {"env", JANET_SANDBOX_ENV}, + {"ffi", JANET_SANDBOX_FFI}, + {"ffi-define", JANET_SANDBOX_FFI_DEFINE}, + {"ffi-jit", JANET_SANDBOX_FFI_JIT}, + {"ffi-use", JANET_SANDBOX_FFI_USE}, + {"fs", JANET_SANDBOX_FS}, + {"fs-read", JANET_SANDBOX_FS_READ}, + {"fs-temp", JANET_SANDBOX_FS_TEMP}, + {"fs-write", JANET_SANDBOX_FS_WRITE}, + {"hrtime", JANET_SANDBOX_HRTIME}, + {"modules", JANET_SANDBOX_DYNAMIC_MODULES}, + {"net", JANET_SANDBOX_NET}, + {"net-connect", JANET_SANDBOX_NET_CONNECT}, + {"net-listen", JANET_SANDBOX_NET_LISTEN}, + {"sandbox", JANET_SANDBOX_SANDBOX}, + {"signal", JANET_SANDBOX_SIGNAL}, + {"subprocess", JANET_SANDBOX_SUBPROCESS}, + {NULL, 0} +}; + +JANET_CORE_FN(janet_core_sandbox, + "(sandbox & forbidden-capabilities)", + "Disable feature sets to prevent the interpreter from using certain system resources. " + "Once a feature is disabled, there is no way to re-enable it. Capabilities can be:\n\n" + "* :all - disallow all (except IO to stdout, stderr, and stdin)\n" + "* :env - disallow reading and write env variables\n" + "* :ffi - disallow FFI (recommended if disabling anything else)\n" + "* :ffi-define - disallow loading new FFI modules and binding new functions\n" + "* :ffi-jit - disallow calling `ffi/jitfn`\n" + "* :ffi-use - disallow using any previously bound FFI functions and memory-unsafe functions.\n" + "* :fs - disallow access to the file system\n" + "* :fs-read - disallow read access to the file system\n" + "* :fs-temp - disallow creating temporary files\n" + "* :fs-write - disallow write access to the file system\n" + "* :hrtime - disallow high-resolution timers\n" + "* :modules - disallow load dynamic modules (natives)\n" + "* :net - disallow network access\n" + "* :net-connect - disallow making outbound network connections\n" + "* :net-listen - disallow accepting inbound network connections\n" + "* :sandbox - disallow calling this function\n" + "* :signal - disallow adding or removing signal handlers\n" + "* :subprocess - disallow running subprocesses") { + uint32_t flags = 0; + for (int32_t i = 0; i < argc; i++) { + JanetKeyword kw = janet_getkeyword(argv, i); + const SandboxOption *opt = sandbox_options; + while (opt->name != NULL) { + if (janet_cstrcmp(kw, opt->name) == 0) { + flags |= opt->flag; + break; + } + opt++; + } + if (opt->name == NULL) janet_panicf("unknown capability %v", argv[i]); + } + janet_sandbox(flags); + return janet_wrap_nil(); +} + +#ifdef JANET_BOOTSTRAP + +/* Utility for inline assembly */ +static void janet_quick_asm( + JanetTable *env, + int32_t flags, + const char *name, + int32_t arity, + int32_t min_arity, + int32_t max_arity, + int32_t slots, + const uint32_t *bytecode, + size_t bytecode_size, + const char *doc) { + JanetFuncDef *def = janet_funcdef_alloc(); + def->arity = arity; + def->min_arity = min_arity; + def->max_arity = max_arity; + def->flags = flags; + def->slotcount = slots; + def->bytecode = janet_malloc(bytecode_size); + def->bytecode_length = (int32_t)(bytecode_size / sizeof(uint32_t)); + def->name = janet_cstring(name); + if (!def->bytecode) { + JANET_OUT_OF_MEMORY; + } + memcpy(def->bytecode, bytecode, bytecode_size); + janet_def_addflags(def); + janet_def(env, name, janet_wrap_function(janet_thunk(def)), doc); +} + +/* Macros for easier inline assembly */ +#define SSS(op, a, b, c) ((op) | ((a) << 8) | ((b) << 16) | ((c) << 24)) +#define SS(op, a, b) ((op) | ((a) << 8) | ((b) << 16)) +#define SSI(op, a, b, I) ((op) | ((a) << 8) | ((b) << 16) | ((uint32_t)(I) << 24)) +#define S(op, a) ((op) | ((a) << 8)) +#define SI(op, a, I) ((op) | ((a) << 8) | ((uint32_t)(I) << 16)) + +/* Templatize a varop */ +static void templatize_varop( + JanetTable *env, + int32_t flags, + const char *name, + int32_t nullary, + int32_t unary, + uint32_t op, + const char *doc) { + + /* Variadic operator assembly. Must be templatized for each different opcode. */ + /* Reg 0: Argument tuple (args) */ + /* Reg 1: Argument count (argn) */ + /* Reg 2: Jump flag (jump?) */ + /* Reg 3: Accumulator (accum) */ + /* Reg 4: Next operand (operand) */ + /* Reg 5: Loop iterator (i) */ + uint32_t varop_asm[] = { + SS(JOP_LENGTH, 1, 0), /* Put number of arguments in register 1 -> argn = count(args) */ + + /* Check nullary */ + SSS(JOP_EQUALS_IMMEDIATE, 2, 1, 0), /* Check if numargs equal to 0 */ + SI(JOP_JUMP_IF_NOT, 2, 3), /* If not 0, jump to next check */ + /* Nullary */ + SI(JOP_LOAD_INTEGER, 3, nullary), /* accum = nullary value */ + S(JOP_RETURN, 3), /* return accum */ + + /* Check unary */ + SSI(JOP_EQUALS_IMMEDIATE, 2, 1, 1), /* Check if numargs equal to 1 */ + SI(JOP_JUMP_IF_NOT, 2, 5), /* If not 1, jump to next check */ + /* Unary */ + SI(JOP_LOAD_INTEGER, 3, unary), /* accum = unary value */ + SSI(JOP_GET_INDEX, 4, 0, 0), /* operand = args[0] */ + SSS(op, 3, 3, 4), /* accum = accum op operand */ + S(JOP_RETURN, 3), /* return accum */ + + /* Mutli (2 or more) arity */ + /* Prime loop */ + SSI(JOP_GET_INDEX, 3, 0, 0), /* accum = args[0] */ + SI(JOP_LOAD_INTEGER, 5, 1), /* i = 1 */ + /* Main loop */ + SSS(JOP_IN, 4, 0, 5), /* operand = args[i] */ + SSS(op, 3, 3, 4), /* accum = accum op operand */ + SSI(JOP_ADD_IMMEDIATE, 5, 5, 1), /* i++ */ + SSI(JOP_EQUALS, 2, 5, 1), /* jump? = (i == argn) */ + SI(JOP_JUMP_IF_NOT, 2, -4), /* if not jump? go back 4 */ + + /* Done, do last and return accumulator */ + S(JOP_RETURN, 3) /* return accum */ + }; + + janet_quick_asm( + env, + flags | JANET_FUNCDEF_FLAG_VARARG, + name, + 0, + 0, + INT32_MAX, + 6, + varop_asm, + sizeof(varop_asm), + doc); +} + +/* Templatize variadic comparators */ +static void templatize_comparator( + JanetTable *env, + int32_t flags, + const char *name, + int invert, + uint32_t op, + const char *doc) { + + /* Reg 0: Argument tuple (args) */ + /* Reg 1: Argument count (argn) */ + /* Reg 2: Jump flag (jump?) */ + /* Reg 3: Last value (last) */ + /* Reg 4: Next operand (next) */ + /* Reg 5: Loop iterator (i) */ + uint32_t comparator_asm[] = { + SS(JOP_LENGTH, 1, 0), /* Put number of arguments in register 1 -> argn = count(args) */ + SSS(JOP_LESS_THAN_IMMEDIATE, 2, 1, 2), /* Check if numargs less than 2 */ + SI(JOP_JUMP_IF, 2, 10), /* If numargs < 2, jump to done */ + + /* Prime loop */ + SSI(JOP_GET_INDEX, 3, 0, 0), /* last = args[0] */ + SI(JOP_LOAD_INTEGER, 5, 1), /* i = 1 */ + + /* Main loop */ + SSS(JOP_IN, 4, 0, 5), /* next = args[i] */ + SSS(op, 2, 3, 4), /* jump? = last compare next */ + SI(JOP_JUMP_IF_NOT, 2, 7), /* if not jump? goto fail (return false) */ + SSI(JOP_ADD_IMMEDIATE, 5, 5, 1), /* i++ */ + SS(JOP_MOVE_NEAR, 3, 4), /* last = next */ + SSI(JOP_EQUALS, 2, 5, 1), /* jump? = (i == argn) */ + SI(JOP_JUMP_IF_NOT, 2, -6), /* if not jump? go back 6 */ + + /* Done, return true */ + S(invert ? JOP_LOAD_FALSE : JOP_LOAD_TRUE, 3), + S(JOP_RETURN, 3), + + /* Failed, return false */ + S(invert ? JOP_LOAD_TRUE : JOP_LOAD_FALSE, 3), + S(JOP_RETURN, 3) + }; + + janet_quick_asm( + env, + flags | JANET_FUNCDEF_FLAG_VARARG, + name, + 0, + 0, + INT32_MAX, + 6, + comparator_asm, + sizeof(comparator_asm), + doc); +} + +/* Make the apply function */ +static void make_apply(JanetTable *env) { + /* Reg 0: Function (fun) */ + /* Reg 1: Argument tuple (args) */ + /* Reg 2: Argument count (argn) */ + /* Reg 3: Jump flag (jump?) */ + /* Reg 4: Loop iterator (i) */ + /* Reg 5: Loop values (x) */ + uint32_t apply_asm[] = { + SS(JOP_LENGTH, 2, 1), + SSS(JOP_EQUALS_IMMEDIATE, 3, 2, 0), /* Immediate tail call if no args */ + SI(JOP_JUMP_IF, 3, 9), + + /* Prime loop */ + SI(JOP_LOAD_INTEGER, 4, 0), /* i = 0 */ + + /* Main loop */ + SSS(JOP_IN, 5, 1, 4), /* x = args[i] */ + SSI(JOP_ADD_IMMEDIATE, 4, 4, 1), /* i++ */ + SSI(JOP_EQUALS, 3, 4, 2), /* jump? = (i == argn) */ + SI(JOP_JUMP_IF, 3, 3), /* if jump? go forward 3 */ + S(JOP_PUSH, 5), + (JOP_JUMP | ((uint32_t)(-5) << 8)), + + /* Push the array */ + S(JOP_PUSH_ARRAY, 5), + + /* Call the funciton */ + S(JOP_TAILCALL, 0) + }; + janet_quick_asm(env, JANET_FUN_APPLY | JANET_FUNCDEF_FLAG_VARARG, + "apply", 1, 1, INT32_MAX, 6, apply_asm, sizeof(apply_asm), + JDOC("(apply f & args)\n\n" + "Applies a function to a variable number of arguments. Each element in args " + "is used as an argument to f, except the last element in args, which is expected to " + "be an array-like. Each element in this last argument is then also pushed as an argument to " + "f. For example:\n\n" + "\t(apply + 1000 (range 10))\n\n" + "sums the first 10 integers and 1000.")); +} + +static const uint32_t error_asm[] = { + JOP_ERROR +}; +static const uint32_t debug_asm[] = { + JOP_SIGNAL | (2 << 24), + JOP_RETURN +}; +static const uint32_t yield_asm[] = { + JOP_SIGNAL | (3 << 24), + JOP_RETURN +}; +static const uint32_t resume_asm[] = { + JOP_RESUME | (1 << 24), + JOP_RETURN +}; +static const uint32_t cancel_asm[] = { + JOP_CANCEL | (1 << 24), + JOP_RETURN +}; +static const uint32_t in_asm[] = { + JOP_IN | (1 << 24), + JOP_LOAD_NIL | (3 << 8), + JOP_EQUALS | (3 << 8) | (3 << 24), + JOP_JUMP_IF | (3 << 8) | (2 << 16), + JOP_RETURN, + JOP_RETURN | (2 << 8) +}; +static const uint32_t get_asm[] = { + JOP_GET | (1 << 24), + JOP_LOAD_NIL | (3 << 8), + JOP_EQUALS | (3 << 8) | (3 << 24), + JOP_JUMP_IF | (3 << 8) | (2 << 16), + JOP_RETURN, + JOP_RETURN | (2 << 8) +}; +static const uint32_t put_asm[] = { + JOP_PUT | (1 << 16) | (2 << 24), + JOP_RETURN +}; +static const uint32_t length_asm[] = { + JOP_LENGTH, + JOP_RETURN +}; +static const uint32_t bnot_asm[] = { + JOP_BNOT, + JOP_RETURN +}; +static const uint32_t propagate_asm[] = { + JOP_PROPAGATE | (1 << 24), + JOP_RETURN +}; +static const uint32_t next_asm[] = { + JOP_NEXT | (1 << 24), + JOP_RETURN +}; +static const uint32_t cmp_asm[] = { + JOP_COMPARE | (1 << 24), + JOP_RETURN +}; +#endif /* ifdef JANET_BOOTSTRAP */ + +/* + * Setup Environment + */ + +static void janet_load_libs(JanetTable *env) { + JanetRegExt corelib_cfuns[] = { + JANET_CORE_REG("native", janet_core_native), + JANET_CORE_REG("describe", janet_core_describe), + JANET_CORE_REG("string", janet_core_string), + JANET_CORE_REG("symbol", janet_core_symbol), + JANET_CORE_REG("keyword", janet_core_keyword), + JANET_CORE_REG("buffer", janet_core_buffer), + JANET_CORE_REG("abstract?", janet_core_is_abstract), + JANET_CORE_REG("table", janet_core_table), + JANET_CORE_REG("array", janet_core_array), + JANET_CORE_REG("scan-number", janet_core_scannumber), + JANET_CORE_REG("tuple", janet_core_tuple), + JANET_CORE_REG("struct", janet_core_struct), + JANET_CORE_REG("gensym", janet_core_gensym), + JANET_CORE_REG("gccollect", janet_core_gccollect), + JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), + JANET_CORE_REG("gcinterval", janet_core_gcinterval), + JANET_CORE_REG("type", janet_core_type), + JANET_CORE_REG("hash", janet_core_hash), + JANET_CORE_REG("getline", janet_core_getline), + JANET_CORE_REG("dyn", janet_core_dyn), + JANET_CORE_REG("setdyn", janet_core_setdyn), + JANET_CORE_REG("trace", janet_core_trace), + JANET_CORE_REG("untrace", janet_core_untrace), + JANET_CORE_REG("module/expand-path", janet_core_expand_path), + JANET_CORE_REG("int?", janet_core_check_int), + JANET_CORE_REG("nat?", janet_core_check_nat), + JANET_CORE_REG("bytes?", janet_core_is_bytes), + JANET_CORE_REG("indexed?", janet_core_is_indexed), + JANET_CORE_REG("dictionary?", janet_core_is_dictionary), + JANET_CORE_REG("lengthable?", janet_core_is_lengthable), + JANET_CORE_REG("slice", janet_core_slice), + JANET_CORE_REG("range", janet_core_range), + JANET_CORE_REG("signal", janet_core_signal), + JANET_CORE_REG("memcmp", janet_core_memcmp), + JANET_CORE_REG("getproto", janet_core_getproto), + JANET_CORE_REG("sandbox", janet_core_sandbox), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, corelib_cfuns); + janet_lib_io(env); + janet_lib_math(env); + janet_lib_array(env); + janet_lib_tuple(env); + janet_lib_buffer(env); + janet_lib_table(env); + janet_lib_struct(env); + janet_lib_fiber(env); + janet_lib_os(env); + janet_lib_parse(env); + janet_lib_compile(env); + janet_lib_debug(env); + janet_lib_string(env); + janet_lib_marsh(env); +#ifdef JANET_PEG + janet_lib_peg(env); +#endif +#ifdef JANET_ASSEMBLER + janet_lib_asm(env); +#endif +#ifdef JANET_INT_TYPES + janet_lib_inttypes(env); +#endif +#ifdef JANET_EV + janet_lib_ev(env); +#endif +#ifdef JANET_NET + janet_lib_net(env); +#endif +#ifdef JANET_FFI + janet_lib_ffi(env); +#endif +} + +#ifdef JANET_BOOTSTRAP + +JanetTable *janet_core_env(JanetTable *replacements) { + JanetTable *env = (NULL != replacements) ? replacements : janet_table(0); + janet_quick_asm(env, JANET_FUN_CMP, + "cmp", 2, 2, 2, 2, cmp_asm, sizeof(cmp_asm), + JDOC("(cmp x y)\n\n" + "Returns -1 if x is strictly less than y, 1 if y is strictly greater " + "than x, and 0 otherwise. To return 0, x and y must be the exact same type.")); + janet_quick_asm(env, JANET_FUN_NEXT, + "next", 2, 1, 2, 2, next_asm, sizeof(next_asm), + JDOC("(next ds &opt key)\n\n" + "Gets the next key in a data structure. Can be used to iterate through " + "the keys of a data structure in an unspecified order. Keys are guaranteed " + "to be seen only once per iteration if the data structure is not mutated " + "during iteration. If key is nil, next returns the first key. If next " + "returns nil, there are no more keys to iterate through.")); + janet_quick_asm(env, JANET_FUN_PROP, + "propagate", 2, 2, 2, 2, propagate_asm, sizeof(propagate_asm), + JDOC("(propagate x fiber)\n\n" + "Propagate a signal from a fiber to the current fiber and " + "set the last value of the current fiber to `x`. The signal " + "value is then available as the status of the current fiber. " + "The resulting stack trace from the current fiber will include " + "frames from fiber. If fiber is in a state that can be resumed, " + "resuming the current fiber will first resume `fiber`. " + "This function can be used to re-raise an error without losing " + "the original stack trace.")); + janet_quick_asm(env, JANET_FUN_DEBUG, + "debug", 1, 0, 1, 1, debug_asm, sizeof(debug_asm), + JDOC("(debug &opt x)\n\n" + "Throws a debug signal that can be caught by a parent fiber and used to inspect " + "the running state of the current fiber. Returns the value passed in by resume.")); + janet_quick_asm(env, JANET_FUN_ERROR, + "error", 1, 1, 1, 1, error_asm, sizeof(error_asm), + JDOC("(error e)\n\n" + "Throws an error e that can be caught and handled by a parent fiber.")); + janet_quick_asm(env, JANET_FUN_YIELD, + "yield", 1, 0, 1, 2, yield_asm, sizeof(yield_asm), + JDOC("(yield &opt x)\n\n" + "Yield a value to a parent fiber. When a fiber yields, its execution is paused until " + "another thread resumes it. The fiber will then resume, and the last yield call will " + "return the value that was passed to resume.")); + janet_quick_asm(env, JANET_FUN_CANCEL, + "cancel", 2, 2, 2, 2, cancel_asm, sizeof(cancel_asm), + JDOC("(cancel fiber err)\n\n" + "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. " + "Returns the same result as resume.")); + janet_quick_asm(env, JANET_FUN_RESUME, + "resume", 2, 1, 2, 2, resume_asm, sizeof(resume_asm), + JDOC("(resume fiber &opt x)\n\n" + "Resume a new or suspended fiber and optionally pass in a value to the fiber that " + "will be returned to the last yield in the case of a pending fiber, or the argument to " + "the dispatch function in the case of a new fiber. Returns either the return result of " + "the fiber's dispatch function, or the value from the next yield call in fiber.")); + janet_quick_asm(env, JANET_FUN_IN, + "in", 3, 2, 3, 4, in_asm, sizeof(in_asm), + JDOC("(in ds key &opt dflt)\n\n" + "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, " + "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, " + "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can " + "take any value as a key except nil and will return nil or dflt if not found.")); + janet_quick_asm(env, JANET_FUN_GET, + "get", 3, 2, 3, 4, get_asm, sizeof(in_asm), + JDOC("(get ds key &opt dflt)\n\n" + "Get the value mapped to key in data structure ds, and return dflt or nil if not found. " + "Similar to in, but will not throw an error if the key is invalid for the data structure " + "unless the data structure is an abstract type. In that case, the abstract type getter may throw " + "an error.")); + janet_quick_asm(env, JANET_FUN_PUT, + "put", 3, 3, 3, 3, put_asm, sizeof(put_asm), + JDOC("(put ds key value)\n\n" + "Associate a key with a value in any mutable associative data structure. Indexed data structures " + "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds " + "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra " + "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype " + "will hide the association defined by the prototype, but will not mutate the prototype table. Putting " + "a value nil into a table will remove the key from the table. Returns the data structure ds.")); + janet_quick_asm(env, JANET_FUN_LENGTH, + "length", 1, 1, 1, 1, length_asm, sizeof(length_asm), + JDOC("(length ds)\n\n" + "Returns the length or count of a data structure in constant time as an integer. For " + "structs and tables, returns the number of key-value pairs in the data structure.")); + janet_quick_asm(env, JANET_FUN_BNOT, + "bnot", 1, 1, 1, 1, bnot_asm, sizeof(bnot_asm), + JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x.")); + make_apply(env); + + /* Variadic ops */ + templatize_varop(env, JANET_FUN_ADD, "+", 0, 0, JOP_ADD, + JDOC("(+ & xs)\n\n" + "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0.")); + templatize_varop(env, JANET_FUN_SUBTRACT, "-", 0, 0, JOP_SUBTRACT, + JDOC("(- & xs)\n\n" + "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the " + "negative value of that element. Otherwise, returns the first element in xs minus the sum of " + "the rest of the elements.")); + templatize_varop(env, JANET_FUN_MULTIPLY, "*", 1, 1, JOP_MULTIPLY, + JDOC("(* & xs)\n\n" + "Returns the product of all elements in xs. If xs is empty, returns 1.")); + templatize_varop(env, JANET_FUN_DIVIDE, "/", 1, 1, JOP_DIVIDE, + JDOC("(/ & xs)\n\n" + "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns " + "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining " + "values.")); + templatize_varop(env, JANET_FUN_DIVIDE_FLOOR, "div", 1, 1, JOP_DIVIDE_FLOOR, + JDOC("(div & xs)\n\n" + "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns " + "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining " + "values.")); + templatize_varop(env, JANET_FUN_MODULO, "mod", 0, 1, JOP_MODULO, + JDOC("(mod & xs)\n\n" + "Returns the result of applying the modulo operator on the first value of xs with each remaining value. " + "`(mod x 0)` is defined to be `x`.")); + templatize_varop(env, JANET_FUN_REMAINDER, "%", 0, 1, JOP_REMAINDER, + JDOC("(% & xs)\n\n" + "Returns the remainder of dividing the first value of xs by each remaining value.")); + templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND, + JDOC("(band & xs)\n\n" + "Returns the bit-wise and of all values in xs. Each x in xs must be an integer.")); + templatize_varop(env, JANET_FUN_BOR, "bor", 0, 0, JOP_BOR, + JDOC("(bor & xs)\n\n" + "Returns the bit-wise or of all values in xs. Each x in xs must be an integer.")); + templatize_varop(env, JANET_FUN_BXOR, "bxor", 0, 0, JOP_BXOR, + JDOC("(bxor & xs)\n\n" + "Returns the bit-wise xor of all values in xs. Each in xs must be an integer.")); + templatize_varop(env, JANET_FUN_LSHIFT, "blshift", 1, 1, JOP_SHIFT_LEFT, + JDOC("(blshift x & shifts)\n\n" + "Returns the value of x bit shifted left by the sum of all values in shifts. x " + "and each element in shift must be an integer.")); + templatize_varop(env, JANET_FUN_RSHIFT, "brshift", 1, 1, JOP_SHIFT_RIGHT, + JDOC("(brshift x & shifts)\n\n" + "Returns the value of x bit shifted right by the sum of all values in shifts. x " + "and each element in shift must be an integer.")); + templatize_varop(env, JANET_FUN_RSHIFTU, "brushift", 1, 1, JOP_SHIFT_RIGHT_UNSIGNED, + JDOC("(brushift x & shifts)\n\n" + "Returns the value of x bit shifted right by the sum of all values in shifts. x " + "and each element in shift must be an integer. The sign of x is not preserved, so " + "for positive shifts the return value will always be positive.")); + + /* Variadic comparators */ + templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_GREATER_THAN, + JDOC("(> & xs)\n\n" + "Check if xs is in descending order. Returns a boolean.")); + templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_LESS_THAN, + JDOC("(< & xs)\n\n" + "Check if xs is in ascending order. Returns a boolean.")); + templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_GREATER_THAN_EQUAL, + JDOC("(>= & xs)\n\n" + "Check if xs is in non-ascending order. Returns a boolean.")); + templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_LESS_THAN_EQUAL, + JDOC("(<= & xs)\n\n" + "Check if xs is in non-descending order. Returns a boolean.")); + templatize_comparator(env, JANET_FUN_EQ, "=", 0, JOP_EQUALS, + JDOC("(= & xs)\n\n" + "Check if all values in xs are equal. Returns a boolean.")); + templatize_comparator(env, JANET_FUN_NEQ, "not=", 1, JOP_EQUALS, + JDOC("(not= & xs)\n\n" + "Check if any values in xs are not equal. Returns a boolean.")); + + /* Platform detection */ + janet_def(env, "janet/version", janet_cstringv(JANET_VERSION), + JDOC("The version number of the running janet program.")); + janet_def(env, "janet/build", janet_cstringv(JANET_BUILD), + JDOC("The build identifier of the running janet program.")); + janet_def(env, "janet/config-bits", janet_wrap_integer(JANET_CURRENT_CONFIG_BITS), + JDOC("The flag set of config options from janetconf.h which is used to check " + "if native modules are compatible with the host program.")); + + /* Allow references to the environment */ + janet_def(env, "root-env", janet_wrap_table(env), + JDOC("The root environment used to create environments with (make-env).")); + + janet_load_libs(env); + janet_gcroot(janet_wrap_table(env)); + return env; +} + +#else + +JanetTable *janet_core_env(JanetTable *replacements) { + /* Memoize core env, ignoring replacements the second time around. */ + if (NULL != janet_vm.core_env) { + return janet_vm.core_env; + } + + JanetTable *dict = janet_core_lookup_table(replacements); + + /* Unmarshal bytecode */ + Janet marsh_out = janet_unmarshal( + janet_core_image, + janet_core_image_size, + 0, + dict, + NULL); + + /* Memoize */ + janet_gcroot(marsh_out); + JanetTable *env = janet_unwrap_table(marsh_out); + janet_vm.core_env = env; + + /* Invert image dict manually here. We can't do this in boot.janet as it + * breaks deterministic builds */ + Janet lidv, midv; + lidv = midv = janet_wrap_nil(); + janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); + janet_resolve(env, janet_csymbol("make-image-dict"), &midv); + JanetTable *lid = janet_unwrap_table(lidv); + JanetTable *mid = janet_unwrap_table(midv); + for (int32_t i = 0; i < lid->capacity; i++) { + const JanetKV *kv = lid->data + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_table_put(mid, kv->value, kv->key); + } + } + + return env; +} + +#endif + +JanetTable *janet_core_lookup_table(JanetTable *replacements) { + JanetTable *dict = janet_table(512); + janet_load_libs(dict); + + /* Add replacements */ + if (replacements != NULL) { + for (int32_t i = 0; i < replacements->capacity; i++) { + JanetKV kv = replacements->data[i]; + if (!janet_checktype(kv.key, JANET_NIL)) { + janet_table_put(dict, kv.key, kv.value); + /* Add replacement functions to registry? */ + } + } + } + + return dict; +} + + +/* src/core/debug.c */ +#line 0 "src/core/debug.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "state.h" +#include "util.h" +#include "vector.h" +#endif + +/* Implements functionality to build a debugger from within janet. + * The repl should also be able to serve as pretty featured debugger + * out of the box. */ + +/* Add a break point to a function */ +void janet_debug_break(JanetFuncDef *def, int32_t pc) { + if (pc >= def->bytecode_length || pc < 0) + janet_panic("invalid bytecode offset"); + def->bytecode[pc] |= 0x80; +} + +/* Remove a break point from a function */ +void janet_debug_unbreak(JanetFuncDef *def, int32_t pc) { + if (pc >= def->bytecode_length || pc < 0) + janet_panic("invalid bytecode offset"); + def->bytecode[pc] &= ~((uint32_t)0x80); +} + +/* + * Find a location for a breakpoint given a source file an + * location. + */ +void janet_debug_find( + JanetFuncDef **def_out, int32_t *pc_out, + const uint8_t *source, int32_t sourceLine, int32_t sourceColumn) { + /* Scan the heap for right func def */ + JanetGCObject *current = janet_vm.blocks; + /* Keep track of the best source mapping we have seen so far */ + int32_t besti = -1; + int32_t best_line = -1; + int32_t best_column = -1; + JanetFuncDef *best_def = NULL; + while (NULL != current) { + if ((current->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_FUNCDEF) { + JanetFuncDef *def = (JanetFuncDef *)(current); + if (def->sourcemap && + def->source && + !janet_string_compare(source, def->source)) { + /* Correct source file, check mappings. The chosen + * pc index is the instruction closest to the given line column, but + * not after. */ + int32_t i; + for (i = 0; i < def->bytecode_length; i++) { + int32_t line = def->sourcemap[i].line; + int32_t column = def->sourcemap[i].column; + if (line <= sourceLine && line >= best_line) { + if (column <= sourceColumn && + (line > best_line || column > best_column)) { + best_line = line; + best_column = column; + besti = i; + best_def = def; + } + } + } + } + } + current = current->data.next; + } + if (best_def) { + *def_out = best_def; + *pc_out = besti; + } else { + janet_panic("could not find breakpoint"); + } +} + +void janet_stacktrace(JanetFiber *fiber, Janet err) { + const char *prefix = janet_checktype(err, JANET_NIL) ? NULL : ""; + janet_stacktrace_ext(fiber, err, prefix); +} + +/* Error reporting. This can be emulated from within Janet, but for + * consitency with the top level code it is defined once. */ +void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) { + + int32_t fi; + const char *errstr = (const char *)janet_to_string(err); + JanetFiber **fibers = NULL; + int wrote_error = !prefix; + + int print_color = janet_truthy(janet_dyn("err-color")); + if (print_color) janet_eprintf("\x1b[31m"); + + while (fiber) { + janet_v_push(fibers, fiber); + fiber = fiber->child; + } + + for (fi = janet_v_count(fibers) - 1; fi >= 0; fi--) { + fiber = fibers[fi]; + int32_t i = fiber->frame; + while (i > 0) { + JanetCFunRegistry *reg = NULL; + JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + JanetFuncDef *def = NULL; + i = frame->prevframe; + + /* Print prelude to stack frame */ + if (!wrote_error) { + JanetFiberStatus status = janet_fiber_status(fiber); + janet_eprintf("%s%s: %s\n", + prefix ? prefix : "", + janet_status_names[status], + errstr ? errstr : janet_status_names[status]); + wrote_error = 1; + } + + janet_eprintf(" in"); + + if (frame->func) { + def = frame->func->def; + janet_eprintf(" %s", def->name ? (const char *)def->name : ""); + if (def->source) { + janet_eprintf(" [%s]", (const char *)def->source); + } + } else { + JanetCFunction cfun = (JanetCFunction)(frame->pc); + if (cfun) { + reg = janet_registry_get(cfun); + if (NULL != reg && NULL != reg->name) { + if (reg->name_prefix) { + janet_eprintf(" %s/%s", reg->name_prefix, reg->name); + } else { + janet_eprintf(" %s", reg->name); + } + if (NULL != reg->source_file) { + janet_eprintf(" [%s]", reg->source_file); + } + } else { + janet_eprintf(" "); + } + } + } + if (frame->flags & JANET_STACKFRAME_TAILCALL) + janet_eprintf(" (tailcall)"); + if (frame->func && frame->pc) { + int32_t off = (int32_t)(frame->pc - def->bytecode); + if (def->sourcemap) { + JanetSourceMapping mapping = def->sourcemap[off]; + janet_eprintf(" on line %d, column %d", mapping.line, mapping.column); + } else { + janet_eprintf(" pc=%d", off); + } + } else if (NULL != reg) { + /* C Function */ + if (reg->source_line > 0) { + janet_eprintf(" on line %d", (long) reg->source_line); + } + } + janet_eprintf("\n"); + } + } + + if (print_color) janet_eprintf("\x1b[0m"); + + janet_v_free(fibers); +} + +/* + * CFuns + */ + +/* Helper to find funcdef and bytecode offset to insert or remove breakpoints. + * Takes a source file name and byte offset. */ +static void helper_find(int32_t argc, Janet *argv, JanetFuncDef **def, int32_t *bytecode_offset) { + janet_fixarity(argc, 3); + const uint8_t *source = janet_getstring(argv, 0); + int32_t line = janet_getinteger(argv, 1); + int32_t col = janet_getinteger(argv, 2); + janet_debug_find(def, bytecode_offset, source, line, col); +} + +/* Helper to find funcdef and bytecode offset to insert or remove breakpoints. + * Takes a function and byte offset*/ +static void helper_find_fun(int32_t argc, Janet *argv, JanetFuncDef **def, int32_t *bytecode_offset) { + janet_arity(argc, 1, 2); + JanetFunction *func = janet_getfunction(argv, 0); + int32_t offset = (argc == 2) ? janet_getinteger(argv, 1) : 0; + *def = func->def; + *bytecode_offset = offset; +} + +JANET_CORE_FN(cfun_debug_break, + "(debug/break source line col)", + "Sets a breakpoint in `source` at a given line and column. " + "Will throw an error if the breakpoint location " + "cannot be found. For example\n\n" + "\t(debug/break \"core.janet\" 10 4)\n\n" + "will set a breakpoint at line 10, 4th column of the file core.janet.") { + JanetFuncDef *def; + int32_t offset; + helper_find(argc, argv, &def, &offset); + janet_debug_break(def, offset); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_debug_unbreak, + "(debug/unbreak source line column)", + "Remove a breakpoint with a source key at a given line and column. " + "Will throw an error if the breakpoint " + "cannot be found.") { + JanetFuncDef *def; + int32_t offset = 0; + helper_find(argc, argv, &def, &offset); + janet_debug_unbreak(def, offset); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_debug_fbreak, + "(debug/fbreak fun &opt pc)", + "Set a breakpoint in a given function. pc is an optional offset, which " + "is in bytecode instructions. fun is a function value. Will throw an error " + "if the offset is too large or negative.") { + JanetFuncDef *def; + int32_t offset = 0; + helper_find_fun(argc, argv, &def, &offset); + janet_debug_break(def, offset); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_debug_unfbreak, + "(debug/unfbreak fun &opt pc)", + "Unset a breakpoint set with debug/fbreak.") { + JanetFuncDef *def; + int32_t offset; + helper_find_fun(argc, argv, &def, &offset); + janet_debug_unbreak(def, offset); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_debug_lineage, + "(debug/lineage fib)", + "Returns an array of all child fibers from a root fiber. This function " + "is useful when a fiber signals or errors to an ancestor fiber. Using this function, " + "the fiber handling the error can see which fiber raised the signal. This function should " + "be used mostly for debugging purposes.") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + JanetArray *array = janet_array(0); + while (fiber) { + janet_array_push(array, janet_wrap_fiber(fiber)); + fiber = fiber->child; + } + return janet_wrap_array(array); +} + +/* Extract info from one stack frame */ +static Janet doframe(JanetStackFrame *frame) { + int32_t off; + JanetTable *t = janet_table(3); + JanetFuncDef *def = NULL; + if (frame->func) { + janet_table_put(t, janet_ckeywordv("function"), janet_wrap_function(frame->func)); + def = frame->func->def; + if (def->name) { + janet_table_put(t, janet_ckeywordv("name"), janet_wrap_string(def->name)); + } + } else { + JanetCFunction cfun = (JanetCFunction)(frame->pc); + if (cfun) { + JanetCFunRegistry *reg = janet_registry_get(cfun); + if (NULL != reg->name) { + if (NULL != reg->name_prefix) { + janet_table_put(t, janet_ckeywordv("name"), janet_wrap_string(janet_formatc("%s/%s", reg->name_prefix, reg->name))); + } else { + janet_table_put(t, janet_ckeywordv("name"), janet_cstringv(reg->name)); + } + if (NULL != reg->source_file) { + janet_table_put(t, janet_ckeywordv("source"), janet_cstringv(reg->source_file)); + } + if (reg->source_line > 0) { + janet_table_put(t, janet_ckeywordv("source-line"), janet_wrap_integer(reg->source_line)); + janet_table_put(t, janet_ckeywordv("source-column"), janet_wrap_integer(1)); + } + } + } + janet_table_put(t, janet_ckeywordv("c"), janet_wrap_true()); + } + if (frame->flags & JANET_STACKFRAME_TAILCALL) { + janet_table_put(t, janet_ckeywordv("tail"), janet_wrap_true()); + } + if (frame->func && frame->pc) { + Janet *stack = (Janet *)frame + JANET_FRAME_SIZE; + JanetArray *slots; + janet_assert(def != NULL, "def != NULL"); + off = (int32_t)(frame->pc - def->bytecode); + janet_table_put(t, janet_ckeywordv("pc"), janet_wrap_integer(off)); + if (def->sourcemap) { + JanetSourceMapping mapping = def->sourcemap[off]; + janet_table_put(t, janet_ckeywordv("source-line"), janet_wrap_integer(mapping.line)); + janet_table_put(t, janet_ckeywordv("source-column"), janet_wrap_integer(mapping.column)); + } + if (def->source) { + janet_table_put(t, janet_ckeywordv("source"), janet_wrap_string(def->source)); + } + /* Add stack arguments */ + slots = janet_array(def->slotcount); + safe_memcpy(slots->data, stack, sizeof(Janet) * def->slotcount); + slots->count = def->slotcount; + janet_table_put(t, janet_ckeywordv("slots"), janet_wrap_array(slots)); + /* Add local bindings */ + if (def->symbolmap) { + JanetTable *local_bindings = janet_table(0); + for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { + JanetSymbolMap jsm = def->symbolmap[i]; + Janet value = janet_wrap_nil(); + uint32_t pc = (uint32_t)(frame->pc - def->bytecode); + if (jsm.birth_pc == UINT32_MAX) { + JanetFuncEnv *env = frame->func->envs[jsm.death_pc]; + if (env->offset > 0) { + value = env->as.fiber->data[env->offset + jsm.slot_index]; + } else { + value = env->as.values[jsm.slot_index]; + } + } else if (pc >= jsm.birth_pc && pc < jsm.death_pc) { + value = stack[jsm.slot_index]; + } + janet_table_put(local_bindings, janet_wrap_symbol(jsm.symbol), value); + } + janet_table_put(t, janet_ckeywordv("locals"), janet_wrap_table(local_bindings)); + } + } + return janet_wrap_table(t); +} + +JANET_CORE_FN(cfun_debug_stack, + "(debug/stack fib)", + "Gets information about the stack as an array of tables. Each table " + "in the array contains information about a stack frame. The top-most, current " + "stack frame is the first table in the array, and the bottom-most stack frame " + "is the last value. Each stack frame contains some of the following attributes:\n\n" + "* :c - true if the stack frame is a c function invocation\n\n" + "* :source-column - the current source column of the stack frame\n\n" + "* :function - the function that the stack frame represents\n\n" + "* :source-line - the current source line of the stack frame\n\n" + "* :name - the human-friendly name of the function\n\n" + "* :pc - integer indicating the location of the program counter\n\n" + "* :source - string with the file path or other identifier for the source code\n\n" + "* :slots - array of all values in each slot\n\n" + "* :tail - boolean indicating a tail call") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + JanetArray *array = janet_array(0); + { + int32_t i = fiber->frame; + JanetStackFrame *frame; + while (i > 0) { + frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + janet_array_push(array, doframe(frame)); + i = frame->prevframe; + } + } + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_debug_stacktrace, + "(debug/stacktrace fiber &opt err prefix)", + "Prints a nice looking stacktrace for a fiber. Can optionally provide " + "an error value to print the stack trace with. If `prefix` is nil or not " + "provided, will skip the error line. Returns the fiber.") { + janet_arity(argc, 1, 3); + JanetFiber *fiber = janet_getfiber(argv, 0); + Janet x = argc == 1 ? janet_wrap_nil() : argv[1]; + const char *prefix = janet_optcstring(argv, argc, 2, NULL); + janet_stacktrace_ext(fiber, x, prefix); + return argv[0]; +} + +JANET_CORE_FN(cfun_debug_argstack, + "(debug/arg-stack fiber)", + "Gets all values currently on the fiber's argument stack. Normally, " + "this should be empty unless the fiber signals while pushing arguments " + "to make a function call. Returns a new array.") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + JanetArray *array = janet_array(fiber->stacktop - fiber->stackstart); + memcpy(array->data, fiber->data + fiber->stackstart, array->capacity * sizeof(Janet)); + array->count = array->capacity; + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_debug_step, + "(debug/step fiber &opt x)", + "Run a fiber for one virtual instruction of the Janet machine. Can optionally " + "pass in a value that will be passed as the resuming value. Returns the signal value, " + "which will usually be nil, as breakpoints raise nil signals.") { + janet_arity(argc, 1, 2); + JanetFiber *fiber = janet_getfiber(argv, 0); + Janet out = janet_wrap_nil(); + janet_step(fiber, argc == 1 ? janet_wrap_nil() : argv[1], &out); + return out; +} + +/* Module entry point */ +void janet_lib_debug(JanetTable *env) { + JanetRegExt debug_cfuns[] = { + JANET_CORE_REG("debug/break", cfun_debug_break), + JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), + JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), + JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), + JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), + JANET_CORE_REG("debug/stack", cfun_debug_stack), + JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), + JANET_CORE_REG("debug/lineage", cfun_debug_lineage), + JANET_CORE_REG("debug/step", cfun_debug_step), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, debug_cfuns); +} + + +/* src/core/emit.c */ +#line 0 "src/core/emit.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "emit.h" +#include "vector.h" +#include "regalloc.h" +#include "util.h" +#endif + +/* Get a register */ +int32_t janetc_allocfar(JanetCompiler *c) { + int32_t reg = janetc_regalloc_1(&c->scope->ra); + if (reg > 0xFFFF) { + janetc_cerror(c, "ran out of internal registers"); + } + return reg; +} + +/* Get a register less than 256 for temporary use. */ +int32_t janetc_allocnear(JanetCompiler *c, JanetcRegisterTemp tag) { + return janetc_regalloc_temp(&c->scope->ra, tag); +} + +/* Emit a raw instruction with source mapping. */ +void janetc_emit(JanetCompiler *c, uint32_t instr) { + janet_v_push(c->buffer, instr); + janet_v_push(c->mapbuffer, c->current_mapping); +} + +/* Add a constant to the current scope. Return the index of the constant. */ +static int32_t janetc_const(JanetCompiler *c, Janet x) { + JanetScope *scope = c->scope; + int32_t i, len; + /* Get the topmost function scope */ + while (scope) { + if (scope->flags & JANET_SCOPE_FUNCTION) + break; + scope = scope->parent; + } + /* Check if already added */ + len = janet_v_count(scope->consts); + for (i = 0; i < len; i++) { + if (janet_equals(x, scope->consts[i])) + return i; + } + /* Ensure not too many constants. */ + if (len >= 0xFFFF) { + janetc_cerror(c, "too many constants"); + return 0; + } + janet_v_push(scope->consts, x); + return len; +} + +/* Load a constant into a local register */ +static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) { + switch (janet_type(k)) { + case JANET_NIL: + janetc_emit(c, (reg << 8) | JOP_LOAD_NIL); + break; + case JANET_BOOLEAN: + janetc_emit(c, (reg << 8) | + (janet_unwrap_boolean(k) ? JOP_LOAD_TRUE : JOP_LOAD_FALSE)); + break; + case JANET_NUMBER: { + double dval = janet_unwrap_number(k); + if (dval < INT16_MIN || dval > INT16_MAX) + goto do_constant; + int32_t i = (int32_t) dval; + if (dval != i) + goto do_constant; + uint32_t iu = (uint32_t)i; + janetc_emit(c, + (iu << 16) | + (reg << 8) | + JOP_LOAD_INTEGER); + break; + } + default: + do_constant: { + int32_t cindex = janetc_const(c, k); + janetc_emit(c, + (cindex << 16) | + (reg << 8) | + JOP_LOAD_CONSTANT); + break; + } + } +} + +/* Move a slot to a near register */ +static void janetc_movenear(JanetCompiler *c, + int32_t dest, + JanetSlot src) { + if (src.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { + janetc_loadconst(c, src.constant, dest); + /* If we also are a reference, deref the one element array */ + if (src.flags & JANET_SLOT_REF) { + janetc_emit(c, + (dest << 16) | + (dest << 8) | + JOP_GET_INDEX); + } + } else if (src.envindex >= 0) { + janetc_emit(c, + ((uint32_t)(src.index) << 24) | + ((uint32_t)(src.envindex) << 16) | + ((uint32_t)(dest) << 8) | + JOP_LOAD_UPVALUE); + } else if (src.index != dest) { + janet_assert(src.index >= 0, "bad slot"); + janetc_emit(c, + ((uint32_t)(src.index) << 16) | + ((uint32_t)(dest) << 8) | + JOP_MOVE_NEAR); + } +} + +/* Move a near register to a Slot. */ +static void janetc_moveback(JanetCompiler *c, + JanetSlot dest, + int32_t src) { + if (dest.flags & JANET_SLOT_REF) { + int32_t refreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_5); + janetc_loadconst(c, dest.constant, refreg); + janetc_emit(c, + (src << 16) | + (refreg << 8) | + JOP_PUT_INDEX); + janetc_regalloc_freetemp(&c->scope->ra, refreg, JANETC_REGTEMP_5); + } else if (dest.envindex >= 0) { + janetc_emit(c, + ((uint32_t)(dest.index) << 24) | + ((uint32_t)(dest.envindex) << 16) | + ((uint32_t)(src) << 8) | + JOP_SET_UPVALUE); + } else if (dest.index != src) { + janet_assert(dest.index >= 0, "bad slot"); + janetc_emit(c, + ((uint32_t)(dest.index) << 16) | + ((uint32_t)(src) << 8) | + JOP_MOVE_FAR); + } +} + +/* Call this to release a register after emitting the instruction. */ +static void janetc_free_regnear(JanetCompiler *c, JanetSlot s, int32_t reg, JanetcRegisterTemp tag) { + if (reg != s.index || + s.envindex >= 0 || + s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { + /* We need to free the temporary slot */ + janetc_regalloc_freetemp(&c->scope->ra, reg, tag); + } +} + +/* Convert a slot to a two byte register */ +static int32_t janetc_regfar(JanetCompiler *c, JanetSlot s, JanetcRegisterTemp tag) { + /* check if already near register */ + if (s.envindex < 0 && s.index >= 0) { + return s.index; + } + int32_t reg; + int32_t nearreg = janetc_regalloc_temp(&c->scope->ra, tag); + janetc_movenear(c, nearreg, s); + if (nearreg >= 0xF0) { + reg = janetc_allocfar(c); + janetc_emit(c, JOP_MOVE_FAR | (nearreg << 8) | (reg << 16)); + janetc_regalloc_freetemp(&c->scope->ra, nearreg, tag); + } else { + reg = nearreg; + janetc_regalloc_freetemp(&c->scope->ra, nearreg, tag); + janetc_regalloc_touch(&c->scope->ra, reg); + } + return reg; +} + +/* Convert a slot to a temporary 1 byte register */ +static int32_t janetc_regnear(JanetCompiler *c, JanetSlot s, JanetcRegisterTemp tag) { + /* check if already near register */ + if (s.envindex < 0 && s.index >= 0 && s.index <= 0xFF) { + return s.index; + } + int32_t reg = janetc_regalloc_temp(&c->scope->ra, tag); + janetc_movenear(c, reg, s); + return reg; +} + +/* Check if two slots are equal */ +int janetc_sequal(JanetSlot lhs, JanetSlot rhs) { + if ((lhs.flags & ~JANET_SLOTTYPE_ANY) == (rhs.flags & ~JANET_SLOTTYPE_ANY) && + lhs.index == rhs.index && + lhs.envindex == rhs.envindex) { + if (lhs.flags & (JANET_SLOT_REF | JANET_SLOT_CONSTANT)) { + return janet_equals(lhs.constant, rhs.constant); + } else { + return 1; + } + } + return 0; +} + +/* Move values from one slot to another. The destination must + * be writeable (not a literal). */ +void janetc_copy( + JanetCompiler *c, + JanetSlot dest, + JanetSlot src) { + if (dest.flags & JANET_SLOT_CONSTANT) { + janetc_cerror(c, "cannot write to constant"); + return; + } + if (janetc_sequal(dest, src)) return; + /* If dest is a near register */ + if (dest.envindex < 0 && dest.index >= 0 && dest.index <= 0xFF) { + janetc_movenear(c, dest.index, src); + return; + } + /* If src is a near register */ + if (src.envindex < 0 && src.index >= 0 && src.index <= 0xFF) { + janetc_moveback(c, dest, src.index); + return; + } + /* Process: src -> near -> dest */ + int32_t nearreg = janetc_allocnear(c, JANETC_REGTEMP_3); + janetc_movenear(c, nearreg, src); + janetc_moveback(c, dest, nearreg); + /* Cleanup */ + janetc_regalloc_freetemp(&c->scope->ra, nearreg, JANETC_REGTEMP_3); +} + +/* Instruction templated emitters */ + +static int32_t emit1s(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t rest, int wr) { + int32_t reg = janetc_regnear(c, s, JANETC_REGTEMP_0); + int32_t label = janet_v_count(c->buffer); + janetc_emit(c, op | (reg << 8) | ((uint32_t)rest << 16)); + if (wr) + janetc_moveback(c, s, reg); + janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0); + return label; +} + +int32_t janetc_emit_s(JanetCompiler *c, uint8_t op, JanetSlot s, int wr) { + int32_t reg = janetc_regfar(c, s, JANETC_REGTEMP_0); + int32_t label = janet_v_count(c->buffer); + janetc_emit(c, op | (reg << 8)); + if (wr) + janetc_moveback(c, s, reg); + janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0); + return label; +} + +int32_t janetc_emit_sl(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t label) { + int32_t current = janet_v_count(c->buffer) - 1; + int32_t jump = label - current; + if (jump < INT16_MIN || jump > INT16_MAX) { + janetc_cerror(c, "jump is too far"); + } + return emit1s(c, op, s, jump, 0); +} + +int32_t janetc_emit_st(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t tflags) { + return emit1s(c, op, s, tflags, 0); +} + +int32_t janetc_emit_si(JanetCompiler *c, uint8_t op, JanetSlot s, int16_t immediate, int wr) { + return emit1s(c, op, s, immediate, wr); +} + +int32_t janetc_emit_su(JanetCompiler *c, uint8_t op, JanetSlot s, uint16_t immediate, int wr) { + return emit1s(c, op, s, (int32_t) immediate, wr); +} + +static int32_t emit2s(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int32_t rest, int wr) { + int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); + int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1); + int32_t label = janet_v_count(c->buffer); + janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)rest << 24)); + janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); + if (wr) + janetc_moveback(c, s1, reg1); + janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); + return label; +} + +int32_t janetc_emit_ss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int wr) { + int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); + int32_t reg2 = janetc_regfar(c, s2, JANETC_REGTEMP_1); + int32_t label = janet_v_count(c->buffer); + janetc_emit(c, op | (reg1 << 8) | (reg2 << 16)); + janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); + if (wr) + janetc_moveback(c, s1, reg1); + janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); + return label; +} + +int32_t janetc_emit_ssi(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int8_t immediate, int wr) { + return emit2s(c, op, s1, s2, immediate, wr); +} + +int32_t janetc_emit_ssu(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, uint8_t immediate, int wr) { + return emit2s(c, op, s1, s2, (int32_t) immediate, wr); +} + +int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, JanetSlot s3, int wr) { + int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); + int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1); + int32_t reg3 = janetc_regnear(c, s3, JANETC_REGTEMP_2); + int32_t label = janet_v_count(c->buffer); + janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)reg3 << 24)); + janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); + janetc_free_regnear(c, s3, reg3, JANETC_REGTEMP_2); + if (wr) + janetc_moveback(c, s1, reg1); + janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); + return label; +} + + +/* src/core/ev.c */ +#line 0 "src/core/ev.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "gc.h" +#include "state.h" +#include "fiber.h" +#endif + +#ifdef JANET_EV + +#include +#ifdef JANET_WINDOWS +#include +#include +#else +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef JANET_EV_EPOLL +#include +#include +#endif +#ifdef JANET_EV_KQUEUE +#include +#endif +#ifdef JANET_EV_POLL +#include +#endif +#endif + +typedef struct { + JanetVM *thread; + JanetFiber *fiber; + uint32_t sched_id; + enum { + JANET_CP_MODE_READ, + JANET_CP_MODE_WRITE, + JANET_CP_MODE_CHOICE_READ, + JANET_CP_MODE_CHOICE_WRITE, + JANET_CP_MODE_CLOSE + } mode; +} JanetChannelPending; + +typedef struct { + JanetQueue items; + JanetQueue read_pending; + JanetQueue write_pending; + int32_t limit; + int closed; + int is_threaded; +#ifdef JANET_WINDOWS + CRITICAL_SECTION lock; +#else + pthread_mutex_t lock; +#endif +} JanetChannel; + +typedef struct { + JanetFiber *fiber; + Janet value; + JanetSignal sig; + uint32_t expected_sched_id; /* If the fiber has been rescheduled this loop, don't run first scheduling. */ +} JanetTask; + +/* Wrap return value by pairing it with the callback used to handle it + * in the main thread */ +typedef struct { + JanetEVGenericMessage msg; + JanetThreadedCallback cb; +} JanetSelfPipeEvent; + +/* Structure used to initialize threads in the thread pool + * (same head structure as self pipe event)*/ +typedef struct { + JanetEVGenericMessage msg; + JanetThreadedCallback cb; + JanetThreadedSubroutine subr; + JanetHandle write_pipe; +} JanetEVThreadInit; + +#define JANET_MAX_Q_CAPACITY 0x7FFFFFF + +static void janet_q_init(JanetQueue *q) { + q->data = NULL; + q->head = 0; + q->tail = 0; + q->capacity = 0; +} + +static void janet_q_deinit(JanetQueue *q) { + janet_free(q->data); +} + +static int32_t janet_q_count(JanetQueue *q) { + return (q->head > q->tail) + ? (q->tail + q->capacity - q->head) + : (q->tail - q->head); +} + +static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) { + int32_t count = janet_q_count(q); + /* Resize if needed */ + if (count + 1 >= q->capacity) { + if (count + 1 >= JANET_MAX_Q_CAPACITY) return 1; + int32_t newcap = (count + 2) * 2; + if (newcap > JANET_MAX_Q_CAPACITY) newcap = JANET_MAX_Q_CAPACITY; + q->data = janet_realloc(q->data, itemsize * newcap); + if (NULL == q->data) { + JANET_OUT_OF_MEMORY; + } + if (q->head > q->tail) { + /* Two segments, fix 2nd seg. */ + int32_t newhead = q->head + (newcap - q->capacity); + size_t seg1 = (size_t)(q->capacity - q->head); + if (seg1 > 0) { + memmove((char *) q->data + (newhead * itemsize), + (char *) q->data + (q->head * itemsize), + seg1 * itemsize); + } + q->head = newhead; + } + q->capacity = newcap; + } + return 0; +} + +static int janet_q_push(JanetQueue *q, void *item, size_t itemsize) { + if (janet_q_maybe_resize(q, itemsize)) return 1; + memcpy((char *) q->data + itemsize * q->tail, item, itemsize); + q->tail = q->tail + 1 < q->capacity ? q->tail + 1 : 0; + return 0; +} + +static int janet_q_push_head(JanetQueue *q, void *item, size_t itemsize) { + if (janet_q_maybe_resize(q, itemsize)) return 1; + int32_t newhead = q->head - 1; + if (newhead < 0) { + newhead += q->capacity; + } + memcpy((char *) q->data + itemsize * newhead, item, itemsize); + q->head = newhead; + return 0; +} + +static int janet_q_pop(JanetQueue *q, void *out, size_t itemsize) { + if (q->head == q->tail) return 1; + memcpy(out, (char *) q->data + itemsize * q->head, itemsize); + q->head = q->head + 1 < q->capacity ? q->head + 1 : 0; + return 0; +} + +/* Get current timestamp (millisecond precision) */ +static JanetTimestamp ts_now(void); + +/* Get current timestamp + an interval (millisecond precision) */ +static JanetTimestamp ts_delta(JanetTimestamp ts, double delta) { + if (isinf(delta)) { + return delta < 0 ? ts : INT64_MAX; + } + ts += (int64_t)round(delta * 1000); + return ts; +} + +/* Look at the next timeout value without removing it. */ +static int peek_timeout(JanetTimeout *out) { + if (janet_vm.tq_count == 0) return 0; + *out = janet_vm.tq[0]; + return 1; +} + +/* Remove the next timeout from the priority queue */ +static void pop_timeout(size_t index) { + if (janet_vm.tq_count <= index) return; + janet_vm.tq[index] = janet_vm.tq[--janet_vm.tq_count]; + for (;;) { + size_t left = (index << 1) + 1; + size_t right = left + 1; + size_t smallest = index; + if (left < janet_vm.tq_count && + (janet_vm.tq[left].when < janet_vm.tq[smallest].when)) + smallest = left; + if (right < janet_vm.tq_count && + (janet_vm.tq[right].when < janet_vm.tq[smallest].when)) + smallest = right; + if (smallest == index) return; + JanetTimeout temp = janet_vm.tq[index]; + janet_vm.tq[index] = janet_vm.tq[smallest]; + janet_vm.tq[smallest] = temp; + index = smallest; + } +} + +/* Add a timeout to the timeout min heap */ +static void add_timeout(JanetTimeout to) { + size_t oldcount = janet_vm.tq_count; + size_t newcount = oldcount + 1; + if (newcount > janet_vm.tq_capacity) { + size_t newcap = 2 * newcount; + JanetTimeout *tq = janet_realloc(janet_vm.tq, newcap * sizeof(JanetTimeout)); + if (NULL == tq) { + JANET_OUT_OF_MEMORY; + } + janet_vm.tq = tq; + janet_vm.tq_capacity = newcap; + } + /* Append */ + janet_vm.tq_count = (int32_t) newcount; + janet_vm.tq[oldcount] = to; + /* Heapify */ + size_t index = oldcount; + while (index > 0) { + size_t parent = (index - 1) >> 1; + if (janet_vm.tq[parent].when <= janet_vm.tq[index].when) break; + /* Swap */ + JanetTimeout tmp = janet_vm.tq[index]; + janet_vm.tq[index] = janet_vm.tq[parent]; + janet_vm.tq[parent] = tmp; + /* Next */ + index = parent; + } +} + +void janet_async_end(JanetFiber *fiber) { + if (fiber->ev_callback) { + fiber->ev_callback(fiber, JANET_ASYNC_EVENT_DEINIT); + janet_gcunroot(janet_wrap_abstract(fiber->ev_stream)); + fiber->ev_callback = NULL; + if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { + if (fiber->ev_state) { + janet_free(fiber->ev_state); + fiber->ev_state = NULL; + } + janet_ev_dec_refcount(); + } + } +} + +void janet_async_in_flight(JanetFiber *fiber) { +#ifdef JANET_WINDOWS + fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT; +#else + (void) fiber; +#endif +} + +void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state) { + JanetFiber *fiber = janet_vm.root_fiber; + janet_assert(!fiber->ev_callback, "double async on fiber"); + if (mode & JANET_ASYNC_LISTEN_READ) stream->read_fiber = fiber; + if (mode & JANET_ASYNC_LISTEN_WRITE) stream->write_fiber = fiber; + fiber->ev_callback = callback; + fiber->ev_stream = stream; + janet_ev_inc_refcount(); + janet_gcroot(janet_wrap_abstract(stream)); + fiber->ev_state = state; + callback(fiber, JANET_ASYNC_EVENT_INIT); + janet_await(); +} + +void janet_fiber_did_resume(JanetFiber *fiber) { + janet_async_end(fiber); +} + +static void janet_stream_checktoclose(JanetStream *stream) { + if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->read_fiber && !stream->write_fiber) { + janet_stream_close(stream); + } +} + +/* Forward declaration */ +static void janet_register_stream(JanetStream *stream); + +static const JanetMethod ev_default_stream_methods[] = { + {"close", janet_cfun_stream_close}, + {"read", janet_cfun_stream_read}, + {"chunk", janet_cfun_stream_chunk}, + {"write", janet_cfun_stream_write}, + {NULL, NULL} +}; + +/* Create a stream*/ +JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod *methods) { + JanetStream *stream = janet_abstract(&janet_stream_type, sizeof(JanetStream)); + stream->handle = handle; + stream->flags = flags; + stream->read_fiber = NULL; + stream->write_fiber = NULL; + if (methods == NULL) methods = ev_default_stream_methods; + stream->methods = methods; + stream->index = 0; + janet_register_stream(stream); + return stream; +} + +static void janet_stream_close_impl(JanetStream *stream) { + stream->flags |= JANET_STREAM_CLOSED; +#ifdef JANET_WINDOWS + if (stream->handle != INVALID_HANDLE_VALUE) { +#ifdef JANET_NET + if (stream->flags & JANET_STREAM_SOCKET) { + closesocket((SOCKET) stream->handle); + } else +#endif + { + CloseHandle(stream->handle); + } + stream->handle = INVALID_HANDLE_VALUE; + } +#else + if (stream->handle != -1) { + close(stream->handle); + stream->handle = -1; +#ifdef JANET_EV_POLL + uint32_t i = stream->index; + size_t j = janet_vm.stream_count - 1; + JanetStream *last = janet_vm.streams[j]; + struct pollfd lastfd = janet_vm.fds[j + 1]; + janet_vm.fds[i + 1] = lastfd; + janet_vm.streams[i] = last; + last->index = stream->index; + janet_vm.stream_count--; +#endif + } +#endif +} + +void janet_stream_close(JanetStream *stream) { + JanetFiber *rf = stream->read_fiber; + JanetFiber *wf = stream->write_fiber; + if (rf && rf->ev_callback) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_CLOSE); + stream->read_fiber = NULL; + } + if (wf && wf->ev_callback) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_CLOSE); + stream->write_fiber = NULL; + } + janet_stream_close_impl(stream); +} + +/* Called to clean up a stream */ +static int janet_stream_gc(void *p, size_t s) { + (void) s; + JanetStream *stream = (JanetStream *)p; + janet_stream_close_impl(stream); + return 0; +} + +/* Mark a stream for GC */ +static int janet_stream_mark(void *p, size_t s) { + (void) s; + JanetStream *stream = (JanetStream *) p; + JanetFiber *rf = stream->read_fiber; + JanetFiber *wf = stream->write_fiber; + if (rf) { + janet_mark(janet_wrap_fiber(rf)); + } + if (wf) { + janet_mark(janet_wrap_fiber(wf)); + } + return 0; +} + +static int janet_stream_getter(void *p, Janet key, Janet *out) { + JanetStream *stream = (JanetStream *)p; + if (!janet_checktype(key, JANET_KEYWORD)) return 0; + const JanetMethod *stream_methods = stream->methods; + return janet_getmethod(janet_unwrap_keyword(key), stream_methods, out); +} + +static void janet_stream_marshal(void *p, JanetMarshalContext *ctx) { + JanetStream *s = p; + if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) { + janet_panic("can only marshal stream with unsafe flag"); + } + janet_marshal_abstract(ctx, p); + janet_marshal_int(ctx, (int32_t) s->flags); + janet_marshal_ptr(ctx, s->methods); +#ifdef JANET_WINDOWS + /* TODO - ref counting to avoid situation where a handle is closed or GCed + * while in transit, and it's value gets reused. DuplicateHandle does not work + * for network sockets, and in general for winsock it is better to not duplicate + * unless there is a need to. */ + HANDLE duph = INVALID_HANDLE_VALUE; + if (s->flags & JANET_STREAM_SOCKET) { + duph = s->handle; + } else { + DuplicateHandle( + GetCurrentProcess(), + s->handle, + GetCurrentProcess(), + &duph, + 0, + FALSE, + DUPLICATE_SAME_ACCESS); + } + janet_marshal_int64(ctx, (int64_t)(duph)); +#else + /* Marshal after dup becuse it is easier than maintaining our own ref counting. */ + int duph = dup(s->handle); + if (duph < 0) janet_panicf("failed to duplicate stream handle: %V", janet_ev_lasterr()); + janet_marshal_int(ctx, (int32_t)(duph)); +#endif +} + +static void *janet_stream_unmarshal(JanetMarshalContext *ctx) { + if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) { + janet_panic("can only unmarshal stream with unsafe flag"); + } + JanetStream *p = janet_unmarshal_abstract(ctx, sizeof(JanetStream)); + /* Can't share listening state and such across threads */ + p->read_fiber = NULL; + p->write_fiber = NULL; + p->flags = (uint32_t) janet_unmarshal_int(ctx); + p->methods = janet_unmarshal_ptr(ctx); +#ifdef JANET_WINDOWS + p->handle = (JanetHandle) janet_unmarshal_int64(ctx); +#else + p->handle = (JanetHandle) janet_unmarshal_int(ctx); +#endif +#ifdef JANET_EV_POLL + janet_register_stream(p); +#endif + return p; +} + +static Janet janet_stream_next(void *p, Janet key) { + JanetStream *stream = (JanetStream *)p; + return janet_nextmethod(stream->methods, key); +} + +const JanetAbstractType janet_stream_type = { + "core/stream", + janet_stream_gc, + janet_stream_mark, + janet_stream_getter, + NULL, + janet_stream_marshal, + janet_stream_unmarshal, + NULL, + NULL, + NULL, + janet_stream_next, + JANET_ATEND_NEXT +}; + +/* Register a fiber to resume with value */ +static void janet_schedule_general(JanetFiber *fiber, Janet value, JanetSignal sig, int soon) { + if (fiber->gc.flags & JANET_FIBER_EV_FLAG_CANCELED) return; + if (!(fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) { + Janet task_element = janet_wrap_fiber(fiber); + janet_table_put(&janet_vm.active_tasks, task_element, janet_wrap_true()); + } + JanetTask t = { fiber, value, sig, ++fiber->sched_id }; + fiber->gc.flags |= JANET_FIBER_FLAG_ROOT; + if (sig == JANET_SIGNAL_ERROR) fiber->gc.flags |= JANET_FIBER_EV_FLAG_CANCELED; + if (soon) { + janet_q_push_head(&janet_vm.spawn, &t, sizeof(t)); + } else { + janet_q_push(&janet_vm.spawn, &t, sizeof(t)); + } +} + +void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig) { + janet_schedule_general(fiber, value, sig, 0); +} + +void janet_schedule_soon(JanetFiber *fiber, Janet value, JanetSignal sig) { + janet_schedule_general(fiber, value, sig, 1); +} + +void janet_cancel(JanetFiber *fiber, Janet value) { + janet_schedule_signal(fiber, value, JANET_SIGNAL_ERROR); +} + +void janet_schedule(JanetFiber *fiber, Janet value) { + janet_schedule_signal(fiber, value, JANET_SIGNAL_OK); +} + +/* Mark all pending tasks */ +void janet_ev_mark(void) { + + /* Pending tasks */ + JanetTask *tasks = janet_vm.spawn.data; + if (janet_vm.spawn.head <= janet_vm.spawn.tail) { + for (int32_t i = janet_vm.spawn.head; i < janet_vm.spawn.tail; i++) { + janet_mark(janet_wrap_fiber(tasks[i].fiber)); + janet_mark(tasks[i].value); + } + } else { + for (int32_t i = janet_vm.spawn.head; i < janet_vm.spawn.capacity; i++) { + janet_mark(janet_wrap_fiber(tasks[i].fiber)); + janet_mark(tasks[i].value); + } + for (int32_t i = 0; i < janet_vm.spawn.tail; i++) { + janet_mark(janet_wrap_fiber(tasks[i].fiber)); + janet_mark(tasks[i].value); + } + } + + /* Pending timeouts */ + for (size_t i = 0; i < janet_vm.tq_count; i++) { + janet_mark(janet_wrap_fiber(janet_vm.tq[i].fiber)); + if (janet_vm.tq[i].curr_fiber != NULL) { + janet_mark(janet_wrap_fiber(janet_vm.tq[i].curr_fiber)); + } + } +} + +static int janet_channel_push(JanetChannel *channel, Janet x, int mode); +static int janet_channel_pop(JanetChannel *channel, Janet *item, int is_choice); + +static Janet make_supervisor_event(const char *name, JanetFiber *fiber, int threaded) { + Janet tup[3]; + tup[0] = janet_ckeywordv(name); + tup[1] = threaded ? fiber->last_value : janet_wrap_fiber(fiber) ; + if (fiber->env != NULL) { + tup[2] = janet_table_get(fiber->env, janet_ckeywordv("task-id")); + } else { + tup[2] = janet_wrap_nil(); + } + return janet_wrap_tuple(janet_tuple_n(tup, 3)); +} + +/* Common init code */ +void janet_ev_init_common(void) { + janet_q_init(&janet_vm.spawn); + janet_vm.tq = NULL; + janet_vm.tq_count = 0; + janet_vm.tq_capacity = 0; + janet_table_init_raw(&janet_vm.threaded_abstracts, 0); + janet_table_init_raw(&janet_vm.active_tasks, 0); + janet_table_init_raw(&janet_vm.signal_handlers, 0); + janet_rng_seed(&janet_vm.ev_rng, 0); +#ifndef JANET_WINDOWS + pthread_attr_init(&janet_vm.new_thread_attr); + pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); +#endif +} + +/* Common deinit code */ +void janet_ev_deinit_common(void) { + janet_q_deinit(&janet_vm.spawn); + janet_free(janet_vm.tq); + janet_table_deinit(&janet_vm.threaded_abstracts); + janet_table_deinit(&janet_vm.active_tasks); + janet_table_deinit(&janet_vm.signal_handlers); +#ifndef JANET_WINDOWS + pthread_attr_destroy(&janet_vm.new_thread_attr); +#endif +} + +/* Shorthand to yield to event loop */ +void janet_await(void) { + /* Store the fiber in a gobal table */ + janet_signalv(JANET_SIGNAL_EVENT, janet_wrap_nil()); +} + +/* Set timeout for the current root fiber */ +void janet_addtimeout(double sec) { + JanetFiber *fiber = janet_vm.root_fiber; + JanetTimeout to; + to.when = ts_delta(ts_now(), sec); + to.fiber = fiber; + to.curr_fiber = NULL; + to.sched_id = fiber->sched_id; + to.is_error = 1; + add_timeout(to); +} + +void janet_ev_inc_refcount(void) { + janet_atomic_inc(&janet_vm.listener_count); +} + +void janet_ev_dec_refcount(void) { + janet_atomic_dec(&janet_vm.listener_count); +} + +/* Channels */ + +#define JANET_MAX_CHANNEL_CAPACITY 0xFFFFFF + +static inline int janet_chan_is_threaded(JanetChannel *chan) { + return chan->is_threaded; +} + +static int janet_chan_pack(JanetChannel *chan, Janet *x) { + if (!janet_chan_is_threaded(chan)) return 0; + switch (janet_type(*x)) { + default: { + JanetBuffer *buf = janet_malloc(sizeof(JanetBuffer)); + if (NULL == buf) { + JANET_OUT_OF_MEMORY; + } + janet_buffer_init(buf, 10); + janet_marshal(buf, *x, NULL, JANET_MARSHAL_UNSAFE); + *x = janet_wrap_buffer(buf); + return 0; + } + case JANET_NIL: + case JANET_NUMBER: + case JANET_POINTER: + case JANET_BOOLEAN: + case JANET_CFUNCTION: + return 0; + } +} + +static int janet_chan_unpack(JanetChannel *chan, Janet *x, int is_cleanup) { + if (!janet_chan_is_threaded(chan)) return 0; + switch (janet_type(*x)) { + default: + return 1; + case JANET_BUFFER: { + JanetBuffer *buf = janet_unwrap_buffer(*x); + int flags = is_cleanup ? (JANET_MARSHAL_UNSAFE | JANET_MARSHAL_DECREF) : JANET_MARSHAL_UNSAFE; + *x = janet_unmarshal(buf->data, buf->count, flags, NULL, NULL); + janet_buffer_deinit(buf); + janet_free(buf); + return 0; + } + case JANET_NIL: + case JANET_NUMBER: + case JANET_POINTER: + case JANET_BOOLEAN: + case JANET_CFUNCTION: + return 0; + } +} + +static void janet_chan_init(JanetChannel *chan, int32_t limit, int threaded) { + chan->limit = limit; + chan->closed = 0; + chan->is_threaded = threaded; + janet_q_init(&chan->items); + janet_q_init(&chan->read_pending); + janet_q_init(&chan->write_pending); + janet_os_mutex_init((JanetOSMutex *) &chan->lock); +} + +static void janet_chan_lock(JanetChannel *chan) { + if (!janet_chan_is_threaded(chan)) return; + janet_os_mutex_lock((JanetOSMutex *) &chan->lock); +} + +static void janet_chan_unlock(JanetChannel *chan) { + if (!janet_chan_is_threaded(chan)) return; + janet_os_mutex_unlock((JanetOSMutex *) &chan->lock); +} + +static void janet_chan_deinit(JanetChannel *chan) { + if (janet_chan_is_threaded(chan)) { + Janet item; + janet_chan_lock(chan); + janet_q_deinit(&chan->read_pending); + janet_q_deinit(&chan->write_pending); + while (!janet_q_pop(&chan->items, &item, sizeof(item))) { + janet_chan_unpack(chan, &item, 1); + } + janet_q_deinit(&chan->items); + janet_chan_unlock(chan); + } else { + janet_q_deinit(&chan->read_pending); + janet_q_deinit(&chan->write_pending); + janet_q_deinit(&chan->items); + } + janet_os_mutex_deinit((JanetOSMutex *) &chan->lock); +} + +/* + * Janet Channel abstract type + */ + +static Janet janet_wrap_channel(JanetChannel *channel) { + return janet_wrap_abstract(channel); +} + +static int janet_chanat_gc(void *p, size_t s) { + (void) s; + JanetChannel *channel = p; + janet_chan_deinit(channel); + return 0; +} + +static void janet_chanat_mark_fq(JanetQueue *fq) { + JanetChannelPending *pending = fq->data; + if (fq->head <= fq->tail) { + for (int32_t i = fq->head; i < fq->tail; i++) + janet_mark(janet_wrap_fiber(pending[i].fiber)); + } else { + for (int32_t i = fq->head; i < fq->capacity; i++) + janet_mark(janet_wrap_fiber(pending[i].fiber)); + for (int32_t i = 0; i < fq->tail; i++) + janet_mark(janet_wrap_fiber(pending[i].fiber)); + } +} + +static int janet_chanat_mark(void *p, size_t s) { + (void) s; + JanetChannel *chan = p; + janet_chanat_mark_fq(&chan->read_pending); + janet_chanat_mark_fq(&chan->write_pending); + JanetQueue *items = &chan->items; + Janet *data = chan->items.data; + if (items->head <= items->tail) { + for (int32_t i = items->head; i < items->tail; i++) + janet_mark(data[i]); + } else { + for (int32_t i = items->head; i < items->capacity; i++) + janet_mark(data[i]); + for (int32_t i = 0; i < items->tail; i++) + janet_mark(data[i]); + } + return 0; +} + +static Janet make_write_result(JanetChannel *channel) { + Janet *tup = janet_tuple_begin(2); + tup[0] = janet_ckeywordv("give"); + tup[1] = janet_wrap_channel(channel); + return janet_wrap_tuple(janet_tuple_end(tup)); +} + +static Janet make_read_result(JanetChannel *channel, Janet x) { + Janet *tup = janet_tuple_begin(3); + tup[0] = janet_ckeywordv("take"); + tup[1] = janet_wrap_channel(channel); + tup[2] = x; + return janet_wrap_tuple(janet_tuple_end(tup)); +} + +static Janet make_close_result(JanetChannel *channel) { + Janet *tup = janet_tuple_begin(2); + tup[0] = janet_ckeywordv("close"); + tup[1] = janet_wrap_channel(channel); + return janet_wrap_tuple(janet_tuple_end(tup)); +} + +/* Callback to use for scheduling a fiber from another thread. */ +static void janet_thread_chan_cb(JanetEVGenericMessage msg) { + uint32_t sched_id = (uint32_t) msg.argi; + JanetFiber *fiber = msg.fiber; + int mode = msg.tag; + JanetChannel *channel = (JanetChannel *) msg.argp; + Janet x = msg.argj; + janet_chan_lock(channel); + if (fiber->sched_id == sched_id) { + if (mode == JANET_CP_MODE_CHOICE_READ) { + janet_assert(!janet_chan_unpack(channel, &x, 0), "packing error"); + janet_schedule(fiber, make_read_result(channel, x)); + } else if (mode == JANET_CP_MODE_CHOICE_WRITE) { + janet_schedule(fiber, make_write_result(channel)); + } else if (mode == JANET_CP_MODE_READ) { + janet_assert(!janet_chan_unpack(channel, &x, 0), "packing error"); + janet_schedule(fiber, x); + } else if (mode == JANET_CP_MODE_WRITE) { + janet_schedule(fiber, janet_wrap_channel(channel)); + } else { /* (mode == JANET_CP_MODE_CLOSE) */ + janet_schedule(fiber, janet_wrap_nil()); + } + } else if (mode != JANET_CP_MODE_CLOSE) { + /* Fiber has already been cancelled or resumed. */ + /* Resend event to another waiting thread, depending on mode */ + int is_read = (mode == JANET_CP_MODE_CHOICE_READ) || (mode == JANET_CP_MODE_READ); + if (is_read) { + JanetChannelPending reader; + if (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) { + JanetVM *vm = reader.thread; + JanetEVGenericMessage msg; + msg.tag = reader.mode; + msg.fiber = reader.fiber; + msg.argi = (int32_t) reader.sched_id; + msg.argp = channel; + msg.argj = x; + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } + } else { + JanetChannelPending writer; + if (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) { + JanetVM *vm = writer.thread; + JanetEVGenericMessage msg; + msg.tag = writer.mode; + msg.fiber = writer.fiber; + msg.argi = (int32_t) writer.sched_id; + msg.argp = channel; + msg.argj = janet_wrap_nil(); + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } + } + } + janet_chan_unlock(channel); +} + +/* Push a value to a channel, and return 1 if channel should block, zero otherwise. + * If the push would block, will add to the write_pending queue in the channel. + * Handles both threaded and unthreaded channels. */ +static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode) { + JanetChannelPending reader; + int is_empty; + if (janet_chan_pack(channel, &x)) { + janet_chan_unlock(channel); + janet_panicf("failed to pack value for channel: %v", x); + } + if (channel->closed) { + janet_chan_unlock(channel); + janet_panic("cannot write to closed channel"); + } + int is_threaded = janet_chan_is_threaded(channel); + if (is_threaded) { + /* don't dereference fiber from another thread */ + is_empty = janet_q_pop(&channel->read_pending, &reader, sizeof(reader)); + } else { + do { + is_empty = janet_q_pop(&channel->read_pending, &reader, sizeof(reader)); + } while (!is_empty && (reader.sched_id != reader.fiber->sched_id)); + } + if (is_empty) { + /* No pending reader */ + if (janet_q_push(&channel->items, &x, sizeof(Janet))) { + janet_chan_unlock(channel); + janet_panicf("channel overflow: %v", x); + } else if (janet_q_count(&channel->items) > channel->limit) { + /* No root fiber, we are in completion on a root fiber. Don't block. */ + if (mode == 2) { + janet_chan_unlock(channel); + return 0; + } + /* Pushed successfully, but should block. */ + JanetChannelPending pending; + pending.thread = &janet_vm; + pending.fiber = janet_vm.root_fiber, + pending.sched_id = janet_vm.root_fiber->sched_id, + pending.mode = mode ? JANET_CP_MODE_CHOICE_WRITE : JANET_CP_MODE_WRITE; + janet_q_push(&channel->write_pending, &pending, sizeof(pending)); + janet_chan_unlock(channel); + if (is_threaded) { + janet_gcroot(janet_wrap_fiber(pending.fiber)); + } + return 1; + } + } else { + /* Pending reader */ + if (is_threaded) { + JanetVM *vm = reader.thread; + JanetEVGenericMessage msg; + msg.tag = reader.mode; + msg.fiber = reader.fiber; + msg.argi = (int32_t) reader.sched_id; + msg.argp = channel; + msg.argj = x; + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } else { + if (reader.mode == JANET_CP_MODE_CHOICE_READ) { + janet_schedule(reader.fiber, make_read_result(channel, x)); + } else { + janet_schedule(reader.fiber, x); + } + } + } + janet_chan_unlock(channel); + return 0; +} + +static int janet_channel_push(JanetChannel *channel, Janet x, int mode) { + janet_chan_lock(channel); + return janet_channel_push_with_lock(channel, x, mode); +} + +/* Pop from a channel - returns 1 if item was obtained, 0 otherwise. The item + * is returned by reference. If the pop would block, will add to the read_pending + * queue in the channel. */ +static int janet_channel_pop_with_lock(JanetChannel *channel, Janet *item, int is_choice) { + JanetChannelPending writer; + if (channel->closed) { + janet_chan_unlock(channel); + *item = janet_wrap_nil(); + return 1; + } + int is_threaded = janet_chan_is_threaded(channel); + if (janet_q_pop(&channel->items, item, sizeof(Janet))) { + /* Queue empty */ + JanetChannelPending pending; + pending.thread = &janet_vm; + pending.fiber = janet_vm.root_fiber, + pending.sched_id = janet_vm.root_fiber->sched_id; + pending.mode = is_choice ? JANET_CP_MODE_CHOICE_READ : JANET_CP_MODE_READ; + janet_q_push(&channel->read_pending, &pending, sizeof(pending)); + janet_chan_unlock(channel); + if (is_threaded) { + janet_gcroot(janet_wrap_fiber(pending.fiber)); + } + return 0; + } + janet_assert(!janet_chan_unpack(channel, item, 0), "bad channel packing"); + if (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) { + /* Pending writer */ + if (is_threaded) { + JanetVM *vm = writer.thread; + JanetEVGenericMessage msg; + msg.tag = writer.mode; + msg.fiber = writer.fiber; + msg.argi = (int32_t) writer.sched_id; + msg.argp = channel; + msg.argj = janet_wrap_nil(); + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } else { + if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) { + janet_schedule(writer.fiber, make_write_result(channel)); + } else { + janet_schedule(writer.fiber, janet_wrap_abstract(channel)); + } + } + } + janet_chan_unlock(channel); + return 1; +} + +static int janet_channel_pop(JanetChannel *channel, Janet *item, int is_choice) { + janet_chan_lock(channel); + return janet_channel_pop_with_lock(channel, item, is_choice); +} + +JanetChannel *janet_channel_unwrap(void *abstract) { + return abstract; +} + +JanetChannel *janet_getchannel(const Janet *argv, int32_t n) { + return janet_channel_unwrap(janet_getabstract(argv, n, &janet_channel_type)); +} + +JanetChannel *janet_optchannel(const Janet *argv, int32_t argc, int32_t n, JanetChannel *dflt) { + if (argc > n && !janet_checktype(argv[n], JANET_NIL)) { + return janet_getchannel(argv, n); + } else { + return dflt; + } +} + +/* Channel Methods */ + +JANET_CORE_FN(cfun_channel_push, + "(ev/give channel value)", + "Write a value to a channel, suspending the current fiber if the channel is full. " + "Returns the channel if the write succeeded, nil otherwise.") { + janet_fixarity(argc, 2); + JanetChannel *channel = janet_getchannel(argv, 0); + if (janet_channel_push(channel, argv[1], 0)) { + janet_await(); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_channel_pop, + "(ev/take channel)", + "Read from a channel, suspending the current fiber if no value is available.") { + janet_fixarity(argc, 1); + JanetChannel *channel = janet_getchannel(argv, 0); + Janet item; + if (janet_channel_pop(channel, &item, 0)) { + janet_schedule(janet_vm.root_fiber, item); + } + janet_await(); +} + +static void chan_unlock_args(const Janet *argv, int32_t n) { + for (int32_t i = 0; i < n; i++) { + int32_t len; + const Janet *data; + JanetChannel *chan; + if (janet_indexed_view(argv[i], &data, &len) && len == 2) { + chan = janet_getchannel(data, 0); + } else { + chan = janet_getchannel(argv, i); + } + janet_chan_unlock(chan); + } +} + +JANET_CORE_FN(cfun_channel_choice, + "(ev/select & clauses)", + "Block until the first of several channel operations occur. Returns a " + "tuple of the form [:give chan], [:take chan x], or [:close chan], " + "where a :give tuple is the result of a write and a :take tuple is the " + "result of a read. Each clause must be either a channel (for a channel " + "take operation) or a tuple [channel x] (for a channel give operation). " + "Operations are tried in order such that earlier clauses take " + "precedence over later clauses. Both give and take operations can " + "return a [:close chan] tuple, which indicates that the specified " + "channel was closed while waiting, or that the channel was already " + "closed.") { + janet_arity(argc, 1, -1); + int32_t len; + const Janet *data; + + /* Check channels for immediate reads and writes */ + for (int32_t i = 0; i < argc; i++) { + if (janet_indexed_view(argv[i], &data, &len) && len == 2) { + /* Write */ + JanetChannel *chan = janet_getchannel(data, 0); + janet_chan_lock(chan); + if (chan->closed) { + janet_chan_unlock(chan); + chan_unlock_args(argv, i); + return make_close_result(chan); + } + if (janet_q_count(&chan->items) < chan->limit) { + janet_channel_push_with_lock(chan, data[1], 1); + chan_unlock_args(argv, i); + return make_write_result(chan); + } + } else { + /* Read */ + JanetChannel *chan = janet_getchannel(argv, i); + janet_chan_lock(chan); + if (chan->closed) { + janet_chan_unlock(chan); + chan_unlock_args(argv, i); + return make_close_result(chan); + } + if (chan->items.head != chan->items.tail) { + Janet item; + janet_channel_pop_with_lock(chan, &item, 1); + chan_unlock_args(argv, i); + return make_read_result(chan, item); + } + } + } + + /* Wait for all readers or writers */ + for (int32_t i = 0; i < argc; i++) { + if (janet_indexed_view(argv[i], &data, &len) && len == 2) { + /* Write */ + JanetChannel *chan = janet_getchannel(data, 0); + janet_channel_push_with_lock(chan, data[1], 1); + } else { + /* Read */ + Janet item; + JanetChannel *chan = janet_getchannel(argv, i); + janet_channel_pop_with_lock(chan, &item, 1); + } + } + + janet_await(); +} + +JANET_CORE_FN(cfun_channel_full, + "(ev/full channel)", + "Check if a channel is full or not.") { + janet_fixarity(argc, 1); + JanetChannel *channel = janet_getchannel(argv, 0); + janet_chan_lock(channel); + Janet ret = janet_wrap_boolean(janet_q_count(&channel->items) >= channel->limit); + janet_chan_unlock(channel); + return ret; +} + +JANET_CORE_FN(cfun_channel_capacity, + "(ev/capacity channel)", + "Get the number of items a channel will store before blocking writers.") { + janet_fixarity(argc, 1); + JanetChannel *channel = janet_getchannel(argv, 0); + janet_chan_lock(channel); + Janet ret = janet_wrap_integer(channel->limit); + janet_chan_unlock(channel); + return ret; +} + +JANET_CORE_FN(cfun_channel_count, + "(ev/count channel)", + "Get the number of items currently waiting in a channel.") { + janet_fixarity(argc, 1); + JanetChannel *channel = janet_getchannel(argv, 0); + janet_chan_lock(channel); + Janet ret = janet_wrap_integer(janet_q_count(&channel->items)); + janet_chan_unlock(channel); + return ret; +} + +/* Fisher yates shuffle of arguments to get fairness */ +static void fisher_yates_args(int32_t argc, Janet *argv) { + for (int32_t i = argc; i > 1; i--) { + int32_t swap_index = janet_rng_u32(&janet_vm.ev_rng) % i; + Janet temp = argv[swap_index]; + argv[swap_index] = argv[i - 1]; + argv[i - 1] = temp; + } +} + +JANET_CORE_FN(cfun_channel_rchoice, + "(ev/rselect & clauses)", + "Similar to ev/select, but will try clauses in a random order for fairness.") { + fisher_yates_args(argc, argv); + return cfun_channel_choice(argc, argv); +} + +JANET_CORE_FN(cfun_channel_new, + "(ev/chan &opt capacity)", + "Create a new channel. capacity is the number of values to queue before " + "blocking writers, defaults to 0 if not provided. Returns a new channel.") { + janet_arity(argc, 0, 1); + int32_t limit = janet_optnat(argv, argc, 0, 0); + JanetChannel *channel = janet_abstract(&janet_channel_type, sizeof(JanetChannel)); + janet_chan_init(channel, limit, 0); + return janet_wrap_abstract(channel); +} + +JANET_CORE_FN(cfun_channel_new_threaded, + "(ev/thread-chan &opt limit)", + "Create a threaded channel. A threaded channel is a channel that can be shared between threads and " + "used to communicate between any number of operating system threads.") { + janet_arity(argc, 0, 1); + int32_t limit = janet_optnat(argv, argc, 0, 0); + JanetChannel *tchan = janet_abstract_threaded(&janet_channel_type, sizeof(JanetChannel)); + janet_chan_init(tchan, limit, 1); + return janet_wrap_abstract(tchan); +} + +JANET_CORE_FN(cfun_channel_close, + "(ev/chan-close chan)", + "Close a channel. A closed channel will cause all pending reads and writes to return nil. " + "Returns the channel.") { + janet_fixarity(argc, 1); + JanetChannel *channel = janet_getchannel(argv, 0); + janet_chan_lock(channel); + if (!channel->closed) { + channel->closed = 1; + JanetChannelPending writer; + while (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) { + if (writer.thread != &janet_vm) { + JanetVM *vm = writer.thread; + JanetEVGenericMessage msg; + msg.fiber = writer.fiber; + msg.argp = channel; + msg.tag = JANET_CP_MODE_CLOSE; + msg.argi = (int32_t) writer.sched_id; + msg.argj = janet_wrap_nil(); + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } else { + if (janet_fiber_can_resume(writer.fiber)) { + if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) { + janet_schedule(writer.fiber, make_close_result(channel)); + } else { + janet_schedule(writer.fiber, janet_wrap_nil()); + } + } + } + } + JanetChannelPending reader; + while (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) { + if (reader.thread != &janet_vm) { + JanetVM *vm = reader.thread; + JanetEVGenericMessage msg; + msg.fiber = reader.fiber; + msg.argp = channel; + msg.tag = JANET_CP_MODE_CLOSE; + msg.argi = (int32_t) reader.sched_id; + msg.argj = janet_wrap_nil(); + janet_ev_post_event(vm, janet_thread_chan_cb, msg); + } else { + if (janet_fiber_can_resume(reader.fiber)) { + if (reader.mode == JANET_CP_MODE_CHOICE_READ) { + janet_schedule(reader.fiber, make_close_result(channel)); + } else { + janet_schedule(reader.fiber, janet_wrap_nil()); + } + } + } + } + } + janet_chan_unlock(channel); + return argv[0]; +} + +static const JanetMethod ev_chanat_methods[] = { + {"select", cfun_channel_choice}, + {"rselect", cfun_channel_rchoice}, + {"count", cfun_channel_count}, + {"take", cfun_channel_pop}, + {"give", cfun_channel_push}, + {"capacity", cfun_channel_capacity}, + {"full", cfun_channel_full}, + {"close", cfun_channel_close}, + {NULL, NULL} +}; + +static int janet_chanat_get(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) return 0; + return janet_getmethod(janet_unwrap_keyword(key), ev_chanat_methods, out); +} + +static Janet janet_chanat_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(ev_chanat_methods, key); +} + +static void janet_chanat_marshal(void *p, JanetMarshalContext *ctx) { + JanetChannel *channel = (JanetChannel *)p; + janet_marshal_byte(ctx, channel->is_threaded); + janet_marshal_abstract(ctx, channel); + janet_marshal_byte(ctx, channel->closed); + janet_marshal_int(ctx, channel->limit); + int32_t count = janet_q_count(&channel->items); + janet_marshal_int(ctx, count); + JanetQueue *items = &channel->items; + Janet *data = channel->items.data; + if (items->head <= items->tail) { + for (int32_t i = items->head; i < items->tail; i++) + janet_marshal_janet(ctx, data[i]); + } else { + for (int32_t i = items->head; i < items->capacity; i++) + janet_marshal_janet(ctx, data[i]); + for (int32_t i = 0; i < items->tail; i++) + janet_marshal_janet(ctx, data[i]); + } +} + +static void *janet_chanat_unmarshal(JanetMarshalContext *ctx) { + uint8_t is_threaded = janet_unmarshal_byte(ctx); + JanetChannel *abst; + if (is_threaded) { + abst = janet_unmarshal_abstract_threaded(ctx, sizeof(JanetChannel)); + } else { + abst = janet_unmarshal_abstract(ctx, sizeof(JanetChannel)); + } + uint8_t is_closed = janet_unmarshal_byte(ctx); + int32_t limit = janet_unmarshal_int(ctx); + int32_t count = janet_unmarshal_int(ctx); + if (count < 0) janet_panic("invalid negative channel count"); + janet_chan_init(abst, limit, 0); + abst->closed = !!is_closed; + for (int32_t i = 0; i < count; i++) { + Janet item = janet_unmarshal_janet(ctx); + janet_q_push(&abst->items, &item, sizeof(item)); + } + return abst; +} + +const JanetAbstractType janet_channel_type = { + "core/channel", + janet_chanat_gc, + janet_chanat_mark, + janet_chanat_get, + NULL, /* put */ + janet_chanat_marshal, + janet_chanat_unmarshal, + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + janet_chanat_next, + JANET_ATEND_NEXT +}; + +/* Main event loop */ + +void janet_loop1_impl(int has_timeout, JanetTimestamp timeout); + +int janet_loop_done(void) { + return !((janet_vm.spawn.head != janet_vm.spawn.tail) || + janet_vm.tq_count || + janet_atomic_load(&janet_vm.listener_count)); +} + +JanetFiber *janet_loop1(void) { + /* Schedule expired timers */ + JanetTimeout to; + JanetTimestamp now = ts_now(); + while (peek_timeout(&to) && to.when <= now) { + pop_timeout(0); + if (to.curr_fiber != NULL) { + if (janet_fiber_can_resume(to.curr_fiber)) { + janet_cancel(to.fiber, janet_cstringv("deadline expired")); + } + } else { + /* This is a timeout (for a function call, not a whole fiber) */ + if (to.fiber->sched_id == to.sched_id) { + if (to.is_error) { + janet_cancel(to.fiber, janet_cstringv("timeout")); + } else { + janet_schedule(to.fiber, janet_wrap_nil()); + } + } + } + } + + /* Run scheduled fibers unless interrupts need to be handled. */ + while (janet_vm.spawn.head != janet_vm.spawn.tail) { + /* Don't run until all interrupts have been marked as handled by calling janet_interpreter_interrupt_handled */ + if (janet_vm.auto_suspend) break; + JanetTask task = {NULL, janet_wrap_nil(), JANET_SIGNAL_OK, 0}; + janet_q_pop(&janet_vm.spawn, &task, sizeof(task)); + if (task.fiber->gc.flags & JANET_FIBER_EV_FLAG_SUSPENDED) janet_ev_dec_refcount(); + task.fiber->gc.flags &= ~(JANET_FIBER_EV_FLAG_CANCELED | JANET_FIBER_EV_FLAG_SUSPENDED); + if (task.expected_sched_id != task.fiber->sched_id) continue; + Janet res; + JanetSignal sig = janet_continue_signal(task.fiber, task.value, &res, task.sig); + if (!janet_fiber_can_resume(task.fiber)) { + janet_table_remove(&janet_vm.active_tasks, janet_wrap_fiber(task.fiber)); + } + void *sv = task.fiber->supervisor_channel; + int is_suspended = sig == JANET_SIGNAL_EVENT || sig == JANET_SIGNAL_YIELD || sig == JANET_SIGNAL_INTERRUPT; + if (is_suspended) { + task.fiber->gc.flags |= JANET_FIBER_EV_FLAG_SUSPENDED; + janet_ev_inc_refcount(); + } + if (NULL == sv) { + if (!is_suspended) { + janet_stacktrace_ext(task.fiber, res, ""); + } + } else if (sig == JANET_SIGNAL_OK || (task.fiber->flags & (1 << sig))) { + JanetChannel *chan = janet_channel_unwrap(sv); + janet_channel_push(chan, make_supervisor_event(janet_signal_names[sig], + task.fiber, chan->is_threaded), 2); + } else if (!is_suspended) { + janet_stacktrace_ext(task.fiber, res, ""); + } + if (sig == JANET_SIGNAL_INTERRUPT) { + return task.fiber; + } + } + + /* Poll for events */ + if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) { + JanetTimeout to; + memset(&to, 0, sizeof(to)); + int has_timeout; + /* Drop timeouts that are no longer needed */ + while ((has_timeout = peek_timeout(&to))) { + if (to.curr_fiber != NULL) { + if (!janet_fiber_can_resume(to.curr_fiber)) { + janet_table_remove(&janet_vm.active_tasks, janet_wrap_fiber(to.curr_fiber)); + pop_timeout(0); + continue; + } + } else if (to.fiber->sched_id != to.sched_id) { + pop_timeout(0); + continue; + } + break; + } + /* Run polling implementation only if pending timeouts or pending events */ + if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) { + janet_loop1_impl(has_timeout, to.when); + } + } + + /* No fiber was interrupted */ + return NULL; +} + +/* Same as janet_interpreter_interrupt, but will also + * break out of the event loop if waiting for an event + * (say, waiting for ev/sleep to finish). Does this by pushing + * an empty event to the event loop. */ +void janet_loop1_interrupt(JanetVM *vm) { + janet_interpreter_interrupt(vm); + JanetEVGenericMessage msg = {0}; + JanetCallback cb = NULL; + janet_ev_post_event(vm, cb, msg); +} + +void janet_loop(void) { + while (!janet_loop_done()) { + JanetFiber *interrupted_fiber = janet_loop1(); + if (NULL != interrupted_fiber) { + janet_schedule(interrupted_fiber, janet_wrap_nil()); + } + } +} + +/* + * Self-pipe handling code. + */ + +#ifdef JANET_WINDOWS + +/* On windows, use PostQueuedCompletionStatus instead for + * custom events */ + +#else + +static void janet_ev_setup_selfpipe(void) { + if (janet_make_pipe(janet_vm.selfpipe, 1)) { + JANET_EXIT("failed to initialize self pipe in event loop"); + } +} + +/* Handle events from the self pipe inside the event loop */ +static void janet_ev_handle_selfpipe(void) { + JanetSelfPipeEvent response; + int status; +recur: + do { + status = read(janet_vm.selfpipe[0], &response, sizeof(response)); + } while (status == -1 && errno == EINTR); + if (status > 0) { + if (NULL != response.cb) { + response.cb(response.msg); + janet_ev_dec_refcount(); + } + goto recur; + } +} + +static void janet_ev_cleanup_selfpipe(void) { + close(janet_vm.selfpipe[0]); + close(janet_vm.selfpipe[1]); +} + +#endif + +#ifdef JANET_WINDOWS + +static JanetTimestamp ts_now(void) { + return (JanetTimestamp) GetTickCount64(); +} + +void janet_ev_init(void) { + janet_ev_init_common(); + janet_vm.iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); + if (NULL == janet_vm.iocp) janet_panic("could not create io completion port"); +} + +void janet_ev_deinit(void) { + janet_ev_deinit_common(); + CloseHandle(janet_vm.iocp); +} + +static void janet_register_stream(JanetStream *stream) { + if (NULL == CreateIoCompletionPort(stream->handle, janet_vm.iocp, (ULONG_PTR) stream, 0)) { + janet_panicf("failed to listen for events: %V", janet_ev_lasterr()); + } +} + +void janet_loop1_impl(int has_timeout, JanetTimestamp to) { + ULONG_PTR completionKey = 0; + DWORD num_bytes_transfered = 0; + LPOVERLAPPED overlapped = NULL; + + /* Calculate how long to wait before timeout */ + uint64_t waittime; + if (has_timeout) { + JanetTimestamp now = ts_now(); + if (now > to) { + waittime = 0; + } else { + waittime = (uint64_t)(to - now); + } + } else { + waittime = INFINITE; + } + BOOL result = GetQueuedCompletionStatus(janet_vm.iocp, &num_bytes_transfered, &completionKey, &overlapped, (DWORD) waittime); + + if (result || overlapped) { + if (0 == completionKey) { + /* Custom event */ + JanetSelfPipeEvent *response = (JanetSelfPipeEvent *)(overlapped); + if (NULL != response->cb) { + response->cb(response->msg); + } + janet_ev_dec_refcount(); + janet_free(response); + } else { + /* Normal event */ + JanetStream *stream = (JanetStream *) completionKey; + JanetFiber *fiber = NULL; + if (stream->read_fiber && stream->read_fiber->ev_state == overlapped) { + fiber = stream->read_fiber; + } else if (stream->write_fiber && stream->write_fiber->ev_state == overlapped) { + fiber = stream->write_fiber; + } + if (fiber != NULL) { + fiber->flags &= ~JANET_FIBER_EV_FLAG_IN_FLIGHT; + /* System is done with this, we can reused this data */ + overlapped->InternalHigh = (ULONG_PTR) num_bytes_transfered; + fiber->ev_callback(fiber, result ? JANET_ASYNC_EVENT_COMPLETE : JANET_ASYNC_EVENT_FAILED); + } else { + janet_free((void *) overlapped); + janet_ev_dec_refcount(); + } + janet_stream_checktoclose(stream); + } + } +} + +#elif defined(JANET_EV_EPOLL) + +static JanetTimestamp ts_now(void) { + struct timespec now; + janet_assert(-1 != clock_gettime(CLOCK_MONOTONIC, &now), "failed to get time"); + uint64_t res = 1000 * now.tv_sec; + res += now.tv_nsec / 1000000; + return res; +} + +/* Wait for the next event */ +static void janet_register_stream(JanetStream *stream) { + struct epoll_event ev; + ev.events = EPOLLET; + if (stream->flags & (JANET_STREAM_READABLE | JANET_STREAM_ACCEPTABLE)) ev.events |= EPOLLIN; + if (stream->flags & JANET_STREAM_WRITABLE) ev.events |= EPOLLOUT; + ev.data.ptr = stream; + int status; + do { + status = epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, stream->handle, &ev); + } while (status == -1 && errno == EINTR); + if (status == -1) { + if (errno == EPERM) { + /* Couldn't add to event loop, so assume that it completes + * synchronously. */ + stream->flags |= JANET_STREAM_UNREGISTERED; + } else { + /* Unexpected error */ + janet_panicv(janet_ev_lasterr()); + } + } +} + +#define JANET_EPOLL_MAX_EVENTS 64 +void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) { + struct itimerspec its; + if (janet_vm.timer_enabled || has_timeout) { + memset(&its, 0, sizeof(its)); + if (has_timeout) { + its.it_value.tv_sec = timeout / 1000; + its.it_value.tv_nsec = (timeout % 1000) * 1000000; + } + timerfd_settime(janet_vm.timerfd, TFD_TIMER_ABSTIME, &its, NULL); + } + janet_vm.timer_enabled = has_timeout; + + /* Poll for events */ + struct epoll_event events[JANET_EPOLL_MAX_EVENTS]; + int ready; + do { + ready = epoll_wait(janet_vm.epoll, events, JANET_EPOLL_MAX_EVENTS, -1); + } while (ready == -1 && errno == EINTR); + if (ready == -1) { + JANET_EXIT("failed to poll events"); + } + + /* Step state machines */ + for (int i = 0; i < ready; i++) { + void *p = events[i].data.ptr; + if (&janet_vm.timerfd == p) { + /* Timer expired, ignore */; + } else if (janet_vm.selfpipe == p) { + /* Self-pipe handling */ + janet_ev_handle_selfpipe(); + } else { + JanetStream *stream = p; + int mask = events[i].events; + int has_err = mask & EPOLLERR; + int has_hup = mask & EPOLLHUP; + JanetFiber *rf = stream->read_fiber; + JanetFiber *wf = stream->write_fiber; + if (rf) { + if (rf->ev_callback && (mask & EPOLLIN)) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_READ); + } + if (rf->ev_callback && has_err) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_ERR); + } + if (rf->ev_callback && has_hup) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_HUP); + } + } + if (wf) { + if (wf->ev_callback && (mask & EPOLLOUT)) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_WRITE); + } + if (wf->ev_callback && has_err) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_ERR); + } + if (wf->ev_callback && has_hup) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_HUP); + } + } + janet_stream_checktoclose(stream); + } + } +} + +void janet_ev_init(void) { + janet_ev_init_common(); + janet_ev_setup_selfpipe(); + janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); + janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); + janet_vm.timer_enabled = 0; + if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = &janet_vm.timerfd; + if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = janet_vm.selfpipe; + if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; + return; +error: + JANET_EXIT("failed to initialize event loop"); +} + +void janet_ev_deinit(void) { + janet_ev_deinit_common(); + close(janet_vm.epoll); + close(janet_vm.timerfd); + janet_ev_cleanup_selfpipe(); + janet_vm.epoll = 0; +} + +/* + * End epoll implementation + */ + +#elif defined(JANET_EV_KQUEUE) +/* Definition from: + * https://github.com/wahern/cqueues/blob/master/src/lib/kpoll.c + * NetBSD uses intptr_t while others use void * for .udata */ +#define EV_SETx(ev, a, b, c, d, e, f) EV_SET((ev), (a), (b), (c), (d), (e), ((__typeof__((ev)->udata))(f))) +#define JANET_KQUEUE_MIN_INTERVAL 0 + +/* NOTE: + * NetBSD and OpenBSD expect things are always intervals, and FreeBSD doesn't + * like an ABSTIME in the past so just use intervals always. Introduces a + * calculation to determine the minimum timeout per timeout requested of + * kqueue. Also note that NetBSD doesn't accept timeout intervals less than 1 + * millisecond, so correct all intervals on that platform to be at least 1 + * millisecond.*/ +JanetTimestamp to_interval(const JanetTimestamp ts) { + return ts >= JANET_KQUEUE_MIN_INTERVAL ? ts : JANET_KQUEUE_MIN_INTERVAL; +} +#define JANET_KQUEUE_INTERVAL(timestamp) (to_interval((timestamp - ts_now()))) + +static JanetTimestamp ts_now(void) { + struct timespec now; + janet_assert(-1 != clock_gettime(CLOCK_MONOTONIC, &now), "failed to get time"); + uint64_t res = 1000 * now.tv_sec; + res += now.tv_nsec / 1000000; + return res; +} + +/* NOTE: Assumes Janet's timestamp precision is in milliseconds. */ +static void timestamp2timespec(struct timespec *t, JanetTimestamp ts) { + t->tv_sec = ts == 0 ? 0 : ts / 1000; + t->tv_nsec = ts == 0 ? 0 : (ts % 1000) * 1000000; +} + +void janet_register_stream(JanetStream *stream) { + struct kevent kevs[2]; + int length = 0; + if (stream->flags & (JANET_STREAM_READABLE | JANET_STREAM_ACCEPTABLE)) { + EV_SETx(&kevs[length++], stream->handle, EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, stream); + } + if (stream->flags & JANET_STREAM_WRITABLE) { + EV_SETx(&kevs[length++], stream->handle, EVFILT_WRITE, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, stream); + } + int status; + do { + status = kevent(janet_vm.kq, kevs, length, NULL, 0, NULL); + } while (status == -1 && errno == EINTR); + if (status == -1) { + stream->flags |= JANET_STREAM_UNREGISTERED; + } +} + +#define JANET_KQUEUE_MAX_EVENTS 64 + +void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) { + /* Poll for events */ + /* NOTE: + * We calculate the timeout interval per iteration. When the interval + * drops to 0 or negative, we effect a timeout of 0. Effecting a timeout + * of infinity will not work and could make other fibers with timeouts + * miss their timeouts if we did so. + * JANET_KQUEUE_INTERVAL insures we have a timeout of no less than 0. */ + int status; + struct timespec ts; + struct kevent events[JANET_KQUEUE_MAX_EVENTS]; + do { + if (janet_vm.timer_enabled || has_timeout) { + timestamp2timespec(&ts, JANET_KQUEUE_INTERVAL(timeout)); + status = kevent(janet_vm.kq, NULL, 0, events, + JANET_KQUEUE_MAX_EVENTS, &ts); + } else { + status = kevent(janet_vm.kq, NULL, 0, events, + JANET_KQUEUE_MAX_EVENTS, NULL); + } + } while (status == -1 && errno == EINTR); + if (status == -1) { + JANET_EXIT("failed to poll events"); + } + + /* Make sure timer is set accordingly. */ + janet_vm.timer_enabled = has_timeout; + + /* Step state machines */ + for (int i = 0; i < status; i++) { + void *p = (void *) events[i].udata; + if (janet_vm.selfpipe == p) { + /* Self-pipe handling */ + janet_ev_handle_selfpipe(); + } else { + JanetStream *stream = p; + int filt = events[i].filter; + int has_err = events[i].flags & EV_ERROR; + int has_hup = events[i].flags & EV_EOF; + for (int j = 0; j < 2; j++) { + JanetFiber *f = j ? stream->read_fiber : stream->write_fiber; + if (!f) continue; + if (f->ev_callback && has_err) { + f->ev_callback(f, JANET_ASYNC_EVENT_ERR); + } + if (f->ev_callback && (filt == EVFILT_READ) && f == stream->read_fiber) { + f->ev_callback(f, JANET_ASYNC_EVENT_READ); + } + if (f->ev_callback && (filt == EVFILT_WRITE) && f == stream->write_fiber) { + f->ev_callback(f, JANET_ASYNC_EVENT_WRITE); + } + if (f->ev_callback && has_hup) { + f->ev_callback(f, JANET_ASYNC_EVENT_HUP); + } + } + janet_stream_checktoclose(stream); + } + } +} + +void janet_ev_init(void) { + janet_ev_init_common(); + janet_ev_setup_selfpipe(); + janet_vm.kq = kqueue(); + janet_vm.timer_enabled = 0; + if (janet_vm.kq == -1) goto error; + struct kevent event; + EV_SETx(&event, janet_vm.selfpipe[0], EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, janet_vm.selfpipe); + int status; + do { + status = kevent(janet_vm.kq, &event, 1, NULL, 0, NULL); + } while (status == -1 && errno != EINTR); + if (status == -1) goto error; + return; +error: + JANET_EXIT("failed to initialize event loop"); +} + +void janet_ev_deinit(void) { + janet_ev_deinit_common(); + close(janet_vm.kq); + janet_ev_cleanup_selfpipe(); + janet_vm.kq = 0; +} + +#elif defined(JANET_EV_POLL) + +/* Simple poll implementation. Efficiency is not the goal here, although the poll implementation should be farily efficient + * for low numbers of concurrent file descriptors. Rather, the code should be simple, portable, correct, and mirror the + * epoll and kqueue code. */ + +static JanetTimestamp ts_now(void) { + struct timespec now; + janet_assert(-1 != clock_gettime(CLOCK_REALTIME, &now), "failed to get time"); + uint64_t res = 1000 * now.tv_sec; + res += now.tv_nsec / 1000000; + return res; +} + +/* Wait for the next event */ +void janet_register_stream(JanetStream *stream) { + struct pollfd ev = {0}; + stream->index = (uint32_t) janet_vm.stream_count; + size_t new_count = janet_vm.stream_count + 1; + if (new_count > janet_vm.stream_capacity) { + size_t new_cap = new_count * 2; + janet_vm.fds = janet_realloc(janet_vm.fds, (1 + new_cap) * sizeof(struct pollfd)); + janet_vm.streams = janet_realloc(janet_vm.streams, new_cap * sizeof(JanetStream *)); + if (!janet_vm.fds || !janet_vm.streams) { + JANET_OUT_OF_MEMORY; + } + janet_vm.stream_capacity = new_cap; + } + ev.fd = stream->handle; + ev.events = POLLIN | POLLOUT; + janet_vm.fds[janet_vm.stream_count + 1] = ev; + janet_vm.streams[janet_vm.stream_count] = stream; + janet_vm.stream_count = new_count; +} + +void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) { + + /* set event flags */ + for (size_t i = 0; i < janet_vm.stream_count; i++) { + JanetStream *stream = janet_vm.streams[i]; + janet_vm.fds[i + 1].events = 0; + janet_vm.fds[i + 1].revents = 0; + if (stream->read_fiber && stream->read_fiber->ev_callback) janet_vm.fds[i + 1].events |= POLLIN; + if (stream->write_fiber && stream->write_fiber->ev_callback) janet_vm.fds[i + 1].events |= POLLOUT; + } + + /* Poll for events */ + int ready; + do { + int to = -1; + if (has_timeout) { + JanetTimestamp now = ts_now(); + to = now > timeout ? 0 : (int)(timeout - now); + } + ready = poll(janet_vm.fds, janet_vm.stream_count + 1, to); + } while (ready == -1 && errno == EINTR); + if (ready == -1) { + JANET_EXIT("failed to poll events"); + } + + /* Check selfpipe */ + if (janet_vm.fds[0].revents & POLLIN) { + janet_vm.fds[0].revents = 0; + janet_ev_handle_selfpipe(); + } + + /* Step state machines */ + for (size_t i = 0; i < janet_vm.stream_count; i++) { + struct pollfd *pfd = janet_vm.fds + i + 1; + JanetStream *stream = janet_vm.streams[i]; + int mask = pfd->revents; + if (!mask) continue; + int has_err = mask & POLLERR; + int has_hup = mask & POLLHUP; + JanetFiber *rf = stream->read_fiber; + JanetFiber *wf = stream->write_fiber; + if (rf) { + if (rf->ev_callback && (mask & POLLIN)) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_READ); + } else if (rf->ev_callback && has_hup) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_HUP); + } else if (rf->ev_callback && has_err) { + rf->ev_callback(rf, JANET_ASYNC_EVENT_ERR); + } + } + if (wf) { + if (wf->ev_callback && (mask & POLLOUT)) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_WRITE); + } else if (wf->ev_callback && has_hup) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_HUP); + } else if (wf->ev_callback && has_err) { + wf->ev_callback(wf, JANET_ASYNC_EVENT_ERR); + } + } + janet_stream_checktoclose(stream); + } +} + +void janet_ev_init(void) { + janet_ev_init_common(); + janet_vm.fds = NULL; + janet_ev_setup_selfpipe(); + janet_vm.fds = janet_malloc(sizeof(struct pollfd)); + if (NULL == janet_vm.fds) { + JANET_OUT_OF_MEMORY; + } + janet_vm.fds[0].fd = janet_vm.selfpipe[0]; + janet_vm.fds[0].events = POLLIN; + janet_vm.fds[0].revents = 0; + janet_vm.streams = NULL; + janet_vm.stream_count = 0; + janet_vm.stream_capacity = 0; + return; +} + +void janet_ev_deinit(void) { + janet_ev_deinit_common(); + janet_ev_cleanup_selfpipe(); + janet_free(janet_vm.fds); + janet_free(janet_vm.streams); + janet_vm.fds = NULL; + janet_vm.streams = NULL; +} + +#endif + +/* + * End poll implementation + */ + +/* + * Generic Callback system. Post a function pointer + data to the event loop (from another + * thread or even a signal handler). Allows posting events from another thread or signal handler. + */ +void janet_ev_post_event(JanetVM *vm, JanetCallback cb, JanetEVGenericMessage msg) { + vm = vm ? vm : &janet_vm; + janet_atomic_inc(&vm->listener_count); +#ifdef JANET_WINDOWS + JanetHandle iocp = vm->iocp; + JanetSelfPipeEvent *event = janet_malloc(sizeof(JanetSelfPipeEvent)); + if (NULL == event) { + JANET_OUT_OF_MEMORY; + } + event->msg = msg; + event->cb = cb; + janet_assert(PostQueuedCompletionStatus(iocp, + sizeof(JanetSelfPipeEvent), + 0, + (LPOVERLAPPED) event), + "failed to post completion event"); +#else + JanetSelfPipeEvent event; + memset(&event, 0, sizeof(event)); + event.msg = msg; + event.cb = cb; + int fd = vm->selfpipe[1]; + /* handle a bit of back pressure before giving up. */ + int tries = 4; + while (tries > 0) { + int status; + do { + status = write(fd, &event, sizeof(event)); + } while (status == -1 && errno == EINTR); + if (status > 0) break; + sleep(0); + tries--; + } + janet_assert(tries > 0, "failed to write event to self-pipe"); +#endif +} + +/* + * Threaded calls + */ + +#ifdef JANET_WINDOWS +static DWORD WINAPI janet_thread_body(LPVOID ptr) { + JanetEVThreadInit *init = (JanetEVThreadInit *)ptr; + JanetEVGenericMessage msg = init->msg; + JanetThreadedSubroutine subr = init->subr; + JanetThreadedCallback cb = init->cb; + JanetHandle iocp = init->write_pipe; + /* Reuse memory from thread init for returning data */ + init->msg = subr(msg); + init->cb = cb; + janet_assert(PostQueuedCompletionStatus(iocp, + sizeof(JanetSelfPipeEvent), + 0, + (LPOVERLAPPED) init), + "failed to post completion event"); + return 0; +} +#else +static void *janet_thread_body(void *ptr) { + JanetEVThreadInit *init = (JanetEVThreadInit *)ptr; + JanetEVGenericMessage msg = init->msg; + JanetThreadedSubroutine subr = init->subr; + JanetThreadedCallback cb = init->cb; + int fd = init->write_pipe; + janet_free(init); + JanetSelfPipeEvent response; + memset(&response, 0, sizeof(response)); + response.msg = subr(msg); + response.cb = cb; + /* handle a bit of back pressure before giving up. */ + int tries = 4; + while (tries > 0) { + int status; + do { + status = write(fd, &response, sizeof(response)); + } while (status == -1 && errno == EINTR); + if (status > 0) break; + sleep(1); + tries--; + } + return NULL; +} +#endif + +void janet_ev_threaded_call(JanetThreadedSubroutine fp, JanetEVGenericMessage arguments, JanetThreadedCallback cb) { + JanetEVThreadInit *init = janet_malloc(sizeof(JanetEVThreadInit)); + if (NULL == init) { + JANET_OUT_OF_MEMORY; + } + init->msg = arguments; + init->subr = fp; + init->cb = cb; + +#ifdef JANET_WINDOWS + init->write_pipe = janet_vm.iocp; + HANDLE thread_handle = CreateThread(NULL, 0, janet_thread_body, init, 0, NULL); + if (NULL == thread_handle) { + janet_free(init); + janet_panic("failed to create thread"); + } + CloseHandle(thread_handle); /* detach from thread */ +#else + init->write_pipe = janet_vm.selfpipe[1]; + pthread_t waiter_thread; + int err = pthread_create(&waiter_thread, &janet_vm.new_thread_attr, janet_thread_body, init); + if (err) { + janet_free(init); + janet_panicf("%s", strerror(err)); + } +#endif + + /* Increment ev refcount so we don't quit while waiting for a subprocess */ + janet_ev_inc_refcount(); +} + +/* Default callback for janet_ev_threaded_await. */ +void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value) { + if (return_value.fiber == NULL) { + return; + } + if (janet_fiber_can_resume(return_value.fiber)) { + switch (return_value.tag) { + default: + case JANET_EV_TCTAG_NIL: + janet_schedule(return_value.fiber, janet_wrap_nil()); + break; + case JANET_EV_TCTAG_INTEGER: + janet_schedule(return_value.fiber, janet_wrap_integer(return_value.argi)); + break; + case JANET_EV_TCTAG_STRING: + case JANET_EV_TCTAG_STRINGF: + janet_schedule(return_value.fiber, janet_cstringv((const char *) return_value.argp)); + if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp); + break; + case JANET_EV_TCTAG_KEYWORD: + janet_schedule(return_value.fiber, janet_ckeywordv((const char *) return_value.argp)); + break; + case JANET_EV_TCTAG_ERR_STRING: + case JANET_EV_TCTAG_ERR_STRINGF: + janet_cancel(return_value.fiber, janet_cstringv((const char *) return_value.argp)); + if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp); + break; + case JANET_EV_TCTAG_ERR_KEYWORD: + janet_cancel(return_value.fiber, janet_ckeywordv((const char *) return_value.argp)); + break; + case JANET_EV_TCTAG_BOOLEAN: + janet_schedule(return_value.fiber, janet_wrap_boolean(return_value.argi)); + break; + } + } + janet_gcunroot(janet_wrap_fiber(return_value.fiber)); +} + +/* Convenience method for common case */ +JANET_NO_RETURN +void janet_ev_threaded_await(JanetThreadedSubroutine fp, int tag, int argi, void *argp) { + JanetEVGenericMessage arguments; + memset(&arguments, 0, sizeof(arguments)); + arguments.tag = tag; + arguments.argi = argi; + arguments.argp = argp; + arguments.fiber = janet_root_fiber(); + janet_gcroot(janet_wrap_fiber(arguments.fiber)); + janet_ev_threaded_call(fp, arguments, janet_ev_default_threaded_callback); + janet_await(); +} + +/* + * C API helpers for reading and writing from streams. + * There is some networking code in here as well as generic + * reading and writing primitives. + */ + +void janet_stream_flags(JanetStream *stream, uint32_t flags) { + if (stream->flags & JANET_STREAM_CLOSED) { + janet_panic("stream is closed"); + } + if ((stream->flags & flags) != flags) { + const char *rmsg = "", *wmsg = "", *amsg = "", *dmsg = "", *smsg = "stream"; + if (flags & JANET_STREAM_READABLE) rmsg = "readable "; + if (flags & JANET_STREAM_WRITABLE) wmsg = "writable "; + if (flags & JANET_STREAM_ACCEPTABLE) amsg = "server "; + if (flags & JANET_STREAM_UDPSERVER) dmsg = "datagram "; + if (flags & JANET_STREAM_SOCKET) smsg = "socket"; + janet_panicf("bad stream, expected %s%s%s%s%s", rmsg, wmsg, amsg, dmsg, smsg); + } +} + +/* When there is an IO error, we need to be able to convert it to a Janet + * string to raise a Janet error. */ +#ifdef JANET_WINDOWS +#define JANET_EV_CHUNKSIZE 4096 +Janet janet_ev_lasterr(void) { + int code = GetLastError(); + char msgbuf[256]; + msgbuf[0] = '\0'; + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + code, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + msgbuf, + sizeof(msgbuf), + NULL); + if (!*msgbuf) sprintf(msgbuf, "%d", code); + char *c = msgbuf; + while (*c) { + if (*c == '\n' || *c == '\r') { + *c = '\0'; + break; + } + c++; + } + return janet_cstringv(msgbuf); +} +#else +Janet janet_ev_lasterr(void) { + return janet_cstringv(strerror(errno)); +} +#endif + +/* State machine for read/recv/recvfrom */ + +typedef enum { + JANET_ASYNC_READMODE_READ, + JANET_ASYNC_READMODE_RECV, + JANET_ASYNC_READMODE_RECVFROM +} JanetReadMode; + +typedef struct { +#ifdef JANET_WINDOWS + OVERLAPPED overlapped; + DWORD flags; +#ifdef JANET_NET + WSABUF wbuf; + struct sockaddr from; + int fromlen; +#endif + uint8_t chunk_buf[JANET_EV_CHUNKSIZE]; +#else + int flags; +#endif + int32_t bytes_left; + int32_t bytes_read; + JanetBuffer *buf; + int is_chunk; + JanetReadMode mode; +} StateRead; + +void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) { + JanetStream *stream = fiber->ev_stream; + StateRead *state = (StateRead *) fiber->ev_state; + switch (event) { + default: + break; + case JANET_ASYNC_EVENT_MARK: + janet_mark(janet_wrap_buffer(state->buf)); + break; + case JANET_ASYNC_EVENT_CLOSE: + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + break; +#ifdef JANET_WINDOWS + case JANET_ASYNC_EVENT_FAILED: + case JANET_ASYNC_EVENT_COMPLETE: { + /* Called when read finished */ + uint32_t ev_bytes = (uint32_t) state->overlapped.InternalHigh; + state->bytes_read += ev_bytes; + if (state->bytes_read == 0 && (state->mode != JANET_ASYNC_READMODE_RECVFROM)) { + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + return; + } + + janet_buffer_push_bytes(state->buf, state->chunk_buf, ev_bytes); + state->bytes_left -= ev_bytes; + + if (state->bytes_left == 0 || !state->is_chunk || ev_bytes == 0) { + Janet resume_val; +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_READMODE_RECVFROM) { + void *abst = janet_abstract(&janet_address_type, state->fromlen); + memcpy(abst, &state->from, state->fromlen); + resume_val = janet_wrap_abstract(abst); + } else +#endif + { + resume_val = janet_wrap_buffer(state->buf); + } + janet_schedule(fiber, resume_val); + janet_async_end(fiber); + return; + } + } + + /* fallthrough */ + case JANET_ASYNC_EVENT_INIT: { + int32_t chunk_size = state->bytes_left > JANET_EV_CHUNKSIZE ? JANET_EV_CHUNKSIZE : state->bytes_left; + memset(&(state->overlapped), 0, sizeof(OVERLAPPED)); + int status; +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_READMODE_RECVFROM) { + state->wbuf.len = (ULONG) chunk_size; + state->wbuf.buf = (char *) state->chunk_buf; + state->fromlen = sizeof(state->from); + status = WSARecvFrom((SOCKET) stream->handle, &state->wbuf, 1, + NULL, &state->flags, &state->from, &state->fromlen, &state->overlapped, NULL); + if (status && (WSA_IO_PENDING != WSAGetLastError())) { + janet_cancel(fiber, janet_ev_lasterr()); + janet_async_end(fiber); + return; + } + } else +#endif + { + /* Some handles (not all) read from the offset in lpOverlapped + * if its not set before calling `ReadFile` these streams will always read from offset 0 */ + state->overlapped.Offset = (DWORD) state->bytes_read; + + status = ReadFile(stream->handle, state->chunk_buf, chunk_size, NULL, &state->overlapped); + if (!status && (ERROR_IO_PENDING != GetLastError())) { + if (GetLastError() == ERROR_BROKEN_PIPE) { + if (state->bytes_read) { + janet_schedule(fiber, janet_wrap_buffer(state->buf)); + } else { + janet_schedule(fiber, janet_wrap_nil()); + } + } else { + janet_cancel(fiber, janet_ev_lasterr()); + } + janet_async_end(fiber); + return; + } + } + janet_async_in_flight(fiber); + } + break; +#else + case JANET_ASYNC_EVENT_ERR: { + if (state->bytes_read) { + janet_schedule(fiber, janet_wrap_buffer(state->buf)); + } else { + janet_schedule(fiber, janet_wrap_nil()); + } + janet_async_end(fiber); + break; + } + + read_more: + case JANET_ASYNC_EVENT_HUP: + case JANET_ASYNC_EVENT_INIT: + case JANET_ASYNC_EVENT_READ: { + JanetBuffer *buffer = state->buf; + int32_t bytes_left = state->bytes_left; + int32_t read_limit = state->is_chunk ? (bytes_left > 4096 ? 4096 : bytes_left) : bytes_left; + janet_buffer_extra(buffer, read_limit); + ssize_t nread; +#ifdef JANET_NET + char saddr[256]; + socklen_t socklen = sizeof(saddr); +#endif + do { +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_READMODE_RECVFROM) { + nread = recvfrom(stream->handle, buffer->data + buffer->count, read_limit, state->flags, + (struct sockaddr *)&saddr, &socklen); + } else if (state->mode == JANET_ASYNC_READMODE_RECV) { + nread = recv(stream->handle, buffer->data + buffer->count, read_limit, state->flags); + } else +#endif + { + nread = read(stream->handle, buffer->data + buffer->count, read_limit); + } + } while (nread == -1 && errno == EINTR); + + /* Check for errors - special case errors that can just be waited on to fix */ + if (nread == -1) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + break; + } + /* In stream protocols, a pipe error is end of stream */ + if (errno == EPIPE && (state->mode != JANET_ASYNC_READMODE_RECVFROM)) { + nread = 0; + } else { + janet_cancel(fiber, janet_ev_lasterr()); + janet_async_end(fiber); + break; + } + } + + /* Only allow 0-length packets in recv-from. In stream protocols, a zero length packet is EOS. */ + state->bytes_read += nread; + if (state->bytes_read == 0 && (state->mode != JANET_ASYNC_READMODE_RECVFROM)) { + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + break; + } + + /* Increment buffer counts */ + buffer->count += nread; + bytes_left -= nread; + state->bytes_left = bytes_left; + + /* Resume if done */ + if (!state->is_chunk || bytes_left == 0 || nread == 0) { + Janet resume_val; +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_READMODE_RECVFROM) { + void *abst = janet_abstract(&janet_address_type, socklen); + memcpy(abst, &saddr, socklen); + resume_val = janet_wrap_abstract(abst); + } else +#endif + { + resume_val = janet_wrap_buffer(buffer); + } + janet_schedule(fiber, resume_val); + janet_async_end(fiber); + break; + } + + /* Read some more if possible */ + goto read_more; + } + break; +#endif + } +} + +static JANET_NO_RETURN void janet_ev_read_generic(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int is_chunked, JanetReadMode mode, int flags) { + StateRead *state = janet_malloc(sizeof(StateRead)); + state->is_chunk = is_chunked; + state->buf = buf; + state->bytes_left = nbytes; + state->bytes_read = 0; + state->mode = mode; +#ifdef JANET_WINDOWS + state->flags = (DWORD) flags; +#else + state->flags = flags; +#endif + janet_async_start(stream, JANET_ASYNC_LISTEN_READ, ev_callback_read, state); +} + +JANET_NO_RETURN void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) { + janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_READ, 0); +} +JANET_NO_RETURN void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) { + janet_ev_read_generic(stream, buf, nbytes, 1, JANET_ASYNC_READMODE_READ, 0); +} +#ifdef JANET_NET +JANET_NO_RETURN void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) { + janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_RECV, flags); +} +JANET_NO_RETURN void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) { + janet_ev_read_generic(stream, buf, nbytes, 1, JANET_ASYNC_READMODE_RECV, flags); +} +JANET_NO_RETURN void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) { + janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_RECVFROM, flags); +} +#endif + +/* + * State machine for write/send/send-to + */ + +typedef enum { + JANET_ASYNC_WRITEMODE_WRITE, + JANET_ASYNC_WRITEMODE_SEND, + JANET_ASYNC_WRITEMODE_SENDTO +} JanetWriteMode; + +typedef struct { +#ifdef JANET_WINDOWS + OVERLAPPED overlapped; + DWORD flags; +#ifdef JANET_NET + WSABUF wbuf; +#endif +#else + int flags; + int32_t start; +#endif + union { + JanetBuffer *buf; + const uint8_t *str; + } src; + int is_buffer; + JanetWriteMode mode; + void *dest_abst; +} StateWrite; + +void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) { + JanetStream *stream = fiber->ev_stream; + StateWrite *state = (StateWrite *) fiber->ev_state; + switch (event) { + default: + break; + case JANET_ASYNC_EVENT_MARK: { + janet_mark(state->is_buffer + ? janet_wrap_buffer(state->src.buf) + : janet_wrap_string(state->src.str)); + if (state->mode == JANET_ASYNC_WRITEMODE_SENDTO) { + janet_mark(janet_wrap_abstract(state->dest_abst)); + } + break; + } + case JANET_ASYNC_EVENT_CLOSE: + janet_cancel(fiber, janet_cstringv("stream closed")); + janet_async_end(fiber); + break; +#ifdef JANET_WINDOWS + case JANET_ASYNC_EVENT_FAILED: + case JANET_ASYNC_EVENT_COMPLETE: { + /* Called when write finished */ + uint32_t ev_bytes = (uint32_t) state->overlapped.InternalHigh; + if (ev_bytes == 0 && (state->mode != JANET_ASYNC_WRITEMODE_SENDTO)) { + janet_cancel(fiber, janet_cstringv("disconnect")); + janet_async_end(fiber); + return; + } + + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + return; + } + break; + case JANET_ASYNC_EVENT_INIT: { + /* Begin write */ + int32_t len; + const uint8_t *bytes; + if (state->is_buffer) { + /* If buffer, convert to string. */ + /* TODO - be more efficient about this */ + JanetBuffer *buffer = state->src.buf; + JanetString str = janet_string(buffer->data, buffer->count); + bytes = str; + len = buffer->count; + state->is_buffer = 0; + state->src.str = str; + } else { + bytes = state->src.str; + len = janet_string_length(bytes); + } + memset(&(state->overlapped), 0, sizeof(WSAOVERLAPPED)); + + int status; +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_WRITEMODE_SENDTO) { + SOCKET sock = (SOCKET) stream->handle; + state->wbuf.buf = (char *) bytes; + state->wbuf.len = len; + const struct sockaddr *to = state->dest_abst; + int tolen = (int) janet_abstract_size((void *) to); + status = WSASendTo(sock, &state->wbuf, 1, NULL, state->flags, to, tolen, &state->overlapped, NULL); + if (status) { + if (WSA_IO_PENDING == WSAGetLastError()) { + janet_async_in_flight(fiber); + } else { + janet_cancel(fiber, janet_ev_lasterr()); + janet_async_end(fiber); + return; + } + } + } else +#endif + { + /* + * File handles in IOCP need to specify this if they are writing to the + * ends of files, like how this is used here. + * If the underlying resource doesn't support seeking + * byte offsets, they will be ignored + * but this otherwise writes to the end of the file in question + * Right now, os/open streams aren't seekable, so this works. + * for more details see the lpOverlapped parameter in + * https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefile + */ + state->overlapped.Offset = (DWORD) 0xFFFFFFFF; + state->overlapped.OffsetHigh = (DWORD) 0xFFFFFFFF; + status = WriteFile(stream->handle, bytes, len, NULL, &state->overlapped); + if (!status) { + if (ERROR_IO_PENDING == GetLastError()) { + janet_async_in_flight(fiber); + } else { + janet_cancel(fiber, janet_ev_lasterr()); + janet_async_end(fiber); + return; + } + } + } + } + break; +#else + case JANET_ASYNC_EVENT_ERR: + janet_cancel(fiber, janet_cstringv("stream err")); + janet_async_end(fiber); + break; + case JANET_ASYNC_EVENT_HUP: + janet_cancel(fiber, janet_cstringv("stream hup")); + janet_async_end(fiber); + break; + case JANET_ASYNC_EVENT_INIT: + case JANET_ASYNC_EVENT_WRITE: { + int32_t start, len; + const uint8_t *bytes; + start = state->start; + if (state->is_buffer) { + JanetBuffer *buffer = state->src.buf; + bytes = buffer->data; + len = buffer->count; + } else { + bytes = state->src.str; + len = janet_string_length(bytes); + } + ssize_t nwrote = 0; + if (start < len) { + int32_t nbytes = len - start; + void *dest_abst = state->dest_abst; + do { +#ifdef JANET_NET + if (state->mode == JANET_ASYNC_WRITEMODE_SENDTO) { + nwrote = sendto(stream->handle, bytes + start, nbytes, state->flags, + (struct sockaddr *) dest_abst, janet_abstract_size(dest_abst)); + } else if (state->mode == JANET_ASYNC_WRITEMODE_SEND) { + nwrote = send(stream->handle, bytes + start, nbytes, state->flags); + } else +#endif + { + nwrote = write(stream->handle, bytes + start, nbytes); + } + } while (nwrote == -1 && errno == EINTR); + + /* Handle write errors */ + if (nwrote == -1) { + if (errno == EAGAIN || errno == EWOULDBLOCK) break; + janet_cancel(fiber, janet_ev_lasterr()); + janet_async_end(fiber); + break; + } + + /* Unless using datagrams, empty message is a disconnect */ + if (nwrote == 0 && !dest_abst) { + janet_cancel(fiber, janet_cstringv("disconnect")); + janet_async_end(fiber); + break; + } + + if (nwrote > 0) { + start += nwrote; + } else { + start = len; + } + } + state->start = start; + if (start >= len) { + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + break; + } + break; + } + break; +#endif + } +} + +static JANET_NO_RETURN void janet_ev_write_generic(JanetStream *stream, void *buf, void *dest_abst, JanetWriteMode mode, int is_buffer, int flags) { + StateWrite *state = janet_malloc(sizeof(StateWrite)); + state->is_buffer = is_buffer; + state->src.buf = buf; + state->dest_abst = dest_abst; + state->mode = mode; +#ifdef JANET_WINDOWS + state->flags = (DWORD) flags; +#else + state->flags = flags; + state->start = 0; +#endif + janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, ev_callback_write, state); +} + +JANET_NO_RETURN void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf) { + janet_ev_write_generic(stream, buf, NULL, JANET_ASYNC_WRITEMODE_WRITE, 1, 0); +} + +JANET_NO_RETURN void janet_ev_write_string(JanetStream *stream, JanetString str) { + janet_ev_write_generic(stream, (void *) str, NULL, JANET_ASYNC_WRITEMODE_WRITE, 0, 0); +} + +#ifdef JANET_NET +JANET_NO_RETURN void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags) { + janet_ev_write_generic(stream, buf, NULL, JANET_ASYNC_WRITEMODE_SEND, 1, flags); +} + +JANET_NO_RETURN void janet_ev_send_string(JanetStream *stream, JanetString str, int flags) { + janet_ev_write_generic(stream, (void *) str, NULL, JANET_ASYNC_WRITEMODE_SEND, 0, flags); +} + +JANET_NO_RETURN void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags) { + janet_ev_write_generic(stream, buf, dest, JANET_ASYNC_WRITEMODE_SENDTO, 1, flags); +} + +JANET_NO_RETURN void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags) { + janet_ev_write_generic(stream, (void *) str, dest, JANET_ASYNC_WRITEMODE_SENDTO, 0, flags); +} +#endif + +/* For a pipe ID */ +#ifdef JANET_WINDOWS +static volatile long PipeSerialNumber; +#endif + +/* + * mode = 0: both sides non-blocking. + * mode = 1: only read side non-blocking: write side sent to subprocess + * mode = 2: only write side non-blocking: read side sent to subprocess + */ +int janet_make_pipe(JanetHandle handles[2], int mode) { +#ifdef JANET_WINDOWS + /* + * On windows, the built in CreatePipe function doesn't support overlapped IO + * so we lift from the windows source code and modify for our own version. + */ + JanetHandle shandle, chandle; + CHAR PipeNameBuffer[MAX_PATH]; + SECURITY_ATTRIBUTES saAttr; + memset(&saAttr, 0, sizeof(saAttr)); + saAttr.nLength = sizeof(saAttr); + saAttr.bInheritHandle = TRUE; + sprintf(PipeNameBuffer, + "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", + (unsigned int) GetCurrentProcessId(), + (unsigned int) InterlockedIncrement(&PipeSerialNumber)); + + /* server handle goes to subprocess */ + shandle = CreateNamedPipeA( + PipeNameBuffer, + (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, + PIPE_TYPE_BYTE | PIPE_WAIT, + 255, /* Max number of pipes for duplication. */ + 4096, /* Out buffer size */ + 4096, /* In buffer size */ + 120 * 1000, /* Timeout in ms */ + &saAttr); + if (shandle == INVALID_HANDLE_VALUE) { + return -1; + } + + /* we keep client handle */ + chandle = CreateFileA( + PipeNameBuffer, + (mode == 2 ? GENERIC_WRITE : GENERIC_READ), + 0, + &saAttr, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, + NULL); + + if (chandle == INVALID_HANDLE_VALUE) { + CloseHandle(shandle); + return -1; + } + if (mode == 2) { + handles[0] = shandle; + handles[1] = chandle; + } else { + handles[0] = chandle; + handles[1] = shandle; + } + return 0; +#else + if (pipe(handles)) return -1; + if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; + if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; + if (mode != 2 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; + if (mode != 1 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; + return 0; +error: + close(handles[0]); + close(handles[1]); + return -1; +#endif +} + +/* C functions */ + +JANET_CORE_FN(cfun_ev_go, + "(ev/go fiber-or-fun &opt value supervisor)", + "Put a fiber on the event loop to be resumed later. If a function is used, it is wrapped " + "with `fiber/new` first. " + "Optionally pass a value to resume with, otherwise resumes with nil. Returns the fiber. " + "An optional `core/channel` can be provided as a supervisor. When various " + "events occur in the newly scheduled fiber, an event will be pushed to the supervisor. " + "If not provided, the new fiber will inherit the current supervisor.") { + janet_arity(argc, 1, 3); + Janet value = argc >= 2 ? argv[1] : janet_wrap_nil(); + void *supervisor = janet_optabstract(argv, argc, 2, &janet_channel_type, janet_vm.root_fiber->supervisor_channel); + JanetFiber *fiber; + if (janet_checktype(argv[0], JANET_FUNCTION)) { + /* Create a fiber for the user */ + JanetFunction *func = janet_unwrap_function(argv[0]); + if (func->def->min_arity > 1) { + janet_panicf("task function must accept 0 or 1 arguments"); + } + fiber = janet_fiber(func, 64, func->def->min_arity, &value); + fiber->flags |= + JANET_FIBER_MASK_ERROR | + JANET_FIBER_MASK_USER0 | + JANET_FIBER_MASK_USER1 | + JANET_FIBER_MASK_USER2 | + JANET_FIBER_MASK_USER3 | + JANET_FIBER_MASK_USER4; + if (!janet_vm.fiber->env) { + janet_vm.fiber->env = janet_table(0); + } + fiber->env = janet_table(0); + fiber->env->proto = janet_vm.fiber->env; + } else { + fiber = janet_getfiber(argv, 0); + } + fiber->supervisor_channel = supervisor; + janet_schedule(fiber, value); + return janet_wrap_fiber(fiber); +} + +#define JANET_THREAD_SUPERVISOR_FLAG 0x100 + +/* For ev/thread - Run an interpreter in the new thread. */ +static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) { + JanetBuffer *buffer = (JanetBuffer *) args.argp; + const uint8_t *nextbytes = buffer->data; + const uint8_t *endbytes = nextbytes + buffer->count; + uint32_t flags = args.tag; + args.tag = 0; + janet_init(); + janet_vm.sandbox_flags = (uint32_t) args.argi; + JanetTryState tstate; + JanetSignal signal = janet_try(&tstate); + if (!signal) { + + /* Set abstract registry */ + if (!(flags & 0x2)) { + Janet aregv = janet_unmarshal(nextbytes, endbytes - nextbytes, + JANET_MARSHAL_UNSAFE, NULL, &nextbytes); + if (!janet_checktype(aregv, JANET_TABLE)) janet_panic("expected table for abstract registry"); + janet_vm.abstract_registry = janet_unwrap_table(aregv); + janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); + } + + /* Get supervsior */ + if (flags & JANET_THREAD_SUPERVISOR_FLAG) { + Janet sup = + janet_unmarshal(nextbytes, endbytes - nextbytes, + JANET_MARSHAL_UNSAFE, NULL, &nextbytes); + /* Hack - use a global variable to avoid longjmp clobber */ + janet_vm.user = janet_unwrap_pointer(sup); + } + + /* Set cfunction registry */ + if (!(flags & 0x4)) { + uint32_t count1; + memcpy(&count1, nextbytes, sizeof(count1)); + size_t count = (size_t) count1; + if (count > (endbytes - nextbytes) * sizeof(JanetCFunRegistry)) { + janet_panic("thread message invalid"); + } + janet_vm.registry_count = count; + janet_vm.registry_cap = count; + janet_vm.registry = janet_malloc(count * sizeof(JanetCFunRegistry)); + if (janet_vm.registry == NULL) { + JANET_OUT_OF_MEMORY; + } + janet_vm.registry_dirty = 1; + nextbytes += sizeof(uint32_t); + memcpy(janet_vm.registry, nextbytes, count * sizeof(JanetCFunRegistry)); + nextbytes += count * sizeof(JanetCFunRegistry); + } + + Janet fiberv = janet_unmarshal(nextbytes, endbytes - nextbytes, + JANET_MARSHAL_UNSAFE, NULL, &nextbytes); + Janet value = janet_unmarshal(nextbytes, endbytes - nextbytes, + JANET_MARSHAL_UNSAFE, NULL, &nextbytes); + JanetFiber *fiber; + if (!janet_checktype(fiberv, JANET_FIBER)) { + if (!janet_checktype(fiberv, JANET_FUNCTION)) { + janet_panicf("expected function or fiber, got %v", fiberv); + } + JanetFunction *func = janet_unwrap_function(fiberv); + fiber = janet_fiber(func, 64, func->def->min_arity, &value); + if (fiber == NULL) { + janet_panicf("thread function must accept 0 or 1 arguments"); + } + fiber->flags |= + JANET_FIBER_MASK_ERROR | + JANET_FIBER_MASK_USER0 | + JANET_FIBER_MASK_USER1 | + JANET_FIBER_MASK_USER2 | + JANET_FIBER_MASK_USER3 | + JANET_FIBER_MASK_USER4; + } else { + fiber = janet_unwrap_fiber(fiberv); + } + if (flags & 0x8) { + if (NULL == fiber->env) fiber->env = janet_table(0); + janet_table_put(fiber->env, janet_ckeywordv("task-id"), value); + } + fiber->supervisor_channel = janet_vm.user; + janet_schedule(fiber, value); + janet_loop(); + args.tag = JANET_EV_TCTAG_NIL; + } else { + void *supervisor = janet_vm.user; + if (NULL != supervisor) { + /* Got a supervisor, write error there */ + Janet pair[] = { + janet_ckeywordv("error"), + tstate.payload + }; + janet_channel_push((JanetChannel *)supervisor, + janet_wrap_tuple(janet_tuple_n(pair, 2)), 2); + } else if (flags & 0x1) { + /* No wait, just print to stderr */ + janet_eprintf("thread start failure: %v\n", tstate.payload); + } else { + /* Make ev/thread call from parent thread error */ + if (janet_checktype(tstate.payload, JANET_STRING)) { + args.tag = JANET_EV_TCTAG_ERR_STRINGF; + args.argp = strdup((const char *) janet_unwrap_string(tstate.payload)); + } else { + args.tag = JANET_EV_TCTAG_ERR_STRING; + args.argp = "failed to start thread"; + } + } + } + janet_restore(&tstate); + janet_buffer_deinit(buffer); + janet_free(buffer); + janet_deinit(); + return args; +} + +JANET_CORE_FN(cfun_ev_thread, + "(ev/thread main &opt value flags supervisor)", + "Run `main` in a new operating system thread, optionally passing `value` " + "to resume with. The parameter `main` can either be a fiber, or a function that accepts " + "0 or 1 arguments. " + "Unlike `ev/go`, this function will suspend the current fiber until the thread is complete. " + "If you want to run the thread without waiting for a result, pass the `:n` flag to return nil immediately. " + "Otherwise, returns nil. Available flags:\n\n" + "* `:n` - return immediately\n" + "* `:t` - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.\n" + "* `:a` - don't copy abstract registry to new thread (performance optimization)\n" + "* `:c` - don't copy cfunction registry to new thread (performance optimization)") { + janet_arity(argc, 1, 4); + Janet value = argc >= 2 ? argv[1] : janet_wrap_nil(); + if (!janet_checktype(argv[0], JANET_FUNCTION)) janet_getfiber(argv, 0); + uint64_t flags = 0; + if (argc >= 3) { + flags = janet_getflags(argv, 2, "nact"); + } + void *supervisor = janet_optabstract(argv, argc, 3, &janet_channel_type, janet_vm.root_fiber->supervisor_channel); + if (NULL != supervisor) flags |= JANET_THREAD_SUPERVISOR_FLAG; + + /* Marshal arguments for the new thread. */ + JanetBuffer *buffer = janet_malloc(sizeof(JanetBuffer)); + if (NULL == buffer) { + JANET_OUT_OF_MEMORY; + } + janet_buffer_init(buffer, 0); + if (!(flags & 0x2)) { + janet_marshal(buffer, janet_wrap_table(janet_vm.abstract_registry), NULL, JANET_MARSHAL_UNSAFE); + } + if (flags & JANET_THREAD_SUPERVISOR_FLAG) { + janet_marshal(buffer, janet_wrap_abstract(supervisor), NULL, JANET_MARSHAL_UNSAFE); + } + if (!(flags & 0x4)) { + janet_assert(janet_vm.registry_count <= INT32_MAX, "assert failed size check"); + uint32_t temp = (uint32_t) janet_vm.registry_count; + janet_buffer_push_bytes(buffer, (uint8_t *) &temp, sizeof(temp)); + janet_buffer_push_bytes(buffer, (uint8_t *) janet_vm.registry, (int32_t) janet_vm.registry_count * sizeof(JanetCFunRegistry)); + } + janet_marshal(buffer, argv[0], NULL, JANET_MARSHAL_UNSAFE); + janet_marshal(buffer, value, NULL, JANET_MARSHAL_UNSAFE); + if (flags & 0x1) { + /* Return immediately */ + JanetEVGenericMessage arguments; + memset(&arguments, 0, sizeof(arguments)); + arguments.tag = (uint32_t) flags; + arguments.argi = (uint32_t) janet_vm.sandbox_flags; + arguments.argp = buffer; + arguments.fiber = NULL; + janet_ev_threaded_call(janet_go_thread_subr, arguments, janet_ev_default_threaded_callback); + return janet_wrap_nil(); + } else { + janet_ev_threaded_await(janet_go_thread_subr, (uint32_t) flags, (uint32_t) janet_vm.sandbox_flags, buffer); + } +} + +JANET_CORE_FN(cfun_ev_give_supervisor, + "(ev/give-supervisor tag & payload)", + "Send a message to the current supervisor channel if there is one. The message will be a " + "tuple of all of the arguments combined into a single message, where the first element is tag. " + "By convention, tag should be a keyword indicating the type of message. Returns nil.") { + janet_arity(argc, 1, -1); + void *chanv = janet_vm.root_fiber->supervisor_channel; + if (NULL != chanv) { + JanetChannel *chan = janet_channel_unwrap(chanv); + if (janet_channel_push(chan, janet_wrap_tuple(janet_tuple_n(argv, argc)), 0)) { + janet_await(); + } + } + return janet_wrap_nil(); +} + +JANET_NO_RETURN void janet_sleep_await(double sec) { + JanetTimeout to; + to.when = ts_delta(ts_now(), sec); + to.fiber = janet_vm.root_fiber; + to.is_error = 0; + to.sched_id = to.fiber->sched_id; + to.curr_fiber = NULL; + add_timeout(to); + janet_await(); +} + +JANET_CORE_FN(cfun_ev_sleep, + "(ev/sleep sec)", + "Suspend the current fiber for sec seconds without blocking the event loop.") { + janet_fixarity(argc, 1); + double sec = janet_getnumber(argv, 0); + janet_sleep_await(sec); +} + +JANET_CORE_FN(cfun_ev_deadline, + "(ev/deadline sec &opt tocancel tocheck)", + "Schedules the event loop to try to cancel the `tocancel` " + "task as with `ev/cancel`. After `sec` seconds, the event " + "loop will attempt cancellation of `tocancel` if the " + "`tocheck` fiber is resumable. `sec` is a number that can " + "have a fractional part. `tocancel` defaults to " + "`(fiber/root)`, but if specified, must be a task (root " + "fiber). `tocheck` defaults to `(fiber/current)`, but if " + "specified, should be a fiber. Returns `tocancel` " + "immediately.") { + janet_arity(argc, 1, 3); + double sec = janet_getnumber(argv, 0); + JanetFiber *tocancel = janet_optfiber(argv, argc, 1, janet_vm.root_fiber); + JanetFiber *tocheck = janet_optfiber(argv, argc, 2, janet_vm.fiber); + JanetTimeout to; + to.when = ts_delta(ts_now(), sec); + to.fiber = tocancel; + to.curr_fiber = tocheck; + to.is_error = 0; + to.sched_id = to.fiber->sched_id; + add_timeout(to); + return janet_wrap_fiber(tocancel); +} + +JANET_CORE_FN(cfun_ev_cancel, + "(ev/cancel fiber err)", + "Cancel a suspended fiber in the event loop. Differs from cancel in that it returns the canceled fiber immediately.") { + janet_fixarity(argc, 2); + JanetFiber *fiber = janet_getfiber(argv, 0); + Janet err = argv[1]; + janet_cancel(fiber, err); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_stream_close, + "(ev/close stream)", + "Close a stream. This should be the same as calling (:close stream) for all streams.") { + janet_fixarity(argc, 1); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_close(stream); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_stream_read, + "(ev/read stream n &opt buffer timeout)", + "Read up to n bytes into a buffer asynchronously from a stream. `n` can also be the keyword " + "`:all` to read into the buffer until end of stream. " + "Optionally provide a buffer to write into " + "as well as a timeout in seconds after which to cancel the operation and raise an error. " + "Returns the buffer if the read was successful or nil if end-of-stream reached. Will raise an " + "error if there are problems with the IO operation.") { + janet_arity(argc, 2, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_READABLE); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (janet_keyeq(argv[1], "all")) { + if (to != INFINITY) janet_addtimeout(to); + janet_ev_readchunk(stream, buffer, INT32_MAX); + } else { + int32_t n = janet_getnat(argv, 1); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_read(stream, buffer, n); + } +} + +JANET_CORE_FN(janet_cfun_stream_chunk, + "(ev/chunk stream n &opt buffer timeout)", + "Same as ev/read, but will not return early if less than n bytes are available. If an end of " + "stream is reached, will also return early with the collected bytes.") { + janet_arity(argc, 2, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_READABLE); + int32_t n = janet_getnat(argv, 1); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_readchunk(stream, buffer, n); +} + +JANET_CORE_FN(janet_cfun_stream_write, + "(ev/write stream data &opt timeout)", + "Write data to a stream, suspending the current fiber until the write " + "completes. Takes an optional timeout in seconds, after which will return nil. " + "Returns nil, or raises an error if the write failed.") { + janet_arity(argc, 2, 3); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_WRITABLE); + double to = janet_optnumber(argv, argc, 2, INFINITY); + if (janet_checktype(argv[1], JANET_BUFFER)) { + if (to != INFINITY) janet_addtimeout(to); + janet_ev_write_buffer(stream, janet_getbuffer(argv, 1)); + } else { + JanetByteView bytes = janet_getbytes(argv, 1); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_write_string(stream, bytes.bytes); + } +} + +static int mutexgc(void *p, size_t size) { + (void) size; + janet_os_mutex_deinit(p); + return 0; +} + +const JanetAbstractType janet_mutex_type = { + "core/lock", + mutexgc, + JANET_ATEND_GC +}; + +JANET_CORE_FN(janet_cfun_mutex, + "(ev/lock)", + "Create a new lock to coordinate threads.") { + janet_fixarity(argc, 0); + (void) argv; + void *mutex = janet_abstract_threaded(&janet_mutex_type, janet_os_mutex_size()); + janet_os_mutex_init(mutex); + return janet_wrap_abstract(mutex); +} + +JANET_CORE_FN(janet_cfun_mutex_acquire, + "(ev/acquire-lock lock)", + "Acquire a lock such that this operating system thread is the only thread with access to this resource." + " This will block this entire thread until the lock becomes available, and will not yield to other fibers " + "on this system thread.") { + janet_fixarity(argc, 1); + void *mutex = janet_getabstract(argv, 0, &janet_mutex_type); + janet_os_mutex_lock(mutex); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_mutex_release, + "(ev/release-lock lock)", + "Release a lock such that other threads may acquire it.") { + janet_fixarity(argc, 1); + void *mutex = janet_getabstract(argv, 0, &janet_mutex_type); + janet_os_mutex_unlock(mutex); + return argv[0]; +} + +static int rwlockgc(void *p, size_t size) { + (void) size; + janet_os_rwlock_deinit(p); + return 0; +} + +const JanetAbstractType janet_rwlock_type = { + "core/rwlock", + rwlockgc, + JANET_ATEND_GC +}; + +JANET_CORE_FN(janet_cfun_rwlock, + "(ev/rwlock)", + "Create a new read-write lock to coordinate threads.") { + janet_fixarity(argc, 0); + (void) argv; + void *rwlock = janet_abstract_threaded(&janet_rwlock_type, janet_os_rwlock_size()); + janet_os_rwlock_init(rwlock); + return janet_wrap_abstract(rwlock); +} + +JANET_CORE_FN(janet_cfun_rwlock_read_lock, + "(ev/acquire-rlock rwlock)", + "Acquire a read lock an a read-write lock.") { + janet_fixarity(argc, 1); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_rlock(rwlock); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_rwlock_write_lock, + "(ev/acquire-wlock rwlock)", + "Acquire a write lock on a read-write lock.") { + janet_fixarity(argc, 1); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_wlock(rwlock); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_rwlock_read_release, + "(ev/release-rlock rwlock)", + "Release a read lock on a read-write lock") { + janet_fixarity(argc, 1); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_runlock(rwlock); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_rwlock_write_release, + "(ev/release-wlock rwlock)", + "Release a write lock on a read-write lock") { + janet_fixarity(argc, 1); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_wunlock(rwlock); + return argv[0]; +} + +JANET_CORE_FN(janet_cfun_ev_all_tasks, + "(ev/all-tasks)", + "Get an array of all active fibers that are being used by the scheduler.") { + janet_fixarity(argc, 0); + (void) argv; + JanetArray *array = janet_array(janet_vm.active_tasks.count); + for (int32_t i = 0; i < janet_vm.active_tasks.capacity; i++) { + if (!janet_checktype(janet_vm.active_tasks.data[i].key, JANET_NIL)) { + janet_array_push(array, janet_vm.active_tasks.data[i].key); + } + } + return janet_wrap_array(array); +} + +void janet_lib_ev(JanetTable *env) { + JanetRegExt ev_cfuns_ext[] = { + JANET_CORE_REG("ev/give", cfun_channel_push), + JANET_CORE_REG("ev/take", cfun_channel_pop), + JANET_CORE_REG("ev/full", cfun_channel_full), + JANET_CORE_REG("ev/capacity", cfun_channel_capacity), + JANET_CORE_REG("ev/count", cfun_channel_count), + JANET_CORE_REG("ev/select", cfun_channel_choice), + JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), + JANET_CORE_REG("ev/chan", cfun_channel_new), + JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), + JANET_CORE_REG("ev/chan-close", cfun_channel_close), + JANET_CORE_REG("ev/go", cfun_ev_go), + JANET_CORE_REG("ev/thread", cfun_ev_thread), + JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), + JANET_CORE_REG("ev/sleep", cfun_ev_sleep), + JANET_CORE_REG("ev/deadline", cfun_ev_deadline), + JANET_CORE_REG("ev/cancel", cfun_ev_cancel), + JANET_CORE_REG("ev/close", janet_cfun_stream_close), + JANET_CORE_REG("ev/read", janet_cfun_stream_read), + JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), + JANET_CORE_REG("ev/write", janet_cfun_stream_write), + JANET_CORE_REG("ev/lock", janet_cfun_mutex), + JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), + JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), + JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), + JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), + JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), + JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), + JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), + JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), + JANET_REG_END + }; + + janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); + janet_register_abstract_type(&janet_stream_type); + janet_register_abstract_type(&janet_channel_type); + janet_register_abstract_type(&janet_mutex_type); + janet_register_abstract_type(&janet_rwlock_type); +} + +#endif + + +/* src/core/ffi.c */ +#line 0 "src/core/ffi.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "gc.h" +#endif + +#ifdef JANET_FFI + +#ifdef _MSC_VER +#define alloca _alloca +#elif defined(JANET_LINUX) +#include +#elif !defined(alloca) +/* Last ditch effort to get alloca - works for gcc and clang */ +#define alloca __builtin_alloca +#endif + +/* FFI jit includes */ +#ifdef JANET_FFI_JIT +#ifndef JANET_WINDOWS +#include +#endif +#endif + +#define JANET_FFI_MAX_RECUR 64 + +/* Compiler, OS, and arch detection. Used + * to enable a set of calling conventions. The + * :none calling convention is always enabled. */ +#if defined(JANET_WINDOWS) && (defined(__x86_64__) || defined(_M_X64)) +#define JANET_FFI_WIN64_ENABLED +#endif +#if (defined(__x86_64__) || defined(_M_X64)) && !defined(JANET_WINDOWS) +#define JANET_FFI_SYSV64_ENABLED +#endif + +typedef struct JanetFFIType JanetFFIType; +typedef struct JanetFFIStruct JanetFFIStruct; + +typedef enum { + JANET_FFI_TYPE_VOID, + JANET_FFI_TYPE_BOOL, + JANET_FFI_TYPE_PTR, + JANET_FFI_TYPE_STRING, + JANET_FFI_TYPE_FLOAT, + JANET_FFI_TYPE_DOUBLE, + JANET_FFI_TYPE_INT8, + JANET_FFI_TYPE_UINT8, + JANET_FFI_TYPE_INT16, + JANET_FFI_TYPE_UINT16, + JANET_FFI_TYPE_INT32, + JANET_FFI_TYPE_UINT32, + JANET_FFI_TYPE_INT64, + JANET_FFI_TYPE_UINT64, + JANET_FFI_TYPE_STRUCT +} JanetFFIPrimType; + +/* Custom alignof since alignof not in c99 standard */ +#define ALIGNOF(type) offsetof(struct { char c; type member; }, member) + +typedef struct { + size_t size; + size_t align; +} JanetFFIPrimInfo; + +static const JanetFFIPrimInfo janet_ffi_type_info[] = { + {0, 0}, /* JANET_FFI_TYPE_VOID */ + {sizeof(char), ALIGNOF(char)}, /* JANET_FFI_TYPE_BOOL */ + {sizeof(void *), ALIGNOF(void *)}, /* JANET_FFI_TYPE_PTR */ + {sizeof(char *), ALIGNOF(char *)}, /* JANET_FFI_TYPE_STRING */ + {sizeof(float), ALIGNOF(float)}, /* JANET_FFI_TYPE_FLOAT */ + {sizeof(double), ALIGNOF(double)}, /* JANET_FFI_TYPE_DOUBLE */ + {sizeof(int8_t), ALIGNOF(int8_t)}, /* JANET_FFI_TYPE_INT8 */ + {sizeof(uint8_t), ALIGNOF(uint8_t)}, /* JANET_FFI_TYPE_UINT8 */ + {sizeof(int16_t), ALIGNOF(int16_t)}, /* JANET_FFI_TYPE_INT16 */ + {sizeof(uint16_t), ALIGNOF(uint16_t)}, /* JANET_FFI_TYPE_UINT16 */ + {sizeof(int32_t), ALIGNOF(int32_t)}, /* JANET_FFI_TYPE_INT32 */ + {sizeof(uint32_t), ALIGNOF(uint32_t)}, /* JANET_FFI_TYPE_UINT32 */ + {sizeof(int64_t), ALIGNOF(int64_t)}, /* JANET_FFI_TYPE_INT64 */ + {sizeof(uint64_t), ALIGNOF(uint64_t)}, /* JANET_FFI_TYPE_UINT64 */ + {0, ALIGNOF(uint64_t)} /* JANET_FFI_TYPE_STRUCT */ +}; + +struct JanetFFIType { + JanetFFIStruct *st; + JanetFFIPrimType prim; + int32_t array_count; +}; + +typedef struct { + JanetFFIType type; + size_t offset; +} JanetFFIStructMember; + +/* Also used to store array types */ +struct JanetFFIStruct { + uint32_t size; + uint32_t align; + uint32_t field_count; + uint32_t is_aligned; + JanetFFIStructMember fields[]; +}; + +/* Specifies how the registers are classified. This is used + * to determine if a certain argument should be passed in a register, + * on the stack, special floating pointer register, etc. */ +typedef enum { + JANET_SYSV64_INTEGER, + JANET_SYSV64_SSE, + JANET_SYSV64_SSEUP, + JANET_SYSV64_PAIR_INTINT, + JANET_SYSV64_PAIR_INTSSE, + JANET_SYSV64_PAIR_SSEINT, + JANET_SYSV64_PAIR_SSESSE, + JANET_SYSV64_NO_CLASS, + JANET_SYSV64_MEMORY, + JANET_WIN64_REGISTER, + JANET_WIN64_STACK, + JANET_WIN64_REGISTER_REF, + JANET_WIN64_STACK_REF +} JanetFFIWordSpec; + +/* Describe how each Janet argument is interpreted in terms of machine words + * that will be mapped to registers/stack. */ +typedef struct { + JanetFFIType type; + JanetFFIWordSpec spec; + uint32_t offset; /* point to the exact register / stack offset depending on spec. */ + uint32_t offset2; /* for reference passing apis (windows), use to allocate reference */ +} JanetFFIMapping; + +typedef enum { + JANET_FFI_CC_NONE, + JANET_FFI_CC_SYSV_64, + JANET_FFI_CC_WIN_64 +} JanetFFICallingConvention; + +#ifdef JANET_FFI_WIN64_ENABLED +#define JANET_FFI_CC_DEFAULT JANET_FFI_CC_WIN_64 +#elif defined(JANET_FFI_SYSV64_ENABLED) +#define JANET_FFI_CC_DEFAULT JANET_FFI_CC_SYSV_64 +#else +#define JANET_FFI_CC_DEFAULT JANET_FFI_CC_NONE +#endif + +#define JANET_FFI_MAX_ARGS 32 + +typedef struct { + uint32_t frame_size; + uint32_t arg_count; + uint32_t word_count; + uint32_t variant; + uint32_t stack_count; + JanetFFICallingConvention cc; + JanetFFIMapping ret; + JanetFFIMapping args[JANET_FFI_MAX_ARGS]; +} JanetFFISignature; + +int signature_mark(void *p, size_t s) { + (void) s; + JanetFFISignature *sig = p; + for (uint32_t i = 0; i < sig->arg_count; i++) { + JanetFFIType t = sig->args[i].type; + if (t.prim == JANET_FFI_TYPE_STRUCT) { + janet_mark(janet_wrap_abstract(t.st)); + } + } + return 0; +} + +static const JanetAbstractType janet_signature_type = { + "core/ffi-signature", + NULL, + signature_mark, + JANET_ATEND_GCMARK +}; + +int struct_mark(void *p, size_t s) { + (void) s; + JanetFFIStruct *st = p; + for (uint32_t i = 0; i < st->field_count; i++) { + JanetFFIType t = st->fields[i].type; + if (t.prim == JANET_FFI_TYPE_STRUCT) { + janet_mark(janet_wrap_abstract(t.st)); + } + } + return 0; +} + +typedef struct { + void *function_pointer; + size_t size; +} JanetFFIJittedFn; + +static const JanetAbstractType janet_struct_type = { + "core/ffi-struct", + NULL, + struct_mark, + JANET_ATEND_GCMARK +}; + +static int janet_ffijit_gc(void *p, size_t s) { + (void) s; + JanetFFIJittedFn *fn = p; + if (fn->function_pointer == NULL) return 0; +#ifdef JANET_FFI_JIT +#ifdef JANET_WINDOWS + VirtualFree(fn->function_pointer, fn->size, MEM_RELEASE); +#else + munmap(fn->function_pointer, fn->size); +#endif +#endif + return 0; +} + +static JanetByteView janet_ffijit_getbytes(void *p, size_t s) { + (void) s; + JanetFFIJittedFn *fn = p; + JanetByteView bytes; + bytes.bytes = fn->function_pointer; + bytes.len = (int32_t) fn->size; + return bytes; +} + +static size_t janet_ffijit_length(void *p, size_t s) { + (void) s; + JanetFFIJittedFn *fn = p; + return fn->size; +} + +const JanetAbstractType janet_type_ffijit = { + .name = "ffi/jitfn", + .gc = janet_ffijit_gc, + .bytes = janet_ffijit_getbytes, + .length = janet_ffijit_length +}; + +typedef struct { + Clib clib; + int closed; + int is_self; +} JanetAbstractNative; + +static const JanetAbstractType janet_native_type = { + "core/ffi-native", + JANET_ATEND_NAME +}; + +static JanetFFIType prim_type(JanetFFIPrimType pt) { + JanetFFIType t; + t.prim = pt; + t.st = NULL; + t.array_count = -1; + return t; +} + +static size_t type_size(JanetFFIType t) { + size_t count = t.array_count < 0 ? 1 : (size_t) t.array_count; + if (t.prim == JANET_FFI_TYPE_STRUCT) { + return t.st->size * count; + } else { + return janet_ffi_type_info[t.prim].size * count; + } +} + +static size_t type_align(JanetFFIType t) { + if (t.prim == JANET_FFI_TYPE_STRUCT) { + return t.st->align; + } else { + return janet_ffi_type_info[t.prim].align; + } +} + +static JanetFFICallingConvention decode_ffi_cc(const uint8_t *name) { + if (!janet_cstrcmp(name, "none")) return JANET_FFI_CC_NONE; +#ifdef JANET_FFI_WIN64_ENABLED + if (!janet_cstrcmp(name, "win64")) return JANET_FFI_CC_WIN_64; +#endif +#ifdef JANET_FFI_SYSV64_ENABLED + if (!janet_cstrcmp(name, "sysv64")) return JANET_FFI_CC_SYSV_64; +#endif + if (!janet_cstrcmp(name, "default")) return JANET_FFI_CC_DEFAULT; + janet_panicf("unknown calling convention %s", name); +} + +static JanetFFIPrimType decode_ffi_prim(const uint8_t *name) { + if (!janet_cstrcmp(name, "void")) return JANET_FFI_TYPE_VOID; + if (!janet_cstrcmp(name, "bool")) return JANET_FFI_TYPE_BOOL; + if (!janet_cstrcmp(name, "ptr")) return JANET_FFI_TYPE_PTR; + if (!janet_cstrcmp(name, "pointer")) return JANET_FFI_TYPE_PTR; + if (!janet_cstrcmp(name, "string")) return JANET_FFI_TYPE_STRING; + if (!janet_cstrcmp(name, "float")) return JANET_FFI_TYPE_FLOAT; + if (!janet_cstrcmp(name, "double")) return JANET_FFI_TYPE_DOUBLE; + if (!janet_cstrcmp(name, "int8")) return JANET_FFI_TYPE_INT8; + if (!janet_cstrcmp(name, "uint8")) return JANET_FFI_TYPE_UINT8; + if (!janet_cstrcmp(name, "int16")) return JANET_FFI_TYPE_INT16; + if (!janet_cstrcmp(name, "uint16")) return JANET_FFI_TYPE_UINT16; + if (!janet_cstrcmp(name, "int32")) return JANET_FFI_TYPE_INT32; + if (!janet_cstrcmp(name, "uint32")) return JANET_FFI_TYPE_UINT32; + if (!janet_cstrcmp(name, "int64")) return JANET_FFI_TYPE_INT64; + if (!janet_cstrcmp(name, "uint64")) return JANET_FFI_TYPE_UINT64; +#ifdef JANET_64 + if (!janet_cstrcmp(name, "size")) return JANET_FFI_TYPE_UINT64; + if (!janet_cstrcmp(name, "ssize")) return JANET_FFI_TYPE_INT64; +#else + if (!janet_cstrcmp(name, "size")) return JANET_FFI_TYPE_UINT32; + if (!janet_cstrcmp(name, "ssize")) return JANET_FFI_TYPE_INT32; +#endif + /* aliases */ + if (!janet_cstrcmp(name, "r32")) return JANET_FFI_TYPE_FLOAT; + if (!janet_cstrcmp(name, "r64")) return JANET_FFI_TYPE_DOUBLE; + if (!janet_cstrcmp(name, "s8")) return JANET_FFI_TYPE_INT8; + if (!janet_cstrcmp(name, "u8")) return JANET_FFI_TYPE_UINT8; + if (!janet_cstrcmp(name, "s16")) return JANET_FFI_TYPE_INT16; + if (!janet_cstrcmp(name, "u16")) return JANET_FFI_TYPE_UINT16; + if (!janet_cstrcmp(name, "s32")) return JANET_FFI_TYPE_INT32; + if (!janet_cstrcmp(name, "u32")) return JANET_FFI_TYPE_UINT32; + if (!janet_cstrcmp(name, "s64")) return JANET_FFI_TYPE_INT64; + if (!janet_cstrcmp(name, "u64")) return JANET_FFI_TYPE_UINT64; + if (!janet_cstrcmp(name, "char")) return JANET_FFI_TYPE_INT8; + if (!janet_cstrcmp(name, "short")) return JANET_FFI_TYPE_INT16; + if (!janet_cstrcmp(name, "int")) return JANET_FFI_TYPE_INT32; + if (!janet_cstrcmp(name, "long")) return JANET_FFI_TYPE_INT64; + if (!janet_cstrcmp(name, "byte")) return JANET_FFI_TYPE_UINT8; + if (!janet_cstrcmp(name, "uchar")) return JANET_FFI_TYPE_UINT8; + if (!janet_cstrcmp(name, "ushort")) return JANET_FFI_TYPE_UINT16; + if (!janet_cstrcmp(name, "uint")) return JANET_FFI_TYPE_UINT32; + if (!janet_cstrcmp(name, "ulong")) return JANET_FFI_TYPE_UINT64; + janet_panicf("unknown machine type %s", name); +} + +/* A common callback function signature. To avoid runtime code generation, which is prohibited + * on many platforms, often buggy (see libffi), and generally complicated, instead provide + * a single (or small set of commonly used function signatures). All callbacks should + * eventually call this. */ +void janet_ffi_trampoline(void *ctx, void *userdata) { + if (NULL == userdata) { + /* Userdata not set. */ + janet_eprintf("no userdata found for janet callback"); + return; + } + Janet context = janet_wrap_pointer(ctx); + JanetFunction *fun = userdata; + janet_call(fun, 1, &context); +} + +static JanetFFIType decode_ffi_type(Janet x); + +static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) { + /* Use :pack to indicate a single packed struct member and :pack-all + * to pack the remaining members */ + int32_t member_count = argc; + int all_packed = 0; + for (int32_t i = 0; i < argc; i++) { + if (janet_keyeq(argv[i], "pack")) { + member_count--; + } else if (janet_keyeq(argv[i], "pack-all")) { + member_count--; + all_packed = 1; + } + } + + JanetFFIStruct *st = janet_abstract(&janet_struct_type, + sizeof(JanetFFIStruct) + argc * sizeof(JanetFFIStructMember)); + st->field_count = member_count; + st->size = 0; + st->align = 1; + if (argc == 0) { + janet_panic("invalid empty struct"); + } + uint32_t is_aligned = 1; + int32_t i = 0; + for (int32_t j = 0; j < argc; j++) { + int pack_one = 0; + if (janet_keyeq(argv[j], "pack") || janet_keyeq(argv[j], "pack-all")) { + pack_one = 1; + j++; + if (j == argc) break; + } + st->fields[i].type = decode_ffi_type(argv[j]); + size_t el_size = type_size(st->fields[i].type); + size_t el_align = type_align(st->fields[i].type); + if (all_packed || pack_one) { + if (st->size % el_align != 0) is_aligned = 0; + st->fields[i].offset = st->size; + st->size += (uint32_t) el_size; + } else { + if (el_align > st->align) st->align = (uint32_t) el_align; + st->fields[i].offset = (uint32_t)(((st->size + el_align - 1) / el_align) * el_align); + st->size = (uint32_t)(el_size + st->fields[i].offset); + } + i++; + } + st->is_aligned = is_aligned; + st->size += (st->align - 1); + st->size /= st->align; + st->size *= st->align; + return st; +} + +static JanetFFIType decode_ffi_type(Janet x) { + if (janet_checktype(x, JANET_KEYWORD)) { + return prim_type(decode_ffi_prim(janet_unwrap_keyword(x))); + } + JanetFFIType ret; + ret.array_count = -1; + ret.prim = JANET_FFI_TYPE_STRUCT; + if (janet_checkabstract(x, &janet_struct_type)) { + ret.st = janet_unwrap_abstract(x); + return ret; + } + int32_t len; + const Janet *els; + if (janet_indexed_view(x, &els, &len)) { + if (janet_checktype(x, JANET_ARRAY)) { + if (len != 2 && len != 1) janet_panicf("array type must be of form @[type count], got %v", x); + ret = decode_ffi_type(els[0]); + int32_t array_count = len == 1 ? 0 : janet_getnat(els, 1); + ret.array_count = array_count; + } else { + ret.st = build_struct_type(len, els); + } + return ret; + } else { + janet_panicf("bad native type %v", x); + } +} + +JANET_CORE_FN(cfun_ffi_struct, + "(ffi/struct & types)", + "Create a struct type definition that can be used to pass structs into native functions. ") { + janet_arity(argc, 1, -1); + return janet_wrap_abstract(build_struct_type(argc, argv)); +} + +JANET_CORE_FN(cfun_ffi_size, + "(ffi/size type)", + "Get the size of an ffi type in bytes.") { + janet_fixarity(argc, 1); + size_t size = type_size(decode_ffi_type(argv[0])); + return janet_wrap_number((double) size); +} + +JANET_CORE_FN(cfun_ffi_align, + "(ffi/align type)", + "Get the align of an ffi type in bytes.") { + janet_fixarity(argc, 1); + size_t size = type_align(decode_ffi_type(argv[0])); + return janet_wrap_number((double) size); +} + +static void *janet_ffi_getpointer(const Janet *argv, int32_t n) { + switch (janet_type(argv[n])) { + default: + janet_panicf("bad slot #%d, expected ffi pointer convertable type, got %v", n, argv[n]); + case JANET_POINTER: + case JANET_STRING: + case JANET_KEYWORD: + case JANET_SYMBOL: + case JANET_CFUNCTION: + return janet_unwrap_pointer(argv[n]); + case JANET_ABSTRACT: + return (void *) janet_getbytes(argv, n).bytes; + case JANET_BUFFER: + return janet_unwrap_buffer(argv[n])->data; + case JANET_FUNCTION: + /* Users may pass in a function. Any function passed is almost certainly + * being used as a callback, so we add it to the root set. */ + janet_gcroot(argv[n]); + return janet_unwrap_pointer(argv[n]); + case JANET_NIL: + return NULL; + } +} + +static void *janet_ffi_get_callable_pointer(const Janet *argv, int32_t n) { + switch (janet_type(argv[n])) { + default: + break; + case JANET_POINTER: + return janet_unwrap_pointer(argv[n]); + case JANET_ABSTRACT: + if (!janet_checkabstract(argv[n], &janet_type_ffijit)) break; + return ((JanetFFIJittedFn *)janet_unwrap_abstract(argv[n]))->function_pointer; + } + janet_panicf("bad slot #%d, expected ffi callable pointer type, got %v", n, argv[n]); +} + +/* Write a value given by some Janet values and an FFI type as it would appear in memory. + * The alignment and space available is assumed to already be sufficient */ +static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFIType type, int recur) { + if (recur == 0) janet_panic("recursion too deep"); + if (type.array_count >= 0) { + JanetFFIType el_type = type; + el_type.array_count = -1; + size_t el_size = type_size(el_type); + JanetView els = janet_getindexed(argv, n); + if (els.len != type.array_count) { + janet_panicf("bad array length, expected %d, got %d", type.array_count, els.len); + } + char *cursor = to; + for (int32_t i = 0; i < els.len; i++) { + janet_ffi_write_one(cursor, els.items, i, el_type, recur - 1); + cursor += el_size; + } + return; + } + switch (type.prim) { + case JANET_FFI_TYPE_VOID: + if (!janet_checktype(argv[n], JANET_NIL)) { + janet_panicf("expected nil, got %v", argv[n]); + } + break; + case JANET_FFI_TYPE_STRUCT: { + JanetView els = janet_getindexed(argv, n); + JanetFFIStruct *st = type.st; + if ((uint32_t) els.len != st->field_count) { + janet_panicf("wrong number of fields in struct, expected %d, got %d", + (int32_t) st->field_count, els.len); + } + for (int32_t i = 0; i < els.len; i++) { + JanetFFIType tp = st->fields[i].type; + janet_ffi_write_one((char *) to + st->fields[i].offset, els.items, i, tp, recur - 1); + } + } + break; + case JANET_FFI_TYPE_DOUBLE: + ((double *)(to))[0] = janet_getnumber(argv, n); + break; + case JANET_FFI_TYPE_FLOAT: + ((float *)(to))[0] = (float) janet_getnumber(argv, n); + break; + case JANET_FFI_TYPE_PTR: + ((void **)(to))[0] = janet_ffi_getpointer(argv, n); + break; + case JANET_FFI_TYPE_STRING: + ((const char **)(to))[0] = janet_getcstring(argv, n); + break; + case JANET_FFI_TYPE_BOOL: + ((bool *)(to))[0] = janet_getboolean(argv, n); + break; + case JANET_FFI_TYPE_INT8: + ((int8_t *)(to))[0] = janet_getinteger(argv, n); + break; + case JANET_FFI_TYPE_INT16: + ((int16_t *)(to))[0] = janet_getinteger(argv, n); + break; + case JANET_FFI_TYPE_INT32: + ((int32_t *)(to))[0] = janet_getinteger(argv, n); + break; + case JANET_FFI_TYPE_INT64: + ((int64_t *)(to))[0] = janet_getinteger64(argv, n); + break; + case JANET_FFI_TYPE_UINT8: + ((uint8_t *)(to))[0] = (uint8_t) janet_getuinteger64(argv, n); + break; + case JANET_FFI_TYPE_UINT16: + ((uint16_t *)(to))[0] = (uint16_t) janet_getuinteger64(argv, n); + break; + case JANET_FFI_TYPE_UINT32: + ((uint32_t *)(to))[0] = (uint32_t) janet_getuinteger64(argv, n); + break; + case JANET_FFI_TYPE_UINT64: + ((uint64_t *)(to))[0] = janet_getuinteger64(argv, n); + break; + } +} + +/* Read a value from memory and construct a Janet data structure that can be passed back into + * the interpreter. This should be the inverse to janet_ffi_write_one. It is assumed that the + * size of the data is correct. */ +static Janet janet_ffi_read_one(const uint8_t *from, JanetFFIType type, int recur) { + if (recur == 0) janet_panic("recursion too deep"); + if (type.array_count >= 0) { + JanetFFIType el_type = type; + el_type.array_count = -1; + size_t el_size = type_size(el_type); + JanetArray *array = janet_array(type.array_count); + for (int32_t i = 0; i < type.array_count; i++) { + janet_array_push(array, janet_ffi_read_one(from, el_type, recur - 1)); + from += el_size; + } + return janet_wrap_array(array); + } + switch (type.prim) { + default: + case JANET_FFI_TYPE_VOID: + return janet_wrap_nil(); + case JANET_FFI_TYPE_STRUCT: { + JanetFFIStruct *st = type.st; + Janet *tup = janet_tuple_begin(st->field_count); + for (uint32_t i = 0; i < st->field_count; i++) { + JanetFFIType tp = st->fields[i].type; + tup[i] = janet_ffi_read_one(from + st->fields[i].offset, tp, recur - 1); + } + return janet_wrap_tuple(janet_tuple_end(tup)); + } + case JANET_FFI_TYPE_DOUBLE: + return janet_wrap_number(((double *)(from))[0]); + case JANET_FFI_TYPE_FLOAT: + return janet_wrap_number(((float *)(from))[0]); + case JANET_FFI_TYPE_PTR: { + void *ptr = ((void **)(from))[0]; + return (NULL == ptr) ? janet_wrap_nil() : janet_wrap_pointer(ptr); + } + case JANET_FFI_TYPE_STRING: + return janet_cstringv(((char **)(from))[0]); + case JANET_FFI_TYPE_BOOL: + return janet_wrap_boolean(((bool *)(from))[0]); + case JANET_FFI_TYPE_INT8: + return janet_wrap_number(((int8_t *)(from))[0]); + case JANET_FFI_TYPE_INT16: + return janet_wrap_number(((int16_t *)(from))[0]); + case JANET_FFI_TYPE_INT32: + return janet_wrap_number(((int32_t *)(from))[0]); + case JANET_FFI_TYPE_UINT8: + return janet_wrap_number(((uint8_t *)(from))[0]); + case JANET_FFI_TYPE_UINT16: + return janet_wrap_number(((uint16_t *)(from))[0]); + case JANET_FFI_TYPE_UINT32: + return janet_wrap_number(((uint32_t *)(from))[0]); +#ifdef JANET_INT_TYPES + case JANET_FFI_TYPE_INT64: + return janet_wrap_s64(((int64_t *)(from))[0]); + case JANET_FFI_TYPE_UINT64: + return janet_wrap_u64(((uint64_t *)(from))[0]); +#else + case JANET_FFI_TYPE_INT64: + return janet_wrap_number(((int64_t *)(from))[0]); + case JANET_FFI_TYPE_UINT64: + return janet_wrap_number(((uint64_t *)(from))[0]); +#endif + } +} + +static JanetFFIMapping void_mapping(void) { + JanetFFIMapping m; + m.type = prim_type(JANET_FFI_TYPE_VOID); + m.spec = JANET_SYSV64_NO_CLASS; + m.offset = 0; + return m; +} + +#ifdef JANET_FFI_SYSV64_ENABLED +/* AMD64 ABI Draft 0.99.7 – November 17, 2014 – 15:08 + * See section 3.2.3 Parameter Passing */ +static JanetFFIWordSpec sysv64_classify_ext(JanetFFIType type, size_t shift) { + switch (type.prim) { + case JANET_FFI_TYPE_PTR: + case JANET_FFI_TYPE_STRING: + case JANET_FFI_TYPE_BOOL: + case JANET_FFI_TYPE_INT8: + case JANET_FFI_TYPE_INT16: + case JANET_FFI_TYPE_INT32: + case JANET_FFI_TYPE_INT64: + case JANET_FFI_TYPE_UINT8: + case JANET_FFI_TYPE_UINT16: + case JANET_FFI_TYPE_UINT32: + case JANET_FFI_TYPE_UINT64: + return JANET_SYSV64_INTEGER; + case JANET_FFI_TYPE_DOUBLE: + case JANET_FFI_TYPE_FLOAT: + return JANET_SYSV64_SSE; + case JANET_FFI_TYPE_STRUCT: { + JanetFFIStruct *st = type.st; + if (st->size > 16) return JANET_SYSV64_MEMORY; + if (!st->is_aligned) return JANET_SYSV64_MEMORY; + JanetFFIWordSpec clazz = JANET_SYSV64_NO_CLASS; + if (st->size > 8 && st->size <= 16) { + /* map to pair classification */ + int has_int_lo = 0; + int has_int_hi = 0; + for (uint32_t i = 0; i < st->field_count; i++) { + JanetFFIWordSpec next_class = sysv64_classify_ext(st->fields[i].type, shift + st->fields[i].offset); + switch (next_class) { + default: + break; + case JANET_SYSV64_INTEGER: + if (shift + st->fields[i].offset + type_size(st->fields[i].type) <= 8) { + has_int_lo = 1; + } else { + has_int_hi = 2; + } + break; + case JANET_SYSV64_PAIR_INTINT: + has_int_lo = 1; + has_int_hi = 2; + break; + case JANET_SYSV64_PAIR_INTSSE: + has_int_lo = 1; + break; + case JANET_SYSV64_PAIR_SSEINT: + has_int_hi = 2; + break; + break; + } + } + switch (has_int_hi + has_int_lo) { + case 0: + clazz = JANET_SYSV64_PAIR_SSESSE; + break; + case 1: + clazz = JANET_SYSV64_PAIR_INTSSE; + break; + case 2: + clazz = JANET_SYSV64_PAIR_SSEINT; + break; + case 3: + clazz = JANET_SYSV64_PAIR_INTINT; + break; + } + } else { + /* Normal struct classification */ + for (uint32_t i = 0; i < st->field_count; i++) { + JanetFFIWordSpec next_class = sysv64_classify_ext(st->fields[i].type, shift + st->fields[i].offset); + if (next_class != clazz) { + if (clazz == JANET_SYSV64_NO_CLASS) { + clazz = next_class; + } else if (clazz == JANET_SYSV64_MEMORY || next_class == JANET_SYSV64_MEMORY) { + clazz = JANET_SYSV64_MEMORY; + } else if (clazz == JANET_SYSV64_INTEGER || next_class == JANET_SYSV64_INTEGER) { + clazz = JANET_SYSV64_INTEGER; + } else { + clazz = JANET_SYSV64_SSE; + } + } + } + } + return clazz; + } + case JANET_FFI_TYPE_VOID: + return JANET_SYSV64_NO_CLASS; + default: + janet_panic("nyi"); + return JANET_SYSV64_NO_CLASS; + } +} +static JanetFFIWordSpec sysv64_classify(JanetFFIType type) { + return sysv64_classify_ext(type, 0); +} +#endif + +JANET_CORE_FN(cfun_ffi_signature, + "(ffi/signature calling-convention ret-type & arg-types)", + "Create a function signature object that can be used to make calls " + "with raw function pointers.") { + janet_arity(argc, 2, -1); + uint32_t frame_size = 0; + uint32_t variant = 0; + uint32_t arg_count = argc - 2; + uint32_t stack_count = 0; + JanetFFICallingConvention cc = decode_ffi_cc(janet_getkeyword(argv, 0)); + JanetFFIType ret_type = decode_ffi_type(argv[1]); + JanetFFIMapping ret = { + ret_type, + JANET_SYSV64_NO_CLASS, + 0, + 0 + }; + JanetFFIMapping mappings[JANET_FFI_MAX_ARGS]; + for (int i = 0; i < JANET_FFI_MAX_ARGS; i++) mappings[i] = void_mapping(); + switch (cc) { + default: + case JANET_FFI_CC_NONE: { + /* Even if unsupported, we can check that the signature is valid + * and error at runtime */ + for (uint32_t i = 0; i < arg_count; i++) { + decode_ffi_type(argv[i + 2]); + } + } + break; + +#ifdef JANET_FFI_WIN64_ENABLED + case JANET_FFI_CC_WIN_64: { + size_t ret_size = type_size(ret.type); + uint32_t ref_stack_count = 0; + ret.spec = JANET_WIN64_REGISTER; + uint32_t next_register = 0; + if (ret_size != 0 && ret_size != 1 && ret_size != 2 && ret_size != 4 && ret_size != 8) { + ret.spec = JANET_WIN64_REGISTER_REF; + next_register++; + } else if (ret.type.prim == JANET_FFI_TYPE_FLOAT || + ret.type.prim == JANET_FFI_TYPE_DOUBLE) { + variant += 16; + } + for (uint32_t i = 0; i < arg_count; i++) { + mappings[i].type = decode_ffi_type(argv[i + 2]); + size_t el_size = type_size(mappings[i].type); + int is_register_sized = (el_size == 1 || el_size == 2 || el_size == 4 || el_size == 8); + if (next_register < 4) { + mappings[i].offset = next_register; + if (is_register_sized) { + mappings[i].spec = JANET_WIN64_REGISTER; + if (mappings[i].type.prim == JANET_FFI_TYPE_FLOAT || + mappings[i].type.prim == JANET_FFI_TYPE_DOUBLE) { + variant += 1 << (3 - next_register); + } + } else { + mappings[i].spec = JANET_WIN64_REGISTER_REF; + mappings[i].offset2 = ref_stack_count; + ref_stack_count += (uint32_t)((el_size + 15) / 16); + } + next_register++; + } else { + if (is_register_sized) { + mappings[i].spec = JANET_WIN64_STACK; + mappings[i].offset = stack_count; + stack_count++; + } else { + mappings[i].spec = JANET_WIN64_STACK_REF; + mappings[i].offset = stack_count; + stack_count++; + mappings[i].offset2 = ref_stack_count; + ref_stack_count += (uint32_t)((el_size + 15) / 16); + } + } + } + + /* Add reference items */ + stack_count += 2 * ref_stack_count; + if (stack_count & 0x1) { + stack_count++; + } + + /* Invert stack + * Offsets are in units of 8-bytes */ + for (uint32_t i = 0; i < arg_count; i++) { + if (mappings[i].spec == JANET_WIN64_STACK_REF || mappings[i].spec == JANET_WIN64_REGISTER_REF) { + /* Align size to 16 bytes */ + size_t size = (type_size(mappings[i].type) + 15) & ~0xFUL; + mappings[i].offset2 = (uint32_t)(stack_count - mappings[i].offset2 - (size / 8)); + } + } + + } + break; +#endif + +#ifdef JANET_FFI_SYSV64_ENABLED + case JANET_FFI_CC_SYSV_64: { + JanetFFIWordSpec ret_spec = sysv64_classify(ret.type); + ret.spec = ret_spec; + if (ret_spec == JANET_SYSV64_SSE) variant = 1; + if (ret_spec == JANET_SYSV64_PAIR_INTSSE) variant = 2; + if (ret_spec == JANET_SYSV64_PAIR_SSEINT) variant = 3; + /* Spill register overflow to memory */ + uint32_t next_register = 0; + uint32_t next_fp_register = 0; + const uint32_t max_regs = 6; + const uint32_t max_fp_regs = 8; + if (ret_spec == JANET_SYSV64_MEMORY) { + /* First integer reg is pointer. */ + next_register = 1; + } + for (uint32_t i = 0; i < arg_count; i++) { + mappings[i].type = decode_ffi_type(argv[i + 2]); + mappings[i].offset = 0; + mappings[i].spec = sysv64_classify(mappings[i].type); + if (mappings[i].spec == JANET_SYSV64_NO_CLASS) { + janet_panic("unexpected void parameter"); + } + size_t el_size = (type_size(mappings[i].type) + 7) / 8; + switch (mappings[i].spec) { + default: + janet_panicf("nyi: %d", mappings[i].spec); + case JANET_SYSV64_INTEGER: { + if (next_register < max_regs) { + mappings[i].offset = next_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + case JANET_SYSV64_SSE: { + if (next_fp_register < max_fp_regs) { + mappings[i].offset = next_fp_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + case JANET_SYSV64_MEMORY: { + mappings[i].offset = stack_count; + stack_count += el_size; + } + break; + case JANET_SYSV64_PAIR_INTINT: { + if (next_register + 1 < max_regs) { + mappings[i].offset = next_register++; + mappings[i].offset2 = next_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + case JANET_SYSV64_PAIR_INTSSE: { + if (next_register < max_regs && next_fp_register < max_fp_regs) { + mappings[i].offset = next_register++; + mappings[i].offset2 = next_fp_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + case JANET_SYSV64_PAIR_SSEINT: { + if (next_register < max_regs && next_fp_register < max_fp_regs) { + mappings[i].offset = next_fp_register++; + mappings[i].offset2 = next_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + case JANET_SYSV64_PAIR_SSESSE: { + if (next_fp_register < max_fp_regs) { + mappings[i].offset = next_fp_register++; + mappings[i].offset2 = next_fp_register++; + } else { + mappings[i].spec = JANET_SYSV64_MEMORY; + mappings[i].offset = stack_count; + stack_count += el_size; + } + } + break; + } + } + } + break; +#endif + } + + /* Create signature abstract value */ + JanetFFISignature *abst = janet_abstract(&janet_signature_type, sizeof(JanetFFISignature)); + abst->frame_size = frame_size; + abst->cc = cc; + abst->ret = ret; + abst->arg_count = arg_count; + abst->variant = variant; + abst->stack_count = stack_count; + memcpy(abst->args, mappings, sizeof(JanetFFIMapping) * JANET_FFI_MAX_ARGS); + return janet_wrap_abstract(abst); +} + +#ifdef JANET_FFI_SYSV64_ENABLED + +static void janet_ffi_sysv64_standard_callback(void *ctx, void *userdata) { + janet_ffi_trampoline(ctx, userdata); +} + +/* Functions that set all argument registers. Two variants - one to read rax and rdx returns, another + * to read xmm0 and xmm1 returns. */ +typedef struct { + uint64_t x; + uint64_t y; +} sysv64_int_return; +typedef struct { + double x; + double y; +} sysv64_sse_return; +typedef struct { + uint64_t x; + double y; +} sysv64_intsse_return; +typedef struct { + double y; + uint64_t x; +} sysv64_sseint_return; +typedef sysv64_int_return janet_sysv64_variant_1(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, + double r1, double r2, double r3, double r4, double r5, double r6, double r7, double r8); +typedef sysv64_sse_return janet_sysv64_variant_2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, + double r1, double r2, double r3, double r4, double r5, double r6, double r7, double r8); +typedef sysv64_intsse_return janet_sysv64_variant_3(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, + double r1, double r2, double r3, double r4, double r5, double r6, double r7, double r8); +typedef sysv64_sseint_return janet_sysv64_variant_4(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, + double r1, double r2, double r3, double r4, double r5, double r6, double r7, double r8); + +static Janet janet_ffi_sysv64(JanetFFISignature *signature, void *function_pointer, const Janet *argv) { + union { + sysv64_int_return int_return; + sysv64_sse_return sse_return; + sysv64_sseint_return sseint_return; + sysv64_intsse_return intsse_return; + } retu; + uint64_t pair[2]; + uint64_t regs[6]; + double fp_regs[8]; + JanetFFIWordSpec ret_spec = signature->ret.spec; + void *ret_mem = &retu.int_return; + if (ret_spec == JANET_SYSV64_MEMORY) { + ret_mem = alloca(type_size(signature->ret.type)); + regs[0] = (uint64_t) ret_mem; + } + uint64_t *stack = alloca(sizeof(uint64_t) * signature->stack_count); + for (uint32_t i = 0; i < signature->arg_count; i++) { + uint64_t *to; + int32_t n = i + 2; + JanetFFIMapping arg = signature->args[i]; + switch (arg.spec) { + default: + janet_panic("nyi"); + case JANET_SYSV64_INTEGER: + to = regs + arg.offset; + break; + case JANET_SYSV64_SSE: + to = (uint64_t *)(fp_regs + arg.offset); + break; + case JANET_SYSV64_MEMORY: + to = stack + arg.offset; + break; + case JANET_SYSV64_PAIR_INTINT: + janet_ffi_write_one(pair, argv, n, arg.type, JANET_FFI_MAX_RECUR); + regs[arg.offset] = pair[0]; + regs[arg.offset2] = pair[1]; + continue; + case JANET_SYSV64_PAIR_INTSSE: + janet_ffi_write_one(pair, argv, n, arg.type, JANET_FFI_MAX_RECUR); + regs[arg.offset] = pair[0]; + ((uint64_t *) fp_regs)[arg.offset2] = pair[1]; + continue; + case JANET_SYSV64_PAIR_SSEINT: + janet_ffi_write_one(pair, argv, n, arg.type, JANET_FFI_MAX_RECUR); + ((uint64_t *) fp_regs)[arg.offset] = pair[0]; + regs[arg.offset2] = pair[1]; + continue; + case JANET_SYSV64_PAIR_SSESSE: + janet_ffi_write_one(pair, argv, n, arg.type, JANET_FFI_MAX_RECUR); + ((uint64_t *) fp_regs)[arg.offset] = pair[0]; + ((uint64_t *) fp_regs)[arg.offset2] = pair[1]; + continue; + } + janet_ffi_write_one(to, argv, n, arg.type, JANET_FFI_MAX_RECUR); + } + + switch (signature->variant) { + case 0: + retu.int_return = ((janet_sysv64_variant_1 *)(function_pointer))( + regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], + fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3], + fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]); + break; + case 1: + retu.sse_return = ((janet_sysv64_variant_2 *)(function_pointer))( + regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], + fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3], + fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]); + break; + case 2: + retu.intsse_return = ((janet_sysv64_variant_3 *)(function_pointer))( + regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], + fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3], + fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]); + break; + case 3: + retu.sseint_return = ((janet_sysv64_variant_4 *)(function_pointer))( + regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], + fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3], + fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]); + break; + } + + return janet_ffi_read_one(ret_mem, signature->ret.type, JANET_FFI_MAX_RECUR); +} + +#endif + +#ifdef JANET_FFI_WIN64_ENABLED + +static void janet_ffi_win64_standard_callback(void *ctx, void *userdata) { + janet_ffi_trampoline(ctx, userdata); +} + +/* Variants that allow setting all required registers for 64 bit windows calling convention. + * win64 calling convention has up to 4 arguments on registers, and one register for returns. + * Each register can either be an integer or floating point register, resulting in + * 2^5 = 32 variants. Unlike sysv, there are no function signatures that will fill + * all of the possible registers which is why we have so many variants. If you were using + * assembly, you could manually fill all of the registers and only have a single variant. + * And msvc does not support inline assembly on 64 bit targets, so yeah, we have this hackery. */ +typedef uint64_t (win64_variant_i_iiii)(uint64_t, uint64_t, uint64_t, uint64_t); +typedef uint64_t (win64_variant_i_iiif)(uint64_t, uint64_t, uint64_t, double); +typedef uint64_t (win64_variant_i_iifi)(uint64_t, uint64_t, double, uint64_t); +typedef uint64_t (win64_variant_i_iiff)(uint64_t, uint64_t, double, double); +typedef uint64_t (win64_variant_i_ifii)(uint64_t, double, uint64_t, uint64_t); +typedef uint64_t (win64_variant_i_ifif)(uint64_t, double, uint64_t, double); +typedef uint64_t (win64_variant_i_iffi)(uint64_t, double, double, uint64_t); +typedef uint64_t (win64_variant_i_ifff)(uint64_t, double, double, double); +typedef uint64_t (win64_variant_i_fiii)(double, uint64_t, uint64_t, uint64_t); +typedef uint64_t (win64_variant_i_fiif)(double, uint64_t, uint64_t, double); +typedef uint64_t (win64_variant_i_fifi)(double, uint64_t, double, uint64_t); +typedef uint64_t (win64_variant_i_fiff)(double, uint64_t, double, double); +typedef uint64_t (win64_variant_i_ffii)(double, double, uint64_t, uint64_t); +typedef uint64_t (win64_variant_i_ffif)(double, double, uint64_t, double); +typedef uint64_t (win64_variant_i_fffi)(double, double, double, uint64_t); +typedef uint64_t (win64_variant_i_ffff)(double, double, double, double); +typedef double (win64_variant_f_iiii)(uint64_t, uint64_t, uint64_t, uint64_t); +typedef double (win64_variant_f_iiif)(uint64_t, uint64_t, uint64_t, double); +typedef double (win64_variant_f_iifi)(uint64_t, uint64_t, double, uint64_t); +typedef double (win64_variant_f_iiff)(uint64_t, uint64_t, double, double); +typedef double (win64_variant_f_ifii)(uint64_t, double, uint64_t, uint64_t); +typedef double (win64_variant_f_ifif)(uint64_t, double, uint64_t, double); +typedef double (win64_variant_f_iffi)(uint64_t, double, double, uint64_t); +typedef double (win64_variant_f_ifff)(uint64_t, double, double, double); +typedef double (win64_variant_f_fiii)(double, uint64_t, uint64_t, uint64_t); +typedef double (win64_variant_f_fiif)(double, uint64_t, uint64_t, double); +typedef double (win64_variant_f_fifi)(double, uint64_t, double, uint64_t); +typedef double (win64_variant_f_fiff)(double, uint64_t, double, double); +typedef double (win64_variant_f_ffii)(double, double, uint64_t, uint64_t); +typedef double (win64_variant_f_ffif)(double, double, uint64_t, double); +typedef double (win64_variant_f_fffi)(double, double, double, uint64_t); +typedef double (win64_variant_f_ffff)(double, double, double, double); + +static Janet janet_ffi_win64(JanetFFISignature *signature, void *function_pointer, const Janet *argv) { + union { + uint64_t integer; + double real; + } regs[4]; + union { + uint64_t integer; + double real; + } ret_reg; + JanetFFIWordSpec ret_spec = signature->ret.spec; + void *ret_mem = &ret_reg.integer; + if (ret_spec == JANET_WIN64_REGISTER_REF) { + ret_mem = alloca(type_size(signature->ret.type)); + regs[0].integer = (uint64_t) ret_mem; + } + size_t stack_size = signature->stack_count * 8; + size_t stack_shift = 2; + uint64_t *stack = alloca(stack_size); + for (uint32_t i = 0; i < signature->arg_count; i++) { + int32_t n = i + 2; + JanetFFIMapping arg = signature->args[i]; + if (arg.spec == JANET_WIN64_STACK) { + janet_ffi_write_one(stack + arg.offset, argv, n, arg.type, JANET_FFI_MAX_RECUR); + } else if (arg.spec == JANET_WIN64_STACK_REF) { + uint8_t *ptr = (uint8_t *)(stack + arg.offset2); + janet_ffi_write_one(ptr, argv, n, arg.type, JANET_FFI_MAX_RECUR); + stack[arg.offset] = (uint64_t)(ptr - stack_shift * sizeof(uint64_t)); + } else if (arg.spec == JANET_WIN64_REGISTER_REF) { + uint8_t *ptr = (uint8_t *)(stack + arg.offset2); + janet_ffi_write_one(ptr, argv, n, arg.type, JANET_FFI_MAX_RECUR); + regs[arg.offset].integer = (uint64_t)(ptr - stack_shift * sizeof(uint64_t)); + } else { + janet_ffi_write_one((uint8_t *) ®s[arg.offset].integer, argv, n, arg.type, JANET_FFI_MAX_RECUR); + } + } + + /* hack to get proper stack placement and avoid clobbering from logic above - shift stack down, otherwise we have issues. + * Technically, this writes into 16 bytes of unallocated stack memory */ +#ifdef JANET_MINGW +#pragma GCC diagnostic ignored "-Wstringop-overflow" +#endif + if (stack_size) memmove(stack - stack_shift, stack, stack_size); +#ifdef JANET_MINGW +#pragma GCC diagnostic pop +#endif + + switch (signature->variant) { + default: + janet_panicf("unknown variant %d", signature->variant); + case 0: + ret_reg.integer = ((win64_variant_i_iiii *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].integer, regs[3].integer); + break; + case 1: + ret_reg.integer = ((win64_variant_i_iiif *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].integer, regs[3].real); + break; + case 2: + ret_reg.integer = ((win64_variant_i_iifi *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].real, regs[3].integer); + break; + case 3: + ret_reg.integer = ((win64_variant_i_iiff *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].real, regs[3].real); + break; + case 4: + ret_reg.integer = ((win64_variant_i_ifii *) function_pointer)(regs[0].integer, regs[1].real, regs[2].integer, regs[3].integer); + break; + case 5: + ret_reg.integer = ((win64_variant_i_ifif *) function_pointer)(regs[0].integer, regs[1].real, regs[2].integer, regs[3].real); + break; + case 6: + ret_reg.integer = ((win64_variant_i_iffi *) function_pointer)(regs[0].integer, regs[1].real, regs[2].real, regs[3].integer); + break; + case 7: + ret_reg.integer = ((win64_variant_i_ifff *) function_pointer)(regs[0].integer, regs[1].real, regs[2].real, regs[3].real); + break; + case 8: + ret_reg.integer = ((win64_variant_i_fiii *) function_pointer)(regs[0].real, regs[1].integer, regs[2].integer, regs[3].integer); + break; + case 9: + ret_reg.integer = ((win64_variant_i_fiif *) function_pointer)(regs[0].real, regs[1].integer, regs[2].integer, regs[3].real); + break; + case 10: + ret_reg.integer = ((win64_variant_i_fifi *) function_pointer)(regs[0].real, regs[1].integer, regs[2].real, regs[3].integer); + break; + case 11: + ret_reg.integer = ((win64_variant_i_fiff *) function_pointer)(regs[0].real, regs[1].integer, regs[2].real, regs[3].real); + break; + case 12: + ret_reg.integer = ((win64_variant_i_ffii *) function_pointer)(regs[0].real, regs[1].real, regs[2].integer, regs[3].integer); + break; + case 13: + ret_reg.integer = ((win64_variant_i_ffif *) function_pointer)(regs[0].real, regs[1].real, regs[2].integer, regs[3].real); + break; + case 14: + ret_reg.integer = ((win64_variant_i_fffi *) function_pointer)(regs[0].real, regs[1].real, regs[2].real, regs[3].integer); + break; + case 15: + ret_reg.integer = ((win64_variant_i_ffff *) function_pointer)(regs[0].real, regs[1].real, regs[2].real, regs[3].real); + break; + case 16: + ret_reg.real = ((win64_variant_f_iiii *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].integer, regs[3].integer); + break; + case 17: + ret_reg.real = ((win64_variant_f_iiif *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].integer, regs[3].real); + break; + case 18: + ret_reg.real = ((win64_variant_f_iifi *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].real, regs[3].integer); + break; + case 19: + ret_reg.real = ((win64_variant_f_iiff *) function_pointer)(regs[0].integer, regs[1].integer, regs[2].real, regs[3].real); + break; + case 20: + ret_reg.real = ((win64_variant_f_ifii *) function_pointer)(regs[0].integer, regs[1].real, regs[2].integer, regs[3].integer); + break; + case 21: + ret_reg.real = ((win64_variant_f_ifif *) function_pointer)(regs[0].integer, regs[1].real, regs[2].integer, regs[3].real); + break; + case 22: + ret_reg.real = ((win64_variant_f_iffi *) function_pointer)(regs[0].integer, regs[1].real, regs[2].real, regs[3].integer); + break; + case 23: + ret_reg.real = ((win64_variant_f_ifff *) function_pointer)(regs[0].integer, regs[1].real, regs[2].real, regs[3].real); + break; + case 24: + ret_reg.real = ((win64_variant_f_fiii *) function_pointer)(regs[0].real, regs[1].integer, regs[2].integer, regs[3].integer); + break; + case 25: + ret_reg.real = ((win64_variant_f_fiif *) function_pointer)(regs[0].real, regs[1].integer, regs[2].integer, regs[3].real); + break; + case 26: + ret_reg.real = ((win64_variant_f_fifi *) function_pointer)(regs[0].real, regs[1].integer, regs[2].real, regs[3].integer); + break; + case 27: + ret_reg.real = ((win64_variant_f_fiff *) function_pointer)(regs[0].real, regs[1].integer, regs[2].real, regs[3].real); + break; + case 28: + ret_reg.real = ((win64_variant_f_ffii *) function_pointer)(regs[0].real, regs[1].real, regs[2].integer, regs[3].integer); + break; + case 29: + ret_reg.real = ((win64_variant_f_ffif *) function_pointer)(regs[0].real, regs[1].real, regs[2].integer, regs[3].real); + break; + case 30: + ret_reg.real = ((win64_variant_f_fffi *) function_pointer)(regs[0].real, regs[1].real, regs[2].real, regs[3].integer); + break; + case 31: + ret_reg.real = ((win64_variant_f_ffff *) function_pointer)(regs[0].real, regs[1].real, regs[2].real, regs[3].real); + break; + } + + return janet_ffi_read_one(ret_mem, signature->ret.type, JANET_FFI_MAX_RECUR); +} + +#endif + +/* Allocate executable memory chunks in sizes of a page. Ideally we would keep + * an allocator around so that multiple JIT allocations would point to the same + * region but it isn't really worth it. */ +#define FFI_PAGE_MASK 0xFFF + +JANET_CORE_FN(cfun_ffi_jitfn, + "(ffi/jitfn bytes)", + "Create an abstract type that can be used as the pointer argument to `ffi/call`. The content " + "of `bytes` is architecture specific machine code that will be copied into executable memory.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_JIT); + janet_fixarity(argc, 1); + JanetByteView bytes = janet_getbytes(argv, 0); + + /* Quick hack to align to page boundary, we should query OS. FIXME */ + size_t alloc_size = ((size_t) bytes.len + FFI_PAGE_MASK) & ~FFI_PAGE_MASK; + +#ifdef JANET_FFI_JIT +#ifdef JANET_EV + JanetFFIJittedFn *fn = janet_abstract_threaded(&janet_type_ffijit, sizeof(JanetFFIJittedFn)); +#else + JanetFFIJittedFn *fn = janet_abstract(&janet_type_ffijit, sizeof(JanetFFIJittedFn)); +#endif + fn->function_pointer = NULL; + fn->size = 0; +#ifdef JANET_WINDOWS + void *ptr = VirtualAlloc(NULL, alloc_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); +#elif defined(MAP_ANONYMOUS) + void *ptr = mmap(0, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +#elif defined(MAP_ANON) + /* macos doesn't have MAP_ANONYMOUS */ + void *ptr = mmap(0, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); +#else + /* -std=c99 gets in the way */ + /* #define MAP_ANONYMOUS 0x20 should work, though. */ + void *ptr = mmap(0, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0); +#endif + if (!ptr) { + janet_panic("failed to memory map writable memory"); + } + memcpy(ptr, bytes.bytes, bytes.len); +#ifdef JANET_WINDOWS + DWORD old = 0; + if (!VirtualProtect(ptr, alloc_size, PAGE_EXECUTE_READ, &old)) { + janet_panic("failed to make mapped memory executable"); + } +#else + if (mprotect(ptr, alloc_size, PROT_READ | PROT_EXEC) == -1) { + janet_panic("failed to make mapped memory executable"); + } +#endif + fn->size = alloc_size; + fn->function_pointer = ptr; + return janet_wrap_abstract(fn); +#else + janet_panic("ffi/jitfn not available on this platform"); +#endif +} + +JANET_CORE_FN(cfun_ffi_call, + "(ffi/call pointer signature & args)", + "Call a raw pointer as a function pointer. The function signature specifies " + "how Janet values in `args` are converted to native machine types.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_arity(argc, 2, -1); + void *function_pointer = janet_ffi_get_callable_pointer(argv, 0); + JanetFFISignature *signature = janet_getabstract(argv, 1, &janet_signature_type); + janet_fixarity(argc - 2, signature->arg_count); + switch (signature->cc) { + default: + case JANET_FFI_CC_NONE: + (void) function_pointer; + janet_panic("calling convention not supported"); +#ifdef JANET_FFI_WIN64_ENABLED + case JANET_FFI_CC_WIN_64: + return janet_ffi_win64(signature, function_pointer, argv); +#endif +#ifdef JANET_FFI_SYSV64_ENABLED + case JANET_FFI_CC_SYSV_64: + return janet_ffi_sysv64(signature, function_pointer, argv); +#endif + } +} + +JANET_CORE_FN(cfun_ffi_buffer_write, + "(ffi/write ffi-type data &opt buffer index)", + "Append a native type to a buffer such as it would appear in memory. This can be used " + "to pass pointers to structs in the ffi, or send C/C++/native structs over the network " + "or to files. Returns a modified buffer or a new buffer if one is not supplied.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_arity(argc, 2, 4); + JanetFFIType type = decode_ffi_type(argv[0]); + uint32_t el_size = (uint32_t) type_size(type); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, el_size); + int32_t index = janet_optnat(argv, argc, 3, 0); + int32_t old_count = buffer->count; + if (index > old_count) janet_panic("index out of bounds"); + buffer->count = index; + janet_buffer_extra(buffer, el_size); + buffer->count = old_count; + memset(buffer->data + index, 0, el_size); + janet_ffi_write_one(buffer->data + index, argv, 1, type, JANET_FFI_MAX_RECUR); + index += el_size; + if (buffer->count < index) buffer->count = index; + return janet_wrap_buffer(buffer); +} + +JANET_CORE_FN(cfun_ffi_buffer_read, + "(ffi/read ffi-type bytes &opt offset)", + "Parse a native struct out of a buffer and convert it to normal Janet data structures. " + "This function is the inverse of `ffi/write`. `bytes` can also be a raw pointer, although " + "this is unsafe.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_arity(argc, 2, 3); + JanetFFIType type = decode_ffi_type(argv[0]); + size_t offset = (size_t) janet_optnat(argv, argc, 2, 0); + if (janet_checktype(argv[1], JANET_POINTER)) { + uint8_t *ptr = janet_unwrap_pointer(argv[1]); + return janet_ffi_read_one(ptr + offset, type, JANET_FFI_MAX_RECUR); + } else { + size_t el_size = type_size(type); + JanetByteView bytes = janet_getbytes(argv, 1); + if ((size_t) bytes.len < offset + el_size) janet_panic("read out of range"); + return janet_ffi_read_one(bytes.bytes + offset, type, JANET_FFI_MAX_RECUR); + } +} + +JANET_CORE_FN(cfun_ffi_get_callback_trampoline, + "(ffi/trampoline cc)", + "Get a native function pointer that can be used as a callback and passed to C libraries. " + "This callback trampoline has the signature `void trampoline(void \\*ctx, void \\*userdata)` in " + "the given calling convention. This is the only function signature supported. " + "It is up to the programmer to ensure that the `userdata` argument contains a janet function " + "the will be called with one argument, `ctx` which is an opaque pointer. This pointer can " + "be further inspected with `ffi/read`.") { + janet_arity(argc, 0, 1); + JanetFFICallingConvention cc = JANET_FFI_CC_DEFAULT; + if (argc >= 1) cc = decode_ffi_cc(janet_getkeyword(argv, 0)); + switch (cc) { + default: + case JANET_FFI_CC_NONE: + janet_panic("calling convention not supported"); +#ifdef JANET_FFI_WIN64_ENABLED + case JANET_FFI_CC_WIN_64: + return janet_wrap_pointer(janet_ffi_win64_standard_callback); +#endif +#ifdef JANET_FFI_SYSV64_ENABLED + case JANET_FFI_CC_SYSV_64: + return janet_wrap_pointer(janet_ffi_sysv64_standard_callback); +#endif + } +} + +JANET_CORE_FN(janet_core_raw_native, + "(ffi/native &opt path)", + "Load a shared object or dll from the given path, and do not extract" + " or run any code from it. This is different than `native`, which will " + "run initialization code to get a module table. If `path` is nil, opens the current running binary. " + "Returns a `core/native`.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_DEFINE); + janet_arity(argc, 0, 1); + const char *path = janet_optcstring(argv, argc, 0, NULL); + Clib lib = load_clib(path); + if (!lib) janet_panic(error_clib()); + JanetAbstractNative *anative = janet_abstract(&janet_native_type, sizeof(JanetAbstractNative)); + anative->clib = lib; + anative->closed = 0; + anative->is_self = path == NULL; + return janet_wrap_abstract(anative); +} + +JANET_CORE_FN(janet_core_native_lookup, + "(ffi/lookup native symbol-name)", + "Lookup a symbol from a native object. All symbol lookups will return a raw pointer " + "if the symbol is found, else nil.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_DEFINE); + janet_fixarity(argc, 2); + JanetAbstractNative *anative = janet_getabstract(argv, 0, &janet_native_type); + const char *sym = janet_getcstring(argv, 1); + if (anative->closed) janet_panic("native object already closed"); + void *value = symbol_clib(anative->clib, sym); + if (NULL == value) return janet_wrap_nil(); + return janet_wrap_pointer(value); +} + +JANET_CORE_FN(janet_core_native_close, + "(ffi/close native)", + "Free a native object. Dereferencing pointers to symbols in the object will have undefined " + "behavior after freeing.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_DEFINE); + janet_fixarity(argc, 1); + JanetAbstractNative *anative = janet_getabstract(argv, 0, &janet_native_type); + if (anative->closed) janet_panic("native object already closed"); + if (anative->is_self) janet_panic("cannot close self"); + anative->closed = 1; + free_clib(anative->clib); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_ffi_malloc, + "(ffi/malloc size)", + "Allocates memory directly using the janet memory allocator. Memory allocated in this way must be freed manually! Returns a raw pointer, or nil if size = 0.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_fixarity(argc, 1); + size_t size = janet_getsize(argv, 0); + if (size == 0) return janet_wrap_nil(); + return janet_wrap_pointer(janet_malloc(size)); +} + +JANET_CORE_FN(cfun_ffi_free, + "(ffi/free pointer)", + "Free memory allocated with `ffi/malloc`. Returns nil.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_fixarity(argc, 1); + if (janet_checktype(argv[0], JANET_NIL)) return janet_wrap_nil(); + void *pointer = janet_getpointer(argv, 0); + janet_free(pointer); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_ffi_pointer_buffer, + "(ffi/pointer-buffer pointer capacity &opt count offset)", + "Create a buffer from a pointer. The underlying memory of the buffer will not be " + "reallocated or freed by the garbage collector, allowing unmanaged, mutable memory " + "to be manipulated with buffer functions. Attempts to resize or extend the buffer " + "beyond its initial capacity will raise an error. As with many FFI functions, this is memory " + "unsafe and can potentially allow out of bounds memory access. Returns a new buffer.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_arity(argc, 2, 4); + void *pointer = janet_getpointer(argv, 0); + int32_t capacity = janet_getnat(argv, 1); + int32_t count = janet_optnat(argv, argc, 2, 0); + int64_t offset = janet_optinteger64(argv, argc, 3, 0); + uint8_t *offset_pointer = ((uint8_t *) pointer) + offset; + return janet_wrap_buffer(janet_pointer_buffer_unsafe(offset_pointer, capacity, count)); +} + +JANET_CORE_FN(cfun_ffi_pointer_cfunction, + "(ffi/pointer-cfunction pointer &opt name source-file source-line)", + "Create a C Function from a raw pointer. Optionally give the cfunction a name and " + "source location for stack traces and debugging.") { + janet_sandbox_assert(JANET_SANDBOX_FFI_USE); + janet_arity(argc, 1, 4); + void *pointer = janet_getpointer(argv, 0); + const char *name = janet_optcstring(argv, argc, 1, NULL); + const char *source = janet_optcstring(argv, argc, 2, NULL); + int32_t line = janet_optinteger(argv, argc, 3, -1); + if ((name != NULL) || (source != NULL) || (line != -1)) { + janet_registry_put((JanetCFunction) pointer, name, NULL, source, line); + } + return janet_wrap_cfunction((JanetCFunction) pointer); +} + +JANET_CORE_FN(cfun_ffi_supported_calling_conventions, + "(ffi/calling-conventions)", + "Get an array of all supported calling conventions on the current architecture. Some architectures may have some FFI " + "functionality (ffi/malloc, ffi/free, ffi/read, ffi/write, etc.) but not support " + "any calling conventions. This function can be used to get all supported calling conventions " + "that can be used on this architecture. All architectures support the :none calling " + "convention which is a placeholder that cannot be used at runtime.") { + janet_fixarity(argc, 0); + (void) argv; + JanetArray *array = janet_array(4); +#ifdef JANET_FFI_WIN64_ENABLED + janet_array_push(array, janet_ckeywordv("win64")); +#endif +#ifdef JANET_FFI_SYSV64_ENABLED + janet_array_push(array, janet_ckeywordv("sysv64")); +#endif + janet_array_push(array, janet_ckeywordv("none")); + return janet_wrap_array(array); +} + +void janet_lib_ffi(JanetTable *env) { + JanetRegExt ffi_cfuns[] = { + JANET_CORE_REG("ffi/native", janet_core_raw_native), + JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), + JANET_CORE_REG("ffi/close", janet_core_native_close), + JANET_CORE_REG("ffi/signature", cfun_ffi_signature), + JANET_CORE_REG("ffi/call", cfun_ffi_call), + JANET_CORE_REG("ffi/struct", cfun_ffi_struct), + JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), + JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), + JANET_CORE_REG("ffi/size", cfun_ffi_size), + JANET_CORE_REG("ffi/align", cfun_ffi_align), + JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), + JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), + JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), + JANET_CORE_REG("ffi/free", cfun_ffi_free), + JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), + JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), + JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, ffi_cfuns); +} + +#endif + + +/* src/core/fiber.c */ +#line 0 "src/core/fiber.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "fiber.h" +#include "state.h" +#include "gc.h" +#include "util.h" +#endif + +static void fiber_reset(JanetFiber *fiber) { + fiber->maxstack = JANET_STACK_MAX; + fiber->frame = 0; + fiber->stackstart = JANET_FRAME_SIZE; + fiber->stacktop = JANET_FRAME_SIZE; + fiber->child = NULL; + fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; + fiber->env = NULL; + fiber->last_value = janet_wrap_nil(); +#ifdef JANET_EV + fiber->sched_id = 0; + fiber->ev_callback = NULL; + fiber->ev_state = NULL; + fiber->ev_stream = NULL; + fiber->supervisor_channel = NULL; +#endif + janet_fiber_set_status(fiber, JANET_STATUS_NEW); +} + +static JanetFiber *fiber_alloc(int32_t capacity) { + Janet *data; + JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); + if (capacity < 32) { + capacity = 32; + } + fiber->capacity = capacity; + data = janet_malloc(sizeof(Janet) * (size_t) capacity); + if (NULL == data) { + JANET_OUT_OF_MEMORY; + } + janet_vm.next_collection += sizeof(Janet) * capacity; + fiber->data = data; + return fiber; +} + +/* Create a new fiber with argn values on the stack by reusing a fiber. */ +JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv) { + int32_t newstacktop; + fiber_reset(fiber); + if (argc) { + newstacktop = fiber->stacktop + argc; + if (newstacktop >= fiber->capacity) { + janet_fiber_setcapacity(fiber, 2 * newstacktop); + } + if (argv) { + memcpy(fiber->data + fiber->stacktop, argv, argc * sizeof(Janet)); + } else { + /* If argv not given, fill with nil */ + for (int32_t i = 0; i < argc; i++) { + fiber->data[fiber->stacktop + i] = janet_wrap_nil(); + } + } + fiber->stacktop = newstacktop; + } + /* Don't panic on failure since we use this to implement janet_pcall */ + if (janet_fiber_funcframe(fiber, callee)) return NULL; + janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE; +#ifdef JANET_EV + fiber->supervisor_channel = NULL; +#endif + return fiber; +} + +/* Create a new fiber with argn values on the stack. */ +JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv) { + return janet_fiber_reset(fiber_alloc(capacity), callee, argc, argv); +} + +#ifdef JANET_DEBUG +/* Test for memory issues by reallocating fiber every time we push a stack frame */ +static void janet_fiber_refresh_memory(JanetFiber *fiber) { + int32_t n = fiber->capacity; + if (n) { + Janet *newData = janet_malloc(sizeof(Janet) * n); + if (NULL == newData) { + JANET_OUT_OF_MEMORY; + } + memcpy(newData, fiber->data, fiber->capacity * sizeof(Janet)); + janet_free(fiber->data); + fiber->data = newData; + } +} +#endif + +/* Ensure that the fiber has enough extra capacity */ +void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) { + int32_t old_size = fiber->capacity; + int32_t diff = n - old_size; + Janet *newData = janet_realloc(fiber->data, sizeof(Janet) * n); + if (NULL == newData) { + JANET_OUT_OF_MEMORY; + } + fiber->data = newData; + fiber->capacity = n; + janet_vm.next_collection += sizeof(Janet) * diff; +} + +/* Grow fiber if needed */ +static void janet_fiber_grow(JanetFiber *fiber, int32_t needed) { + int32_t cap = needed > (INT32_MAX / 2) ? INT32_MAX : 2 * needed; + janet_fiber_setcapacity(fiber, cap); +} + +/* Push a value on the next stack frame */ +void janet_fiber_push(JanetFiber *fiber, Janet x) { + if (fiber->stacktop == INT32_MAX) janet_panic("stack overflow"); + if (fiber->stacktop >= fiber->capacity) { + janet_fiber_grow(fiber, fiber->stacktop); + } + fiber->data[fiber->stacktop++] = x; +} + +/* Push 2 values on the next stack frame */ +void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y) { + if (fiber->stacktop >= INT32_MAX - 1) janet_panic("stack overflow"); + int32_t newtop = fiber->stacktop + 2; + if (newtop > fiber->capacity) { + janet_fiber_grow(fiber, newtop); + } + fiber->data[fiber->stacktop] = x; + fiber->data[fiber->stacktop + 1] = y; + fiber->stacktop = newtop; +} + +/* Push 3 values on the next stack frame */ +void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z) { + if (fiber->stacktop >= INT32_MAX - 2) janet_panic("stack overflow"); + int32_t newtop = fiber->stacktop + 3; + if (newtop > fiber->capacity) { + janet_fiber_grow(fiber, newtop); + } + fiber->data[fiber->stacktop] = x; + fiber->data[fiber->stacktop + 1] = y; + fiber->data[fiber->stacktop + 2] = z; + fiber->stacktop = newtop; +} + +/* Push an array on the next stack frame */ +void janet_fiber_pushn(JanetFiber *fiber, const Janet *arr, int32_t n) { + if (fiber->stacktop > INT32_MAX - n) janet_panic("stack overflow"); + int32_t newtop = fiber->stacktop + n; + if (newtop > fiber->capacity) { + janet_fiber_grow(fiber, newtop); + } + safe_memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet)); + fiber->stacktop = newtop; +} + +/* Create a struct with n values. If n is odd, the last value is ignored. */ +static Janet make_struct_n(const Janet *args, int32_t n) { + int32_t i = 0; + JanetKV *st = janet_struct_begin(n & (~1)); + for (; i < n; i += 2) { + janet_struct_put(st, args[i], args[i + 1]); + } + return janet_wrap_struct(janet_struct_end(st)); +} + +/* Push a stack frame to a fiber */ +int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) { + JanetStackFrame *newframe; + + int32_t i; + int32_t oldtop = fiber->stacktop; + int32_t oldframe = fiber->frame; + int32_t nextframe = fiber->stackstart; + int32_t nextstacktop = nextframe + func->def->slotcount + JANET_FRAME_SIZE; + int32_t next_arity = fiber->stacktop - fiber->stackstart; + + /* Check strict arity before messing with state */ + if (next_arity < func->def->min_arity) return 1; + if (next_arity > func->def->max_arity) return 1; + + if (fiber->capacity < nextstacktop) { + janet_fiber_setcapacity(fiber, 2 * nextstacktop); +#ifdef JANET_DEBUG + } else { + janet_fiber_refresh_memory(fiber); +#endif + } + + /* Nil unset stack arguments (Needed for gc correctness) */ + for (i = fiber->stacktop; i < nextstacktop; ++i) { + fiber->data[i] = janet_wrap_nil(); + } + + /* Set up the next frame */ + fiber->frame = nextframe; + fiber->stacktop = fiber->stackstart = nextstacktop; + newframe = janet_fiber_frame(fiber); + newframe->prevframe = oldframe; + newframe->pc = func->def->bytecode; + newframe->func = func; + newframe->env = NULL; + newframe->flags = 0; + + /* Check varargs */ + if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { + int32_t tuplehead = fiber->frame + func->def->arity; + int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG; + if (tuplehead >= oldtop) { + fiber->data[tuplehead] = st + ? make_struct_n(NULL, 0) + : janet_wrap_tuple(janet_tuple_n(NULL, 0)); + } else { + fiber->data[tuplehead] = st + ? make_struct_n( + fiber->data + tuplehead, + oldtop - tuplehead) + : janet_wrap_tuple(janet_tuple_n( + fiber->data + tuplehead, + oldtop - tuplehead)); + } + } + + /* Good return */ + return 0; +} + +/* If a frame has a closure environment, detach it from + * the stack and have it keep its own values */ +static void janet_env_detach(JanetFuncEnv *env) { + /* Check for closure environment */ + if (env) { + janet_env_valid(env); + int32_t len = env->length; + size_t s = sizeof(Janet) * (size_t) len; + Janet *vmem = janet_malloc(s); + janet_vm.next_collection += (uint32_t) s; + if (NULL == vmem) { + JANET_OUT_OF_MEMORY; + } + Janet *values = env->as.fiber->data + env->offset; + safe_memcpy(vmem, values, s); + uint32_t *bitset = janet_stack_frame(values)->func->def->closure_bitset; + if (bitset) { + /* Clear unneeded references in closure environment */ + for (int32_t i = 0; i < len; i += 32) { + uint32_t mask = ~(bitset[i >> 5]); + int32_t maxj = i + 32 > len ? len : i + 32; + for (int32_t j = i; j < maxj; j++) { + if (mask & 1) vmem[j] = janet_wrap_nil(); + mask >>= 1; + } + } + } + env->offset = 0; + env->as.values = vmem; + } +} + +/* Validate potentially untrusted func env (unmarshalled envs are difficult to verify) */ +int janet_env_valid(JanetFuncEnv *env) { + if (env->offset < 0) { + int32_t real_offset = -(env->offset); + JanetFiber *fiber = env->as.fiber; + int32_t i = fiber->frame; + while (i > 0) { + JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + if (real_offset == i && + frame->env == env && + frame->func && + frame->func->def->slotcount == env->length) { + env->offset = real_offset; + return 1; + } + i = frame->prevframe; + } + /* Invalid, set to empty off-stack variant. */ + env->offset = 0; + env->length = 0; + env->as.values = NULL; + return 0; + } else { + return 1; + } +} + +/* Detach a fiber from the env if the target fiber has stopped mutating */ +void janet_env_maybe_detach(JanetFuncEnv *env) { + /* Check for detachable closure envs */ + janet_env_valid(env); + if (env->offset > 0) { + JanetFiberStatus s = janet_fiber_status(env->as.fiber); + int isFinished = s == JANET_STATUS_DEAD || + s == JANET_STATUS_ERROR || + s == JANET_STATUS_USER0 || + s == JANET_STATUS_USER1 || + s == JANET_STATUS_USER2 || + s == JANET_STATUS_USER3 || + s == JANET_STATUS_USER4; + if (isFinished) { + janet_env_detach(env); + } + } +} + +/* Create a tail frame for a function */ +int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) { + int32_t i; + int32_t nextframetop = fiber->frame + func->def->slotcount; + int32_t nextstacktop = nextframetop + JANET_FRAME_SIZE; + int32_t next_arity = fiber->stacktop - fiber->stackstart; + int32_t stacksize; + + /* Check strict arity before messing with state */ + if (next_arity < func->def->min_arity) return 1; + if (next_arity > func->def->max_arity) return 1; + + if (fiber->capacity < nextstacktop) { + janet_fiber_setcapacity(fiber, 2 * nextstacktop); +#ifdef JANET_DEBUG + } else { + janet_fiber_refresh_memory(fiber); +#endif + } + + Janet *stack = fiber->data + fiber->frame; + Janet *args = fiber->data + fiber->stackstart; + + /* Detach old function */ + if (NULL != janet_fiber_frame(fiber)->func) + janet_env_detach(janet_fiber_frame(fiber)->env); + janet_fiber_frame(fiber)->env = NULL; + + /* Check varargs */ + if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { + int32_t tuplehead = fiber->stackstart + func->def->arity; + int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG; + if (tuplehead >= fiber->stacktop) { + if (tuplehead >= fiber->capacity) janet_fiber_setcapacity(fiber, 2 * (tuplehead + 1)); + for (i = fiber->stacktop; i < tuplehead; ++i) fiber->data[i] = janet_wrap_nil(); + fiber->data[tuplehead] = st + ? make_struct_n(NULL, 0) + : janet_wrap_tuple(janet_tuple_n(NULL, 0)); + } else { + fiber->data[tuplehead] = st + ? make_struct_n( + fiber->data + tuplehead, + fiber->stacktop - tuplehead) + : janet_wrap_tuple(janet_tuple_n( + fiber->data + tuplehead, + fiber->stacktop - tuplehead)); + } + stacksize = tuplehead - fiber->stackstart + 1; + } else { + stacksize = fiber->stacktop - fiber->stackstart; + } + + if (stacksize) memmove(stack, args, stacksize * sizeof(Janet)); + + /* Nil unset locals (Needed for functional correctness) */ + for (i = fiber->frame + stacksize; i < nextframetop; ++i) + fiber->data[i] = janet_wrap_nil(); + + /* Set stack stuff */ + fiber->stacktop = fiber->stackstart = nextstacktop; + + /* Set frame stuff */ + janet_fiber_frame(fiber)->func = func; + janet_fiber_frame(fiber)->pc = func->def->bytecode; + janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_TAILCALL; + + /* Good return */ + return 0; +} + +/* Push a stack frame to a fiber for a c function */ +void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun) { + JanetStackFrame *newframe; + + int32_t oldframe = fiber->frame; + int32_t nextframe = fiber->stackstart; + int32_t nextstacktop = fiber->stacktop + JANET_FRAME_SIZE; + + if (fiber->capacity < nextstacktop) { + janet_fiber_setcapacity(fiber, 2 * nextstacktop); +#ifdef JANET_DEBUG + } else { + janet_fiber_refresh_memory(fiber); +#endif + } + + /* Set the next frame */ + fiber->frame = nextframe; + fiber->stacktop = fiber->stackstart = nextstacktop; + newframe = janet_fiber_frame(fiber); + + /* Set up the new frame */ + newframe->prevframe = oldframe; + newframe->pc = (uint32_t *) cfun; + newframe->func = NULL; + newframe->env = NULL; + newframe->flags = 0; +} + +/* Pop a stack frame from the fiber. */ +void janet_fiber_popframe(JanetFiber *fiber) { + JanetStackFrame *frame = janet_fiber_frame(fiber); + if (fiber->frame == 0) return; + + /* Clean up the frame (detach environments) */ + if (NULL != frame->func) + janet_env_detach(frame->env); + + /* Shrink stack */ + fiber->stacktop = fiber->stackstart = fiber->frame; + fiber->frame = frame->prevframe; +} + +JanetFiberStatus janet_fiber_status(JanetFiber *f) { + return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; +} + +JanetFiber *janet_current_fiber(void) { + return janet_vm.fiber; +} + +JanetFiber *janet_root_fiber(void) { + return janet_vm.root_fiber; +} + +/* CFuns */ + +JANET_CORE_FN(cfun_fiber_getenv, + "(fiber/getenv fiber)", + "Gets the environment for a fiber. Returns nil if no such table is " + "set yet.") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + return fiber->env ? + janet_wrap_table(fiber->env) : + janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_fiber_setenv, + "(fiber/setenv fiber table)", + "Sets the environment table for a fiber. Set to nil to remove the current " + "environment.") { + janet_fixarity(argc, 2); + JanetFiber *fiber = janet_getfiber(argv, 0); + if (janet_checktype(argv[1], JANET_NIL)) { + fiber->env = NULL; + } else { + fiber->env = janet_gettable(argv, 1); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_fiber_new, + "(fiber/new func &opt sigmask env)", + "Create a new fiber with function body func. Can optionally " + "take a set of signals `sigmask` to capture from child fibers, " + "and an environment table `env`. The mask is specified as a keyword where each character " + "is used to indicate a signal to block. If the ev module is enabled, and " + "this fiber is used as an argument to `ev/go`, these \"blocked\" signals " + "will result in messages being sent to the supervisor channel. " + "The default sigmask is :y. " + "For example,\n\n" + " (fiber/new myfun :e123)\n\n" + "blocks error signals and user signals 1, 2 and 3. The signals are " + "as follows:\n\n" + "* :a - block all signals\n" + "* :d - block debug signals\n" + "* :e - block error signals\n" + "* :t - block termination signals: error + user[0-4]\n" + "* :u - block user signals\n" + "* :y - block yield signals\n" + "* :w - block await signals (user9)\n" + "* :r - block interrupt signals (user8)\n" + "* :0-9 - block a specific user signal\n\n" + "The sigmask argument also can take environment flags. If any mutually " + "exclusive flags are present, the last flag takes precedence.\n\n" + "* :i - inherit the environment from the current fiber\n" + "* :p - the environment table's prototype is the current environment table") { + janet_arity(argc, 1, 3); + JanetFunction *func = janet_getfunction(argv, 0); + JanetFiber *fiber; + if (func->def->min_arity > 1) { + janet_panicf("fiber function must accept 0 or 1 arguments"); + } + fiber = janet_fiber(func, 64, func->def->min_arity, NULL); + janet_assert(fiber != NULL, "bad fiber arity check"); + if (argc == 3 && !janet_checktype(argv[2], JANET_NIL)) { + fiber->env = janet_gettable(argv, 2); + } + if (argc >= 2) { + int32_t i; + JanetByteView view = janet_getbytes(argv, 1); + fiber->flags = JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; + janet_fiber_set_status(fiber, JANET_STATUS_NEW); + for (i = 0; i < view.len; i++) { + if (view.bytes[i] >= '0' && view.bytes[i] <= '9') { + fiber->flags |= JANET_FIBER_MASK_USERN(view.bytes[i] - '0'); + } else { + switch (view.bytes[i]) { + default: + janet_panicf("invalid flag %c, expected a, t, d, e, u, y, w, r, i, or p", view.bytes[i]); + break; + case 'a': + fiber->flags |= + JANET_FIBER_MASK_DEBUG | + JANET_FIBER_MASK_ERROR | + JANET_FIBER_MASK_USER | + JANET_FIBER_MASK_YIELD; + break; + case 't': + fiber->flags |= + JANET_FIBER_MASK_ERROR | + JANET_FIBER_MASK_USER0 | + JANET_FIBER_MASK_USER1 | + JANET_FIBER_MASK_USER2 | + JANET_FIBER_MASK_USER3 | + JANET_FIBER_MASK_USER4; + break; + case 'd': + fiber->flags |= JANET_FIBER_MASK_DEBUG; + break; + case 'e': + fiber->flags |= JANET_FIBER_MASK_ERROR; + break; + case 'u': + fiber->flags |= JANET_FIBER_MASK_USER; + break; + case 'y': + fiber->flags |= JANET_FIBER_MASK_YIELD; + break; + case 'w': + fiber->flags |= JANET_FIBER_MASK_USER9; + break; + case 'r': + fiber->flags |= JANET_FIBER_MASK_USER8; + break; + case 'i': + if (!janet_vm.fiber->env) { + janet_vm.fiber->env = janet_table(0); + } + fiber->env = janet_vm.fiber->env; + break; + case 'p': + if (!janet_vm.fiber->env) { + janet_vm.fiber->env = janet_table(0); + } + fiber->env = janet_table(0); + fiber->env->proto = janet_vm.fiber->env; + break; + } + } + } + } + return janet_wrap_fiber(fiber); +} + +JANET_CORE_FN(cfun_fiber_status, + "(fiber/status fib)", + "Get the status of a fiber. The status will be one of:\n\n" + "* :dead - the fiber has finished\n" + "* :error - the fiber has errored out\n" + "* :debug - the fiber is suspended in debug mode\n" + "* :pending - the fiber has been yielded\n" + "* :user(0-7) - the fiber is suspended by a user signal\n" + "* :interrupted - the fiber was interrupted\n" + "* :suspended - the fiber is waiting to be resumed by the scheduler\n" + "* :alive - the fiber is currently running and cannot be resumed\n" + "* :new - the fiber has just been created and not yet run") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + uint32_t s = janet_fiber_status(fiber); + return janet_ckeywordv(janet_status_names[s]); +} + +JANET_CORE_FN(cfun_fiber_current, + "(fiber/current)", + "Returns the currently running fiber.") { + (void) argv; + janet_fixarity(argc, 0); + return janet_wrap_fiber(janet_vm.fiber); +} + +JANET_CORE_FN(cfun_fiber_root, + "(fiber/root)", + "Returns the current root fiber. The root fiber is the oldest ancestor " + "that does not have a parent.") { + (void) argv; + janet_fixarity(argc, 0); + return janet_wrap_fiber(janet_vm.root_fiber); +} + +JANET_CORE_FN(cfun_fiber_maxstack, + "(fiber/maxstack fib)", + "Gets the maximum stack size in janet values allowed for a fiber. While memory for " + "the fiber's stack is not allocated up front, the fiber will not allocated more " + "than this amount and will throw a stack-overflow error if more memory is needed. ") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + return janet_wrap_integer(fiber->maxstack); +} + +JANET_CORE_FN(cfun_fiber_setmaxstack, + "(fiber/setmaxstack fib maxstack)", + "Sets the maximum stack size in janet values for a fiber. By default, the " + "maximum stack size is usually 8192.") { + janet_fixarity(argc, 2); + JanetFiber *fiber = janet_getfiber(argv, 0); + int32_t maxs = janet_getinteger(argv, 1); + if (maxs < 0) { + janet_panic("expected positive integer"); + } + fiber->maxstack = maxs; + return argv[0]; +} + +int janet_fiber_can_resume(JanetFiber *fiber) { + JanetFiberStatus s = janet_fiber_status(fiber); + int isFinished = s == JANET_STATUS_DEAD || + s == JANET_STATUS_ERROR || + s == JANET_STATUS_USER0 || + s == JANET_STATUS_USER1 || + s == JANET_STATUS_USER2 || + s == JANET_STATUS_USER3 || + s == JANET_STATUS_USER4; + return !isFinished; +} + +JANET_CORE_FN(cfun_fiber_can_resume, + "(fiber/can-resume? fiber)", + "Check if a fiber is finished and cannot be resumed.") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + return janet_wrap_boolean(janet_fiber_can_resume(fiber)); +} + +JANET_CORE_FN(cfun_fiber_last_value, + "(fiber/last-value fiber)", + "Get the last value returned or signaled from the fiber.") { + janet_fixarity(argc, 1); + JanetFiber *fiber = janet_getfiber(argv, 0); + return fiber->last_value; +} + +/* Module entry point */ +void janet_lib_fiber(JanetTable *env) { + JanetRegExt fiber_cfuns[] = { + JANET_CORE_REG("fiber/new", cfun_fiber_new), + JANET_CORE_REG("fiber/status", cfun_fiber_status), + JANET_CORE_REG("fiber/root", cfun_fiber_root), + JANET_CORE_REG("fiber/current", cfun_fiber_current), + JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), + JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), + JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), + JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), + JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), + JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, fiber_cfuns); +} + + +/* src/core/gc.c */ +#line 0 "src/core/gc.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "symcache.h" +#include "gc.h" +#include "util.h" +#include "fiber.h" +#include "vector.h" +#endif + +/* Helpers for marking the various gc types */ +static void janet_mark_funcenv(JanetFuncEnv *env); +static void janet_mark_funcdef(JanetFuncDef *def); +static void janet_mark_function(JanetFunction *func); +static void janet_mark_array(JanetArray *array); +static void janet_mark_table(JanetTable *table); +static void janet_mark_struct(const JanetKV *st); +static void janet_mark_tuple(const Janet *tuple); +static void janet_mark_buffer(JanetBuffer *buffer); +static void janet_mark_string(const uint8_t *str); +static void janet_mark_fiber(JanetFiber *fiber); +static void janet_mark_abstract(void *adata); + +/* Local state that is only temporary for gc */ +static JANET_THREAD_LOCAL uint32_t depth = JANET_RECURSION_GUARD; +static JANET_THREAD_LOCAL size_t orig_rootcount; + +/* Hint to the GC that we may need to collect */ +void janet_gcpressure(size_t s) { + janet_vm.next_collection += s; +} + +/* Mark a value */ +void janet_mark(Janet x) { + if (depth) { + depth--; + switch (janet_type(x)) { + default: + break; + case JANET_STRING: + case JANET_KEYWORD: + case JANET_SYMBOL: + janet_mark_string(janet_unwrap_string(x)); + break; + case JANET_FUNCTION: + janet_mark_function(janet_unwrap_function(x)); + break; + case JANET_ARRAY: + janet_mark_array(janet_unwrap_array(x)); + break; + case JANET_TABLE: + janet_mark_table(janet_unwrap_table(x)); + break; + case JANET_STRUCT: + janet_mark_struct(janet_unwrap_struct(x)); + break; + case JANET_TUPLE: + janet_mark_tuple(janet_unwrap_tuple(x)); + break; + case JANET_BUFFER: + janet_mark_buffer(janet_unwrap_buffer(x)); + break; + case JANET_FIBER: + janet_mark_fiber(janet_unwrap_fiber(x)); + break; + case JANET_ABSTRACT: + janet_mark_abstract(janet_unwrap_abstract(x)); + break; + } + depth++; + } else { + janet_gcroot(x); + } +} + +static void janet_mark_string(const uint8_t *str) { + janet_gc_mark(janet_string_head(str)); +} + +static void janet_mark_buffer(JanetBuffer *buffer) { + janet_gc_mark(buffer); +} + +static void janet_mark_abstract(void *adata) { +#ifdef JANET_EV + /* Check if abstract type is a threaded abstract type. If it is, marking means + * updating the threaded_abstract table. */ + if ((janet_abstract_head(adata)->gc.flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_THREADED_ABSTRACT) { + janet_table_put(&janet_vm.threaded_abstracts, janet_wrap_abstract(adata), janet_wrap_true()); + return; + } +#endif + if (janet_gc_reachable(janet_abstract_head(adata))) + return; + janet_gc_mark(janet_abstract_head(adata)); + if (janet_abstract_head(adata)->type->gcmark) { + janet_abstract_head(adata)->type->gcmark(adata, janet_abstract_size(adata)); + } +} + +/* Mark a bunch of items in memory */ +static void janet_mark_many(const Janet *values, int32_t n) { + if (values == NULL) + return; + const Janet *end = values + n; + while (values < end) { + janet_mark(*values); + values += 1; + } +} + +/* Mark a bunch of key values items in memory */ +static void janet_mark_keys(const JanetKV *kvs, int32_t n) { + const JanetKV *end = kvs + n; + while (kvs < end) { + janet_mark(kvs->key); + kvs++; + } +} + +/* Mark a bunch of key values items in memory */ +static void janet_mark_values(const JanetKV *kvs, int32_t n) { + const JanetKV *end = kvs + n; + while (kvs < end) { + janet_mark(kvs->value); + kvs++; + } +} + +/* Mark a bunch of key values items in memory */ +static void janet_mark_kvs(const JanetKV *kvs, int32_t n) { + const JanetKV *end = kvs + n; + while (kvs < end) { + janet_mark(kvs->key); + janet_mark(kvs->value); + kvs++; + } +} + +static void janet_mark_array(JanetArray *array) { + if (janet_gc_reachable(array)) + return; + janet_gc_mark(array); + if (janet_gc_type((JanetGCObject *) array) == JANET_MEMORY_ARRAY) { + janet_mark_many(array->data, array->count); + } +} + +static void janet_mark_table(JanetTable *table) { +recur: /* Manual tail recursion */ + if (janet_gc_reachable(table)) + return; + janet_gc_mark(table); + enum JanetMemoryType memtype = janet_gc_type(table); + if (memtype == JANET_MEMORY_TABLE_WEAKK) { + janet_mark_values(table->data, table->capacity); + } else if (memtype == JANET_MEMORY_TABLE_WEAKV) { + janet_mark_keys(table->data, table->capacity); + } else if (memtype == JANET_MEMORY_TABLE) { + janet_mark_kvs(table->data, table->capacity); + } + /* do nothing for JANET_MEMORY_TABLE_WEAKKV */ + if (table->proto) { + table = table->proto; + goto recur; + } +} + +static void janet_mark_struct(const JanetKV *st) { +recur: + if (janet_gc_reachable(janet_struct_head(st))) + return; + janet_gc_mark(janet_struct_head(st)); + janet_mark_kvs(st, janet_struct_capacity(st)); + st = janet_struct_proto(st); + if (st) goto recur; +} + +static void janet_mark_tuple(const Janet *tuple) { + if (janet_gc_reachable(janet_tuple_head(tuple))) + return; + janet_gc_mark(janet_tuple_head(tuple)); + janet_mark_many(tuple, janet_tuple_length(tuple)); +} + +/* Helper to mark function environments */ +static void janet_mark_funcenv(JanetFuncEnv *env) { + if (janet_gc_reachable(env)) + return; + janet_gc_mark(env); + /* If closure env references a dead fiber, we can just copy out the stack frame we need so + * we don't need to keep around the whole dead fiber. */ + janet_env_maybe_detach(env); + if (env->offset > 0) { + /* On stack */ + janet_mark_fiber(env->as.fiber); + } else { + /* Not on stack */ + janet_mark_many(env->as.values, env->length); + } +} + +/* GC helper to mark a FuncDef */ +static void janet_mark_funcdef(JanetFuncDef *def) { + int32_t i; + if (janet_gc_reachable(def)) + return; + janet_gc_mark(def); + janet_mark_many(def->constants, def->constants_length); + for (i = 0; i < def->defs_length; ++i) { + janet_mark_funcdef(def->defs[i]); + } + if (def->source) + janet_mark_string(def->source); + if (def->name) + janet_mark_string(def->name); + if (def->symbolmap) { + for (int i = 0; i < def->symbolmap_length; i++) { + janet_mark_string(def->symbolmap[i].symbol); + } + } + +} + +static void janet_mark_function(JanetFunction *func) { + int32_t i; + int32_t numenvs; + if (janet_gc_reachable(func)) + return; + janet_gc_mark(func); + if (NULL != func->def) { + /* this should always be true, except if function is only partially constructed */ + numenvs = func->def->environments_length; + for (i = 0; i < numenvs; ++i) { + janet_mark_funcenv(func->envs[i]); + } + janet_mark_funcdef(func->def); + } +} + +static void janet_mark_fiber(JanetFiber *fiber) { + int32_t i, j; + JanetStackFrame *frame; +recur: + if (janet_gc_reachable(fiber)) + return; + janet_gc_mark(fiber); + + janet_mark(fiber->last_value); + + /* Mark values on the argument stack */ + janet_mark_many(fiber->data + fiber->stackstart, + fiber->stacktop - fiber->stackstart); + + i = fiber->frame; + j = fiber->stackstart - JANET_FRAME_SIZE; + while (i > 0) { + frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + if (NULL != frame->func) + janet_mark_function(frame->func); + if (NULL != frame->env) + janet_mark_funcenv(frame->env); + /* Mark all values in the stack frame */ + janet_mark_many(fiber->data + i, j - i); + j = i - JANET_FRAME_SIZE; + i = frame->prevframe; + } + + if (fiber->env) + janet_mark_table(fiber->env); + +#ifdef JANET_EV + if (fiber->supervisor_channel) { + janet_mark_abstract(fiber->supervisor_channel); + } + if (fiber->ev_stream) { + janet_mark_abstract(fiber->ev_stream); + } + if (fiber->ev_callback) { + fiber->ev_callback(fiber, JANET_ASYNC_EVENT_MARK); + } +#endif + + /* Explicit tail recursion */ + if (fiber->child) { + fiber = fiber->child; + goto recur; + } +} + +/* Deinitialize a block of memory */ +static void janet_deinit_block(JanetGCObject *mem) { + switch (mem->flags & JANET_MEM_TYPEBITS) { + default: + case JANET_MEMORY_FUNCTION: + break; /* Do nothing for non gc types */ + case JANET_MEMORY_SYMBOL: + janet_symbol_deinit(((JanetStringHead *) mem)->data); + break; + case JANET_MEMORY_ARRAY: + janet_free(((JanetArray *) mem)->data); + break; + case JANET_MEMORY_TABLE: + janet_free(((JanetTable *) mem)->data); + break; + case JANET_MEMORY_FIBER: { + JanetFiber *f = (JanetFiber *)mem; +#ifdef JANET_EV + if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { + janet_ev_dec_refcount(); + janet_free(f->ev_state); + } +#endif + janet_free(f->data); + } + break; + case JANET_MEMORY_BUFFER: + janet_buffer_deinit((JanetBuffer *) mem); + break; + case JANET_MEMORY_ABSTRACT: { + JanetAbstractHead *head = (JanetAbstractHead *)mem; + if (head->type->gc) { + janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); + } + } + break; + case JANET_MEMORY_FUNCENV: { + JanetFuncEnv *env = (JanetFuncEnv *)mem; + if (0 == env->offset) + janet_free(env->as.values); + } + break; + case JANET_MEMORY_FUNCDEF: { + JanetFuncDef *def = (JanetFuncDef *)mem; + /* TODO - get this all with one alloc and one free */ + janet_free(def->defs); + janet_free(def->environments); + janet_free(def->constants); + janet_free(def->bytecode); + janet_free(def->sourcemap); + janet_free(def->closure_bitset); + janet_free(def->symbolmap); + } + break; + } +} + +/* Check that a value x has been visited in the mark phase */ +static int janet_check_liveref(Janet x) { + switch (janet_type(x)) { + default: + return 1; + case JANET_ARRAY: + case JANET_TABLE: + case JANET_FUNCTION: + case JANET_BUFFER: + case JANET_FIBER: + return janet_gc_reachable(janet_unwrap_pointer(x)); + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + return janet_gc_reachable(janet_string_head(janet_unwrap_string(x))); + case JANET_ABSTRACT: + return janet_gc_reachable(janet_abstract_head(janet_unwrap_abstract(x))); + case JANET_TUPLE: + return janet_gc_reachable(janet_tuple_head(janet_unwrap_tuple(x))); + case JANET_STRUCT: + return janet_gc_reachable(janet_struct_head(janet_unwrap_struct(x))); + } +} + +/* Iterate over all allocated memory, and free memory that is not + * marked as reachable. Flip the gc color flag for next sweep. */ +void janet_sweep() { + JanetGCObject *previous = NULL; + JanetGCObject *current = janet_vm.weak_blocks; + JanetGCObject *next; + + /* Sweep weak heap to drop weak refs */ + while (NULL != current) { + next = current->data.next; + if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) { + /* Check for dead references */ + enum JanetMemoryType type = janet_gc_type(current); + if (type == JANET_MEMORY_ARRAY_WEAK) { + JanetArray *array = (JanetArray *) current; + for (uint32_t i = 0; i < (uint32_t) array->count; i++) { + if (!janet_check_liveref(array->data[i])) { + array->data[i] = janet_wrap_nil(); + } + } + } else { + JanetTable *table = (JanetTable *) current; + int check_values = (type == JANET_MEMORY_TABLE_WEAKV) || (type == JANET_MEMORY_TABLE_WEAKKV); + int check_keys = (type == JANET_MEMORY_TABLE_WEAKK) || (type == JANET_MEMORY_TABLE_WEAKKV); + JanetKV *end = table->data + table->capacity; + JanetKV *kvs = table->data; + while (kvs < end) { + int drop = 0; + if (check_keys && !janet_check_liveref(kvs->key)) drop = 1; + if (check_values && !janet_check_liveref(kvs->value)) drop = 1; + if (drop) { + /* Inlined from janet_table_remove without search */ + table->count--; + table->deleted++; + kvs->key = janet_wrap_nil(); + kvs->value = janet_wrap_false(); + } + kvs++; + } + } + } + current = next; + } + + /* Sweep weak heap to free blocks */ + previous = NULL; + current = janet_vm.weak_blocks; + while (NULL != current) { + next = current->data.next; + if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) { + previous = current; + current->flags &= ~JANET_MEM_REACHABLE; + } else { + janet_vm.block_count--; + janet_deinit_block(current); + if (NULL != previous) { + previous->data.next = next; + } else { + janet_vm.weak_blocks = next; + } + janet_free(current); + } + current = next; + } + + /* Sweep main heap to free blocks */ + previous = NULL; + current = janet_vm.blocks; + while (NULL != current) { + next = current->data.next; + if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) { + previous = current; + current->flags &= ~JANET_MEM_REACHABLE; + } else { + janet_vm.block_count--; + janet_deinit_block(current); + if (NULL != previous) { + previous->data.next = next; + } else { + janet_vm.blocks = next; + } + janet_free(current); + } + current = next; + } + +#ifdef JANET_EV + /* Sweep threaded abstract types for references to decrement */ + JanetKV *items = janet_vm.threaded_abstracts.data; + for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { + if (janet_checktype(items[i].key, JANET_ABSTRACT)) { + + /* If item was not visited during the mark phase, then this + * abstract type isn't present in the heap and needs its refcount + * decremented, and shouuld be removed from table. If the refcount is + * then 0, the item will be collected. This ensures that only one interpreter + * will clean up the threaded abstract. */ + + /* If not visited... */ + if (!janet_truthy(items[i].value)) { + void *abst = janet_unwrap_abstract(items[i].key); + if (0 == janet_abstract_decref(abst)) { + /* Run finalizer */ + JanetAbstractHead *head = janet_abstract_head(abst); + if (head->type->gc) { + janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); + } + /* Free memory */ + janet_free(janet_abstract_head(abst)); + } + + /* Mark as tombstone in place */ + items[i].key = janet_wrap_nil(); + items[i].value = janet_wrap_false(); + janet_vm.threaded_abstracts.deleted++; + janet_vm.threaded_abstracts.count--; + } + + /* Reset for next sweep */ + items[i].value = janet_wrap_false(); + } + } +#endif +} + +/* Allocate some memory that is tracked for garbage collection */ +void *janet_gcalloc(enum JanetMemoryType type, size_t size) { + JanetGCObject *mem; + + /* Make sure everything is inited */ + janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); + mem = janet_malloc(size); + + /* Check for bad malloc */ + if (NULL == mem) { + JANET_OUT_OF_MEMORY; + } + + /* Configure block */ + mem->flags = type; + + /* Prepend block to heap list */ + janet_vm.next_collection += size; + if (type < JANET_MEMORY_TABLE_WEAKK) { + /* normal heap */ + mem->data.next = janet_vm.blocks; + janet_vm.blocks = mem; + } else { + /* weak heap */ + mem->data.next = janet_vm.weak_blocks; + janet_vm.weak_blocks = mem; + } + janet_vm.block_count++; + + return (void *)mem; +} + +static void free_one_scratch(JanetScratch *s) { + if (NULL != s->finalize) { + s->finalize((char *) s->mem); + } + janet_free(s); +} + +/* Free all allocated scratch memory */ +static void janet_free_all_scratch(void) { + for (size_t i = 0; i < janet_vm.scratch_len; i++) { + free_one_scratch(janet_vm.scratch_mem[i]); + } + janet_vm.scratch_len = 0; +} + +static JanetScratch *janet_mem2scratch(void *mem) { + JanetScratch *s = (JanetScratch *)mem; + return s - 1; +} + +/* Run garbage collection */ +void janet_collect(void) { + uint32_t i; + if (janet_vm.gc_suspend) return; + depth = JANET_RECURSION_GUARD; + janet_vm.gc_mark_phase = 1; + /* Try to prevent many major collections back to back. + * A full collection will take O(janet_vm.block_count) time. + * If we have a large heap, make sure our interval is not too + * small so we won't make many collections over it. This is just a + * heuristic for automatically changing the gc interval */ + if (janet_vm.block_count * 8 > janet_vm.gc_interval) { + janet_vm.gc_interval = janet_vm.block_count * sizeof(JanetGCObject); + } + orig_rootcount = janet_vm.root_count; +#ifdef JANET_EV + janet_ev_mark(); +#endif + janet_mark_fiber(janet_vm.root_fiber); + for (i = 0; i < orig_rootcount; i++) + janet_mark(janet_vm.roots[i]); + while (orig_rootcount < janet_vm.root_count) { + Janet x = janet_vm.roots[--janet_vm.root_count]; + janet_mark(x); + } + janet_vm.gc_mark_phase = 0; + janet_sweep(); + janet_vm.next_collection = 0; + janet_free_all_scratch(); +} + +/* Add a root value to the GC. This prevents the GC from removing a value + * and all of its children. If gcroot is called on a value n times, unroot + * must also be called n times to remove it as a gc root. */ +void janet_gcroot(Janet root) { + size_t newcount = janet_vm.root_count + 1; + if (newcount > janet_vm.root_capacity) { + size_t newcap = 2 * newcount; + janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); + if (NULL == janet_vm.roots) { + JANET_OUT_OF_MEMORY; + } + janet_vm.root_capacity = newcap; + } + janet_vm.roots[janet_vm.root_count] = root; + janet_vm.root_count = newcount; +} + +/* Identity equality for GC purposes */ +static int janet_gc_idequals(Janet lhs, Janet rhs) { + if (janet_type(lhs) != janet_type(rhs)) + return 0; + switch (janet_type(lhs)) { + case JANET_BOOLEAN: + case JANET_NIL: + case JANET_NUMBER: + /* These values don't really matter to the gc so returning 1 all the time is fine. */ + return 1; + default: + return janet_unwrap_pointer(lhs) == janet_unwrap_pointer(rhs); + } +} + +/* Remove a root value from the GC. This allows the gc to potentially reclaim + * a value and all its children. */ +int janet_gcunroot(Janet root) { + Janet *vtop = janet_vm.roots + janet_vm.root_count; + /* Search from top to bottom as access is most likely LIFO */ + for (Janet *v = janet_vm.roots; v < vtop; v++) { + if (janet_gc_idequals(root, *v)) { + *v = janet_vm.roots[--janet_vm.root_count]; + return 1; + } + } + return 0; +} + +/* Remove a root value from the GC. This sets the effective reference count to 0. */ +int janet_gcunrootall(Janet root) { + Janet *vtop = janet_vm.roots + janet_vm.root_count; + int ret = 0; + /* Search from top to bottom as access is most likely LIFO */ + for (Janet *v = janet_vm.roots; v < vtop; v++) { + if (janet_gc_idequals(root, *v)) { + *v = janet_vm.roots[--janet_vm.root_count]; + vtop--; + ret = 1; + } + } + return ret; +} + +/* Free all allocated memory */ +void janet_clear_memory(void) { +#ifdef JANET_EV + JanetKV *items = janet_vm.threaded_abstracts.data; + for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { + if (janet_checktype(items[i].key, JANET_ABSTRACT)) { + void *abst = janet_unwrap_abstract(items[i].key); + if (0 == janet_abstract_decref(abst)) { + JanetAbstractHead *head = janet_abstract_head(abst); + if (head->type->gc) { + janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); + } + janet_free(janet_abstract_head(abst)); + } + } + } +#endif + JanetGCObject *current = janet_vm.blocks; + while (NULL != current) { + janet_deinit_block(current); + JanetGCObject *next = current->data.next; + janet_free(current); + current = next; + } + janet_vm.blocks = NULL; + janet_free_all_scratch(); + janet_free(janet_vm.scratch_mem); +} + +/* Primitives for suspending GC. */ +int janet_gclock(void) { + return janet_vm.gc_suspend++; +} +void janet_gcunlock(int handle) { + janet_vm.gc_suspend = handle; +} + +/* Scratch memory API + * Scratch memory allocations do not need to be free (but optionally can be), and will be automatically cleaned + * up in the next call to janet_collect. */ + +void *janet_smalloc(size_t size) { + JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); + if (NULL == s) { + JANET_OUT_OF_MEMORY; + } + s->finalize = NULL; + if (janet_vm.scratch_len == janet_vm.scratch_cap) { + size_t newcap = 2 * janet_vm.scratch_cap + 2; + JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); + if (NULL == newmem) { + JANET_OUT_OF_MEMORY; + } + janet_vm.scratch_cap = newcap; + janet_vm.scratch_mem = newmem; + } + janet_vm.scratch_mem[janet_vm.scratch_len++] = s; + return (char *)(s->mem); +} + +void *janet_scalloc(size_t nmemb, size_t size) { + if (nmemb && size > SIZE_MAX / nmemb) { + JANET_OUT_OF_MEMORY; + } + size_t n = nmemb * size; + void *p = janet_smalloc(n); + memset(p, 0, n); + return p; +} + +void *janet_srealloc(void *mem, size_t size) { + if (NULL == mem) return janet_smalloc(size); + JanetScratch *s = janet_mem2scratch(mem); + if (janet_vm.scratch_len) { + for (size_t i = janet_vm.scratch_len - 1; ; i--) { + if (janet_vm.scratch_mem[i] == s) { + JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); + if (NULL == news) { + JANET_OUT_OF_MEMORY; + } + janet_vm.scratch_mem[i] = news; + return (char *)(news->mem); + } + if (i == 0) break; + } + } + JANET_EXIT("invalid janet_srealloc"); +} + +void janet_sfinalizer(void *mem, JanetScratchFinalizer finalizer) { + JanetScratch *s = janet_mem2scratch(mem); + s->finalize = finalizer; +} + +void janet_sfree(void *mem) { + if (NULL == mem) return; + JanetScratch *s = janet_mem2scratch(mem); + if (janet_vm.scratch_len) { + for (size_t i = janet_vm.scratch_len - 1; ; i--) { + if (janet_vm.scratch_mem[i] == s) { + janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; + free_one_scratch(s); + return; + } + if (i == 0) break; + } + } + JANET_EXIT("invalid janet_sfree"); +} + + +/* src/core/inttypes.c */ +#line 0 "src/core/inttypes.c" + +/* +* Copyright (c) 2023 Calvin Rose & contributors +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#endif + +#include +#include +#include +#include +#include + +/* Conditional compilation */ +#ifdef JANET_INT_TYPES + +#define MAX_INT_IN_DBL 9007199254740992ULL /* 2^53 */ + +static int it_s64_get(void *p, Janet key, Janet *out); +static int it_u64_get(void *p, Janet key, Janet *out); +static Janet janet_int64_next(void *p, Janet key); +static Janet janet_uint64_next(void *p, Janet key); + +static int32_t janet_int64_hash(void *p1, size_t size) { + (void) size; + int32_t *words = p1; + return words[0] ^ words[1]; +} + +static int janet_int64_compare(void *p1, void *p2) { + int64_t x = *((int64_t *)p1); + int64_t y = *((int64_t *)p2); + return x == y ? 0 : x < y ? -1 : 1; +} + +static int janet_uint64_compare(void *p1, void *p2) { + uint64_t x = *((uint64_t *)p1); + uint64_t y = *((uint64_t *)p2); + return x == y ? 0 : x < y ? -1 : 1; +} + +static void int64_marshal(void *p, JanetMarshalContext *ctx) { + janet_marshal_abstract(ctx, p); + janet_marshal_int64(ctx, *((int64_t *)p)); +} + +static void *int64_unmarshal(JanetMarshalContext *ctx) { + int64_t *p = janet_unmarshal_abstract(ctx, sizeof(int64_t)); + p[0] = janet_unmarshal_int64(ctx); + return p; +} + +static void it_s64_tostring(void *p, JanetBuffer *buffer) { + char str[32]; + sprintf(str, "%" PRId64, *((int64_t *)p)); + janet_buffer_push_cstring(buffer, str); +} + +static void it_u64_tostring(void *p, JanetBuffer *buffer) { + char str[32]; + sprintf(str, "%" PRIu64, *((uint64_t *)p)); + janet_buffer_push_cstring(buffer, str); +} + +const JanetAbstractType janet_s64_type = { + "core/s64", + NULL, + NULL, + it_s64_get, + NULL, + int64_marshal, + int64_unmarshal, + it_s64_tostring, + janet_int64_compare, + janet_int64_hash, + janet_int64_next, + JANET_ATEND_NEXT +}; + +const JanetAbstractType janet_u64_type = { + "core/u64", + NULL, + NULL, + it_u64_get, + NULL, + int64_marshal, + int64_unmarshal, + it_u64_tostring, + janet_uint64_compare, + janet_int64_hash, + janet_uint64_next, + JANET_ATEND_NEXT +}; + +int64_t janet_unwrap_s64(Janet x) { + switch (janet_type(x)) { + default: + break; + case JANET_NUMBER : { + double d = janet_unwrap_number(x); + if (!janet_checkint64range(d)) break; + return (int64_t) d; + } + case JANET_STRING: { + int64_t value; + const uint8_t *str = janet_unwrap_string(x); + if (janet_scan_int64(str, janet_string_length(str), &value)) + return value; + break; + } + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(x); + if (janet_abstract_type(abst) == &janet_s64_type || + (janet_abstract_type(abst) == &janet_u64_type)) + return *(int64_t *)abst; + break; + } + } + janet_panicf("can not convert %t %q to 64 bit signed integer", x, x); + return 0; +} + +uint64_t janet_unwrap_u64(Janet x) { + switch (janet_type(x)) { + default: + break; + case JANET_NUMBER : { + double d = janet_unwrap_number(x); + if (!janet_checkuint64range(d)) break; + return (uint64_t) d; + } + case JANET_STRING: { + uint64_t value; + const uint8_t *str = janet_unwrap_string(x); + if (janet_scan_uint64(str, janet_string_length(str), &value)) + return value; + break; + } + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(x); + if (janet_abstract_type(abst) == &janet_s64_type || + (janet_abstract_type(abst) == &janet_u64_type)) + return *(uint64_t *)abst; + break; + } + } + janet_panicf("can not convert %t %q to a 64 bit unsigned integer", x, x); + return 0; +} + +JanetIntType janet_is_int(Janet x) { + if (!janet_checktype(x, JANET_ABSTRACT)) return JANET_INT_NONE; + const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x)); + return (at == &janet_s64_type) ? JANET_INT_S64 : + ((at == &janet_u64_type) ? JANET_INT_U64 : + JANET_INT_NONE); +} + +Janet janet_wrap_s64(int64_t x) { + int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); + *box = (int64_t)x; + return janet_wrap_abstract(box); +} + +Janet janet_wrap_u64(uint64_t x) { + uint64_t *box = janet_abstract(&janet_u64_type, sizeof(uint64_t)); + *box = (uint64_t)x; + return janet_wrap_abstract(box); +} + +JANET_CORE_FN(cfun_it_s64_new, + "(int/s64 value)", + "Create a boxed signed 64 bit integer from a string value.") { + janet_fixarity(argc, 1); + return janet_wrap_s64(janet_unwrap_s64(argv[0])); +} + +JANET_CORE_FN(cfun_it_u64_new, + "(int/u64 value)", + "Create a boxed unsigned 64 bit integer from a string value.") { + janet_fixarity(argc, 1); + return janet_wrap_u64(janet_unwrap_u64(argv[0])); +} + +JANET_CORE_FN(cfun_to_number, + "(int/to-number value)", + "Convert an int/u64 or int/s64 to a number. Fails if the number is out of range for an int32.") { + janet_fixarity(argc, 1); + if (janet_type(argv[0]) == JANET_ABSTRACT) { + void *abst = janet_unwrap_abstract(argv[0]); + + if (janet_abstract_type(abst) == &janet_s64_type) { + int64_t value = *((int64_t *)abst); + if (value > JANET_INTMAX_INT64) { + janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE)); + } + if (value < -JANET_INTMAX_INT64) { + janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE)); + } + return janet_wrap_number((double)value); + } + + if (janet_abstract_type(abst) == &janet_u64_type) { + uint64_t value = *((uint64_t *)abst); + if (value > JANET_INTMAX_INT64) { + janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE)); + } + + return janet_wrap_number((double)value); + } + } + + janet_panicf("expected int/u64 or int/s64, got %q", argv[0]); +} + +JANET_CORE_FN(cfun_to_bytes, + "(int/to-bytes value &opt endianness buffer)", + "Write the bytes of an `int/s64` or `int/u64` into a buffer.\n" + "The `buffer` parameter specifies an existing buffer to write to, if unset a new buffer will be created.\n" + "Returns the modified buffer.\n" + "The `endianness` parameter indicates the byte order:\n" + "- `nil` (unset): system byte order\n" + "- `:le`: little-endian, least significant byte first\n" + "- `:be`: big-endian, most significant byte first\n") { + janet_arity(argc, 1, 3); + if (janet_is_int(argv[0]) == JANET_INT_NONE) { + janet_panicf("int/to-bytes: expected an int/s64 or int/u64, got %q", argv[0]); + } + + int reverse = 0; + if (argc > 1 && !janet_checktype(argv[1], JANET_NIL)) { + JanetKeyword endianness_kw = janet_getkeyword(argv, 1); + if (!janet_cstrcmp(endianness_kw, "le")) { +#if JANET_BIG_ENDIAN + reverse = 1; +#endif + } else if (!janet_cstrcmp(endianness_kw, "be")) { +#if JANET_LITTLE_ENDIAN + reverse = 1; +#endif + } else { + janet_panicf("int/to-bytes: expected endianness :le, :be or nil, got %v", argv[1]); + } + } + + JanetBuffer *buffer = NULL; + if (argc > 2 && !janet_checktype(argv[2], JANET_NIL)) { + if (!janet_checktype(argv[2], JANET_BUFFER)) { + janet_panicf("int/to-bytes: expected buffer or nil, got %q", argv[2]); + } + + buffer = janet_unwrap_buffer(argv[2]); + janet_buffer_extra(buffer, 8); + } else { + buffer = janet_buffer(8); + } + + uint8_t *bytes = janet_unwrap_abstract(argv[0]); + if (reverse) { + for (int i = 0; i < 8; ++i) { + buffer->data[buffer->count + 7 - i] = bytes[i]; + } + } else { + memcpy(buffer->data + buffer->count, bytes, 8); + } + buffer->count += 8; + + return janet_wrap_buffer(buffer); +} + +/* + * Code to support polymorphic comparison. + * int/u64 and int/s64 support a "compare" method that allows + * comparison to each other, and to Janet numbers, using the + * "compare" "compare<" ... functions. + * In the following code explicit casts are sometimes used to help + * make it clear when int/float conversions are happening. + */ +static int compare_double_double(double x, double y) { + return (x < y) ? -1 : ((x > y) ? 1 : 0); +} + +static int compare_int64_double(int64_t x, double y) { + if (isnan(y)) { + return 0; + } else if ((y > JANET_INTMIN_DOUBLE) && (y < JANET_INTMAX_DOUBLE)) { + double dx = (double) x; + return compare_double_double(dx, y); + } else if (y > ((double) INT64_MAX)) { + return -1; + } else if (y < ((double) INT64_MIN)) { + return 1; + } else { + int64_t yi = (int64_t) y; + return (x < yi) ? -1 : ((x > yi) ? 1 : 0); + } +} + +static int compare_uint64_double(uint64_t x, double y) { + if (isnan(y)) { + return 0; + } else if (y < 0) { + return 1; + } else if ((y >= 0) && (y < JANET_INTMAX_DOUBLE)) { + double dx = (double) x; + return compare_double_double(dx, y); + } else if (y > ((double) UINT64_MAX)) { + return -1; + } else { + uint64_t yi = (uint64_t) y; + return (x < yi) ? -1 : ((x > yi) ? 1 : 0); + } +} + +static Janet cfun_it_s64_compare(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + if (janet_is_int(argv[0]) != JANET_INT_S64) { + janet_panic("compare method requires int/s64 as first argument"); + } + int64_t x = janet_unwrap_s64(argv[0]); + switch (janet_type(argv[1])) { + default: + break; + case JANET_NUMBER : { + double y = janet_unwrap_number(argv[1]); + return janet_wrap_number(compare_int64_double(x, y)); + } + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(argv[1]); + if (janet_abstract_type(abst) == &janet_s64_type) { + int64_t y = *(int64_t *)abst; + return janet_wrap_number((x < y) ? -1 : (x > y ? 1 : 0)); + } else if (janet_abstract_type(abst) == &janet_u64_type) { + uint64_t y = *(uint64_t *)abst; + if (x < 0) { + return janet_wrap_number(-1); + } else if (y > INT64_MAX) { + return janet_wrap_number(-1); + } else { + int64_t y2 = (int64_t) y; + return janet_wrap_number((x < y2) ? -1 : (x > y2 ? 1 : 0)); + } + } + break; + } + } + return janet_wrap_nil(); +} + +static Janet cfun_it_u64_compare(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + if (janet_is_int(argv[0]) != JANET_INT_U64) { + janet_panic("compare method requires int/u64 as first argument"); + } + uint64_t x = janet_unwrap_u64(argv[0]); + switch (janet_type(argv[1])) { + default: + break; + case JANET_NUMBER : { + double y = janet_unwrap_number(argv[1]); + return janet_wrap_number(compare_uint64_double(x, y)); + } + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(argv[1]); + if (janet_abstract_type(abst) == &janet_u64_type) { + uint64_t y = *(uint64_t *)abst; + return janet_wrap_number((x < y) ? -1 : (x > y ? 1 : 0)); + } else if (janet_abstract_type(abst) == &janet_s64_type) { + int64_t y = *(int64_t *)abst; + if (y < 0) { + return janet_wrap_number(1); + } else if (x > INT64_MAX) { + return janet_wrap_number(1); + } else { + int64_t x2 = (int64_t) x; + return janet_wrap_number((x2 < y) ? -1 : (x2 > y ? 1 : 0)); + } + } + break; + } + } + return janet_wrap_nil(); +} + +/* + * In C, signed arithmetic overflow is undefined behvior + * but unsigned arithmetic overflow is twos complement + * + * Reference: + * https://en.cppreference.com/w/cpp/language/ub + * http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html + * + * This means OPMETHOD & OPMETHODINVERT must always use + * unsigned arithmetic internally, regardless of the true type. + * This will not affect the end result (property of twos complement). + */ +#define OPMETHOD(T, type, name, oper) \ +static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ + janet_arity(argc, 2, -1); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[0]); \ + for (int32_t i = 1; i < argc; i++) \ + /* This avoids undefined behavior. See above for why. */ \ + *box = (T) ((uint64_t) (*box)) oper ((uint64_t) janet_unwrap_##type(argv[i])); \ + return janet_wrap_abstract(box); \ +} \ + +#define OPMETHODINVERT(T, type, name, oper) \ +static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \ + janet_fixarity(argc, 2); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[1]); \ + /* This avoids undefined behavior. See above for why. */ \ + *box = (T) ((uint64_t) *box) oper ((uint64_t) janet_unwrap_##type(argv[0])); \ + return janet_wrap_abstract(box); \ +} \ + +#define UNARYMETHOD(T, type, name, oper) \ +static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ + janet_fixarity(argc, 1); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = oper(janet_unwrap_##type(argv[0])); \ + return janet_wrap_abstract(box); \ +} \ + +#define DIVZERO(name) DIVZERO_##name +#define DIVZERO_div janet_panic("division by zero") +#define DIVZERO_rem janet_panic("division by zero") +#define DIVZERO_mod return janet_wrap_abstract(box) + +#define DIVMETHOD(T, type, name, oper) \ +static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ + janet_arity(argc, 2, -1); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[0]); \ + for (int32_t i = 1; i < argc; i++) { \ + T value = janet_unwrap_##type(argv[i]); \ + if (value == 0) DIVZERO(name); \ + *box oper##= value; \ + } \ + return janet_wrap_abstract(box); \ +} \ + +#define DIVMETHODINVERT(T, type, name, oper) \ +static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \ + janet_fixarity(argc, 2); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[1]); \ + T value = janet_unwrap_##type(argv[0]); \ + if (value == 0) DIVZERO(name); \ + *box oper##= value; \ + return janet_wrap_abstract(box); \ +} \ + +#define DIVMETHOD_SIGNED(T, type, name, oper) \ +static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ + janet_arity(argc, 2, -1); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[0]); \ + for (int32_t i = 1; i < argc; i++) { \ + T value = janet_unwrap_##type(argv[i]); \ + if (value == 0) DIVZERO(name); \ + if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \ + *box oper##= value; \ + } \ + return janet_wrap_abstract(box); \ +} \ + +#define DIVMETHODINVERT_SIGNED(T, type, name, oper) \ +static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \ + janet_fixarity(argc, 2); \ + T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \ + *box = janet_unwrap_##type(argv[1]); \ + T value = janet_unwrap_##type(argv[0]); \ + if (value == 0) DIVZERO(name); \ + if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \ + *box oper##= value; \ + return janet_wrap_abstract(box); \ +} \ + +static Janet cfun_it_s64_divf(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); + int64_t op1 = janet_unwrap_s64(argv[0]); + int64_t op2 = janet_unwrap_s64(argv[1]); + if (op2 == 0) janet_panic("division by zero"); + int64_t x = op1 / op2; + *box = x - (((op1 ^ op2) < 0) && (x * op2 != op1)); + return janet_wrap_abstract(box); +} + +static Janet cfun_it_s64_divfi(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); + int64_t op2 = janet_unwrap_s64(argv[0]); + int64_t op1 = janet_unwrap_s64(argv[1]); + if (op2 == 0) janet_panic("division by zero"); + int64_t x = op1 / op2; + *box = x - (((op1 ^ op2) < 0) && (x * op2 != op1)); + return janet_wrap_abstract(box); +} + +static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); + int64_t op1 = janet_unwrap_s64(argv[0]); + int64_t op2 = janet_unwrap_s64(argv[1]); + if (op2 == 0) { + *box = op1; + } else { + int64_t x = op1 % op2; + *box = (((op1 ^ op2) < 0) && (x != 0)) ? x + op2 : x; + } + return janet_wrap_abstract(box); +} + +static Janet cfun_it_s64_modi(int32_t argc, Janet *argv) { + janet_fixarity(argc, 2); + int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); + int64_t op2 = janet_unwrap_s64(argv[0]); + int64_t op1 = janet_unwrap_s64(argv[1]); + if (op2 == 0) { + *box = op1; + } else { + int64_t x = op1 % op2; + *box = (((op1 ^ op2) < 0) && (x != 0)) ? x + op2 : x; + } + return janet_wrap_abstract(box); +} + +OPMETHOD(int64_t, s64, add, +) +OPMETHOD(int64_t, s64, sub, -) +OPMETHODINVERT(int64_t, s64, sub, -) +OPMETHOD(int64_t, s64, mul, *) +DIVMETHOD_SIGNED(int64_t, s64, div, /) +DIVMETHOD_SIGNED(int64_t, s64, rem, %) +DIVMETHODINVERT_SIGNED(int64_t, s64, div, /) +DIVMETHODINVERT_SIGNED(int64_t, s64, rem, %) +OPMETHOD(int64_t, s64, and, &) +OPMETHOD(int64_t, s64, or, |) +OPMETHOD(int64_t, s64, xor, ^) +UNARYMETHOD(int64_t, s64, not, ~) +OPMETHOD(int64_t, s64, lshift, <<) +OPMETHOD(int64_t, s64, rshift, >>) +OPMETHOD(uint64_t, u64, add, +) +OPMETHOD(uint64_t, u64, sub, -) +OPMETHODINVERT(uint64_t, u64, sub, -) +OPMETHOD(uint64_t, u64, mul, *) +DIVMETHOD(uint64_t, u64, div, /) +DIVMETHOD(uint64_t, u64, rem, %) +DIVMETHOD(uint64_t, u64, mod, %) +DIVMETHODINVERT(uint64_t, u64, div, /) +DIVMETHODINVERT(uint64_t, u64, rem, %) +DIVMETHODINVERT(uint64_t, u64, mod, %) +OPMETHOD(uint64_t, u64, and, &) +OPMETHOD(uint64_t, u64, or, |) +OPMETHOD(uint64_t, u64, xor, ^) +UNARYMETHOD(uint64_t, u64, not, ~) +OPMETHOD(uint64_t, u64, lshift, <<) +OPMETHOD(uint64_t, u64, rshift, >>) + +#undef OPMETHOD +#undef DIVMETHOD +#undef DIVMETHOD_SIGNED +#undef COMPMETHOD + +static JanetMethod it_s64_methods[] = { + {"+", cfun_it_s64_add}, + {"r+", cfun_it_s64_add}, + {"-", cfun_it_s64_sub}, + {"r-", cfun_it_s64_subi}, + {"*", cfun_it_s64_mul}, + {"r*", cfun_it_s64_mul}, + {"/", cfun_it_s64_div}, + {"r/", cfun_it_s64_divi}, + {"div", cfun_it_s64_divf}, + {"rdiv", cfun_it_s64_divfi}, + {"mod", cfun_it_s64_mod}, + {"rmod", cfun_it_s64_modi}, + {"%", cfun_it_s64_rem}, + {"r%", cfun_it_s64_remi}, + {"&", cfun_it_s64_and}, + {"r&", cfun_it_s64_and}, + {"|", cfun_it_s64_or}, + {"r|", cfun_it_s64_or}, + {"^", cfun_it_s64_xor}, + {"r^", cfun_it_s64_xor}, + {"~", cfun_it_s64_not}, + {"<<", cfun_it_s64_lshift}, + {">>", cfun_it_s64_rshift}, + {"compare", cfun_it_s64_compare}, + {NULL, NULL} +}; + +static JanetMethod it_u64_methods[] = { + {"+", cfun_it_u64_add}, + {"r+", cfun_it_u64_add}, + {"-", cfun_it_u64_sub}, + {"r-", cfun_it_u64_subi}, + {"*", cfun_it_u64_mul}, + {"r*", cfun_it_u64_mul}, + {"/", cfun_it_u64_div}, + {"r/", cfun_it_u64_divi}, + {"div", cfun_it_u64_div}, + {"rdiv", cfun_it_u64_divi}, + {"mod", cfun_it_u64_mod}, + {"rmod", cfun_it_u64_modi}, + {"%", cfun_it_u64_rem}, + {"r%", cfun_it_u64_remi}, + {"&", cfun_it_u64_and}, + {"r&", cfun_it_u64_and}, + {"|", cfun_it_u64_or}, + {"r|", cfun_it_u64_or}, + {"^", cfun_it_u64_xor}, + {"r^", cfun_it_u64_xor}, + {"~", cfun_it_u64_not}, + {"<<", cfun_it_u64_lshift}, + {">>", cfun_it_u64_rshift}, + {"compare", cfun_it_u64_compare}, + {NULL, NULL} +}; + +static Janet janet_int64_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(it_s64_methods, key); +} + +static Janet janet_uint64_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(it_u64_methods, key); +} + +static int it_s64_get(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) + return 0; + return janet_getmethod(janet_unwrap_keyword(key), it_s64_methods, out); +} + +static int it_u64_get(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) + return 0; + return janet_getmethod(janet_unwrap_keyword(key), it_u64_methods, out); +} + +/* Module entry point */ +void janet_lib_inttypes(JanetTable *env) { + JanetRegExt it_cfuns[] = { + JANET_CORE_REG("int/s64", cfun_it_s64_new), + JANET_CORE_REG("int/u64", cfun_it_u64_new), + JANET_CORE_REG("int/to-number", cfun_to_number), + JANET_CORE_REG("int/to-bytes", cfun_to_bytes), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, it_cfuns); + janet_register_abstract_type(&janet_s64_type); + janet_register_abstract_type(&janet_u64_type); +} + +#endif + + +/* src/core/io.c */ +#line 0 "src/core/io.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#endif + +#include +#include + +#ifndef JANET_WINDOWS +#include +#include +#include +#endif + +static int cfun_io_gc(void *p, size_t len); +static int io_file_get(void *p, Janet key, Janet *out); +static void io_file_marshal(void *p, JanetMarshalContext *ctx); +static void *io_file_unmarshal(JanetMarshalContext *ctx); +static Janet io_file_next(void *p, Janet key); + +const JanetAbstractType janet_file_type = { + "core/file", + cfun_io_gc, + NULL, + io_file_get, + NULL, + io_file_marshal, + io_file_unmarshal, + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + io_file_next, + JANET_ATEND_NEXT +}; + +/* Check arguments to fopen */ +static int32_t checkflags(const uint8_t *str) { + int32_t flags = 0; + int32_t i; + int32_t len = janet_string_length(str); + if (!len || len > 10) + janet_panic("file mode must have a length between 1 and 10"); + switch (*str) { + default: + janet_panicf("invalid flag %c, expected w, a, or r", *str); + break; + case 'w': + flags |= JANET_FILE_WRITE; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + case 'a': + flags |= JANET_FILE_APPEND; + janet_sandbox_assert(JANET_SANDBOX_FS); + break; + case 'r': + flags |= JANET_FILE_READ; + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + break; + } + for (i = 1; i < len; i++) { + switch (str[i]) { + default: + janet_panicf("invalid flag %c, expected +, b, or n", str[i]); + break; + case '+': + if (flags & JANET_FILE_UPDATE) return -1; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + flags |= JANET_FILE_UPDATE; + break; + case 'b': + if (flags & JANET_FILE_BINARY) return -1; + flags |= JANET_FILE_BINARY; + break; + case 'n': + if (flags & JANET_FILE_NONIL) return -1; + flags |= JANET_FILE_NONIL; + break; + } + } + return flags; +} + +static void *makef(FILE *f, int32_t flags) { + JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); + iof->file = f; + iof->flags = flags; +#ifndef JANET_WINDOWS + /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is + * not standard. */ + if (!(flags & JANET_FILE_NOT_CLOSEABLE)) + fcntl(fileno(f), F_SETFD, FD_CLOEXEC); +#endif + return iof; +} + +JANET_CORE_FN(cfun_io_temp, + "(file/temp)", + "Open an anonymous temporary file that is removed on close. " + "Raises an error on failure.") { + janet_sandbox_assert(JANET_SANDBOX_FS_TEMP); + (void)argv; + janet_fixarity(argc, 0); + // XXX use mkostemp when we can to avoid CLOEXEC race. + FILE *tmp = tmpfile(); + if (!tmp) + janet_panicf("unable to create temporary file - %s", strerror(errno)); + return janet_makefile(tmp, JANET_FILE_WRITE | JANET_FILE_READ | JANET_FILE_BINARY); +} + +JANET_CORE_FN(cfun_io_fopen, + "(file/open path &opt mode buffer-size)", + "Open a file. `path` is an absolute or relative path, and " + "`mode` is a set of flags indicating the mode to open the file in. " + "`mode` is a keyword where each character represents a flag. If the file " + "cannot be opened, returns nil, otherwise returns the new file handle. " + "Mode flags:\n\n" + "* r - allow reading from the file\n\n" + "* w - allow writing to the file\n\n" + "* a - append to the file\n\n" + "Following one of the initial flags, 0 or more of the following flags can be appended:\n\n" + "* b - open the file in binary mode (rather than text mode)\n\n" + "* + - append to the file instead of overwriting it\n\n" + "* n - error if the file cannot be opened instead of returning nil\n\n" + "See fopen (, C99) for further details.") { + janet_arity(argc, 1, 3); + const uint8_t *fname = janet_getstring(argv, 0); + const uint8_t *fmode; + int32_t flags; + if (argc == 2) { + fmode = janet_getkeyword(argv, 1); + flags = checkflags(fmode); + } else { + fmode = (const uint8_t *)"r"; + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + flags = JANET_FILE_READ; + } + FILE *f = fopen((const char *)fname, (const char *)fmode); + if (f != NULL) { + size_t bufsize = janet_optsize(argv, argc, 2, BUFSIZ); + if (bufsize != BUFSIZ) { + int result = setvbuf(f, NULL, bufsize ? _IOFBF : _IONBF, bufsize); + if (result) { + janet_panic("failed to set buffer size for file"); + } + } + } + return f ? janet_makefile(f, flags) + : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, strerror(errno)), janet_wrap_nil()) + : janet_wrap_nil(); +} + +/* Read up to n bytes into buffer. */ +static void read_chunk(JanetFile *iof, JanetBuffer *buffer, int32_t nBytesMax) { + if (!(iof->flags & (JANET_FILE_READ | JANET_FILE_UPDATE))) + janet_panic("file is not readable"); + janet_buffer_extra(buffer, nBytesMax); + size_t ntoread = nBytesMax; + size_t nread = fread((char *)(buffer->data + buffer->count), 1, ntoread, iof->file); + if (nread != ntoread && ferror(iof->file)) + janet_panic("could not read file"); + buffer->count += (int32_t) nread; +} + +/* Read a certain number of bytes into memory */ +JANET_CORE_FN(cfun_io_fread, + "(file/read f what &opt buf)", + "Read a number of bytes from a file `f` into a buffer. A buffer `buf` can " + "be provided as an optional third argument, otherwise a new buffer " + "is created. `what` can either be an integer or a keyword. Returns the " + "buffer with file contents. " + "Values for `what`:\n\n" + "* :all - read the whole file\n\n" + "* :line - read up to and including the next newline character\n\n" + "* n (integer) - read up to n bytes from the file") { + janet_arity(argc, 2, 3); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + if (iof->flags & JANET_FILE_CLOSED) janet_panic("file is closed"); + JanetBuffer *buffer; + if (argc == 2) { + buffer = janet_buffer(0); + } else { + buffer = janet_getbuffer(argv, 2); + } + int32_t bufstart = buffer->count; + if (janet_checktype(argv[1], JANET_KEYWORD)) { + const uint8_t *sym = janet_unwrap_keyword(argv[1]); + if (!janet_cstrcmp(sym, "all")) { + int32_t sizeBefore; + do { + sizeBefore = buffer->count; + read_chunk(iof, buffer, 4096); + } while (sizeBefore < buffer->count); + /* Never return nil for :all */ + return janet_wrap_buffer(buffer); + } else if (!janet_cstrcmp(sym, "line")) { + for (;;) { + int x = fgetc(iof->file); + if (x != EOF) janet_buffer_push_u8(buffer, (uint8_t)x); + if (x == EOF || x == '\n') break; + } + } else { + janet_panicf("expected one of :all, :line, got %v", argv[1]); + } + } else { + int32_t len = janet_getinteger(argv, 1); + if (len < 0) janet_panic("expected positive integer"); + read_chunk(iof, buffer, len); + } + if (bufstart == buffer->count) return janet_wrap_nil(); + return janet_wrap_buffer(buffer); +} + +/* Write bytes to a file */ +JANET_CORE_FN(cfun_io_fwrite, + "(file/write f bytes)", + "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the " + "file.") { + janet_arity(argc, 1, -1); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + if (iof->flags & JANET_FILE_CLOSED) + janet_panic("file is closed"); + if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE))) + janet_panic("file is not writeable"); + int32_t i; + /* Verify all arguments before writing to file */ + for (i = 1; i < argc; i++) + janet_getbytes(argv, i); + for (i = 1; i < argc; i++) { + JanetByteView view = janet_getbytes(argv, i); + if (view.len) { + if (!fwrite(view.bytes, view.len, 1, iof->file)) { + janet_panic("error writing to file"); + } + } + } + return argv[0]; +} + +static void io_assert_writeable(JanetFile *iof) { + if (iof->flags & JANET_FILE_CLOSED) + janet_panic("file is closed"); + if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE))) + janet_panic("file is not writeable"); +} + +/* Flush the bytes in the file */ +JANET_CORE_FN(cfun_io_fflush, + "(file/flush f)", + "Flush any buffered bytes to the file system. In most files, writes are " + "buffered for efficiency reasons. Returns the file handle.") { + janet_fixarity(argc, 1); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + io_assert_writeable(iof); + if (fflush(iof->file)) + janet_panic("could not flush file"); + return argv[0]; +} + +#ifdef JANET_WINDOWS +#define WEXITSTATUS(x) x +#endif + +/* For closing files from C API */ +int janet_file_close(JanetFile *file) { + int ret = 0; + if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { + ret = fclose(file->file); + file->flags |= JANET_FILE_CLOSED; + file->file = NULL; /* NULL derefence is easier to debug then other problems */ + return ret; + } + return 0; +} + +/* Cleanup a file */ +static int cfun_io_gc(void *p, size_t len) { + (void) len; + JanetFile *iof = (JanetFile *)p; + janet_file_close(iof); + return 0; +} + +/* Close a file */ +JANET_CORE_FN(cfun_io_fclose, + "(file/close f)", + "Close a file and release all related resources. When you are " + "done reading a file, close it to prevent a resource leak and let " + "other processes read the file.") { + janet_fixarity(argc, 1); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + if (iof->flags & JANET_FILE_CLOSED) + return janet_wrap_nil(); + if (iof->flags & (JANET_FILE_NOT_CLOSEABLE)) + janet_panic("file not closable"); + if (fclose(iof->file)) { + iof->flags |= JANET_FILE_NOT_CLOSEABLE; + janet_panic("could not close file"); + } + iof->flags |= JANET_FILE_CLOSED; + return janet_wrap_nil(); +} + +/* Seek a file */ +JANET_CORE_FN(cfun_io_fseek, + "(file/seek f &opt whence n)", + "Jump to a relative location in the file `f`. `whence` must be one of:\n\n" + "* :cur - jump relative to the current file location\n\n" + "* :set - jump relative to the beginning of the file\n\n" + "* :end - jump relative to the end of the file\n\n" + "By default, `whence` is :cur. Optionally a value `n` may be passed " + "for the relative number of bytes to seek in the file. `n` may be a real " + "number to handle large files of more than 4GB. Returns the file handle.") { + janet_arity(argc, 2, 3); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + if (iof->flags & JANET_FILE_CLOSED) + janet_panic("file is closed"); + long int offset = 0; + int whence = SEEK_CUR; + if (argc >= 2) { + const uint8_t *whence_sym = janet_getkeyword(argv, 1); + if (!janet_cstrcmp(whence_sym, "cur")) { + whence = SEEK_CUR; + } else if (!janet_cstrcmp(whence_sym, "set")) { + whence = SEEK_SET; + } else if (!janet_cstrcmp(whence_sym, "end")) { + whence = SEEK_END; + } else { + janet_panicf("expected one of :cur, :set, :end, got %v", argv[1]); + } + if (argc == 3) { + offset = (long) janet_getinteger64(argv, 2); + } + } + if (fseek(iof->file, offset, whence)) janet_panic("error seeking file"); + return argv[0]; +} + +JANET_CORE_FN(cfun_io_ftell, + "(file/tell f)", + "Get the current value of the file position for file `f`.") { + janet_fixarity(argc, 1); + JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type); + if (iof->flags & JANET_FILE_CLOSED) + janet_panic("file is closed"); + long pos = ftell(iof->file); + if (pos == -1) janet_panic("error getting position in file"); + return janet_wrap_number((double)pos); +} + +static JanetMethod io_file_methods[] = { + {"close", cfun_io_fclose}, + {"flush", cfun_io_fflush}, + {"read", cfun_io_fread}, + {"seek", cfun_io_fseek}, + {"tell", cfun_io_ftell}, + {"write", cfun_io_fwrite}, + {NULL, NULL} +}; + +static int io_file_get(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) + return 0; + return janet_getmethod(janet_unwrap_keyword(key), io_file_methods, out); +} + +static Janet io_file_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(io_file_methods, key); +} + +static void io_file_marshal(void *p, JanetMarshalContext *ctx) { + JanetFile *iof = (JanetFile *)p; + if (ctx->flags & JANET_MARSHAL_UNSAFE) { + janet_marshal_abstract(ctx, p); +#ifdef JANET_WINDOWS + janet_marshal_int(ctx, _fileno(iof->file)); +#else + janet_marshal_int(ctx, fileno(iof->file)); +#endif + janet_marshal_int(ctx, iof->flags); + } else { + janet_panic("cannot marshal file in safe mode"); + } +} + +static void *io_file_unmarshal(JanetMarshalContext *ctx) { + if (ctx->flags & JANET_MARSHAL_UNSAFE) { + JanetFile *iof = janet_unmarshal_abstract(ctx, sizeof(JanetFile)); + int32_t fd = janet_unmarshal_int(ctx); + int32_t flags = janet_unmarshal_int(ctx); + char fmt[4] = {0}; + int index = 0; + if (flags & JANET_FILE_READ) fmt[index++] = 'r'; + if (flags & JANET_FILE_APPEND) { + fmt[index++] = 'a'; + } else if (flags & JANET_FILE_WRITE) { + fmt[index++] = 'w'; + } +#ifdef JANET_WINDOWS + iof->file = _fdopen(fd, fmt); +#else + iof->file = fdopen(fd, fmt); +#endif + if (iof->file == NULL) { + iof->flags = JANET_FILE_CLOSED; + } else { + iof->flags = flags; + } + return iof; + } else { + janet_panic("cannot unmarshal file in safe mode"); + } +} + +FILE *janet_dynfile(const char *name, FILE *def) { + Janet x = janet_dyn(name); + if (!janet_checktype(x, JANET_ABSTRACT)) return def; + void *abstract = janet_unwrap_abstract(x); + if (janet_abstract_type(abstract) != &janet_file_type) return def; + JanetFile *iofile = abstract; + return iofile->file; +} + +static Janet cfun_io_print_impl_x(int32_t argc, Janet *argv, int newline, + FILE *dflt_file, int32_t offset, Janet x) { + FILE *f; + switch (janet_type(x)) { + default: + janet_panicf("cannot print to %v", x); + case JANET_BUFFER: { + /* Special case buffer */ + JanetBuffer *buf = janet_unwrap_buffer(x); + for (int32_t i = offset; i < argc; ++i) { + janet_to_string_b(buf, argv[i]); + } + if (newline) + janet_buffer_push_u8(buf, '\n'); + return janet_wrap_nil(); + } + case JANET_FUNCTION: { + /* Special case function */ + JanetFunction *fun = janet_unwrap_function(x); + JanetBuffer *buf = janet_buffer(0); + for (int32_t i = offset; i < argc; ++i) { + janet_to_string_b(buf, argv[i]); + } + if (newline) + janet_buffer_push_u8(buf, '\n'); + Janet args[1] = { janet_wrap_buffer(buf) }; + janet_call(fun, 1, args); + return janet_wrap_nil(); + } + case JANET_NIL: + f = dflt_file; + if (f == NULL) janet_panic("cannot print to nil"); + break; + case JANET_ABSTRACT: { + void *abstract = janet_unwrap_abstract(x); + if (janet_abstract_type(abstract) != &janet_file_type) + return janet_wrap_nil(); + JanetFile *iofile = abstract; + io_assert_writeable(iofile); + f = iofile->file; + break; + } + } + for (int32_t i = offset; i < argc; ++i) { + int32_t len; + const uint8_t *vstr; + if (janet_checktype(argv[i], JANET_BUFFER)) { + JanetBuffer *b = janet_unwrap_buffer(argv[i]); + vstr = b->data; + len = b->count; + } else { + vstr = janet_to_string(argv[i]); + len = janet_string_length(vstr); + } + if (len) { + if (1 != fwrite(vstr, len, 1, f)) { + if (f == dflt_file) { + janet_panicf("cannot print %d bytes", len); + } else { + janet_panicf("cannot print %d bytes to %v", len, x); + } + } + } + } + if (newline) + putc('\n', f); + return janet_wrap_nil(); +} + +static Janet cfun_io_print_impl(int32_t argc, Janet *argv, + int newline, const char *name, FILE *dflt_file) { + Janet x = janet_dyn(name); + return cfun_io_print_impl_x(argc, argv, newline, dflt_file, 0, x); +} + +JANET_CORE_FN(cfun_io_print, + "(print & xs)", + "Print values to the console (standard out). Value are converted " + "to strings if they are not already. After printing all values, a " + "newline character is printed. Use the value of `(dyn :out stdout)` to determine " + "what to push characters to. Expects `(dyn :out stdout)` to be either a core/file or " + "a buffer. Returns nil.") { + return cfun_io_print_impl(argc, argv, 1, "out", stdout); +} + +JANET_CORE_FN(cfun_io_prin, + "(prin & xs)", + "Same as `print`, but does not add trailing newline.") { + return cfun_io_print_impl(argc, argv, 0, "out", stdout); +} + +JANET_CORE_FN(cfun_io_eprint, + "(eprint & xs)", + "Same as `print`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.") { + return cfun_io_print_impl(argc, argv, 1, "err", stderr); +} + +JANET_CORE_FN(cfun_io_eprin, + "(eprin & xs)", + "Same as `prin`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.") { + return cfun_io_print_impl(argc, argv, 0, "err", stderr); +} + +JANET_CORE_FN(cfun_io_xprint, + "(xprint to & xs)", + "Print to a file or other value explicitly (no dynamic bindings) with a trailing " + "newline character. The value to print " + "to is the first argument, and is otherwise the same as `print`. Returns nil.") { + janet_arity(argc, 1, -1); + return cfun_io_print_impl_x(argc, argv, 1, NULL, 1, argv[0]); +} + +JANET_CORE_FN(cfun_io_xprin, + "(xprin to & xs)", + "Print to a file or other value explicitly (no dynamic bindings). The value to print " + "to is the first argument, and is otherwise the same as `prin`. Returns nil.") { + janet_arity(argc, 1, -1); + return cfun_io_print_impl_x(argc, argv, 0, NULL, 1, argv[0]); +} + +static Janet cfun_io_printf_impl_x(int32_t argc, Janet *argv, int newline, + FILE *dflt_file, int32_t offset, Janet x) { + FILE *f; + const char *fmt = janet_getcstring(argv, offset); + switch (janet_type(x)) { + default: + janet_panicf("cannot print to %v", x); + case JANET_BUFFER: { + /* Special case buffer */ + JanetBuffer *buf = janet_unwrap_buffer(x); + janet_buffer_format(buf, fmt, offset, argc, argv); + if (newline) janet_buffer_push_u8(buf, '\n'); + return janet_wrap_nil(); + } + case JANET_FUNCTION: { + /* Special case function */ + JanetFunction *fun = janet_unwrap_function(x); + JanetBuffer *buf = janet_buffer(0); + janet_buffer_format(buf, fmt, offset, argc, argv); + if (newline) janet_buffer_push_u8(buf, '\n'); + Janet args[1] = { janet_wrap_buffer(buf) }; + janet_call(fun, 1, args); + return janet_wrap_nil(); + } + case JANET_NIL: + f = dflt_file; + if (f == NULL) janet_panic("cannot print to nil"); + break; + case JANET_ABSTRACT: { + void *abstract = janet_unwrap_abstract(x); + if (janet_abstract_type(abstract) != &janet_file_type) + return janet_wrap_nil(); + JanetFile *iofile = abstract; + if (iofile->flags & JANET_FILE_CLOSED) { + janet_panic("cannot print to closed file"); + } + io_assert_writeable(iofile); + f = iofile->file; + break; + } + } + JanetBuffer *buf = janet_buffer(10); + janet_buffer_format(buf, fmt, offset, argc, argv); + if (newline) janet_buffer_push_u8(buf, '\n'); + if (buf->count) { + if (1 != fwrite(buf->data, buf->count, 1, f)) { + janet_panicf("could not print %d bytes to file", buf->count); + } + } + /* Clear buffer to make things easier for GC */ + buf->count = 0; + buf->capacity = 0; + janet_free(buf->data); + buf->data = NULL; + return janet_wrap_nil(); +} + +static Janet cfun_io_printf_impl(int32_t argc, Janet *argv, int newline, + const char *name, FILE *dflt_file) { + janet_arity(argc, 1, -1); + Janet x = janet_dyn(name); + return cfun_io_printf_impl_x(argc, argv, newline, dflt_file, 0, x); + +} + +JANET_CORE_FN(cfun_io_printf, + "(printf fmt & xs)", + "Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :out stdout)` with a trailing newline.") { + return cfun_io_printf_impl(argc, argv, 1, "out", stdout); +} + +JANET_CORE_FN(cfun_io_prinf, + "(prinf fmt & xs)", + "Like `printf` but with no trailing newline.") { + return cfun_io_printf_impl(argc, argv, 0, "out", stdout); +} + +JANET_CORE_FN(cfun_io_eprintf, + "(eprintf fmt & xs)", + "Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :err stderr)` with a trailing newline.") { + return cfun_io_printf_impl(argc, argv, 1, "err", stderr); +} + +JANET_CORE_FN(cfun_io_eprinf, + "(eprinf fmt & xs)", + "Like `eprintf` but with no trailing newline.") { + return cfun_io_printf_impl(argc, argv, 0, "err", stderr); +} + +JANET_CORE_FN(cfun_io_xprintf, + "(xprintf to fmt & xs)", + "Like `printf` but prints to an explicit file or value `to`. Returns nil.") { + janet_arity(argc, 2, -1); + return cfun_io_printf_impl_x(argc, argv, 1, NULL, 1, argv[0]); +} + +JANET_CORE_FN(cfun_io_xprinf, + "(xprinf to fmt & xs)", + "Like `prinf` but prints to an explicit file or value `to`. Returns nil.") { + janet_arity(argc, 2, -1); + return cfun_io_printf_impl_x(argc, argv, 0, NULL, 1, argv[0]); +} + +static void janet_flusher(const char *name, FILE *dflt_file) { + Janet x = janet_dyn(name); + switch (janet_type(x)) { + default: + break; + case JANET_NIL: + fflush(dflt_file); + break; + case JANET_ABSTRACT: { + void *abstract = janet_unwrap_abstract(x); + if (janet_abstract_type(abstract) != &janet_file_type) break; + JanetFile *iofile = abstract; + fflush(iofile->file); + break; + } + } +} + +JANET_CORE_FN(cfun_io_flush, + "(flush)", + "Flush `(dyn :out stdout)` if it is a file, otherwise do nothing.") { + janet_fixarity(argc, 0); + (void) argv; + janet_flusher("out", stdout); + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_io_eflush, + "(eflush)", + "Flush `(dyn :err stderr)` if it is a file, otherwise do nothing.") { + janet_fixarity(argc, 0); + (void) argv; + janet_flusher("err", stderr); + return janet_wrap_nil(); +} + +void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...) { + va_list args; + va_start(args, format); + Janet x = janet_dyn(name); + JanetType xtype = janet_type(x); + switch (xtype) { + default: + /* Other values simply do nothing */ + break; + case JANET_NIL: + case JANET_ABSTRACT: { + FILE *f = dflt_file; + JanetBuffer buffer; + int32_t len = 0; + while (format[len]) len++; + janet_buffer_init(&buffer, len); + janet_formatbv(&buffer, format, args); + if (xtype == JANET_ABSTRACT) { + void *abstract = janet_unwrap_abstract(x); + if (janet_abstract_type(abstract) != &janet_file_type) + break; + JanetFile *iofile = abstract; + io_assert_writeable(iofile); + f = iofile->file; + } + fwrite(buffer.data, buffer.count, 1, f); + janet_buffer_deinit(&buffer); + break; + } + case JANET_FUNCTION: { + JanetFunction *fun = janet_unwrap_function(x); + int32_t len = 0; + while (format[len]) len++; + JanetBuffer *buf = janet_buffer(len); + janet_formatbv(buf, format, args); + Janet args[1] = { janet_wrap_buffer(buf) }; + janet_call(fun, 1, args); + break; + } + case JANET_BUFFER: + janet_formatbv(janet_unwrap_buffer(x), format, args); + break; + } + va_end(args); + return; +} + +/* C API */ + +JanetFile *janet_getjfile(const Janet *argv, int32_t n) { + return janet_getabstract(argv, n, &janet_file_type); +} + +FILE *janet_getfile(const Janet *argv, int32_t n, int32_t *flags) { + JanetFile *iof = janet_getabstract(argv, n, &janet_file_type); + if (NULL != flags) *flags = iof->flags; + return iof->file; +} + +JanetFile *janet_makejfile(FILE *f, int32_t flags) { + return makef(f, flags); +} + +Janet janet_makefile(FILE *f, int32_t flags) { + return janet_wrap_abstract(makef(f, flags)); +} + +JanetAbstract janet_checkfile(Janet j) { + return janet_checkabstract(j, &janet_file_type); +} + +FILE *janet_unwrapfile(Janet j, int32_t *flags) { + JanetFile *iof = janet_unwrap_abstract(j); + if (NULL != flags) *flags = iof->flags; + return iof->file; +} + +/* Module entry point */ +void janet_lib_io(JanetTable *env) { + JanetRegExt io_cfuns[] = { + JANET_CORE_REG("print", cfun_io_print), + JANET_CORE_REG("prin", cfun_io_prin), + JANET_CORE_REG("printf", cfun_io_printf), + JANET_CORE_REG("prinf", cfun_io_prinf), + JANET_CORE_REG("eprin", cfun_io_eprin), + JANET_CORE_REG("eprint", cfun_io_eprint), + JANET_CORE_REG("eprintf", cfun_io_eprintf), + JANET_CORE_REG("eprinf", cfun_io_eprinf), + JANET_CORE_REG("xprint", cfun_io_xprint), + JANET_CORE_REG("xprin", cfun_io_xprin), + JANET_CORE_REG("xprintf", cfun_io_xprintf), + JANET_CORE_REG("xprinf", cfun_io_xprinf), + JANET_CORE_REG("flush", cfun_io_flush), + JANET_CORE_REG("eflush", cfun_io_eflush), + JANET_CORE_REG("file/temp", cfun_io_temp), + JANET_CORE_REG("file/open", cfun_io_fopen), + JANET_CORE_REG("file/close", cfun_io_fclose), + JANET_CORE_REG("file/read", cfun_io_fread), + JANET_CORE_REG("file/write", cfun_io_fwrite), + JANET_CORE_REG("file/flush", cfun_io_fflush), + JANET_CORE_REG("file/seek", cfun_io_fseek), + JANET_CORE_REG("file/tell", cfun_io_ftell), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, io_cfuns); + janet_register_abstract_type(&janet_file_type); + int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; + /* stdout */ + JANET_CORE_DEF(env, "stdout", + janet_makefile(stdout, JANET_FILE_APPEND | default_flags), + "The standard output file."); + /* stderr */ + JANET_CORE_DEF(env, "stderr", + janet_makefile(stderr, JANET_FILE_APPEND | default_flags), + "The standard error file."); + /* stdin */ + JANET_CORE_DEF(env, "stdin", + janet_makefile(stdin, JANET_FILE_READ | default_flags), + "The standard input file."); + +} + + +/* src/core/marsh.c */ +#line 0 "src/core/marsh.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "vector.h" +#include "gc.h" +#include "fiber.h" +#include "util.h" +#endif + +typedef struct { + JanetBuffer *buf; + JanetTable seen; + JanetTable *rreg; + JanetFuncEnv **seen_envs; + JanetFuncDef **seen_defs; + int32_t nextid; + int maybe_cycles; +} MarshalState; + +/* Lead bytes in marshaling protocol */ +enum { + LB_REAL = 200, + LB_NIL, /* 201 */ + LB_FALSE, /* 202 */ + LB_TRUE, /* 203 */ + LB_FIBER, /* 204 */ + LB_INTEGER, /* 205 */ + LB_STRING, /* 206 */ + LB_SYMBOL, /* 207 */ + LB_KEYWORD, /* 208 */ + LB_ARRAY, /* 209 */ + LB_TUPLE, /* 210 */ + LB_TABLE, /* 211 */ + LB_TABLE_PROTO, /* 212 */ + LB_STRUCT, /* 213 */ + LB_BUFFER, /* 214 */ + LB_FUNCTION, /* 215 */ + LB_REGISTRY, /* 216 */ + LB_ABSTRACT, /* 217 */ + LB_REFERENCE, /* 218 */ + LB_FUNCENV_REF, /* 219 */ + LB_FUNCDEF_REF, /* 220 */ + LB_UNSAFE_CFUNCTION, /* 221 */ + LB_UNSAFE_POINTER, /* 222 */ + LB_STRUCT_PROTO, /* 223 */ +#ifdef JANET_EV + LB_THREADED_ABSTRACT, /* 224 */ + LB_POINTER_BUFFER, /* 224 */ +#endif +} LeadBytes; + +/* Helper to look inside an entry in an environment */ +static Janet entry_getval(Janet env_entry) { + if (janet_checktype(env_entry, JANET_TABLE)) { + JanetTable *entry = janet_unwrap_table(env_entry); + Janet checkval = janet_table_get(entry, janet_ckeywordv("value")); + if (janet_checktype(checkval, JANET_NIL)) { + checkval = janet_table_get(entry, janet_ckeywordv("ref")); + } + return checkval; + } else if (janet_checktype(env_entry, JANET_STRUCT)) { + const JanetKV *entry = janet_unwrap_struct(env_entry); + Janet checkval = janet_struct_get(entry, janet_ckeywordv("value")); + if (janet_checktype(checkval, JANET_NIL)) { + checkval = janet_struct_get(entry, janet_ckeywordv("ref")); + } + return checkval; + } else { + return janet_wrap_nil(); + } +} + +/* Merge values from an environment into an existing lookup table. */ +void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) { + while (env) { + for (int32_t i = 0; i < env->capacity; i++) { + if (janet_checktype(env->data[i].key, JANET_SYMBOL)) { + if (prefix) { + int32_t prelen = (int32_t) strlen(prefix); + const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key); + int32_t oldlen = janet_string_length(oldsym); + uint8_t *symbuf = janet_smalloc(prelen + oldlen); + safe_memcpy(symbuf, prefix, prelen); + safe_memcpy(symbuf + prelen, oldsym, oldlen); + Janet s = janet_symbolv(symbuf, prelen + oldlen); + janet_sfree(symbuf); + janet_table_put(renv, s, entry_getval(env->data[i].value)); + } else { + janet_table_put(renv, + env->data[i].key, + entry_getval(env->data[i].value)); + } + } + } + env = recurse ? env->proto : NULL; + } +} + +/* Make a forward lookup table from an environment (for unmarshaling) */ +JanetTable *janet_env_lookup(JanetTable *env) { + JanetTable *renv = janet_table(env->count); + janet_env_lookup_into(renv, env, NULL, 1); + return renv; +} + +/* Marshal an integer onto the buffer */ +static void pushint(MarshalState *st, int32_t x) { + if (x >= 0 && x < 128) { + janet_buffer_push_u8(st->buf, x); + } else if (x <= 8191 && x >= -8192) { + uint8_t intbuf[2]; + intbuf[0] = ((x >> 8) & 0x3F) | 0x80; + intbuf[1] = x & 0xFF; + janet_buffer_push_bytes(st->buf, intbuf, 2); + } else { + uint8_t intbuf[5]; + intbuf[0] = LB_INTEGER; + intbuf[1] = (x >> 24) & 0xFF; + intbuf[2] = (x >> 16) & 0xFF; + intbuf[3] = (x >> 8) & 0xFF; + intbuf[4] = x & 0xFF; + janet_buffer_push_bytes(st->buf, intbuf, 5); + } +} + +static void pushbyte(MarshalState *st, uint8_t b) { + janet_buffer_push_u8(st->buf, b); +} + +static void pushbytes(MarshalState *st, const uint8_t *bytes, int32_t len) { + janet_buffer_push_bytes(st->buf, bytes, len); +} + +static void pushpointer(MarshalState *st, const void *ptr) { + janet_buffer_push_bytes(st->buf, (const uint8_t *) &ptr, sizeof(ptr)); +} + +/* Marshal a size_t onto the buffer */ +static void push64(MarshalState *st, uint64_t x) { + if (x <= 0xF0) { + /* Single byte */ + pushbyte(st, (uint8_t) x); + } else { + /* Multibyte, little endian */ + uint8_t bytes[9]; + int nbytes = 0; + while (x) { + bytes[++nbytes] = x & 0xFF; + x >>= 8; + } + bytes[0] = 0xF0 + nbytes; + pushbytes(st, bytes, nbytes + 1); + } +} + +/* Forward declaration to enable mutual recursion. */ +static void marshal_one(MarshalState *st, Janet x, int flags); +static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags); +static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags); +static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags); + +/* Prevent stack overflows */ +#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") + +/* Quick check if a fiber cannot be marshalled. This is will + * have no false positives, but may have false negatives. */ +static int fiber_cannot_be_marshalled(JanetFiber *fiber) { + if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) return 1; + int32_t i = fiber->frame; + while (i > 0) { + JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + if (!frame->func) return 1; /* has cfunction on stack */ + i = frame->prevframe; + } + return 0; +} + +/* Marshal a function env */ +static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags) { + MARSH_STACKCHECK; + for (int32_t i = 0; i < janet_v_count(st->seen_envs); i++) { + if (st->seen_envs[i] == env) { + pushbyte(st, LB_FUNCENV_REF); + pushint(st, i); + return; + } + } + janet_env_valid(env); + janet_v_push(st->seen_envs, env); + + /* Special case for early detachment */ + if (env->offset > 0 && fiber_cannot_be_marshalled(env->as.fiber)) { + pushint(st, 0); + pushint(st, env->length); + Janet *values = env->as.fiber->data + env->offset; + uint32_t *bitset = janet_stack_frame(values)->func->def->closure_bitset; + for (int32_t i = 0; i < env->length; i++) { + if (1 & (bitset[i >> 5] >> (i & 0x1F))) { + marshal_one(st, values[i], flags + 1); + } else { + pushbyte(st, LB_NIL); + } + } + } else { + janet_env_maybe_detach(env); + pushint(st, env->offset); + pushint(st, env->length); + if (env->offset > 0) { + /* On stack variant */ + marshal_one(st, janet_wrap_fiber(env->as.fiber), flags + 1); + } else { + /* Off stack variant */ + for (int32_t i = 0; i < env->length; i++) + marshal_one(st, env->as.values[i], flags + 1); + } + } +} + +/* Marshal a sequence of u32s */ +static void janet_marshal_u32s(MarshalState *st, const uint32_t *u32s, int32_t n) { + for (int32_t i = 0; i < n; i++) { + pushbyte(st, u32s[i] & 0xFF); + pushbyte(st, (u32s[i] >> 8) & 0xFF); + pushbyte(st, (u32s[i] >> 16) & 0xFF); + pushbyte(st, (u32s[i] >> 24) & 0xFF); + } +} + +/* Marshal a function def */ +static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) { + MARSH_STACKCHECK; + for (int32_t i = 0; i < janet_v_count(st->seen_defs); i++) { + if (st->seen_defs[i] == def) { + pushbyte(st, LB_FUNCDEF_REF); + pushint(st, i); + return; + } + } + /* Add to lookup */ + janet_v_push(st->seen_defs, def); + + pushint(st, def->flags); + pushint(st, def->slotcount); + pushint(st, def->arity); + pushint(st, def->min_arity); + pushint(st, def->max_arity); + pushint(st, def->constants_length); + pushint(st, def->bytecode_length); + if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) + pushint(st, def->environments_length); + if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) + pushint(st, def->defs_length); + if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) + pushint(st, def->symbolmap_length); + if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) + marshal_one(st, janet_wrap_string(def->name), flags); + if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) + marshal_one(st, janet_wrap_string(def->source), flags); + + /* marshal constants */ + for (int32_t i = 0; i < def->constants_length; i++) + marshal_one(st, def->constants[i], flags + 1); + + /* Marshal symbol map, if needed */ + for (int32_t i = 0; i < def->symbolmap_length; i++) { + pushint(st, (int32_t) def->symbolmap[i].birth_pc); + pushint(st, (int32_t) def->symbolmap[i].death_pc); + pushint(st, (int32_t) def->symbolmap[i].slot_index); + marshal_one(st, janet_wrap_symbol(def->symbolmap[i].symbol), flags + 1); + } + + /* marshal the bytecode */ + janet_marshal_u32s(st, def->bytecode, def->bytecode_length); + + /* marshal the environments if needed */ + for (int32_t i = 0; i < def->environments_length; i++) + pushint(st, def->environments[i]); + + /* marshal the sub funcdefs if needed */ + for (int32_t i = 0; i < def->defs_length; i++) + marshal_one_def(st, def->defs[i], flags + 1); + + /* marshal source maps if needed */ + if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { + int32_t current = 0; + for (int32_t i = 0; i < def->bytecode_length; i++) { + JanetSourceMapping map = def->sourcemap[i]; + pushint(st, map.line - current); + pushint(st, map.column); + current = map.line; + } + } + + /* Marshal closure bitset, if needed */ + if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { + janet_marshal_u32s(st, def->closure_bitset, ((def->slotcount + 31) >> 5)); + } +} + +#define JANET_FIBER_FLAG_HASCHILD (1 << 29) +#define JANET_FIBER_FLAG_HASENV (1 << 30) +#define JANET_STACKFRAME_HASENV (INT32_MIN) + +/* Marshal a fiber */ +static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) { + MARSH_STACKCHECK; + int32_t fflags = fiber->flags; + if (fiber->child) fflags |= JANET_FIBER_FLAG_HASCHILD; + if (fiber->env) fflags |= JANET_FIBER_FLAG_HASENV; + if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) + janet_panic("cannot marshal alive fiber"); + pushint(st, fflags); + pushint(st, fiber->frame); + pushint(st, fiber->stackstart); + pushint(st, fiber->stacktop); + pushint(st, fiber->maxstack); + /* Do frames */ + int32_t i = fiber->frame; + int32_t j = fiber->stackstart - JANET_FRAME_SIZE; + while (i > 0) { + JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); + if (frame->env) frame->flags |= JANET_STACKFRAME_HASENV; + if (!frame->func) janet_panicf("cannot marshal fiber with c stackframe (%v)", janet_wrap_cfunction((JanetCFunction) frame->pc)); + pushint(st, frame->flags); + pushint(st, frame->prevframe); + int32_t pcdiff = (int32_t)(frame->pc - frame->func->def->bytecode); + pushint(st, pcdiff); + marshal_one(st, janet_wrap_function(frame->func), flags + 1); + if (frame->env) marshal_one_env(st, frame->env, flags + 1); + /* Marshal all values in the stack frame */ + for (int32_t k = i; k < j; k++) + marshal_one(st, fiber->data[k], flags + 1); + j = i - JANET_FRAME_SIZE; + i = frame->prevframe; + } + if (fiber->env) { + marshal_one(st, janet_wrap_table(fiber->env), flags + 1); + } + if (fiber->child) + marshal_one(st, janet_wrap_fiber(fiber->child), flags + 1); + marshal_one(st, fiber->last_value, flags + 1); +} + +void janet_marshal_size(JanetMarshalContext *ctx, size_t value) { + janet_marshal_int64(ctx, (int64_t) value); +} + +void janet_marshal_int64(JanetMarshalContext *ctx, int64_t value) { + MarshalState *st = (MarshalState *)(ctx->m_state); + push64(st, (uint64_t) value); +} + +void janet_marshal_int(JanetMarshalContext *ctx, int32_t value) { + MarshalState *st = (MarshalState *)(ctx->m_state); + pushint(st, value); +} + +/* Only use in unsafe - don't marshal pointers otherwise */ +void janet_marshal_ptr(JanetMarshalContext *ctx, const void *ptr) { + if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) { + janet_panic("can only marshal pointers in unsafe mode"); + } + MarshalState *st = (MarshalState *)(ctx->m_state); + pushpointer(st, ptr); +} + +void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value) { + MarshalState *st = (MarshalState *)(ctx->m_state); + pushbyte(st, value); +} + +void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, size_t len) { + MarshalState *st = (MarshalState *)(ctx->m_state); + if (len > INT32_MAX) janet_panic("size_t too large to fit in buffer"); + pushbytes(st, bytes, (int32_t) len); +} + +void janet_marshal_janet(JanetMarshalContext *ctx, Janet x) { + MarshalState *st = (MarshalState *)(ctx->m_state); + marshal_one(st, x, ctx->flags + 1); +} + +#ifdef JANET_MARSHAL_DEBUG +#define MARK_SEEN() \ + do { if (st->maybe_cycles) { \ + Janet _check = janet_table_get(&st->seen, x); \ + if (!janet_checktype(_check, JANET_NIL)) janet_eprintf("double MARK_SEEN on %v\n", x); \ + janet_eprintf("made reference %d (%t) to %v\n", st->nextid, x, x); \ + janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)); \ + } } while (0) +#else +#define MARK_SEEN() \ + do { if (st->maybe_cycles) { \ + janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)); \ + } } while (0) +#endif + +void janet_marshal_abstract(JanetMarshalContext *ctx, void *abstract) { + MarshalState *st = (MarshalState *)(ctx->m_state); + Janet x = janet_wrap_abstract(abstract); + MARK_SEEN(); +} + +static void marshal_one_abstract(MarshalState *st, Janet x, int flags) { + void *abstract = janet_unwrap_abstract(x); +#ifdef JANET_EV + /* Threaded abstract types get passed through as pointers in the unsafe mode */ + if ((flags & JANET_MARSHAL_UNSAFE) && + (JANET_MEMORY_THREADED_ABSTRACT == (janet_abstract_head(abstract)->gc.flags & JANET_MEM_TYPEBITS))) { + + /* Increment refcount before sending message. This prevents a "death in transit" problem + * where a message is garbage collected while in transit between two threads - i.e., the sending threads + * loses the reference and runs a garbage collection before the receiving thread gets the message. */ + janet_abstract_incref(abstract); + pushbyte(st, LB_THREADED_ABSTRACT); + pushbytes(st, (uint8_t *) &abstract, sizeof(abstract)); + MARK_SEEN(); + return; + } +#endif + const JanetAbstractType *at = janet_abstract_type(abstract); + if (at->marshal) { + pushbyte(st, LB_ABSTRACT); + marshal_one(st, janet_csymbolv(at->name), flags + 1); + JanetMarshalContext context = {st, NULL, flags + 1, NULL, at}; + at->marshal(abstract, &context); + } else { + janet_panicf("cannot marshal %p", x); + } +} + +/* The main body of the marshaling function. Is the main + * entry point for the mutually recursive functions. */ +static void marshal_one(MarshalState *st, Janet x, int flags) { + MARSH_STACKCHECK; + JanetType type = janet_type(x); + + /* Check simple primitives (non reference types, no benefit from memoization) */ + switch (type) { + default: + break; + case JANET_NIL: + pushbyte(st, LB_NIL); + return; + case JANET_BOOLEAN: + pushbyte(st, janet_unwrap_boolean(x) ? LB_TRUE : LB_FALSE); + return; + case JANET_NUMBER: { + double xval = janet_unwrap_number(x); + if (janet_checkintrange(xval)) { + pushint(st, (int32_t) xval); + return; + } + break; + } + } + + /* Check reference and registry value */ + { + Janet check; + if (st->maybe_cycles) { + check = janet_table_get(&st->seen, x); + if (janet_checkint(check)) { + pushbyte(st, LB_REFERENCE); + pushint(st, janet_unwrap_integer(check)); + return; + } + } + if (st->rreg) { + check = janet_table_get(st->rreg, x); + if (janet_checktype(check, JANET_SYMBOL)) { + MARK_SEEN(); + const uint8_t *regname = janet_unwrap_symbol(check); + pushbyte(st, LB_REGISTRY); + pushint(st, janet_string_length(regname)); + pushbytes(st, regname, janet_string_length(regname)); + return; + } + } + } + + /* Reference types */ + switch (type) { + case JANET_NUMBER: { + union { + double d; + uint8_t bytes[8]; + } u; + u.d = janet_unwrap_number(x); +#ifdef JANET_BIG_ENDIAN + /* Swap byte order */ + uint8_t temp; + temp = u.bytes[7]; + u.bytes[7] = u.bytes[0]; + u.bytes[0] = temp; + temp = u.bytes[6]; + u.bytes[6] = u.bytes[1]; + u.bytes[1] = temp; + temp = u.bytes[5]; + u.bytes[5] = u.bytes[2]; + u.bytes[2] = temp; + temp = u.bytes[4]; + u.bytes[4] = u.bytes[3]; + u.bytes[3] = temp; +#endif + pushbyte(st, LB_REAL); + pushbytes(st, u.bytes, 8); + MARK_SEEN(); + return; + } + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: { + const uint8_t *str = janet_unwrap_string(x); + int32_t length = janet_string_length(str); + /* Record reference */ + MARK_SEEN(); + uint8_t lb = (type == JANET_STRING) ? LB_STRING : + (type == JANET_SYMBOL) ? LB_SYMBOL : + LB_KEYWORD; + pushbyte(st, lb); + pushint(st, length); + pushbytes(st, str, length); + return; + } + case JANET_BUFFER: { + JanetBuffer *buffer = janet_unwrap_buffer(x); + /* Record reference */ + MARK_SEEN(); +#ifdef JANET_EV + if ((flags & JANET_MARSHAL_UNSAFE) && + (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { + pushbyte(st, LB_POINTER_BUFFER); + pushint(st, buffer->count); + pushint(st, buffer->capacity); + pushpointer(st, buffer->data); + return; + } +#endif + pushbyte(st, LB_BUFFER); + pushint(st, buffer->count); + pushbytes(st, buffer->data, buffer->count); + return; + } + case JANET_ARRAY: { + int32_t i; + JanetArray *a = janet_unwrap_array(x); + MARK_SEEN(); + pushbyte(st, LB_ARRAY); + pushint(st, a->count); + for (i = 0; i < a->count; i++) + marshal_one(st, a->data[i], flags + 1); + return; + } + case JANET_TUPLE: { + int32_t i, count, flag; + const Janet *tup = janet_unwrap_tuple(x); + count = janet_tuple_length(tup); + flag = janet_tuple_flag(tup) >> 16; + pushbyte(st, LB_TUPLE); + pushint(st, count); + pushint(st, flag); + for (i = 0; i < count; i++) + marshal_one(st, tup[i], flags + 1); + /* Mark as seen AFTER marshaling */ + MARK_SEEN(); + return; + } + case JANET_TABLE: { + JanetTable *t = janet_unwrap_table(x); + MARK_SEEN(); + pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE); + pushint(st, t->count); + if (t->proto) + marshal_one(st, janet_wrap_table(t->proto), flags + 1); + for (int32_t i = 0; i < t->capacity; i++) { + if (janet_checktype(t->data[i].key, JANET_NIL)) + continue; + marshal_one(st, t->data[i].key, flags + 1); + marshal_one(st, t->data[i].value, flags + 1); + } + return; + } + case JANET_STRUCT: { + int32_t count; + const JanetKV *struct_ = janet_unwrap_struct(x); + count = janet_struct_length(struct_); + pushbyte(st, janet_struct_proto(struct_) ? LB_STRUCT_PROTO : LB_STRUCT); + pushint(st, count); + if (janet_struct_proto(struct_)) + marshal_one(st, janet_wrap_struct(janet_struct_proto(struct_)), flags + 1); + for (int32_t i = 0; i < janet_struct_capacity(struct_); i++) { + if (janet_checktype(struct_[i].key, JANET_NIL)) + continue; + marshal_one(st, struct_[i].key, flags + 1); + marshal_one(st, struct_[i].value, flags + 1); + } + /* Mark as seen AFTER marshaling */ + MARK_SEEN(); + return; + } + case JANET_ABSTRACT: { + marshal_one_abstract(st, x, flags); + return; + } + case JANET_FUNCTION: { + pushbyte(st, LB_FUNCTION); + JanetFunction *func = janet_unwrap_function(x); + pushint(st, func->def->environments_length); + /* Mark seen before reading def */ + MARK_SEEN(); + marshal_one_def(st, func->def, flags); + for (int32_t i = 0; i < func->def->environments_length; i++) + marshal_one_env(st, func->envs[i], flags + 1); + return; + } + case JANET_FIBER: { + MARK_SEEN(); + pushbyte(st, LB_FIBER); + marshal_one_fiber(st, janet_unwrap_fiber(x), flags + 1); + return; + } + case JANET_CFUNCTION: { + if (!(flags & JANET_MARSHAL_UNSAFE)) goto no_registry; + MARK_SEEN(); + pushbyte(st, LB_UNSAFE_CFUNCTION); + JanetCFunction cfn = janet_unwrap_cfunction(x); + pushbytes(st, (uint8_t *) &cfn, sizeof(JanetCFunction)); + return; + } + case JANET_POINTER: { + if (!(flags & JANET_MARSHAL_UNSAFE)) goto no_registry; + MARK_SEEN(); + pushbyte(st, LB_UNSAFE_POINTER); + pushpointer(st, janet_unwrap_pointer(x)); + return; + } + no_registry: + default: { + janet_panicf("no registry value and cannot marshal %p", x); + } + } +#undef MARK_SEEN +} + +void janet_marshal( + JanetBuffer *buf, + Janet x, + JanetTable *rreg, + int flags) { + MarshalState st; + st.buf = buf; + st.nextid = 0; + st.seen_defs = NULL; + st.seen_envs = NULL; + st.rreg = rreg; + st.maybe_cycles = !(flags & JANET_MARSHAL_NO_CYCLES); + janet_table_init(&st.seen, 0); + marshal_one(&st, x, flags); + janet_table_deinit(&st.seen); + janet_v_free(st.seen_envs); + janet_v_free(st.seen_defs); +} + +typedef struct { + jmp_buf err; + Janet *lookup; + JanetTable *reg; + JanetFuncEnv **lookup_envs; + JanetFuncDef **lookup_defs; + const uint8_t *start; + const uint8_t *end; +} UnmarshalState; + +#define MARSH_EOS(st, data) do { \ + if ((data) >= (st)->end) janet_panic("unexpected end of source");\ +} while (0) + +/* Helper to read a 32 bit integer from an unmarshal state */ +static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { + const uint8_t *data = *atdata; + int32_t ret; + MARSH_EOS(st, data); + if (*data < 128) { + ret = *data++; + } else if (*data < 192) { + MARSH_EOS(st, data + 1); + uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; + /* Sign extend 18 MSBs */ + uret |= (uret >> 13) ? 0xFFFFC000 : 0; + ret = (int32_t)uret; + data += 2; + } else if (*data == LB_INTEGER) { + MARSH_EOS(st, data + 4); + uint32_t ui = ((uint32_t)(data[1]) << 24) | + ((uint32_t)(data[2]) << 16) | + ((uint32_t)(data[3]) << 8) | + (uint32_t)(data[4]); + ret = (int32_t)ui; + data += 5; + } else { + janet_panicf("expected integer, got byte %x at index %d", + *data, + data - st->start); + ret = 0; + } + *atdata = data; + return ret; +} + +/* Helper to read a natural number (int >= 0). */ +static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { + int32_t ret = readint(st, atdata); + if (ret < 0) { + janet_panicf("expected integer >= 0, got %d", ret); + } + return ret; +} + +/* Helper to read a size_t (up to 8 bytes unsigned). */ +static uint64_t read64(UnmarshalState *st, const uint8_t **atdata) { + uint64_t ret; + const uint8_t *data = *atdata; + MARSH_EOS(st, data); + if (*data <= 0xF0) { + /* Single byte */ + ret = *data; + *atdata = data + 1; + } else { + /* Multibyte, little endian */ + int nbytes = *data - 0xF0; + ret = 0; + if (nbytes > 8) janet_panic("invalid 64 bit integer"); + MARSH_EOS(st, data + nbytes); + for (int i = nbytes; i > 0; i--) + ret = (ret << 8) + data[i]; + *atdata = data + nbytes + 1; + } + return ret; +} + +#ifdef JANET_MARSHAL_DEBUG +static void dump_reference_table(UnmarshalState *st) { + for (int32_t i = 0; i < janet_v_count(st->lookup); i++) { + janet_eprintf(" reference %d (%t) = %v\n", i, st->lookup[i], st->lookup[i]); + } +} +#endif + +/* Assert a janet type */ +static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { + if (!janet_checktype(x, t)) { +#ifdef JANET_MARSHAL_DEBUG + dump_reference_table(st); +#else + (void) st; +#endif + janet_panicf("expected type %T, got %v", 1 << t, x); + } +} + +/* Forward declarations for mutual recursion */ +static const uint8_t *unmarshal_one( + UnmarshalState *st, + const uint8_t *data, + Janet *out, + int flags); +static const uint8_t *unmarshal_one_env( + UnmarshalState *st, + const uint8_t *data, + JanetFuncEnv **out, + int flags); +static const uint8_t *unmarshal_one_def( + UnmarshalState *st, + const uint8_t *data, + JanetFuncDef **out, + int flags); +static const uint8_t *unmarshal_one_fiber( + UnmarshalState *st, + const uint8_t *data, + JanetFiber **out, + int flags); + +/* Unmarshal a funcenv */ +static const uint8_t *unmarshal_one_env( + UnmarshalState *st, + const uint8_t *data, + JanetFuncEnv **out, + int flags) { + MARSH_EOS(st, data); + if (*data == LB_FUNCENV_REF) { + data++; + int32_t index = readint(st, &data); + if (index < 0 || index >= janet_v_count(st->lookup_envs)) + janet_panicf("invalid funcenv reference %d", index); + *out = st->lookup_envs[index]; + } else { + JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); + env->length = 0; + env->offset = 0; + env->as.values = NULL; + janet_v_push(st->lookup_envs, env); + int32_t offset = readnat(st, &data); + int32_t length = readnat(st, &data); + if (offset > 0) { + Janet fiberv; + /* On stack variant */ + data = unmarshal_one(st, data, &fiberv, flags); + janet_asserttype(fiberv, JANET_FIBER, st); + env->as.fiber = janet_unwrap_fiber(fiberv); + /* Negative offset indicates untrusted input */ + env->offset = -offset; + } else { + /* Off stack variant */ + if (length == 0) { + janet_panic("invalid funcenv length"); + } + env->as.values = janet_malloc(sizeof(Janet) * (size_t) length); + if (!env->as.values) { + JANET_OUT_OF_MEMORY; + } + env->offset = 0; + for (int32_t i = 0; i < length; i++) + data = unmarshal_one(st, data, env->as.values + i, flags); + } + env->length = length; + *out = env; + } + return data; +} + +/* Unmarshal a series of u32s */ +static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { + for (int32_t i = 0; i < n; i++) { + MARSH_EOS(st, data + 3); + into[i] = + (uint32_t)(data[0]) | + ((uint32_t)(data[1]) << 8) | + ((uint32_t)(data[2]) << 16) | + ((uint32_t)(data[3]) << 24); + data += 4; + } + return data; +} + +/* Unmarshal a funcdef */ +static const uint8_t *unmarshal_one_def( + UnmarshalState *st, + const uint8_t *data, + JanetFuncDef **out, + int flags) { + MARSH_EOS(st, data); + if (*data == LB_FUNCDEF_REF) { + data++; + int32_t index = readint(st, &data); + if (index < 0 || index >= janet_v_count(st->lookup_defs)) + janet_panicf("invalid funcdef reference %d", index); + *out = st->lookup_defs[index]; + } else { + /* Initialize with values that will not break garbage collection + * if unmarshalling fails. */ + JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); + def->environments_length = 0; + def->defs_length = 0; + def->constants_length = 0; + def->bytecode_length = 0; + def->name = NULL; + def->source = NULL; + def->closure_bitset = NULL; + def->defs = NULL; + def->environments = NULL; + def->constants = NULL; + def->bytecode = NULL; + def->sourcemap = NULL; + def->symbolmap = NULL; + def->symbolmap_length = 0; + janet_v_push(st->lookup_defs, def); + + /* Set default lengths to zero */ + int32_t bytecode_length = 0; + int32_t constants_length = 0; + int32_t environments_length = 0; + int32_t defs_length = 0; + int32_t symbolmap_length = 0; + + /* Read flags and other fixed values */ + def->flags = readint(st, &data); + def->slotcount = readnat(st, &data); + def->arity = readnat(st, &data); + def->min_arity = readnat(st, &data); + def->max_arity = readnat(st, &data); + + /* Read some lengths */ + constants_length = readnat(st, &data); + bytecode_length = readnat(st, &data); + if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) + environments_length = readnat(st, &data); + if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) + defs_length = readnat(st, &data); + if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) + symbolmap_length = readnat(st, &data); + + /* Check name and source (optional) */ + if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { + Janet x; + data = unmarshal_one(st, data, &x, flags + 1); + janet_asserttype(x, JANET_STRING, st); + def->name = janet_unwrap_string(x); + } + if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { + Janet x; + data = unmarshal_one(st, data, &x, flags + 1); + janet_asserttype(x, JANET_STRING, st); + def->source = janet_unwrap_string(x); + } + + /* Unmarshal constants */ + if (constants_length) { + def->constants = janet_malloc(sizeof(Janet) * constants_length); + if (!def->constants) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < constants_length; i++) + data = unmarshal_one(st, data, def->constants + i, flags + 1); + } else { + def->constants = NULL; + } + def->constants_length = constants_length; + + /* Unmarshal symbol map, if needed */ + if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { + size_t size = sizeof(JanetSymbolMap) * symbolmap_length; + def->symbolmap = janet_malloc(size); + if (def->symbolmap == NULL) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < symbolmap_length; i++) { + def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); + def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); + def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); + Janet value; + data = unmarshal_one(st, data, &value, flags + 1); + if (!janet_checktype(value, JANET_SYMBOL)) { + janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); + } + def->symbolmap[i].symbol = janet_unwrap_symbol(value); + } + def->symbolmap_length = (uint32_t) symbolmap_length; + } + + /* Unmarshal bytecode */ + def->bytecode = janet_malloc(sizeof(uint32_t) * bytecode_length); + if (!def->bytecode) { + JANET_OUT_OF_MEMORY; + } + data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); + def->bytecode_length = bytecode_length; + + /* Unmarshal environments */ + if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { + def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); + if (!def->environments) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < environments_length; i++) { + def->environments[i] = readint(st, &data); + } + } else { + def->environments = NULL; + } + def->environments_length = environments_length; + + /* Unmarshal sub funcdefs */ + if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { + def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); + if (!def->defs) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < defs_length; i++) { + data = unmarshal_one_def(st, data, def->defs + i, flags + 1); + } + } else { + def->defs = NULL; + } + def->defs_length = defs_length; + + /* Unmarshal source maps if needed */ + if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { + int32_t current = 0; + def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) bytecode_length); + if (!def->sourcemap) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < bytecode_length; i++) { + current += readint(st, &data); + def->sourcemap[i].line = current; + def->sourcemap[i].column = readint(st, &data); + } + } else { + def->sourcemap = NULL; + } + + /* Unmarshal closure bitset if needed */ + if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { + int32_t n = (def->slotcount + 31) >> 5; + def->closure_bitset = janet_malloc(sizeof(uint32_t) * (size_t) n); + if (NULL == def->closure_bitset) { + JANET_OUT_OF_MEMORY; + } + data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); + } + + /* Validate */ + if (janet_verify(def)) + janet_panic("funcdef has invalid bytecode"); + + /* Set def */ + *out = def; + } + return data; +} + +/* Unmarshal a fiber */ +static const uint8_t *unmarshal_one_fiber( + UnmarshalState *st, + const uint8_t *data, + JanetFiber **out, + int flags) { + + /* Initialize a new fiber with gc friendly defaults */ + JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); + fiber->flags = 0; + fiber->frame = 0; + fiber->stackstart = 0; + fiber->stacktop = 0; + fiber->capacity = 0; + fiber->maxstack = 0; + fiber->data = NULL; + fiber->child = NULL; + fiber->env = NULL; + fiber->last_value = janet_wrap_nil(); +#ifdef JANET_EV + fiber->sched_id = 0; + fiber->supervisor_channel = NULL; + fiber->ev_state = NULL; + fiber->ev_callback = NULL; + fiber->ev_stream = NULL; +#endif + + /* Push fiber to seen stack */ + janet_v_push(st->lookup, janet_wrap_fiber(fiber)); + + /* Read ints */ + int32_t fiber_flags = readint(st, &data); + int32_t frame = readnat(st, &data); + int32_t fiber_stackstart = readnat(st, &data); + int32_t fiber_stacktop = readnat(st, &data); + int32_t fiber_maxstack = readnat(st, &data); + JanetTable *fiber_env = NULL; + + /* Check for bad flags and ints */ + if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart || + fiber_stackstart > fiber_stacktop || + fiber_stacktop > fiber_maxstack) { + janet_panic("fiber has incorrect stack setup"); + } + + /* Allocate stack memory */ + fiber->capacity = fiber_stacktop + 10; + fiber->data = janet_malloc(sizeof(Janet) * fiber->capacity); + if (!fiber->data) { + JANET_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < fiber->capacity; i++) { + fiber->data[i] = janet_wrap_nil(); + } + + /* get frames */ + int32_t stack = frame; + int32_t stacktop = fiber_stackstart - JANET_FRAME_SIZE; + while (stack > 0) { + JanetFunction *func = NULL; + JanetFuncDef *def = NULL; + JanetFuncEnv *env = NULL; + int32_t frameflags = readint(st, &data); + int32_t prevframe = readnat(st, &data); + int32_t pcdiff = readnat(st, &data); + + /* Get frame items */ + Janet *framestack = fiber->data + stack; + JanetStackFrame *framep = janet_stack_frame(framestack); + + /* Get function */ + Janet funcv; + data = unmarshal_one(st, data, &funcv, flags + 1); + janet_asserttype(funcv, JANET_FUNCTION, st); + func = janet_unwrap_function(funcv); + def = func->def; + + /* Check env */ + if (frameflags & JANET_STACKFRAME_HASENV) { + frameflags &= ~JANET_STACKFRAME_HASENV; + data = unmarshal_one_env(st, data, &env, flags + 1); + } + + /* Error checking */ + int32_t expected_framesize = def->slotcount; + if (expected_framesize != stacktop - stack) { + janet_panic("fiber stackframe size mismatch"); + } + if (pcdiff >= def->bytecode_length) { + janet_panic("fiber stackframe has invalid pc"); + } + if ((int32_t)(prevframe + JANET_FRAME_SIZE) > stack) { + janet_panic("fiber stackframe does not align with previous frame"); + } + + /* Get stack items */ + for (int32_t i = stack; i < stacktop; i++) + data = unmarshal_one(st, data, fiber->data + i, flags + 1); + + /* Set frame */ + framep->env = env; + framep->pc = def->bytecode + pcdiff; + framep->prevframe = prevframe; + framep->flags = frameflags; + framep->func = func; + + /* Goto previous frame */ + stacktop = stack - JANET_FRAME_SIZE; + stack = prevframe; + } + if (stack < 0) { + janet_panic("fiber has too many stackframes"); + } + + /* Check for fiber env */ + if (fiber_flags & JANET_FIBER_FLAG_HASENV) { + Janet envv; + fiber_flags &= ~JANET_FIBER_FLAG_HASENV; + data = unmarshal_one(st, data, &envv, flags + 1); + janet_asserttype(envv, JANET_TABLE, st); + fiber_env = janet_unwrap_table(envv); + } + + /* Check for child fiber */ + if (fiber_flags & JANET_FIBER_FLAG_HASCHILD) { + Janet fiberv; + fiber_flags &= ~JANET_FIBER_FLAG_HASCHILD; + data = unmarshal_one(st, data, &fiberv, flags + 1); + janet_asserttype(fiberv, JANET_FIBER, st); + fiber->child = janet_unwrap_fiber(fiberv); + } + + /* Get the fiber last value */ + data = unmarshal_one(st, data, &fiber->last_value, flags + 1); + + /* We have valid fiber, finally construct remaining fields. */ + fiber->frame = frame; + fiber->flags = fiber_flags; + fiber->stackstart = fiber_stackstart; + fiber->stacktop = fiber_stacktop; + fiber->maxstack = fiber_maxstack; + fiber->env = fiber_env; + + int status = janet_fiber_status(fiber); + if (status < 0 || status > JANET_STATUS_ALIVE) { + janet_panic("invalid fiber status"); + } + + /* Return data */ + *out = fiber; + return data; +} + +void janet_unmarshal_ensure(JanetMarshalContext *ctx, size_t size) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + MARSH_EOS(st, ctx->data + size); +} + +int32_t janet_unmarshal_int(JanetMarshalContext *ctx) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + return readint(st, &(ctx->data)); +} + +size_t janet_unmarshal_size(JanetMarshalContext *ctx) { + return (size_t) janet_unmarshal_int64(ctx); +} + +int64_t janet_unmarshal_int64(JanetMarshalContext *ctx) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + return read64(st, &(ctx->data)); +} + +void *janet_unmarshal_ptr(JanetMarshalContext *ctx) { + if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) { + janet_panic("can only unmarshal pointers in unsafe mode"); + } + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + void *ptr; + MARSH_EOS(st, ctx->data + sizeof(void *) - 1); + memcpy((char *) &ptr, ctx->data, sizeof(void *)); + ctx->data += sizeof(void *); + return ptr; +} + +uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + MARSH_EOS(st, ctx->data); + return *(ctx->data++); +} + +void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, size_t len) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + MARSH_EOS(st, ctx->data + len - 1); + safe_memcpy(dest, ctx->data, len); + ctx->data += len; +} + +Janet janet_unmarshal_janet(JanetMarshalContext *ctx) { + Janet ret; + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + ctx->data = unmarshal_one(st, ctx->data, &ret, ctx->flags); + return ret; +} + +void janet_unmarshal_abstract_reuse(JanetMarshalContext *ctx, void *p) { + UnmarshalState *st = (UnmarshalState *)(ctx->u_state); + if (ctx->at == NULL) { + janet_panicf("janet_unmarshal_abstract called more than once"); + } + janet_v_push(st->lookup, janet_wrap_abstract(p)); + ctx->at = NULL; +} + +void *janet_unmarshal_abstract(JanetMarshalContext *ctx, size_t size) { + void *p = janet_abstract(ctx->at, size); + janet_unmarshal_abstract_reuse(ctx, p); + return p; +} + +void *janet_unmarshal_abstract_threaded(JanetMarshalContext *ctx, size_t size) { +#ifdef JANET_THREADS + void *p = janet_abstract_threaded(ctx->at, size); + janet_unmarshal_abstract_reuse(ctx, p); + return p; +#else + (void) ctx; + (void) size; + janet_panic("threaded abstracts not supported"); +#endif +} + +static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { + Janet key; + data = unmarshal_one(st, data, &key, flags + 1); + const JanetAbstractType *at = janet_get_abstract_type(key); + if (at == NULL) janet_panic("unknown abstract type"); + if (at->unmarshal) { + JanetMarshalContext context = {NULL, st, flags, data, at}; + void *abst = at->unmarshal(&context); + janet_assert(abst != NULL, "null pointer abstract"); + *out = janet_wrap_abstract(abst); + if (context.at != NULL) { + janet_panic("janet_unmarshal_abstract not called"); + } + return context.data; + } + janet_panic("invalid abstract type - no unmarshal function pointer"); +} + +static const uint8_t *unmarshal_one( + UnmarshalState *st, + const uint8_t *data, + Janet *out, + int flags) { + uint8_t lead; + MARSH_STACKCHECK; + MARSH_EOS(st, data); + lead = data[0]; + if (lead < LB_REAL) { + *out = janet_wrap_integer(readint(st, &data)); + return data; + } + switch (lead) { + case LB_NIL: + *out = janet_wrap_nil(); + return data + 1; + case LB_FALSE: + *out = janet_wrap_false(); + return data + 1; + case LB_TRUE: + *out = janet_wrap_true(); + return data + 1; + case LB_INTEGER: + /* Long integer */ + MARSH_EOS(st, data + 4); + uint32_t ui = ((uint32_t)(data[4])) | + ((uint32_t)(data[3]) << 8) | + ((uint32_t)(data[2]) << 16) | + ((uint32_t)(data[1]) << 24); + int32_t si = (int32_t)ui; + *out = janet_wrap_integer(si); + return data + 5; + case LB_REAL: + /* Real */ + { + union { + double d; + uint8_t bytes[8]; + } u; + MARSH_EOS(st, data + 8); +#ifdef JANET_BIG_ENDIAN + u.bytes[0] = data[8]; + u.bytes[1] = data[7]; + u.bytes[2] = data[6]; + u.bytes[3] = data[5]; + u.bytes[4] = data[4]; + u.bytes[5] = data[3]; + u.bytes[6] = data[2]; + u.bytes[7] = data[1]; +#else + memcpy(&u.bytes, data + 1, sizeof(double)); +#endif + *out = janet_wrap_number_safe(u.d); + janet_v_push(st->lookup, *out); + return data + 9; + } + case LB_STRING: + case LB_SYMBOL: + case LB_BUFFER: + case LB_KEYWORD: + case LB_REGISTRY: { + data++; + int32_t len = readnat(st, &data); + MARSH_EOS(st, data - 1 + len); + if (lead == LB_STRING) { + const uint8_t *str = janet_string(data, len); + *out = janet_wrap_string(str); + } else if (lead == LB_SYMBOL) { + const uint8_t *str = janet_symbol(data, len); + *out = janet_wrap_symbol(str); + } else if (lead == LB_KEYWORD) { + const uint8_t *str = janet_keyword(data, len); + *out = janet_wrap_keyword(str); + } else if (lead == LB_REGISTRY) { + if (st->reg) { + Janet regkey = janet_symbolv(data, len); + *out = janet_table_get(st->reg, regkey); + } else { + *out = janet_wrap_nil(); + } + } else { /* (lead == LB_BUFFER) */ + JanetBuffer *buffer = janet_buffer(len); + buffer->count = len; + safe_memcpy(buffer->data, data, len); + *out = janet_wrap_buffer(buffer); + } + janet_v_push(st->lookup, *out); + return data + len; + } + case LB_FIBER: { + JanetFiber *fiber; + data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); + *out = janet_wrap_fiber(fiber); + return data; + } + case LB_FUNCTION: { + JanetFunction *func; + JanetFuncDef *def; + data++; + int32_t len = readnat(st, &data); + if (len > 255) { + janet_panicf("invalid function - too many environments (%d)", len); + } + func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + + len * sizeof(JanetFuncEnv)); + func->def = NULL; + for (int32_t i = 0; i < len; i++) { + func->envs[i] = NULL; + } + *out = janet_wrap_function(func); + janet_v_push(st->lookup, *out); + data = unmarshal_one_def(st, data, &def, flags + 1); + func->def = def; + for (int32_t i = 0; i < len; i++) { + data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); + } + return data; + } + case LB_ABSTRACT: { + data++; + return unmarshal_one_abstract(st, data, out, flags); + } + case LB_REFERENCE: + case LB_ARRAY: + case LB_TUPLE: + case LB_STRUCT: + case LB_STRUCT_PROTO: + case LB_TABLE: + case LB_TABLE_PROTO: + /* Things that open with integers */ + { + data++; + int32_t len = readnat(st, &data); + /* DOS check */ + if (lead != LB_REFERENCE) { + MARSH_EOS(st, data - 1 + len); + } + if (lead == LB_ARRAY) { + /* Array */ + JanetArray *array = janet_array(len); + array->count = len; + *out = janet_wrap_array(array); + janet_v_push(st->lookup, *out); + for (int32_t i = 0; i < len; i++) { + data = unmarshal_one(st, data, array->data + i, flags + 1); + } + } else if (lead == LB_TUPLE) { + /* Tuple */ + Janet *tup = janet_tuple_begin(len); + int32_t flag = readint(st, &data); + janet_tuple_flag(tup) |= flag << 16; + for (int32_t i = 0; i < len; i++) { + data = unmarshal_one(st, data, tup + i, flags + 1); + } + *out = janet_wrap_tuple(janet_tuple_end(tup)); + janet_v_push(st->lookup, *out); + } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { + /* Struct */ + JanetKV *struct_ = janet_struct_begin(len); + if (lead == LB_STRUCT_PROTO) { + Janet proto; + data = unmarshal_one(st, data, &proto, flags + 1); + janet_asserttype(proto, JANET_STRUCT, st); + janet_struct_proto(struct_) = janet_unwrap_struct(proto); + } + for (int32_t i = 0; i < len; i++) { + Janet key, value; + data = unmarshal_one(st, data, &key, flags + 1); + data = unmarshal_one(st, data, &value, flags + 1); + janet_struct_put(struct_, key, value); + } + *out = janet_wrap_struct(janet_struct_end(struct_)); + janet_v_push(st->lookup, *out); + } else if (lead == LB_REFERENCE) { + if (len >= janet_v_count(st->lookup)) + janet_panicf("invalid reference %d", len); + *out = st->lookup[len]; + } else { + /* Table */ + JanetTable *t = janet_table(len); + *out = janet_wrap_table(t); + janet_v_push(st->lookup, *out); + if (lead == LB_TABLE_PROTO) { + Janet proto; + data = unmarshal_one(st, data, &proto, flags + 1); + janet_asserttype(proto, JANET_TABLE, st); + t->proto = janet_unwrap_table(proto); + } + for (int32_t i = 0; i < len; i++) { + Janet key, value; + data = unmarshal_one(st, data, &key, flags + 1); + data = unmarshal_one(st, data, &value, flags + 1); + janet_table_put(t, key, value); + } + } + return data; + } + case LB_UNSAFE_POINTER: { + MARSH_EOS(st, data + sizeof(void *)); + data++; + if (!(flags & JANET_MARSHAL_UNSAFE)) { + janet_panicf("unsafe flag not given, " + "will not unmarshal raw pointer at index %d", + (int)(data - st->start)); + } + union { + void *ptr; + uint8_t bytes[sizeof(void *)]; + } u; + memcpy(u.bytes, data, sizeof(void *)); + data += sizeof(void *); + *out = janet_wrap_pointer(u.ptr); + janet_v_push(st->lookup, *out); + return data; + } +#ifdef JANET_EV + case LB_POINTER_BUFFER: { + data++; + int32_t count = readnat(st, &data); + int32_t capacity = readnat(st, &data); + MARSH_EOS(st, data + sizeof(void *)); + union { + void *ptr; + uint8_t bytes[sizeof(void *)]; + } u; + if (!(flags & JANET_MARSHAL_UNSAFE)) { + janet_panicf("unsafe flag not given, " + "will not unmarshal raw pointer at index %d", + (int)(data - st->start)); + } + memcpy(u.bytes, data, sizeof(void *)); + data += sizeof(void *); + JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); + *out = janet_wrap_buffer(buffer); + janet_v_push(st->lookup, *out); + return data; + } +#endif + case LB_UNSAFE_CFUNCTION: { + MARSH_EOS(st, data + sizeof(JanetCFunction)); + data++; + if (!(flags & JANET_MARSHAL_UNSAFE)) { + janet_panicf("unsafe flag not given, " + "will not unmarshal function pointer at index %d", + (int)(data - st->start)); + } + union { + JanetCFunction ptr; + uint8_t bytes[sizeof(JanetCFunction)]; + } u; + memcpy(u.bytes, data, sizeof(JanetCFunction)); + data += sizeof(JanetCFunction); + *out = janet_wrap_cfunction(u.ptr); + janet_v_push(st->lookup, *out); + return data; + } +#ifdef JANET_EV + case LB_THREADED_ABSTRACT: { + MARSH_EOS(st, data + sizeof(void *)); + data++; + if (!(flags & JANET_MARSHAL_UNSAFE)) { + janet_panicf("unsafe flag not given, " + "will not unmarshal threaded abstract pointer at index %d", + (int)(data - st->start)); + } + union { + void *ptr; + uint8_t bytes[sizeof(void *)]; + } u; + memcpy(u.bytes, data, sizeof(void *)); + data += sizeof(void *); + + if (flags & JANET_MARSHAL_DECREF) { + /* Decrement immediately and don't bother putting into heap */ + janet_abstract_decref(u.ptr); + *out = janet_wrap_nil(); + } else { + *out = janet_wrap_abstract(u.ptr); + Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); + if (janet_checktype(check, JANET_NIL)) { + /* Transfers reference from threaded channel buffer to current heap */ + janet_table_put(&janet_vm.threaded_abstracts, *out, janet_wrap_false()); + } else { + /* Heap reference already accounted for, remove threaded channel reference. */ + janet_abstract_decref(u.ptr); + } + } + + janet_v_push(st->lookup, *out); + return data; + } +#endif + default: { + janet_panicf("unknown byte %x at index %d", + *data, + (int)(data - st->start)); + return NULL; + } + } +} + +Janet janet_unmarshal( + const uint8_t *bytes, + size_t len, + int flags, + JanetTable *reg, + const uint8_t **next) { + UnmarshalState st; + st.start = bytes; + st.end = bytes + len; + st.lookup_defs = NULL; + st.lookup_envs = NULL; + st.lookup = NULL; + st.reg = reg; + Janet out; + const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); + if (next) *next = nextbytes; + janet_v_free(st.lookup_defs); + janet_v_free(st.lookup_envs); + janet_v_free(st.lookup); + return out; +} + +/* C functions */ + +JANET_CORE_FN(cfun_env_lookup, + "(env-lookup env)", + "Creates a forward lookup table for unmarshalling from an environment. " + "To create a reverse lookup table, use the invert function to swap keys " + "and values in the returned table.") { + janet_fixarity(argc, 1); + JanetTable *env = janet_gettable(argv, 0); + return janet_wrap_table(janet_env_lookup(env)); +} + +JANET_CORE_FN(cfun_marshal, + "(marshal x &opt reverse-lookup buffer no-cycles)", + "Marshal a value into a buffer and return the buffer. The buffer " + "can then later be unmarshalled to reconstruct the initial value. " + "Optionally, one can pass in a reverse lookup table to not marshal " + "aliased values that are found in the table. Then a forward " + "lookup table can be used to recover the original value when " + "unmarshalling.") { + janet_arity(argc, 1, 4); + JanetBuffer *buffer; + JanetTable *rreg = NULL; + uint32_t flags = 0; + if (argc > 1) { + rreg = janet_gettable(argv, 1); + } + if (argc > 2) { + buffer = janet_getbuffer(argv, 2); + } else { + buffer = janet_buffer(10); + } + if (argc > 3 && janet_truthy(argv[3])) { + flags |= JANET_MARSHAL_NO_CYCLES; + } + janet_marshal(buffer, argv[0], rreg, flags); + return janet_wrap_buffer(buffer); +} + +JANET_CORE_FN(cfun_unmarshal, + "(unmarshal buffer &opt lookup)", + "Unmarshal a value from a buffer. An optional lookup table " + "can be provided to allow for aliases to be resolved. Returns the value " + "unmarshalled from the buffer.") { + janet_arity(argc, 1, 2); + JanetByteView view = janet_getbytes(argv, 0); + JanetTable *reg = NULL; + if (argc > 1) { + reg = janet_gettable(argv, 1); + } + return janet_unmarshal(view.bytes, (size_t) view.len, 0, reg, NULL); +} + +/* Module entry point */ +void janet_lib_marsh(JanetTable *env) { + JanetRegExt marsh_cfuns[] = { + JANET_CORE_REG("marshal", cfun_marshal), + JANET_CORE_REG("unmarshal", cfun_unmarshal), + JANET_CORE_REG("env-lookup", cfun_env_lookup), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, marsh_cfuns); +} + + +/* src/core/math.c */ +#line 0 "src/core/math.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "util.h" +#endif + +#include + +static int janet_rng_get(void *p, Janet key, Janet *out); +static Janet janet_rng_next(void *p, Janet key); + +static void janet_rng_marshal(void *p, JanetMarshalContext *ctx) { + JanetRNG *rng = (JanetRNG *)p; + janet_marshal_abstract(ctx, p); + janet_marshal_int(ctx, (int32_t) rng->a); + janet_marshal_int(ctx, (int32_t) rng->b); + janet_marshal_int(ctx, (int32_t) rng->c); + janet_marshal_int(ctx, (int32_t) rng->d); + janet_marshal_int(ctx, (int32_t) rng->counter); +} + +static void *janet_rng_unmarshal(JanetMarshalContext *ctx) { + JanetRNG *rng = janet_unmarshal_abstract(ctx, sizeof(JanetRNG)); + rng->a = (uint32_t) janet_unmarshal_int(ctx); + rng->b = (uint32_t) janet_unmarshal_int(ctx); + rng->c = (uint32_t) janet_unmarshal_int(ctx); + rng->d = (uint32_t) janet_unmarshal_int(ctx); + rng->counter = (uint32_t) janet_unmarshal_int(ctx); + return rng; +} + +const JanetAbstractType janet_rng_type = { + "core/rng", + NULL, + NULL, + janet_rng_get, + NULL, + janet_rng_marshal, + janet_rng_unmarshal, + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + janet_rng_next, + JANET_ATEND_NEXT +}; + +JanetRNG *janet_default_rng(void) { + return &janet_vm.rng; +} + +void janet_rng_seed(JanetRNG *rng, uint32_t seed) { + rng->a = seed; + rng->b = 0x97654321u; + rng->c = 123871873u; + rng->d = 0xf23f56c8u; + rng->counter = 0u; + /* First several numbers aren't that random. */ + for (int i = 0; i < 16; i++) janet_rng_u32(rng); +} + +void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len) { + uint8_t state[16] = {0}; + for (int32_t i = 0; i < len; i++) + state[i & 0xF] ^= bytes[i]; + rng->a = state[0] + (state[1] << 8) + (state[2] << 16) + (state[3] << 24); + rng->b = state[4] + (state[5] << 8) + (state[6] << 16) + (state[7] << 24); + rng->c = state[8] + (state[9] << 8) + (state[10] << 16) + (state[11] << 24); + rng->d = state[12] + (state[13] << 8) + (state[14] << 16) + (state[15] << 24); + rng->counter = 0u; + /* a, b, c, d can't all be 0 */ + if (rng->a == 0) rng->a = 1u; + for (int i = 0; i < 16; i++) janet_rng_u32(rng); +} + +uint32_t janet_rng_u32(JanetRNG *rng) { + /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ + uint32_t t = rng->d; + uint32_t const s = rng->a; + rng->d = rng->c; + rng->c = rng->b; + rng->b = s; + t ^= t >> 2; + t ^= t << 1; + t ^= s ^ (s << 4); + rng->a = t; + rng->counter += 362437; + return t + rng->counter; +} + +double janet_rng_double(JanetRNG *rng) { + uint32_t hi = janet_rng_u32(rng); + uint32_t lo = janet_rng_u32(rng); + uint64_t big = (uint64_t)(lo) | (((uint64_t) hi) << 32); + return ldexp((double)(big >> (64 - 52)), -52); +} + +JANET_CORE_FN(cfun_rng_make, + "(math/rng &opt seed)", + "Creates a Pseudo-Random number generator, with an optional seed. " + "The seed should be an unsigned 32 bit integer or a buffer. " + "Do not use this for cryptography. Returns a core/rng abstract type." + ) { + janet_arity(argc, 0, 1); + JanetRNG *rng = janet_abstract(&janet_rng_type, sizeof(JanetRNG)); + if (argc == 1) { + if (janet_checkint(argv[0])) { + uint32_t seed = (uint32_t)(janet_getinteger(argv, 0)); + janet_rng_seed(rng, seed); + } else { + JanetByteView bytes = janet_getbytes(argv, 0); + janet_rng_longseed(rng, bytes.bytes, bytes.len); + } + } else { + janet_rng_seed(rng, 0); + } + return janet_wrap_abstract(rng); +} + +JANET_CORE_FN(cfun_rng_uniform, + "(math/rng-uniform rng)", + "Extract a random number in the range [0, 1) from the RNG." + ) { + janet_fixarity(argc, 1); + JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type); + return janet_wrap_number(janet_rng_double(rng)); +} + +JANET_CORE_FN(cfun_rng_int, + "(math/rng-int rng &opt max)", + "Extract a random integer in the range [0, max) for max > 0 from the RNG. " + "If max is 0, return 0. If no max is given, the default is 2^31 - 1." + ) { + janet_arity(argc, 1, 2); + JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type); + if (argc == 1) { + uint32_t word = janet_rng_u32(rng) >> 1; + return janet_wrap_integer(word); + } else { + int32_t max = janet_optnat(argv, argc, 1, INT32_MAX); + if (max == 0) return janet_wrap_number(0.0); + uint32_t modulo = (uint32_t) max; + uint32_t maxgen = INT32_MAX; + uint32_t maxword = maxgen - (maxgen % modulo); + uint32_t word; + do { + word = janet_rng_u32(rng) >> 1; + } while (word > maxword); + return janet_wrap_integer(word % modulo); + } +} + +static void rng_get_4bytes(JanetRNG *rng, uint8_t *buf) { + uint32_t word = janet_rng_u32(rng); + buf[0] = word & 0xFF; + buf[1] = (word >> 8) & 0xFF; + buf[2] = (word >> 16) & 0xFF; + buf[3] = (word >> 24) & 0xFF; +} + +JANET_CORE_FN(cfun_rng_buffer, + "(math/rng-buffer rng n &opt buf)", + "Get n random bytes and put them in a buffer. Creates a new buffer if no buffer is " + "provided, otherwise appends to the given buffer. Returns the buffer." + ) { + janet_arity(argc, 2, 3); + JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type); + int32_t n = janet_getnat(argv, 1); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, n); + + /* Split into first part (that is divisible by 4), and rest */ + int32_t first_part = n & ~3; + int32_t second_part = n - first_part; + + /* Get first part in chunks of 4 bytes */ + janet_buffer_extra(buffer, n); + uint8_t *buf = buffer->data + buffer->count; + for (int32_t i = 0; i < first_part; i += 4) rng_get_4bytes(rng, buf + i); + buffer->count += first_part; + + /* Get remaining 0 - 3 bytes */ + if (second_part) { + uint8_t wordbuf[4] = {0}; + rng_get_4bytes(rng, wordbuf); + janet_buffer_push_bytes(buffer, wordbuf, second_part); + } + + return janet_wrap_buffer(buffer); +} + +static const JanetMethod rng_methods[] = { + {"uniform", cfun_rng_uniform}, + {"int", cfun_rng_int}, + {"buffer", cfun_rng_buffer}, + {NULL, NULL} +}; + +static int janet_rng_get(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) return 0; + return janet_getmethod(janet_unwrap_keyword(key), rng_methods, out); +} + +static Janet janet_rng_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(rng_methods, key); +} + +/* Get a random number */ +JANET_CORE_FN(janet_rand, + "(math/random)", + "Returns a uniformly distributed random number between 0 and 1.") { + (void) argv; + janet_fixarity(argc, 0); + return janet_wrap_number(janet_rng_double(&janet_vm.rng)); +} + +/* Seed the random number generator */ +JANET_CORE_FN(janet_srand, + "(math/seedrandom seed)", + "Set the seed for the random number generator. `seed` should be " + "an integer or a buffer." + ) { + janet_fixarity(argc, 1); + if (janet_checkint(argv[0])) { + uint32_t seed = (uint32_t)(janet_getinteger(argv, 0)); + janet_rng_seed(&janet_vm.rng, seed); + } else { + JanetByteView bytes = janet_getbytes(argv, 0); + janet_rng_longseed(&janet_vm.rng, bytes.bytes, bytes.len); + } + return janet_wrap_nil(); +} + +#define JANET_DEFINE_NAMED_MATHOP(janet_name, fop, doc)\ +JANET_CORE_FN(janet_##fop, "(math/" janet_name " x)", doc) {\ + janet_fixarity(argc, 1); \ + double x = janet_getnumber(argv, 0); \ + return janet_wrap_number(fop(x)); \ +} + +#define JANET_DEFINE_MATHOP(fop, doc) JANET_DEFINE_NAMED_MATHOP(#fop, fop, doc) + +JANET_DEFINE_MATHOP(acos, "Returns the arccosine of x.") +JANET_DEFINE_MATHOP(asin, "Returns the arcsin of x.") +JANET_DEFINE_MATHOP(atan, "Returns the arctangent of x.") +JANET_DEFINE_MATHOP(cos, "Returns the cosine of x.") +JANET_DEFINE_MATHOP(cosh, "Returns the hyperbolic cosine of x.") +JANET_DEFINE_MATHOP(acosh, "Returns the hyperbolic arccosine of x.") +JANET_DEFINE_MATHOP(sin, "Returns the sine of x.") +JANET_DEFINE_MATHOP(sinh, "Returns the hyperbolic sine of x.") +JANET_DEFINE_MATHOP(asinh, "Returns the hyperbolic arcsine of x.") +JANET_DEFINE_MATHOP(tan, "Returns the tangent of x.") +JANET_DEFINE_MATHOP(tanh, "Returns the hyperbolic tangent of x.") +JANET_DEFINE_MATHOP(atanh, "Returns the hyperbolic arctangent of x.") +JANET_DEFINE_MATHOP(exp, "Returns e to the power of x.") +JANET_DEFINE_MATHOP(exp2, "Returns 2 to the power of x.") +JANET_DEFINE_MATHOP(expm1, "Returns e to the power of x minus 1.") +JANET_DEFINE_MATHOP(log, "Returns the natural logarithm of x.") +JANET_DEFINE_MATHOP(log10, "Returns the log base 10 of x.") +JANET_DEFINE_MATHOP(log2, "Returns the log base 2 of x.") +JANET_DEFINE_MATHOP(sqrt, "Returns the square root of x.") +JANET_DEFINE_MATHOP(cbrt, "Returns the cube root of x.") +JANET_DEFINE_MATHOP(ceil, "Returns the smallest integer value number that is not less than x.") +JANET_DEFINE_MATHOP(floor, "Returns the largest integer value number that is not greater than x.") +JANET_DEFINE_MATHOP(trunc, "Returns the integer between x and 0 nearest to x.") +JANET_DEFINE_MATHOP(round, "Returns the integer nearest to x.") +JANET_DEFINE_MATHOP(log1p, "Returns (log base e of x) + 1 more accurately than (+ (math/log x) 1)") +JANET_DEFINE_MATHOP(erf, "Returns the error function of x.") +JANET_DEFINE_MATHOP(erfc, "Returns the complementary error function of x.") +JANET_DEFINE_NAMED_MATHOP("log-gamma", lgamma, "Returns log-gamma(x).") +JANET_DEFINE_NAMED_MATHOP("abs", fabs, "Return the absolute value of x.") +JANET_DEFINE_NAMED_MATHOP("gamma", tgamma, "Returns gamma(x).") + +#define JANET_DEFINE_MATH2OP(name, fop, signature, doc)\ +JANET_CORE_FN(janet_##name, signature, doc) {\ + janet_fixarity(argc, 2); \ + double lhs = janet_getnumber(argv, 0); \ + double rhs = janet_getnumber(argv, 1); \ + return janet_wrap_number(fop(lhs, rhs)); \ +} + +JANET_DEFINE_MATH2OP(atan2, atan2, "(math/atan2 y x)", "Returns the arctangent of y/x. Works even when x is 0.") +JANET_DEFINE_MATH2OP(pow, pow, "(math/pow a x)", "Returns a to the power of x.") +JANET_DEFINE_MATH2OP(hypot, hypot, "(math/hypot a b)", "Returns c from the equation c^2 = a^2 + b^2.") +JANET_DEFINE_MATH2OP(nextafter, nextafter, "(math/next x y)", "Returns the next representable floating point value after x in the direction of y.") + +JANET_CORE_FN(janet_not, "(not x)", "Returns the boolean inverse of x.") { + janet_fixarity(argc, 1); + return janet_wrap_boolean(!janet_truthy(argv[0])); +} + +static double janet_gcd(double x, double y) { + if (isnan(x) || isnan(y)) { +#ifdef NAN + return NAN; +#else + return 0.0 / 0.0; +#endif + } + if (isinf(x) || isinf(y)) return INFINITY; + while (y != 0) { + double temp = y; + y = fmod(x, y); + x = temp; + } + return x; +} + +static double janet_lcm(double x, double y) { + return (x / janet_gcd(x, y)) * y; +} + +JANET_CORE_FN(janet_cfun_gcd, "(math/gcd x y)", + "Returns the greatest common divisor between x and y.") { + janet_fixarity(argc, 2); + double x = janet_getnumber(argv, 0); + double y = janet_getnumber(argv, 1); + return janet_wrap_number(janet_gcd(x, y)); +} + +JANET_CORE_FN(janet_cfun_lcm, "(math/lcm x y)", + "Returns the least common multiple of x and y.") { + janet_fixarity(argc, 2); + double x = janet_getnumber(argv, 0); + double y = janet_getnumber(argv, 1); + return janet_wrap_number(janet_lcm(x, y)); +} + +/* Module entry point */ +void janet_lib_math(JanetTable *env) { + JanetRegExt math_cfuns[] = { + JANET_CORE_REG("not", janet_not), + JANET_CORE_REG("math/random", janet_rand), + JANET_CORE_REG("math/seedrandom", janet_srand), + JANET_CORE_REG("math/cos", janet_cos), + JANET_CORE_REG("math/sin", janet_sin), + JANET_CORE_REG("math/tan", janet_tan), + JANET_CORE_REG("math/acos", janet_acos), + JANET_CORE_REG("math/asin", janet_asin), + JANET_CORE_REG("math/atan", janet_atan), + JANET_CORE_REG("math/exp", janet_exp), + JANET_CORE_REG("math/log", janet_log), + JANET_CORE_REG("math/log10", janet_log10), + JANET_CORE_REG("math/log2", janet_log2), + JANET_CORE_REG("math/sqrt", janet_sqrt), + JANET_CORE_REG("math/cbrt", janet_cbrt), + JANET_CORE_REG("math/floor", janet_floor), + JANET_CORE_REG("math/ceil", janet_ceil), + JANET_CORE_REG("math/pow", janet_pow), + JANET_CORE_REG("math/abs", janet_fabs), + JANET_CORE_REG("math/sinh", janet_sinh), + JANET_CORE_REG("math/cosh", janet_cosh), + JANET_CORE_REG("math/tanh", janet_tanh), + JANET_CORE_REG("math/atanh", janet_atanh), + JANET_CORE_REG("math/asinh", janet_asinh), + JANET_CORE_REG("math/acosh", janet_acosh), + JANET_CORE_REG("math/atan2", janet_atan2), + JANET_CORE_REG("math/rng", cfun_rng_make), + JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), + JANET_CORE_REG("math/rng-int", cfun_rng_int), + JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), + JANET_CORE_REG("math/hypot", janet_hypot), + JANET_CORE_REG("math/exp2", janet_exp2), + JANET_CORE_REG("math/log1p", janet_log1p), + JANET_CORE_REG("math/gamma", janet_tgamma), + JANET_CORE_REG("math/log-gamma", janet_lgamma), + JANET_CORE_REG("math/erfc", janet_erfc), + JANET_CORE_REG("math/erf", janet_erf), + JANET_CORE_REG("math/expm1", janet_expm1), + JANET_CORE_REG("math/trunc", janet_trunc), + JANET_CORE_REG("math/round", janet_round), + JANET_CORE_REG("math/next", janet_nextafter), + JANET_CORE_REG("math/gcd", janet_cfun_gcd), + JANET_CORE_REG("math/lcm", janet_cfun_lcm), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, math_cfuns); + janet_register_abstract_type(&janet_rng_type); +#ifdef JANET_BOOTSTRAP + JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), + "The value pi."); + JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), + "The base of the natural log."); + JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), + "The number representing positive infinity"); + JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), + "The number representing negative infinity"); + JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), + "The minimum contiguous integer representable by a 32 bit signed integer"); + JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), + "The maximum contiguous integer representable by a 32 bit signed integer"); + JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), + "The minimum contiguous integer representable by a double (2^53)"); + JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), + "The maximum contiguous integer representable by a double (-(2^53))"); +#ifdef NAN + JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); +#else + JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); +#endif +#endif +} + + +/* src/core/net.c */ +#line 0 "src/core/net.c" + +/* +* Copyright (c) 2023 Calvin Rose and contributors. +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "fiber.h" +#endif + +#ifdef JANET_NET + +#include +#ifdef JANET_WINDOWS +#include +#include +#include +#include +#ifdef JANET_MSVC +#pragma comment (lib, "Ws2_32.lib") +#pragma comment (lib, "Mswsock.lib") +#pragma comment (lib, "Advapi32.lib") +#endif +#else +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif + +const JanetAbstractType janet_address_type = { + "core/socket-address", + JANET_ATEND_NAME +}; + +#ifdef JANET_WINDOWS +#define JSOCKCLOSE(x) closesocket((SOCKET) x) +#define JSOCKDEFAULT INVALID_SOCKET +#define JSOCKVALID(x) ((x) != INVALID_SOCKET) +#define JSock SOCKET +#define JSOCKFLAGS 0 +#else +#define JSOCKCLOSE(x) close(x) +#define JSOCKDEFAULT 0 +#define JSOCKVALID(x) ((x) >= 0) +#define JSock int +#ifdef SOCK_CLOEXEC +#define JSOCKFLAGS SOCK_CLOEXEC +#else +#define JSOCKFLAGS 0 +#endif +#endif + +/* maximum number of bytes in a socket address host (post name resolution) */ +#ifdef JANET_WINDOWS +#ifdef JANET_NO_IPV6 +#define SA_ADDRSTRLEN (INET_ADDRSTRLEN + 1) +#else +#define SA_ADDRSTRLEN (INET6_ADDRSTRLEN + 1) +#endif +typedef unsigned short in_port_t; +#else +#define JANET_SA_MAX(a, b) (((a) > (b))? (a) : (b)) +#ifdef JANET_NO_IPV6 +#define SA_ADDRSTRLEN JANET_SA_MAX(INET_ADDRSTRLEN + 1, (sizeof ((struct sockaddr_un *)0)->sun_path) + 1) +#else +#define SA_ADDRSTRLEN JANET_SA_MAX(INET6_ADDRSTRLEN + 1, (sizeof ((struct sockaddr_un *)0)->sun_path) + 1) +#endif +#endif + +static JanetStream *make_stream(JSock handle, uint32_t flags); + +/* We pass this flag to all send calls to prevent sigpipe */ +#ifndef MSG_NOSIGNAL +#define MSG_NOSIGNAL 0 +#endif + +/* Make sure a socket doesn't block */ +static void janet_net_socknoblock(JSock s) { +#ifdef JANET_WINDOWS + unsigned long arg = 1; + ioctlsocket(s, FIONBIO, &arg); +#else +#if !defined(SOCK_CLOEXEC) && defined(O_CLOEXEC) + int extra = O_CLOEXEC; +#else + int extra = 0; +#endif + fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK | extra); +#ifdef SO_NOSIGPIPE + int enable = 1; + setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, &enable, sizeof(int)); +#endif +#endif +} + +/* State machine for async connect */ + +void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) { + JanetStream *stream = fiber->ev_stream; + switch (event) { + default: + break; +#ifndef JANET_WINDOWS + /* Wait until we have an actual event before checking. + * Windows doesn't support async connect with this, just try immediately.*/ + case JANET_ASYNC_EVENT_INIT: +#endif + case JANET_ASYNC_EVENT_DEINIT: + return; + case JANET_ASYNC_EVENT_CLOSE: + janet_cancel(fiber, janet_cstringv("stream closed")); + janet_async_end(fiber); + return; + } +#ifdef JANET_WINDOWS + int res = 0; + int size = sizeof(res); + int r = getsockopt((SOCKET)stream->handle, SOL_SOCKET, SO_ERROR, (char *)&res, &size); +#else + int res = 0; + socklen_t size = sizeof res; + int r = getsockopt(stream->handle, SOL_SOCKET, SO_ERROR, &res, &size); +#endif + if (r == 0) { + if (res == 0) { + janet_schedule(fiber, janet_wrap_abstract(stream)); + } else { + janet_cancel(fiber, janet_cstringv(strerror(res))); + stream->flags |= JANET_STREAM_TOCLOSE; + } + } else { + janet_cancel(fiber, janet_ev_lasterr()); + stream->flags |= JANET_STREAM_TOCLOSE; + } + janet_async_end(fiber); +} + +static JANET_NO_RETURN void net_sched_connect(JanetStream *stream) { + janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect, NULL); +} + +/* State machine for accepting connections. */ + +#ifdef JANET_WINDOWS + +typedef struct { + WSAOVERLAPPED overlapped; + JanetFunction *function; + JanetStream *lstream; + JanetStream *astream; + char buf[1024]; +} NetStateAccept; + +static int net_sched_accept_impl(NetStateAccept *state, JanetFiber *fiber, Janet *err); + +void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) { + NetStateAccept *state = (NetStateAccept *)fiber->ev_state; + switch (event) { + default: + break; + case JANET_ASYNC_EVENT_MARK: { + if (state->lstream) janet_mark(janet_wrap_abstract(state->lstream)); + if (state->astream) janet_mark(janet_wrap_abstract(state->astream)); + if (state->function) janet_mark(janet_wrap_function(state->function)); + break; + } + case JANET_ASYNC_EVENT_CLOSE: + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + return; + case JANET_ASYNC_EVENT_COMPLETE: { + if (state->astream->flags & JANET_STREAM_CLOSED) { + janet_cancel(fiber, janet_cstringv("failed to accept connection")); + janet_async_end(fiber); + return; + } + SOCKET lsock = (SOCKET) state->lstream->handle; + if (NO_ERROR != setsockopt((SOCKET) state->astream->handle, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, + (char *) &lsock, sizeof(lsock))) { + janet_cancel(fiber, janet_cstringv("failed to accept connection")); + janet_async_end(fiber); + return; + } + + Janet streamv = janet_wrap_abstract(state->astream); + if (state->function) { + /* Schedule worker */ + JanetFiber *sub_fiber = janet_fiber(state->function, 64, 1, &streamv); + sub_fiber->supervisor_channel = fiber->supervisor_channel; + janet_schedule(sub_fiber, janet_wrap_nil()); + /* Now listen again for next connection */ + Janet err; + if (net_sched_accept_impl(state, fiber, &err)) { + janet_cancel(fiber, err); + janet_async_end(fiber); + return; + } + } else { + janet_schedule(fiber, streamv); + janet_async_end(fiber); + return; + } + } + } +} + +JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) { + Janet err; + NetStateAccept *state = janet_malloc(sizeof(NetStateAccept)); + memset(&state->overlapped, 0, sizeof(WSAOVERLAPPED)); + memset(&state->buf, 0, 1024); + state->function = fun; + state->lstream = stream; + if (net_sched_accept_impl(state, janet_root_fiber(), &err)) { + janet_free(state); + janet_panicv(err); + } + janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state); +} + +static int net_sched_accept_impl(NetStateAccept *state, JanetFiber *fiber, Janet *err) { + SOCKET lsock = (SOCKET) state->lstream->handle; + SOCKET asock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED); + if (asock == INVALID_SOCKET) { + *err = janet_ev_lasterr(); + return 1; + } + JanetStream *astream = make_stream(asock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE); + state->astream = astream; + int socksize = sizeof(SOCKADDR_STORAGE) + 16; + if (FALSE == AcceptEx(lsock, asock, state->buf, 0, socksize, socksize, NULL, &state->overlapped)) { + int code = WSAGetLastError(); + if (code == WSA_IO_PENDING) { + /* indicates io is happening async */ + janet_async_in_flight(fiber); + return 0; + } + *err = janet_ev_lasterr(); + return 1; + } + return 0; +} + +#else + +typedef struct { + JanetFunction *function; +} NetStateAccept; + +void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) { + JanetStream *stream = fiber->ev_stream; + NetStateAccept *state = (NetStateAccept *)fiber->ev_state; + switch (event) { + default: + break; + case JANET_ASYNC_EVENT_MARK: { + if (state->function) janet_mark(janet_wrap_function(state->function)); + break; + } + case JANET_ASYNC_EVENT_CLOSE: + janet_schedule(fiber, janet_wrap_nil()); + janet_async_end(fiber); + return; + case JANET_ASYNC_EVENT_INIT: + case JANET_ASYNC_EVENT_READ: { +#if defined(JANET_LINUX) + JSock connfd = accept4(stream->handle, NULL, NULL, SOCK_CLOEXEC); +#else + /* On BSDs, CLOEXEC should be inherited from server socket */ + JSock connfd = accept(stream->handle, NULL, NULL); +#endif + if (JSOCKVALID(connfd)) { + janet_net_socknoblock(connfd); + JanetStream *stream = make_stream(connfd, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE); + Janet streamv = janet_wrap_abstract(stream); + if (state->function) { + JanetFiber *sub_fiber = janet_fiber(state->function, 64, 1, &streamv); + sub_fiber->supervisor_channel = fiber->supervisor_channel; + janet_schedule(sub_fiber, janet_wrap_nil()); + } else { + janet_schedule(fiber, streamv); + janet_async_end(fiber); + return; + } + } + break; + } + } +} + +JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) { + NetStateAccept *state = janet_malloc(sizeof(NetStateAccept)); + memset(state, 0, sizeof(NetStateAccept)); + state->function = fun; + janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state); +} + +#endif + +/* Adress info */ + +static int janet_get_sockettype(Janet *argv, int32_t argc, int32_t n) { + JanetKeyword stype = janet_optkeyword(argv, argc, n, NULL); + int socktype = SOCK_DGRAM; + if ((NULL == stype) || !janet_cstrcmp(stype, "stream")) { + socktype = SOCK_STREAM; + } else if (janet_cstrcmp(stype, "datagram")) { + janet_panicf("expected socket type as :stream or :datagram, got %v", argv[n]); + } + return socktype; +} + +/* Needs argc >= offset + 2 */ +/* For unix paths, just rertuns a single sockaddr and sets *is_unix to 1, + * otherwise 0. Also, ignores is_bind when is a unix socket. */ +static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int socktype, int passive, int *is_unix) { + /* Unix socket support - not yet supported on windows. */ +#ifndef JANET_WINDOWS + if (janet_keyeq(argv[offset], "unix")) { + const char *path = janet_getcstring(argv, offset + 1); + struct sockaddr_un *saddr = janet_calloc(1, sizeof(struct sockaddr_un)); + if (saddr == NULL) { + JANET_OUT_OF_MEMORY; + } + saddr->sun_family = AF_UNIX; + size_t path_size = sizeof(saddr->sun_path); +#ifdef JANET_LINUX + if (path[0] == '@') { + saddr->sun_path[0] = '\0'; + snprintf(saddr->sun_path + 1, path_size - 1, "%s", path + 1); + } else +#endif + { + snprintf(saddr->sun_path, path_size, "%s", path); + } + *is_unix = 1; + return (struct addrinfo *) saddr; + } +#endif + /* Get host and port */ + char *host = (char *)janet_getcstring(argv, offset); + char *port = NULL; + if (janet_checkint(argv[offset + 1])) { + port = (char *)janet_to_string(argv[offset + 1]); + } else { + port = (char *)janet_optcstring(argv, offset + 2, offset + 1, NULL); + } + /* getaddrinfo */ + struct addrinfo *ai = NULL; + struct addrinfo hints; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = socktype; + hints.ai_flags = passive ? AI_PASSIVE : 0; + int status = getaddrinfo(host, port, &hints, &ai); + if (status) { + janet_panicf("could not get address info: %s", gai_strerror(status)); + } + *is_unix = 0; + return ai; +} + +/* + * C Funs + */ + +JANET_CORE_FN(cfun_net_sockaddr, + "(net/address host port &opt type multi)", + "Look up the connection information for a given hostname, port, and connection type. Returns " + "a handle that can be used to send datagrams over network without establishing a connection. " + "On Posix platforms, you can use :unix for host to connect to a unix domain socket, where the name is " + "given in the port argument. On Linux, abstract " + "unix domain sockets are specified with a leading '@' character in port. If `multi` is truthy, will " + "return all address that match in an array instead of just the first.") { + janet_sandbox_assert(JANET_SANDBOX_NET_CONNECT); /* connect OR listen */ + janet_arity(argc, 2, 4); + int socktype = janet_get_sockettype(argv, argc, 2); + int is_unix = 0; + int make_arr = (argc >= 3 && janet_truthy(argv[3])); + struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix); +#ifndef JANET_WINDOWS + /* no unix domain socket support on windows yet */ + if (is_unix) { + void *abst = janet_abstract(&janet_address_type, sizeof(struct sockaddr_un)); + memcpy(abst, ai, sizeof(struct sockaddr_un)); + Janet ret = janet_wrap_abstract(abst); + return make_arr ? janet_wrap_array(janet_array_n(&ret, 1)) : ret; + } +#endif + if (make_arr) { + /* Select all */ + JanetArray *arr = janet_array(10); + struct addrinfo *iter = ai; + while (NULL != iter) { + void *abst = janet_abstract(&janet_address_type, iter->ai_addrlen); + memcpy(abst, iter->ai_addr, iter->ai_addrlen); + janet_array_push(arr, janet_wrap_abstract(abst)); + iter = iter->ai_next; + } + freeaddrinfo(ai); + return janet_wrap_array(arr); + } else { + /* Select first */ + if (NULL == ai) { + janet_panic("no data for given address"); + } + void *abst = janet_abstract(&janet_address_type, ai->ai_addrlen); + memcpy(abst, ai->ai_addr, ai->ai_addrlen); + freeaddrinfo(ai); + return janet_wrap_abstract(abst); + } +} + +JANET_CORE_FN(cfun_net_connect, + "(net/connect host port &opt type bindhost bindport)", + "Open a connection to communicate with a server. Returns a duplex stream " + "that can be used to communicate with the server. Type is an optional keyword " + "to specify a connection type, either :stream or :datagram. The default is :stream. " + "Bindhost is an optional string to select from what address to make the outgoing " + "connection, with the default being the same as using the OS's preferred address. ") { + janet_sandbox_assert(JANET_SANDBOX_NET_CONNECT); + janet_arity(argc, 2, 5); + + /* Check arguments */ + int socktype = janet_get_sockettype(argv, argc, 2); + int is_unix = 0; + char *bindhost = (char *) janet_optcstring(argv, argc, 3, NULL); + char *bindport = NULL; + if (argc >= 5 && janet_checkint(argv[4])) { + bindport = (char *)janet_to_string(argv[4]); + } else { + bindport = (char *)janet_optcstring(argv, argc, 4, NULL); + } + + /* Where we're connecting to */ + struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix); + + /* Check if we're binding address */ + struct addrinfo *binding = NULL; + if (bindhost != NULL) { + if (is_unix) { + freeaddrinfo(ai); + janet_panic("bindhost not supported for unix domain sockets"); + } + /* getaddrinfo */ + struct addrinfo hints; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = socktype; + hints.ai_flags = 0; + int status = getaddrinfo(bindhost, bindport, &hints, &binding); + if (status) { + freeaddrinfo(ai); + janet_panicf("could not get address info for bindhost: %s", gai_strerror(status)); + } + } + + /* Create socket */ + JSock sock = JSOCKDEFAULT; + void *addr = NULL; + socklen_t addrlen = 0; +#ifndef JANET_WINDOWS + if (is_unix) { + sock = socket(AF_UNIX, socktype | JSOCKFLAGS, 0); + if (!JSOCKVALID(sock)) { + Janet v = janet_ev_lasterr(); + janet_free(ai); + janet_panicf("could not create socket: %V", v); + } + addr = (void *) ai; + addrlen = sizeof(struct sockaddr_un); + } else +#endif + { + struct addrinfo *rp = NULL; + for (rp = ai; rp != NULL; rp = rp->ai_next) { +#ifdef JANET_WINDOWS + sock = WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED); +#else + sock = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol); +#endif + if (JSOCKVALID(sock)) { + addr = rp->ai_addr; + addrlen = (socklen_t) rp->ai_addrlen; + break; + } + } + if (NULL == addr) { + Janet v = janet_ev_lasterr(); + if (binding) freeaddrinfo(binding); + freeaddrinfo(ai); + janet_panicf("could not create socket: %V", v); + } + } + + /* Bind to bindhost and bindport if given */ + if (binding) { + struct addrinfo *rp = NULL; + int did_bind = 0; + for (rp = binding; rp != NULL; rp = rp->ai_next) { + if (bind(sock, rp->ai_addr, (int) rp->ai_addrlen) == 0) { + did_bind = 1; + break; + } + } + if (!did_bind) { + Janet v = janet_ev_lasterr(); + freeaddrinfo(binding); + freeaddrinfo(ai); + JSOCKCLOSE(sock); + janet_panicf("could not bind outgoing address: %V", v); + } else { + freeaddrinfo(binding); + } + } + + /* Wrap socket in abstract type JanetStream */ + JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE); + + /* Set up the socket for non-blocking IO before connecting */ + janet_net_socknoblock(sock); + + /* Connect to socket */ +#ifdef JANET_WINDOWS + int status = WSAConnect(sock, addr, addrlen, NULL, NULL, NULL, NULL); + int err = WSAGetLastError(); + freeaddrinfo(ai); +#else + int status = connect(sock, addr, addrlen); + int err = errno; + if (is_unix) { + janet_free(ai); + } else { + freeaddrinfo(ai); + } +#endif + + if (status) { +#ifdef JANET_WINDOWS + if (err != WSAEWOULDBLOCK) { +#else + if (err != EINPROGRESS) { +#endif + JSOCKCLOSE(sock); + Janet lasterr = janet_ev_lasterr(); + janet_panicf("could not connect socket: %V", lasterr); + } + } + + net_sched_connect(stream); +} + +static const char *serverify_socket(JSock sfd) { + /* Set various socket options */ + int enable = 1; + if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(int)) < 0) { + return "setsockopt(SO_REUSEADDR) failed"; + } +#ifdef SO_REUSEPORT + if (setsockopt(sfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0) { + return "setsockopt(SO_REUSEPORT) failed"; + } +#endif + janet_net_socknoblock(sfd); + return NULL; +} + +#ifdef JANET_WINDOWS +#define JANET_SHUTDOWN_RW SD_BOTH +#define JANET_SHUTDOWN_R SD_RECEIVE +#define JANET_SHUTDOWN_W SD_SEND +#else +#define JANET_SHUTDOWN_RW SHUT_RDWR +#define JANET_SHUTDOWN_R SHUT_RD +#define JANET_SHUTDOWN_W SHUT_WR +#endif + +JANET_CORE_FN(cfun_net_shutdown, + "(net/shutdown stream &opt mode)", + "Stop communication on this socket in a graceful manner, either in both directions or just " + "reading/writing from the stream. The `mode` parameter controls which communication to stop on the socket. " + "\n\n* `:wr` is the default and prevents both reading new data from the socket and writing new data to the socket.\n" + "* `:r` disables reading new data from the socket.\n" + "* `:w` disable writing data to the socket.\n\n" + "Returns the original socket.") { + janet_arity(argc, 1, 2); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_SOCKET); + int shutdown_type = JANET_SHUTDOWN_RW; + if (argc == 2) { + const uint8_t *kw = janet_getkeyword(argv, 1); + if (0 == janet_cstrcmp(kw, "rw")) { + shutdown_type = JANET_SHUTDOWN_RW; + } else if (0 == janet_cstrcmp(kw, "r")) { + shutdown_type = JANET_SHUTDOWN_R; + } else if (0 == janet_cstrcmp(kw, "w")) { + shutdown_type = JANET_SHUTDOWN_W; + } else { + janet_panicf("unexpected keyword %v", argv[1]); + } + } + int status; +#ifdef JANET_WINDOWS + status = shutdown((SOCKET) stream->handle, shutdown_type); +#else + do { + status = shutdown(stream->handle, shutdown_type); + } while (status == -1 && errno == EINTR); +#endif + if (status) { + janet_panicf("could not shutdown socket: %V", janet_ev_lasterr()); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_net_listen, + "(net/listen host port &opt type)", + "Creates a server. Returns a new stream that is neither readable nor " + "writeable. Use net/accept or net/accept-loop be to handle connections and start the server. " + "The type parameter specifies the type of network connection, either " + "a :stream (usually tcp), or :datagram (usually udp). If not specified, the default is " + ":stream. The host and port arguments are the same as in net/address.") { + janet_sandbox_assert(JANET_SANDBOX_NET_LISTEN); + janet_arity(argc, 2, 3); + + /* Get host, port, and handler*/ + int socktype = janet_get_sockettype(argv, argc, 2); + int is_unix = 0; + struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 1, &is_unix); + + JSock sfd = JSOCKDEFAULT; +#ifndef JANET_WINDOWS + if (is_unix) { + sfd = socket(AF_UNIX, socktype | JSOCKFLAGS, 0); + if (!JSOCKVALID(sfd)) { + janet_free(ai); + janet_panicf("could not create socket: %V", janet_ev_lasterr()); + } + const char *err = serverify_socket(sfd); + if (NULL != err || bind(sfd, (struct sockaddr *)ai, sizeof(struct sockaddr_un))) { + JSOCKCLOSE(sfd); + janet_free(ai); + if (err) { + janet_panic(err); + } else { + janet_panicf("could not bind socket: %V", janet_ev_lasterr()); + } + } + janet_free(ai); + } else +#endif + { + /* Check all addrinfos in a loop for the first that we can bind to. */ + struct addrinfo *rp = NULL; + for (rp = ai; rp != NULL; rp = rp->ai_next) { +#ifdef JANET_WINDOWS + sfd = WSASocketW(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED); +#else + sfd = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol); +#endif + if (!JSOCKVALID(sfd)) continue; + const char *err = serverify_socket(sfd); + if (NULL != err) { + JSOCKCLOSE(sfd); + continue; + } + /* Bind */ + if (bind(sfd, rp->ai_addr, (int) rp->ai_addrlen) == 0) break; + JSOCKCLOSE(sfd); + } + freeaddrinfo(ai); + if (NULL == rp) { + janet_panic("could not bind to any sockets"); + } + } + + if (socktype == SOCK_DGRAM) { + /* Datagram server (UDP) */ + JanetStream *stream = make_stream(sfd, JANET_STREAM_UDPSERVER | JANET_STREAM_READABLE); + return janet_wrap_abstract(stream); + } else { + /* Stream server (TCP) */ + + /* listen */ + int status = listen(sfd, 1024); + if (status) { + JSOCKCLOSE(sfd); + janet_panicf("could not listen on file descriptor: %V", janet_ev_lasterr()); + } + + /* Put sfd on our loop */ + JanetStream *stream = make_stream(sfd, JANET_STREAM_ACCEPTABLE); + return janet_wrap_abstract(stream); + } +} + +/* Types of socket's we need to deal with - relevant type puns below. +struct sockaddr *sa; // Common base structure +struct sockaddr_storage *ss; // Size of largest socket address type +struct sockaddr_in *sin; // IPv4 address + port +struct sockaddr_in6 *sin6; // IPv6 address + port +struct sockaddr_un *sun; // Unix Domain Socket Address +*/ + +/* Turn a socket address into a host, port pair. + * For unix domain sockets, returned tuple will have only a single element, the path string. */ +static Janet janet_so_getname(const void *sa_any) { + const struct sockaddr *sa = sa_any; + char buffer[SA_ADDRSTRLEN]; + switch (sa->sa_family) { + default: + janet_panic("unknown address family"); + case AF_INET: { + const struct sockaddr_in *sai = sa_any; + if (!inet_ntop(AF_INET, &(sai->sin_addr), buffer, sizeof(buffer))) { + janet_panic("unable to decode ipv4 host address"); + } + Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai->sin_port))}; + return janet_wrap_tuple(janet_tuple_n(pair, 2)); + } +#ifndef JANET_NO_IPV6 + case AF_INET6: { + const struct sockaddr_in6 *sai6 = sa_any; + if (!inet_ntop(AF_INET6, &(sai6->sin6_addr), buffer, sizeof(buffer))) { + janet_panic("unable to decode ipv4 host address"); + } + Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai6->sin6_port))}; + return janet_wrap_tuple(janet_tuple_n(pair, 2)); + } +#endif +#ifndef JANET_WINDOWS + case AF_UNIX: { + const struct sockaddr_un *sun = sa_any; + Janet pathname; + if (sun->sun_path[0] == '\0') { + memcpy(buffer, sun->sun_path, sizeof(sun->sun_path)); + buffer[0] = '@'; + pathname = janet_cstringv(buffer); + } else { + pathname = janet_cstringv(sun->sun_path); + } + return janet_wrap_tuple(janet_tuple_n(&pathname, 1)); + } +#endif + } +} + +JANET_CORE_FN(cfun_net_getsockname, + "(net/localname stream)", + "Gets the local address and port in a tuple in that order.") { + janet_fixarity(argc, 1); + JanetStream *js = janet_getabstract(argv, 0, &janet_stream_type); + if (js->flags & JANET_STREAM_CLOSED) janet_panic("stream closed"); + struct sockaddr_storage ss; + socklen_t slen = sizeof(ss); + memset(&ss, 0, slen); + if (getsockname((JSock)js->handle, (struct sockaddr *) &ss, &slen)) { + janet_panicf("Failed to get localname on %v: %V", argv[0], janet_ev_lasterr()); + } + janet_assert(slen <= (socklen_t) sizeof(ss), "socket address truncated"); + return janet_so_getname(&ss); +} + +JANET_CORE_FN(cfun_net_getpeername, + "(net/peername stream)", + "Gets the remote peer's address and port in a tuple in that order.") { + janet_fixarity(argc, 1); + JanetStream *js = janet_getabstract(argv, 0, &janet_stream_type); + if (js->flags & JANET_STREAM_CLOSED) janet_panic("stream closed"); + struct sockaddr_storage ss; + socklen_t slen = sizeof(ss); + memset(&ss, 0, slen); + if (getpeername((JSock)js->handle, (struct sockaddr *)&ss, &slen)) { + janet_panicf("Failed to get peername on %v: %V", argv[0], janet_ev_lasterr()); + } + janet_assert(slen <= (socklen_t) sizeof(ss), "socket address truncated"); + return janet_so_getname(&ss); +} + +JANET_CORE_FN(cfun_net_address_unpack, + "(net/address-unpack address)", + "Given an address returned by net/address, return a host, port pair. Unix domain sockets " + "will have only the path in the returned tuple.") { + janet_fixarity(argc, 1); + struct sockaddr *sa = janet_getabstract(argv, 0, &janet_address_type); + return janet_so_getname(sa); +} + +JANET_CORE_FN(cfun_stream_accept_loop, + "(net/accept-loop stream handler)", + "Shorthand for running a server stream that will continuously accept new connections. " + "Blocks the current fiber until the stream is closed, and will return the stream.") { + janet_fixarity(argc, 2); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET); + JanetFunction *fun = janet_getfunction(argv, 1); + if (fun->def->min_arity < 1) janet_panic("handler function must take at least 1 argument"); + janet_sched_accept(stream, fun); +} + +JANET_CORE_FN(cfun_stream_accept, + "(net/accept stream &opt timeout)", + "Get the next connection on a server stream. This would usually be called in a loop in a dedicated fiber. " + "Takes an optional timeout in seconds, after which will return nil. " + "Returns a new duplex stream which represents a connection to the client.") { + janet_arity(argc, 1, 2); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET); + double to = janet_optnumber(argv, argc, 1, INFINITY); + if (to != INFINITY) janet_addtimeout(to); + janet_sched_accept(stream, NULL); +} + +JANET_CORE_FN(cfun_stream_read, + "(net/read stream nbytes &opt buf timeout)", + "Read up to n bytes from a stream, suspending the current fiber until the bytes are available. " + "`n` can also be the keyword `:all` to read into the buffer until end of stream. " + "If less than n bytes are available (and more than 0), will push those bytes and return early. " + "Takes an optional timeout in seconds, after which will return nil. " + "Returns a buffer with up to n more bytes in it, or raises an error if the read failed.") { + janet_arity(argc, 2, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_READABLE | JANET_STREAM_SOCKET); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (janet_keyeq(argv[1], "all")) { + if (to != INFINITY) janet_addtimeout(to); + janet_ev_recvchunk(stream, buffer, INT32_MAX, MSG_NOSIGNAL); + } else { + int32_t n = janet_getnat(argv, 1); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_recv(stream, buffer, n, MSG_NOSIGNAL); + } +} + +JANET_CORE_FN(cfun_stream_chunk, + "(net/chunk stream nbytes &opt buf timeout)", + "Same a net/read, but will wait for all n bytes to arrive rather than return early. " + "Takes an optional timeout in seconds, after which will return nil.") { + janet_arity(argc, 2, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_READABLE | JANET_STREAM_SOCKET); + int32_t n = janet_getnat(argv, 1); + JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_recvchunk(stream, buffer, n, MSG_NOSIGNAL); +} + +JANET_CORE_FN(cfun_stream_recv_from, + "(net/recv-from stream nbytes buf &opt timeout)", + "Receives data from a server stream and puts it into a buffer. Returns the socket-address the " + "packet came from. Takes an optional timeout in seconds, after which will return nil.") { + janet_arity(argc, 3, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_UDPSERVER | JANET_STREAM_SOCKET); + int32_t n = janet_getnat(argv, 1); + JanetBuffer *buffer = janet_getbuffer(argv, 2); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_recvfrom(stream, buffer, n, MSG_NOSIGNAL); +} + +JANET_CORE_FN(cfun_stream_write, + "(net/write stream data &opt timeout)", + "Write data to a stream, suspending the current fiber until the write " + "completes. Takes an optional timeout in seconds, after which will return nil. " + "Returns nil, or raises an error if the write failed.") { + janet_arity(argc, 2, 3); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_WRITABLE | JANET_STREAM_SOCKET); + double to = janet_optnumber(argv, argc, 2, INFINITY); + if (janet_checktype(argv[1], JANET_BUFFER)) { + if (to != INFINITY) janet_addtimeout(to); + janet_ev_send_buffer(stream, janet_getbuffer(argv, 1), MSG_NOSIGNAL); + } else { + JanetByteView bytes = janet_getbytes(argv, 1); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_send_string(stream, bytes.bytes, MSG_NOSIGNAL); + } +} + +JANET_CORE_FN(cfun_stream_send_to, + "(net/send-to stream dest data &opt timeout)", + "Writes a datagram to a server stream. dest is a the destination address of the packet. " + "Takes an optional timeout in seconds, after which will return nil. " + "Returns stream.") { + janet_arity(argc, 3, 4); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_UDPSERVER | JANET_STREAM_SOCKET); + void *dest = janet_getabstract(argv, 1, &janet_address_type); + double to = janet_optnumber(argv, argc, 3, INFINITY); + if (janet_checktype(argv[2], JANET_BUFFER)) { + if (to != INFINITY) janet_addtimeout(to); + janet_ev_sendto_buffer(stream, janet_getbuffer(argv, 2), dest, MSG_NOSIGNAL); + } else { + JanetByteView bytes = janet_getbytes(argv, 2); + if (to != INFINITY) janet_addtimeout(to); + janet_ev_sendto_string(stream, bytes.bytes, dest, MSG_NOSIGNAL); + } +} + +JANET_CORE_FN(cfun_stream_flush, + "(net/flush stream)", + "Make sure that a stream is not buffering any data. This temporarily disables Nagle's algorithm. " + "Use this to make sure data is sent without delay. Returns stream.") { + janet_fixarity(argc, 1); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_WRITABLE | JANET_STREAM_SOCKET); + /* Toggle no delay flag */ + int flag = 1; + setsockopt((JSock) stream->handle, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)); + flag = 0; + setsockopt((JSock) stream->handle, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)); + return argv[0]; +} + +struct sockopt_type { + const char *name; + int level; + int optname; + enum JanetType type; +}; + +/* List of supported socket options; The type JANET_POINTER is used + * for options that require special handling depending on the type. */ +static const struct sockopt_type sockopt_type_list[] = { + { "so-broadcast", SOL_SOCKET, SO_BROADCAST, JANET_BOOLEAN }, + { "so-reuseaddr", SOL_SOCKET, SO_REUSEADDR, JANET_BOOLEAN }, + { "so-keepalive", SOL_SOCKET, SO_KEEPALIVE, JANET_BOOLEAN }, + { "ip-multicast-ttl", IPPROTO_IP, IP_MULTICAST_TTL, JANET_NUMBER }, + { "ip-add-membership", IPPROTO_IP, IP_ADD_MEMBERSHIP, JANET_POINTER }, + { "ip-drop-membership", IPPROTO_IP, IP_DROP_MEMBERSHIP, JANET_POINTER }, +#ifndef JANET_NO_IPV6 + { "ipv6-join-group", IPPROTO_IPV6, IPV6_JOIN_GROUP, JANET_POINTER }, + { "ipv6-leave-group", IPPROTO_IPV6, IPV6_LEAVE_GROUP, JANET_POINTER }, +#endif + { NULL, 0, 0, JANET_POINTER } +}; + +JANET_CORE_FN(cfun_net_setsockopt, + "(net/setsockopt stream option value)", + "set socket options.\n" + "\n" + "supported options and associated value types:\n" + "- :so-broadcast boolean\n" + "- :so-reuseaddr boolean\n" + "- :so-keepalive boolean\n" + "- :ip-multicast-ttl number\n" + "- :ip-add-membership string\n" + "- :ip-drop-membership string\n" + "- :ipv6-join-group string\n" + "- :ipv6-leave-group string\n") { + janet_arity(argc, 3, 3); + JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type); + janet_stream_flags(stream, JANET_STREAM_SOCKET); + JanetKeyword optstr = janet_getkeyword(argv, 1); + + const struct sockopt_type *st = sockopt_type_list; + while (st->name) { + if (janet_cstrcmp(optstr, st->name) == 0) { + break; + } + st++; + } + + if (st->name == NULL) { + janet_panicf("unknown socket option %q", argv[1]); + } + + union { + int v_int; + struct ip_mreq v_mreq; +#ifndef JANET_NO_IPV6 + struct ipv6_mreq v_mreq6; +#endif + } val; + + void *optval = (void *)&val; + socklen_t optlen = 0; + + if (st->type == JANET_BOOLEAN) { + val.v_int = janet_getboolean(argv, 2); + optlen = sizeof(val.v_int); + } else if (st->type == JANET_NUMBER) { + val.v_int = janet_getinteger(argv, 2); + optlen = sizeof(val.v_int); + } else if (st->optname == IP_ADD_MEMBERSHIP || st->optname == IP_DROP_MEMBERSHIP) { + const char *addr = janet_getcstring(argv, 2); + memset(&val.v_mreq, 0, sizeof val.v_mreq); + val.v_mreq.imr_interface.s_addr = htonl(INADDR_ANY); + inet_pton(AF_INET, addr, &val.v_mreq.imr_multiaddr.s_addr); + optlen = sizeof(val.v_mreq); +#ifndef JANET_NO_IPV6 + } else if (st->optname == IPV6_JOIN_GROUP || st->optname == IPV6_LEAVE_GROUP) { + const char *addr = janet_getcstring(argv, 2); + memset(&val.v_mreq6, 0, sizeof val.v_mreq6); + val.v_mreq6.ipv6mr_interface = 0; + inet_pton(AF_INET6, addr, &val.v_mreq6.ipv6mr_multiaddr); + optlen = sizeof(val.v_mreq6); +#endif + } else { + janet_panicf("invalid socket option type"); + } + + janet_assert(optlen != 0, "invalid socket option value"); + + int r = setsockopt((JSock) stream->handle, st->level, st->optname, optval, optlen); + if (r == -1) { + janet_panicf("setsockopt(%q): %s", argv[1], strerror(errno)); + } + + return janet_wrap_nil(); +} + +static const JanetMethod net_stream_methods[] = { + {"chunk", cfun_stream_chunk}, + {"close", janet_cfun_stream_close}, + {"read", cfun_stream_read}, + {"write", cfun_stream_write}, + {"flush", cfun_stream_flush}, + {"accept", cfun_stream_accept}, + {"accept-loop", cfun_stream_accept_loop}, + {"send-to", cfun_stream_send_to}, + {"recv-from", cfun_stream_recv_from}, + {"evread", janet_cfun_stream_read}, + {"evchunk", janet_cfun_stream_chunk}, + {"evwrite", janet_cfun_stream_write}, + {"shutdown", cfun_net_shutdown}, + {"setsockopt", cfun_net_setsockopt}, + {NULL, NULL} +}; + +static JanetStream *make_stream(JSock handle, uint32_t flags) { + return janet_stream((JanetHandle) handle, flags | JANET_STREAM_SOCKET, net_stream_methods); +} + +void janet_lib_net(JanetTable *env) { + JanetRegExt net_cfuns[] = { + JANET_CORE_REG("net/address", cfun_net_sockaddr), + JANET_CORE_REG("net/listen", cfun_net_listen), + JANET_CORE_REG("net/accept", cfun_stream_accept), + JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), + JANET_CORE_REG("net/read", cfun_stream_read), + JANET_CORE_REG("net/chunk", cfun_stream_chunk), + JANET_CORE_REG("net/write", cfun_stream_write), + JANET_CORE_REG("net/send-to", cfun_stream_send_to), + JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), + JANET_CORE_REG("net/flush", cfun_stream_flush), + JANET_CORE_REG("net/connect", cfun_net_connect), + JANET_CORE_REG("net/shutdown", cfun_net_shutdown), + JANET_CORE_REG("net/peername", cfun_net_getpeername), + JANET_CORE_REG("net/localname", cfun_net_getsockname), + JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), + JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, net_cfuns); +} + +void janet_net_init(void) { +#ifdef JANET_WINDOWS + WSADATA wsaData; + janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); +#endif +} + +void janet_net_deinit(void) { +#ifdef JANET_WINDOWS + WSACleanup(); +#endif +} + +#endif + + +/* src/core/os.c */ +#line 0 "src/core/os.c" + +/* +* Copyright (c) 2023 Calvin Rose and contributors. +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "gc.h" +#endif + +#ifndef JANET_REDUCED_OS + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef JANET_BSD +#include +#endif + +#ifdef JANET_LINUX +#include +#endif + +#ifdef JANET_WINDOWS +#include +#include +#include +#include +#include +#else +#include +#include +#include +#include +#include +#include +#ifdef JANET_APPLE +#include +#define environ (*_NSGetEnviron()) +#else +extern char **environ; +#endif +#ifdef JANET_THREADS +#include +#endif +#endif + +/* Not POSIX, but all Unixes but Solaris have this function. */ +#if defined(JANET_POSIX) && !defined(__sun) +time_t timegm(struct tm *tm); +#elif defined(JANET_WINDOWS) +#define timegm _mkgmtime +#endif + +/* Access to some global variables should be synchronized if not in single threaded mode, as + * setenv/getenv are not thread safe. */ +#ifdef JANET_THREADS +# ifdef JANET_WINDOWS +static CRITICAL_SECTION env_lock; +static void janet_lock_environ(void) { + EnterCriticalSection(&env_lock); +} +static void janet_unlock_environ(void) { + LeaveCriticalSection(&env_lock); +} +# else +static pthread_mutex_t env_lock = PTHREAD_MUTEX_INITIALIZER; +static void janet_lock_environ(void) { + pthread_mutex_lock(&env_lock); +} +static void janet_unlock_environ(void) { + pthread_mutex_unlock(&env_lock); +} +# endif +#else +static void janet_lock_environ(void) { +} +static void janet_unlock_environ(void) { +} +#endif + +#endif /* JANET_REDCUED_OS */ + +/* Core OS functions */ + +/* Full OS functions */ + +#define janet_stringify1(x) #x +#define janet_stringify(x) janet_stringify1(x) + +JANET_CORE_FN(os_which, + "(os/which)", + "Check the current operating system. Returns one of:\n\n" + "* :windows\n\n" + "* :mingw\n\n" + "* :cygwin\n\n" + "* :macos\n\n" + "* :web - Web assembly (emscripten)\n\n" + "* :linux\n\n" + "* :freebsd\n\n" + "* :openbsd\n\n" + "* :netbsd\n\n" + "* :dragonfly\n\n" + "* :bsd\n\n" + "* :posix - A POSIX compatible system (default)\n\n" + "May also return a custom keyword specified at build time.") { + janet_fixarity(argc, 0); + (void) argv; +#if defined(JANET_OS_NAME) + return janet_ckeywordv(janet_stringify(JANET_OS_NAME)); +#elif defined(JANET_MINGW) + return janet_ckeywordv("mingw"); +#elif defined(JANET_CYGWIN) + return janet_ckeywordv("cygwin"); +#elif defined(JANET_WINDOWS) + return janet_ckeywordv("windows"); +#elif defined(JANET_APPLE) + return janet_ckeywordv("macos"); +#elif defined(__EMSCRIPTEN__) + return janet_ckeywordv("web"); +#elif defined(JANET_LINUX) + return janet_ckeywordv("linux"); +#elif defined(__FreeBSD__) + return janet_ckeywordv("freebsd"); +#elif defined(__NetBSD__) + return janet_ckeywordv("netbsd"); +#elif defined(__OpenBSD__) + return janet_ckeywordv("openbsd"); +#elif defined(__DragonFly__) + return janet_ckeywordv("dragonfly"); +#elif defined(JANET_BSD) + return janet_ckeywordv("bsd"); +#else + return janet_ckeywordv("posix"); +#endif +} + +/* Detect the ISA we are compiled for */ +JANET_CORE_FN(os_arch, + "(os/arch)", + "Check the ISA that janet was compiled for. Returns one of:\n\n" + "* :x86\n\n" + "* :x64\n\n" + "* :arm\n\n" + "* :aarch64\n\n" + "* :riscv32\n\n" + "* :riscv64\n\n" + "* :sparc\n\n" + "* :wasm\n\n" + "* :unknown\n") { + janet_fixarity(argc, 0); + (void) argv; + /* Check 64-bit vs 32-bit */ +#if defined(JANET_ARCH_NAME) + return janet_ckeywordv(janet_stringify(JANET_ARCH_NAME)); +#elif defined(__EMSCRIPTEN__) + return janet_ckeywordv("wasm"); +#elif (defined(__x86_64__) || defined(_M_X64)) + return janet_ckeywordv("x64"); +#elif defined(__i386) || defined(_M_IX86) + return janet_ckeywordv("x86"); +#elif defined(_M_ARM64) || defined(__aarch64__) + return janet_ckeywordv("aarch64"); +#elif defined(_M_ARM) || defined(__arm__) + return janet_ckeywordv("arm"); +#elif (defined(__riscv) && (__riscv_xlen == 64)) + return janet_ckeywordv("riscv64"); +#elif (defined(__riscv) && (__riscv_xlen == 32)) + return janet_ckeywordv("riscv32"); +#elif (defined(__sparc__)) + return janet_ckeywordv("sparc"); +#elif (defined(__ppc__)) + return janet_ckeywordv("ppc"); +#elif (defined(__ppc64__) || defined(_ARCH_PPC64) || defined(_M_PPC)) + return janet_ckeywordv("ppc64"); +#else + return janet_ckeywordv("unknown"); +#endif +} + +/* Detect the compiler used to build the interpreter */ +JANET_CORE_FN(os_compiler, + "(os/compiler)", + "Get the compiler used to compile the interpreter. Returns one of:\n\n" + "* :gcc\n\n" + "* :clang\n\n" + "* :msvc\n\n" + "* :unknown\n\n") { + janet_fixarity(argc, 0); + (void) argv; +#if defined(_MSC_VER) + return janet_ckeywordv("msvc"); +#elif defined(__clang__) + return janet_ckeywordv("clang"); +#elif defined(__GNUC__) + return janet_ckeywordv("gcc"); +#else + return janet_ckeywordv("unknown"); +#endif +} + +#undef janet_stringify1 +#undef janet_stringify + +JANET_CORE_FN(os_exit, + "(os/exit &opt x force)", + "Exit from janet with an exit code equal to x. If x is not an integer, " + "the exit with status equal the hash of x. If `force` is truthy will exit immediately and " + "skip cleanup code.") { + janet_arity(argc, 0, 2); + int status; + if (argc == 0) { + status = EXIT_SUCCESS; + } else if (janet_checkint(argv[0])) { + status = janet_unwrap_integer(argv[0]); + } else { + status = EXIT_FAILURE; + } + janet_deinit(); + if (argc >= 2 && janet_truthy(argv[1])) { + _exit(status); + } else { + exit(status); + } + return janet_wrap_nil(); +} + +#ifndef JANET_REDUCED_OS + +JANET_CORE_FN(os_cpu_count, + "(os/cpu-count &opt dflt)", + "Get an approximate number of CPUs available on for this process to use. If " + "unable to get an approximation, will return a default value dflt.") { + janet_arity(argc, 0, 1); + Janet dflt = argc > 0 ? argv[0] : janet_wrap_nil(); +#ifdef JANET_WINDOWS + (void) dflt; + SYSTEM_INFO info; + GetSystemInfo(&info); + return janet_wrap_integer(info.dwNumberOfProcessors); +#elif defined(JANET_LINUX) + (void) dflt; + cpu_set_t cs; + CPU_ZERO(&cs); + sched_getaffinity(0, sizeof(cs), &cs); + int count = CPU_COUNT(&cs); + return janet_wrap_integer(count); +#elif defined(JANET_BSD) && defined(HW_NCPUONLINE) + (void) dflt; + const int name[2] = {CTL_HW, HW_NCPUONLINE}; + int result = 0; + size_t len = sizeof(int); + if (-1 == sysctl(name, 2, &result, &len, NULL, 0)) { + return dflt; + } + return janet_wrap_integer(result); +#elif defined(JANET_BSD) && defined(HW_NCPU) + (void) dflt; + const int name[2] = {CTL_HW, HW_NCPU}; + int result = 0; + size_t len = sizeof(int); + if (-1 == sysctl(name, 2, &result, &len, NULL, 0)) { + return dflt; + } + return janet_wrap_integer(result); +#else + return dflt; +#endif +} + +#ifndef JANET_NO_PROCESSES + +/* Get env for os_execute */ +#ifdef JANET_WINDOWS +typedef char *EnvBlock; +#else +typedef char **EnvBlock; +#endif + +/* Get env for os_execute */ +static EnvBlock os_execute_env(int32_t argc, const Janet *argv) { + if (argc <= 2) return NULL; + JanetDictView dict = janet_getdictionary(argv, 2); +#ifdef JANET_WINDOWS + JanetBuffer *temp = janet_buffer(10); + for (int32_t i = 0; i < dict.cap; i++) { + const JanetKV *kv = dict.kvs + i; + if (!janet_checktype(kv->key, JANET_STRING)) continue; + if (!janet_checktype(kv->value, JANET_STRING)) continue; + const uint8_t *keys = janet_unwrap_string(kv->key); + const uint8_t *vals = janet_unwrap_string(kv->value); + janet_buffer_push_bytes(temp, keys, janet_string_length(keys)); + janet_buffer_push_u8(temp, '='); + janet_buffer_push_bytes(temp, vals, janet_string_length(vals)); + janet_buffer_push_u8(temp, '\0'); + } + janet_buffer_push_u8(temp, '\0'); + char *ret = janet_smalloc(temp->count); + memcpy(ret, temp->data, temp->count); + return ret; +#else + char **envp = janet_smalloc(sizeof(char *) * ((size_t)dict.len + 1)); + int32_t j = 0; + for (int32_t i = 0; i < dict.cap; i++) { + const JanetKV *kv = dict.kvs + i; + if (!janet_checktype(kv->key, JANET_STRING)) continue; + if (!janet_checktype(kv->value, JANET_STRING)) continue; + const uint8_t *keys = janet_unwrap_string(kv->key); + const uint8_t *vals = janet_unwrap_string(kv->value); + int32_t klen = janet_string_length(keys); + int32_t vlen = janet_string_length(vals); + /* Check keys has no embedded 0s or =s. */ + int skip = 0; + for (int32_t k = 0; k < klen; k++) { + if (keys[k] == '\0' || keys[k] == '=') { + skip = 1; + break; + } + } + if (skip) continue; + char *envitem = janet_smalloc((size_t) klen + (size_t) vlen + 2); + memcpy(envitem, keys, klen); + envitem[klen] = '='; + memcpy(envitem + klen + 1, vals, vlen); + envitem[klen + vlen + 1] = 0; + envp[j++] = envitem; + } + envp[j] = NULL; + return envp; +#endif +} + +static void os_execute_cleanup(EnvBlock envp, const char **child_argv) { +#ifdef JANET_WINDOWS + (void) child_argv; + if (NULL != envp) janet_sfree(envp); +#else + janet_sfree((void *)child_argv); + if (NULL != envp) { + char **envitem = envp; + while (*envitem != NULL) { + janet_sfree(*envitem); + envitem++; + } + } + janet_sfree(envp); +#endif +} + +#ifdef JANET_WINDOWS +/* Windows processes created via CreateProcess get only one command line argument string, and + * must parse this themselves. Each processes is free to do this however they like, but the + * standard parsing method is CommandLineToArgvW. We need to properly escape arguments into + * a single string of this format. Returns a buffer that can be cast into a c string. */ +static JanetBuffer *os_exec_escape(JanetView args) { + JanetBuffer *b = janet_buffer(0); + for (int32_t i = 0; i < args.len; i++) { + const char *arg = janet_getcstring(args.items, i); + + /* Push leading space if not first */ + if (i) janet_buffer_push_u8(b, ' '); + + /* Find first special character */ + const char *first_spec = arg; + while (*first_spec) { + switch (*first_spec) { + case ' ': + case '\t': + case '\v': + case '\n': + case '"': + goto found; + case '\0': + janet_panic("embedded 0 not allowed in command line string"); + default: + first_spec++; + break; + } + } + found: + + /* Check if needs escape */ + if (*first_spec == '\0') { + /* No escape needed */ + janet_buffer_push_cstring(b, arg); + } else { + /* Escape */ + janet_buffer_push_u8(b, '"'); + for (const char *c = arg; ; c++) { + unsigned numBackSlashes = 0; + while (*c == '\\') { + c++; + numBackSlashes++; + } + if (*c == '"') { + /* Escape all backslashes and double quote mark */ + int32_t n = 2 * numBackSlashes + 1; + janet_buffer_extra(b, n + 1); + memset(b->data + b->count, '\\', n); + b->count += n; + janet_buffer_push_u8(b, '"'); + } else if (*c) { + /* Don't escape backslashes. */ + int32_t n = numBackSlashes; + janet_buffer_extra(b, n + 1); + memset(b->data + b->count, '\\', n); + b->count += n; + janet_buffer_push_u8(b, *c); + } else { + /* we finished Escape all backslashes */ + int32_t n = 2 * numBackSlashes; + janet_buffer_extra(b, n + 1); + memset(b->data + b->count, '\\', n); + b->count += n; + break; + } + } + janet_buffer_push_u8(b, '"'); + } + } + janet_buffer_push_u8(b, 0); + return b; +} +#endif + +/* Process type for when running a subprocess and not immediately waiting */ +static const JanetAbstractType ProcAT; +#define JANET_PROC_CLOSED 1 +#define JANET_PROC_WAITED 2 +#define JANET_PROC_WAITING 4 +#define JANET_PROC_ERROR_NONZERO 8 +#define JANET_PROC_OWNS_STDIN 16 +#define JANET_PROC_OWNS_STDOUT 32 +#define JANET_PROC_OWNS_STDERR 64 +#define JANET_PROC_ALLOW_ZOMBIE 128 +typedef struct { + int flags; +#ifdef JANET_WINDOWS + HANDLE pHandle; + HANDLE tHandle; +#else + pid_t pid; +#endif + int return_code; +#ifdef JANET_EV + JanetStream *in; + JanetStream *out; + JanetStream *err; +#else + JanetFile *in; + JanetFile *out; + JanetFile *err; +#endif +} JanetProc; + +#ifdef JANET_EV + +#ifdef JANET_WINDOWS + +static JanetEVGenericMessage janet_proc_wait_subr(JanetEVGenericMessage args) { + JanetProc *proc = (JanetProc *) args.argp; + WaitForSingleObject(proc->pHandle, INFINITE); + DWORD exitcode = 0; + GetExitCodeProcess(proc->pHandle, &exitcode); + args.tag = (int32_t) exitcode; + return args; +} + +#else /* windows check */ + +static int proc_get_status(JanetProc *proc) { + /* Use POSIX shell semantics for interpreting signals */ + int status = 0; + pid_t result; + do { + result = waitpid(proc->pid, &status, 0); + } while (result == -1 && errno == EINTR); + if (WIFEXITED(status)) { + status = WEXITSTATUS(status); + } else if (WIFSTOPPED(status)) { + status = WSTOPSIG(status) + 128; + } else if (WIFSIGNALED(status)) { + status = WTERMSIG(status) + 128; + } else { + /* Could possibly return -1 but for now, just panic */ + janet_panicf("Undefined status code for process termination, %d.", status); + } + return status; +} + +/* Function that is called in separate thread to wait on a pid */ +static JanetEVGenericMessage janet_proc_wait_subr(JanetEVGenericMessage args) { + JanetProc *proc = (JanetProc *) args.argp; + args.tag = proc_get_status(proc); + return args; +} + +#endif /* End windows check */ + +/* Callback that is called in main thread when subroutine completes. */ +static void janet_proc_wait_cb(JanetEVGenericMessage args) { + JanetProc *proc = (JanetProc *) args.argp; + if (NULL != proc) { + int status = args.tag; + proc->return_code = (int32_t) status; + proc->flags |= JANET_PROC_WAITED; + proc->flags &= ~JANET_PROC_WAITING; + janet_gcunroot(janet_wrap_abstract(proc)); + janet_gcunroot(janet_wrap_fiber(args.fiber)); + if ((status != 0) && (proc->flags & JANET_PROC_ERROR_NONZERO)) { + JanetString s = janet_formatc("command failed with non-zero exit code %d", status); + janet_cancel(args.fiber, janet_wrap_string(s)); + } else { + if (janet_fiber_can_resume(args.fiber)) { + janet_schedule(args.fiber, janet_wrap_integer(status)); + } + } + } +} + +#endif /* End ev check */ + +static int janet_proc_gc(void *p, size_t s) { + (void) s; + JanetProc *proc = (JanetProc *) p; +#ifdef JANET_WINDOWS + if (!(proc->flags & JANET_PROC_CLOSED)) { + if (!(proc->flags & JANET_PROC_ALLOW_ZOMBIE)) { + TerminateProcess(proc->pHandle, 1); + } + CloseHandle(proc->pHandle); + CloseHandle(proc->tHandle); + } +#else + if (!(proc->flags & (JANET_PROC_WAITED | JANET_PROC_ALLOW_ZOMBIE))) { + /* Kill and wait to prevent zombies */ + kill(proc->pid, SIGKILL); + int status; + if (!(proc->flags & JANET_PROC_WAITING)) { + waitpid(proc->pid, &status, 0); + } + } +#endif + return 0; +} + +static int janet_proc_mark(void *p, size_t s) { + (void) s; + JanetProc *proc = (JanetProc *)p; + if (NULL != proc->in) janet_mark(janet_wrap_abstract(proc->in)); + if (NULL != proc->out) janet_mark(janet_wrap_abstract(proc->out)); + if (NULL != proc->err) janet_mark(janet_wrap_abstract(proc->err)); + return 0; +} + +#ifdef JANET_EV +static JANET_NO_RETURN void +#else +static Janet +#endif +os_proc_wait_impl(JanetProc *proc) { + if (proc->flags & (JANET_PROC_WAITED | JANET_PROC_WAITING)) { + janet_panicf("cannot wait twice on a process"); + } +#ifdef JANET_EV + /* Event loop implementation - threaded call */ + proc->flags |= JANET_PROC_WAITING; + JanetEVGenericMessage targs; + memset(&targs, 0, sizeof(targs)); + targs.argp = proc; + targs.fiber = janet_root_fiber(); + janet_gcroot(janet_wrap_abstract(proc)); + janet_gcroot(janet_wrap_fiber(targs.fiber)); + janet_ev_threaded_call(janet_proc_wait_subr, targs, janet_proc_wait_cb); + janet_await(); +#else + /* Non evented implementation */ + proc->flags |= JANET_PROC_WAITED; + int status = 0; +#ifdef JANET_WINDOWS + WaitForSingleObject(proc->pHandle, INFINITE); + GetExitCodeProcess(proc->pHandle, &status); + if (!(proc->flags & JANET_PROC_CLOSED)) { + proc->flags |= JANET_PROC_CLOSED; + CloseHandle(proc->pHandle); + CloseHandle(proc->tHandle); + } +#else + waitpid(proc->pid, &status, 0); +#endif + proc->return_code = (int32_t) status; + return janet_wrap_integer(proc->return_code); +#endif +} + +JANET_CORE_FN(os_proc_wait, + "(os/proc-wait proc)", + "Suspend the current fiber until the subprocess completes. Returns the subprocess return code. " + "os/proc-wait cannot be called twice on the same process. If `ev/with-deadline` cancels `os/proc-wait` " + "with an error or os/proc-wait is cancelled with any error caused by anything else, os/proc-wait still " + "finishes in the background. Only after os/proc-wait finishes, a process is cleaned up by the operating " + "system. Thus, a process becomes a zombie process if os/proc-wait is not called.") { + janet_fixarity(argc, 1); + JanetProc *proc = janet_getabstract(argv, 0, &ProcAT); +#ifdef JANET_EV + os_proc_wait_impl(proc); + return janet_wrap_nil(); +#else + return os_proc_wait_impl(proc); +#endif +} + +struct keyword_signal { + const char *keyword; + int signal; +}; + +#ifndef JANET_WINDOWS +static const struct keyword_signal signal_keywords[] = { +#ifdef SIGKILL + {"kill", SIGKILL}, +#endif + {"int", SIGINT}, + {"abrt", SIGABRT}, + {"fpe", SIGFPE}, + {"ill", SIGILL}, + {"segv", SIGSEGV}, +#ifdef SIGTERM + {"term", SIGTERM}, +#endif +#ifdef SIGALRM + {"alrm", SIGALRM}, +#endif +#ifdef SIGHUP + {"hup", SIGHUP}, +#endif +#ifdef SIGPIPE + {"pipe", SIGPIPE}, +#endif +#ifdef SIGQUIT + {"quit", SIGQUIT}, +#endif +#ifdef SIGUSR1 + {"usr1", SIGUSR1}, +#endif +#ifdef SIGUSR2 + {"usr2", SIGUSR2}, +#endif +#ifdef SIGCHLD + {"chld", SIGCHLD}, +#endif +#ifdef SIGCONT + {"cont", SIGCONT}, +#endif +#ifdef SIGSTOP + {"stop", SIGSTOP}, +#endif +#ifdef SIGTSTP + {"tstp", SIGTSTP}, +#endif +#ifdef SIGTTIN + {"ttin", SIGTTIN}, +#endif +#ifdef SIGTTOU + {"ttou", SIGTTOU}, +#endif +#ifdef SIGBUS + {"bus", SIGBUS}, +#endif +#ifdef SIGPOLL + {"poll", SIGPOLL}, +#endif +#ifdef SIGPROF + {"prof", SIGPROF}, +#endif +#ifdef SIGSYS + {"sys", SIGSYS}, +#endif +#ifdef SIGTRAP + {"trap", SIGTRAP}, +#endif +#ifdef SIGURG + {"urg", SIGURG}, +#endif +#ifdef SIGVTALRM + {"vtlarm", SIGVTALRM}, +#endif +#ifdef SIGXCPU + {"xcpu", SIGXCPU}, +#endif +#ifdef SIGXFSZ + {"xfsz", SIGXFSZ}, +#endif + {NULL, 0}, +}; + +static int get_signal_kw(const Janet *argv, int32_t n) { + JanetKeyword signal_kw = janet_getkeyword(argv, n); + const struct keyword_signal *ptr = signal_keywords; + while (ptr->keyword) { + if (!janet_cstrcmp(signal_kw, ptr->keyword)) { + return ptr->signal; + } + ptr++; + } + janet_panicf("undefined signal %v", argv[n]); +} +#endif + +JANET_CORE_FN(os_proc_kill, + "(os/proc-kill proc &opt wait signal)", + "Kill a subprocess by sending SIGKILL to it on posix systems, or by closing the process " + "handle on windows. If os/proc-wait already finished for proc, os/proc-kill raises an error. After " + "sending signal to proc, if `wait` is truthy, will wait for the process to finish and return the exit " + "code by calling os/proc-wait. Otherwise, returns `proc`. If signal is specified, send it instead. " + "Signal keywords are named after their C counterparts but in lowercase with the leading `SIG` stripped. " + "Signals are ignored on windows.") { + janet_arity(argc, 1, 3); + JanetProc *proc = janet_getabstract(argv, 0, &ProcAT); + if (proc->flags & JANET_PROC_WAITED) { + janet_panicf("cannot kill process that has already finished"); + } +#ifdef JANET_WINDOWS + if (proc->flags & JANET_PROC_CLOSED) { + janet_panicf("cannot close process handle that is already closed"); + } + proc->flags |= JANET_PROC_CLOSED; + TerminateProcess(proc->pHandle, 1); + CloseHandle(proc->pHandle); + CloseHandle(proc->tHandle); +#else + int signal = -1; + if (argc == 3) { + signal = get_signal_kw(argv, 2); + } + int status = kill(proc->pid, signal == -1 ? SIGKILL : signal); + if (status) { + janet_panic(strerror(errno)); + } +#endif + /* After killing process we wait on it. */ + if (argc > 1 && janet_truthy(argv[1])) { +#ifdef JANET_EV + os_proc_wait_impl(proc); + return janet_wrap_nil(); +#else + return os_proc_wait_impl(proc); +#endif + } else { + return argv[0]; + } +} + +JANET_CORE_FN(os_proc_close, + "(os/proc-close proc)", + "Close pipes created by `os/spawn` if they have not been closed. Then, if os/proc-wait was not already " + "called on proc, os/proc-wait is called on it, and it returns the exit code returned by os/proc-wait. " + "Otherwise, returns nil.") { + janet_fixarity(argc, 1); + JanetProc *proc = janet_getabstract(argv, 0, &ProcAT); +#ifdef JANET_EV + if (proc->flags & JANET_PROC_OWNS_STDIN) janet_stream_close(proc->in); + if (proc->flags & JANET_PROC_OWNS_STDOUT) janet_stream_close(proc->out); + if (proc->flags & JANET_PROC_OWNS_STDERR) janet_stream_close(proc->err); +#else + if (proc->flags & JANET_PROC_OWNS_STDIN) janet_file_close(proc->in); + if (proc->flags & JANET_PROC_OWNS_STDOUT) janet_file_close(proc->out); + if (proc->flags & JANET_PROC_OWNS_STDERR) janet_file_close(proc->err); +#endif + proc->flags &= ~(JANET_PROC_OWNS_STDIN | JANET_PROC_OWNS_STDOUT | JANET_PROC_OWNS_STDERR); + if (proc->flags & (JANET_PROC_WAITED | JANET_PROC_WAITING)) { + return janet_wrap_nil(); + } +#ifdef JANET_EV + os_proc_wait_impl(proc); + return janet_wrap_nil(); +#else + return os_proc_wait_impl(proc); +#endif +} + +static void swap_handles(JanetHandle *handles) { + JanetHandle temp = handles[0]; + handles[0] = handles[1]; + handles[1] = temp; +} + +static void close_handle(JanetHandle handle) { +#ifdef JANET_WINDOWS + CloseHandle(handle); +#else + close(handle); +#endif +} + +#ifdef JANET_EV + +#ifndef JANET_WINDOWS +static void janet_signal_callback(JanetEVGenericMessage msg) { + int sig = msg.tag; + if (msg.argi) janet_interpreter_interrupt_handled(NULL); + Janet handlerv = janet_table_get(&janet_vm.signal_handlers, janet_wrap_integer(sig)); + if (!janet_checktype(handlerv, JANET_FUNCTION)) { + /* Let another thread/process try to handle this */ + sigset_t set; + sigemptyset(&set); + sigaddset(&set, sig); +#ifdef JANET_THREADS + pthread_sigmask(SIG_BLOCK, &set, NULL); +#else + sigprocmask(SIG_BLOCK, &set, NULL); +#endif + raise(sig); + return; + } + JanetFunction *handler = janet_unwrap_function(handlerv); + JanetFiber *fiber = janet_fiber(handler, 64, 0, NULL); + janet_schedule_soon(fiber, janet_wrap_nil(), JANET_SIGNAL_OK); +} + +static void janet_signal_trampoline_no_interrupt(int sig) { + /* Do not interact with global janet state here except for janet_ev_post_event, unsafe! */ + JanetEVGenericMessage msg; + memset(&msg, 0, sizeof(msg)); + msg.tag = sig; + janet_ev_post_event(&janet_vm, janet_signal_callback, msg); +} + +static void janet_signal_trampoline(int sig) { + /* Do not interact with global janet state here except for janet_ev_post_event, unsafe! */ + JanetEVGenericMessage msg; + memset(&msg, 0, sizeof(msg)); + msg.tag = sig; + msg.argi = 1; + janet_interpreter_interrupt(NULL); + janet_ev_post_event(&janet_vm, janet_signal_callback, msg); +} +#endif + +JANET_CORE_FN(os_sigaction, + "(os/sigaction which &opt handler interrupt-interpreter)", + "Add a signal handler for a given action. Use nil for the `handler` argument to remove a signal handler. " + "All signal handlers are the same as supported by `os/proc-kill`.") { + janet_sandbox_assert(JANET_SANDBOX_SIGNAL); + janet_arity(argc, 1, 3); +#ifdef JANET_WINDOWS + (void) argv; + janet_panic("unsupported on this platform"); +#else + /* TODO - per thread signal masks */ + int rc; + int sig = get_signal_kw(argv, 0); + JanetFunction *handler = janet_optfunction(argv, argc, 1, NULL); + int can_interrupt = janet_optboolean(argv, argc, 2, 0); + Janet oldhandler = janet_table_get(&janet_vm.signal_handlers, janet_wrap_integer(sig)); + if (!janet_checktype(oldhandler, JANET_NIL)) { + janet_gcunroot(oldhandler); + } + if (NULL != handler) { + Janet handlerv = janet_wrap_function(handler); + janet_gcroot(handlerv); + janet_table_put(&janet_vm.signal_handlers, janet_wrap_integer(sig), handlerv); + } else { + janet_table_put(&janet_vm.signal_handlers, janet_wrap_integer(sig), janet_wrap_nil()); + } + struct sigaction action; + sigset_t mask; + sigaddset(&mask, sig); + memset(&action, 0, sizeof(action)); + action.sa_flags |= SA_RESTART; + if (can_interrupt) { +#ifdef JANET_NO_INTERPRETER_INTERRUPT + janet_panic("interpreter interrupt not enabled"); +#else + action.sa_handler = janet_signal_trampoline; +#endif + } else { + action.sa_handler = janet_signal_trampoline_no_interrupt; + } + action.sa_mask = mask; + RETRY_EINTR(rc, sigaction(sig, &action, NULL)); + sigset_t set; + sigemptyset(&set); + sigaddset(&set, sig); +#ifdef JANET_THREADS + pthread_sigmask(SIG_UNBLOCK, &set, NULL); +#else + sigprocmask(SIG_UNBLOCK, &set, NULL); +#endif + return janet_wrap_nil(); +#endif +} + +#endif + +/* Create piped file for os/execute and os/spawn. Need to be careful that we mark + the error flag if we can't create pipe and don't leak handles. *handle will be cleaned + up by the calling function. If everything goes well, *handle is owned by the calling function, + (if it is set) and the returned handle owns the other end of the pipe, which will be closed + on GC or fclose. */ +static JanetHandle make_pipes(JanetHandle *handle, int reverse, int *errflag) { + JanetHandle handles[2]; +#ifdef JANET_EV + + /* non-blocking pipes */ + if (janet_make_pipe(handles, reverse ? 2 : 1)) goto error; + if (reverse) swap_handles(handles); +#ifdef JANET_WINDOWS + if (!SetHandleInformation(handles[0], HANDLE_FLAG_INHERIT, 0)) goto error; +#endif + *handle = handles[1]; + return handles[0]; + +#else + + /* Normal blocking pipes */ +#ifdef JANET_WINDOWS + SECURITY_ATTRIBUTES saAttr; + memset(&saAttr, 0, sizeof(saAttr)); + saAttr.nLength = sizeof(saAttr); + saAttr.bInheritHandle = TRUE; + if (!CreatePipe(handles, handles + 1, &saAttr, 0)) goto error; + if (reverse) swap_handles(handles); + /* Don't inherit the side of the pipe owned by this process */ + if (!SetHandleInformation(handles[0], HANDLE_FLAG_INHERIT, 0)) goto error; + *handle = handles[1]; + return handles[0]; +#else + if (pipe(handles)) goto error; + if (reverse) swap_handles(handles); + *handle = handles[1]; + return handles[0]; +#endif + +#endif +error: + *errflag = 1; + return JANET_HANDLE_NONE; +} + +static const JanetMethod proc_methods[] = { + {"wait", os_proc_wait}, + {"kill", os_proc_kill}, + {"close", os_proc_close}, + /* dud methods for janet_proc_next */ + {"in", NULL}, + {"out", NULL}, + {"err", NULL}, + {NULL, NULL} +}; + +static int janet_proc_get(void *p, Janet key, Janet *out) { + JanetProc *proc = (JanetProc *)p; + if (janet_keyeq(key, "in")) { + *out = (NULL == proc->in) ? janet_wrap_nil() : janet_wrap_abstract(proc->in); + return 1; + } + if (janet_keyeq(key, "out")) { + *out = (NULL == proc->out) ? janet_wrap_nil() : janet_wrap_abstract(proc->out); + return 1; + } + if (janet_keyeq(key, "err")) { + *out = (NULL == proc->err) ? janet_wrap_nil() : janet_wrap_abstract(proc->err); + return 1; + } +#ifndef JANET_WINDOWS + if (janet_keyeq(key, "pid")) { + *out = janet_wrap_number(proc->pid); + return 1; + } +#endif + if ((-1 != proc->return_code) && janet_keyeq(key, "return-code")) { + *out = janet_wrap_integer(proc->return_code); + return 1; + } + if (!janet_checktype(key, JANET_KEYWORD)) return 0; + return janet_getmethod(janet_unwrap_keyword(key), proc_methods, out); +} + +static Janet janet_proc_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(proc_methods, key); +} + +static const JanetAbstractType ProcAT = { + "core/process", + janet_proc_gc, + janet_proc_mark, + janet_proc_get, + NULL, /* put */ + NULL, /* marshal */ + NULL, /* unmarshal */ + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + janet_proc_next, + JANET_ATEND_NEXT +}; + +static JanetHandle janet_getjstream(Janet *argv, int32_t n, void **orig) { +#ifdef JANET_EV + JanetStream *stream = janet_checkabstract(argv[n], &janet_stream_type); + if (stream != NULL) { + if (stream->flags & JANET_STREAM_CLOSED) + janet_panic("stream is closed"); + *orig = stream; + return stream->handle; + } +#endif + JanetFile *f = janet_checkabstract(argv[n], &janet_file_type); + if (f != NULL) { + if (f->flags & JANET_FILE_CLOSED) { + janet_panic("file is closed"); + } + *orig = f; +#ifdef JANET_WINDOWS + return (HANDLE) _get_osfhandle(_fileno(f->file)); +#else + return fileno(f->file); +#endif + } + janet_panicf("expected file|stream, got %v", argv[n]); +} + +#ifdef JANET_EV +static JanetStream *get_stdio_for_handle(JanetHandle handle, void *orig, int iswrite) { + if (orig == NULL) { + return janet_stream(handle, iswrite ? JANET_STREAM_WRITABLE : JANET_STREAM_READABLE, NULL); + } else if (janet_abstract_type(orig) == &janet_file_type) { + JanetFile *jf = (JanetFile *)orig; + uint32_t flags = 0; + if (jf->flags & JANET_FILE_WRITE) { + flags |= JANET_STREAM_WRITABLE; + } + if (jf->flags & JANET_FILE_READ) { + flags |= JANET_STREAM_READABLE; + } + /* duplicate handle when converting file to stream */ +#ifdef JANET_WINDOWS + HANDLE prochandle = GetCurrentProcess(); + HANDLE newHandle = INVALID_HANDLE_VALUE; + if (!DuplicateHandle(prochandle, handle, prochandle, &newHandle, 0, FALSE, DUPLICATE_SAME_ACCESS)) { + return NULL; + } +#else + int newHandle = dup(handle); + if (newHandle < 0) { + return NULL; + } +#endif + return janet_stream(newHandle, flags, NULL); + } else { + return orig; + } +} +#else +static JanetFile *get_stdio_for_handle(JanetHandle handle, void *orig, int iswrite) { + if (NULL != orig) return (JanetFile *) orig; +#ifdef JANET_WINDOWS + int fd = _open_osfhandle((intptr_t) handle, iswrite ? _O_WRONLY : _O_RDONLY); + if (-1 == fd) return NULL; + FILE *f = _fdopen(fd, iswrite ? "w" : "r"); + if (NULL == f) { + _close(fd); + return NULL; + } +#else + FILE *f = fdopen(handle, iswrite ? "w" : "r"); + if (NULL == f) return NULL; +#endif + return janet_makejfile(f, iswrite ? JANET_FILE_WRITE : JANET_FILE_READ); +} +#endif + +typedef enum { + JANET_EXECUTE_EXECUTE, + JANET_EXECUTE_SPAWN, + JANET_EXECUTE_EXEC +} JanetExecuteMode; + +static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) { + janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS); + janet_arity(argc, 1, 3); + + /* Get flags */ + int is_spawn = mode == JANET_EXECUTE_SPAWN; + uint64_t flags = 0; + if (argc > 1) { + flags = janet_getflags(argv, 1, "epxd"); + } + + /* Get environment */ + int use_environ = !janet_flag_at(flags, 0); + EnvBlock envp = os_execute_env(argc, argv); + + /* Get arguments */ + JanetView exargs = janet_getindexed(argv, 0); + if (exargs.len < 1) { + janet_panic("expected at least 1 command line argument"); + } + + /* Optional stdio redirections */ + JanetAbstract orig_in = NULL, orig_out = NULL, orig_err = NULL; + JanetHandle new_in = JANET_HANDLE_NONE, new_out = JANET_HANDLE_NONE, new_err = JANET_HANDLE_NONE; + JanetHandle pipe_in = JANET_HANDLE_NONE, pipe_out = JANET_HANDLE_NONE, pipe_err = JANET_HANDLE_NONE; + int pipe_errflag = 0; /* Track errors setting up pipes */ + int pipe_owner_flags = (is_spawn && (flags & 0x8)) ? JANET_PROC_ALLOW_ZOMBIE : 0; + + /* Get optional redirections */ + if (argc > 2 && (mode != JANET_EXECUTE_EXEC)) { + JanetDictView tab = janet_getdictionary(argv, 2); + Janet maybe_stdin = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("in")); + Janet maybe_stdout = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("out")); + Janet maybe_stderr = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("err")); + if (is_spawn && janet_keyeq(maybe_stdin, "pipe")) { + new_in = make_pipes(&pipe_in, 1, &pipe_errflag); + pipe_owner_flags |= JANET_PROC_OWNS_STDIN; + } else if (!janet_checktype(maybe_stdin, JANET_NIL)) { + new_in = janet_getjstream(&maybe_stdin, 0, &orig_in); + } + if (is_spawn && janet_keyeq(maybe_stdout, "pipe")) { + new_out = make_pipes(&pipe_out, 0, &pipe_errflag); + pipe_owner_flags |= JANET_PROC_OWNS_STDOUT; + } else if (!janet_checktype(maybe_stdout, JANET_NIL)) { + new_out = janet_getjstream(&maybe_stdout, 0, &orig_out); + } + if (is_spawn && janet_keyeq(maybe_stderr, "pipe")) { + new_err = make_pipes(&pipe_err, 0, &pipe_errflag); + pipe_owner_flags |= JANET_PROC_OWNS_STDERR; + } else if (!janet_checktype(maybe_stderr, JANET_NIL)) { + new_err = janet_getjstream(&maybe_stderr, 0, &orig_err); + } + } + + /* Clean up if any of the pipes have any issues */ + if (pipe_errflag) { + if (pipe_in != JANET_HANDLE_NONE) close_handle(pipe_in); + if (pipe_out != JANET_HANDLE_NONE) close_handle(pipe_out); + if (pipe_err != JANET_HANDLE_NONE) close_handle(pipe_err); + janet_panic("failed to create pipes"); + } + +#ifdef JANET_WINDOWS + + HANDLE pHandle, tHandle; + SECURITY_ATTRIBUTES saAttr; + PROCESS_INFORMATION processInfo; + STARTUPINFO startupInfo; + memset(&saAttr, 0, sizeof(saAttr)); + memset(&processInfo, 0, sizeof(processInfo)); + memset(&startupInfo, 0, sizeof(startupInfo)); + startupInfo.cb = sizeof(startupInfo); + startupInfo.dwFlags |= STARTF_USESTDHANDLES; + saAttr.nLength = sizeof(saAttr); + + JanetBuffer *buf = os_exec_escape(exargs); + if (buf->count > 8191) { + if (pipe_in != JANET_HANDLE_NONE) CloseHandle(pipe_in); + if (pipe_out != JANET_HANDLE_NONE) CloseHandle(pipe_out); + if (pipe_err != JANET_HANDLE_NONE) CloseHandle(pipe_err); + janet_panic("command line string too long (max 8191 characters)"); + } + const char *path = (const char *) janet_unwrap_string(exargs.items[0]); + + /* Do IO redirection */ + + if (pipe_in != JANET_HANDLE_NONE) { + startupInfo.hStdInput = pipe_in; + } else if (new_in != JANET_HANDLE_NONE) { + startupInfo.hStdInput = new_in; + } else { + startupInfo.hStdInput = (HANDLE) _get_osfhandle(0); + } + + if (pipe_out != JANET_HANDLE_NONE) { + startupInfo.hStdOutput = pipe_out; + } else if (new_out != JANET_HANDLE_NONE) { + startupInfo.hStdOutput = new_out; + } else { + startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1); + } + + if (pipe_err != JANET_HANDLE_NONE) { + startupInfo.hStdError = pipe_err; + } else if (new_err != NULL) { + startupInfo.hStdError = new_err; + } else { + startupInfo.hStdError = (HANDLE) _get_osfhandle(2); + } + + int cp_failed = 0; + if (!CreateProcess(janet_flag_at(flags, 1) ? NULL : path, + (char *) buf->data, /* Single CLI argument */ + &saAttr, /* no proc inheritance */ + &saAttr, /* no thread inheritance */ + TRUE, /* handle inheritance */ + 0, /* flags */ + use_environ ? NULL : envp, /* pass in environment */ + NULL, /* use parents starting directory */ + &startupInfo, + &processInfo)) { + cp_failed = 1; + } + + if (pipe_in != JANET_HANDLE_NONE) CloseHandle(pipe_in); + if (pipe_out != JANET_HANDLE_NONE) CloseHandle(pipe_out); + if (pipe_err != JANET_HANDLE_NONE) CloseHandle(pipe_err); + + os_execute_cleanup(envp, NULL); + + if (cp_failed) { + janet_panic("failed to create process"); + } + + pHandle = processInfo.hProcess; + tHandle = processInfo.hThread; + +#else + + /* Result */ + int status = 0; + + const char **child_argv = janet_smalloc(sizeof(char *) * ((size_t) exargs.len + 1)); + for (int32_t i = 0; i < exargs.len; i++) + child_argv[i] = janet_getcstring(exargs.items, i); + child_argv[exargs.len] = NULL; + /* Coerce to form that works for spawn. I'm fairly confident no implementation + * of posix_spawn would modify the argv array passed in. */ + char *const *cargv = (char *const *)child_argv; + + if (use_environ) { + janet_lock_environ(); + } + + /* exec mode */ + if (mode == JANET_EXECUTE_EXEC) { +#ifdef JANET_WINDOWS + janet_panic("not supported on windows"); +#else + int status; + if (!use_environ) { + environ = envp; + } + do { + if (janet_flag_at(flags, 1)) { + status = execvp(cargv[0], cargv); + } else { + status = execv(cargv[0], cargv); + } + } while (status == -1 && errno == EINTR); + janet_panicf("%p: %s", cargv[0], strerror(errno ? errno : ENOENT)); +#endif + } + + /* Use posix_spawn to spawn new process */ + + /* Posix spawn setup */ + posix_spawn_file_actions_t actions; + posix_spawn_file_actions_init(&actions); + if (pipe_in != JANET_HANDLE_NONE) { + posix_spawn_file_actions_adddup2(&actions, pipe_in, 0); + posix_spawn_file_actions_addclose(&actions, pipe_in); + } else if (new_in != JANET_HANDLE_NONE && new_in != 0) { + posix_spawn_file_actions_adddup2(&actions, new_in, 0); + if (new_in != new_out && new_in != new_err) + posix_spawn_file_actions_addclose(&actions, new_in); + } + if (pipe_out != JANET_HANDLE_NONE) { + posix_spawn_file_actions_adddup2(&actions, pipe_out, 1); + posix_spawn_file_actions_addclose(&actions, pipe_out); + } else if (new_out != JANET_HANDLE_NONE && new_out != 1) { + posix_spawn_file_actions_adddup2(&actions, new_out, 1); + if (new_out != new_err) + posix_spawn_file_actions_addclose(&actions, new_out); + } + if (pipe_err != JANET_HANDLE_NONE) { + posix_spawn_file_actions_adddup2(&actions, pipe_err, 2); + posix_spawn_file_actions_addclose(&actions, pipe_err); + } else if (new_err != JANET_HANDLE_NONE && new_err != 2) { + posix_spawn_file_actions_adddup2(&actions, new_err, 2); + posix_spawn_file_actions_addclose(&actions, new_err); + } + + pid_t pid; + if (janet_flag_at(flags, 1)) { + status = posix_spawnp(&pid, + child_argv[0], &actions, NULL, cargv, + use_environ ? environ : envp); + } else { + status = posix_spawn(&pid, + child_argv[0], &actions, NULL, cargv, + use_environ ? environ : envp); + } + + posix_spawn_file_actions_destroy(&actions); + + if (pipe_in != JANET_HANDLE_NONE) close(pipe_in); + if (pipe_out != JANET_HANDLE_NONE) close(pipe_out); + if (pipe_err != JANET_HANDLE_NONE) close(pipe_err); + + if (use_environ) { + janet_unlock_environ(); + } + + os_execute_cleanup(envp, child_argv); + if (status) { + /* correct for macos bug where errno is not set */ + janet_panicf("%p: %s", argv[0], strerror(errno ? errno : ENOENT)); + } + +#endif + JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc)); + proc->return_code = -1; +#ifdef JANET_WINDOWS + proc->pHandle = pHandle; + proc->tHandle = tHandle; +#else + proc->pid = pid; +#endif + proc->in = NULL; + proc->out = NULL; + proc->err = NULL; + proc->flags = pipe_owner_flags; + if (janet_flag_at(flags, 2)) { + proc->flags |= JANET_PROC_ERROR_NONZERO; + } + if (is_spawn) { + /* Only set up pointers to stdin, stdout, and stderr if os/spawn. */ + if (new_in != JANET_HANDLE_NONE) { + proc->in = get_stdio_for_handle(new_in, orig_in, 1); + if (NULL == proc->in) janet_panic("failed to construct proc"); + } + if (new_out != JANET_HANDLE_NONE) { + proc->out = get_stdio_for_handle(new_out, orig_out, 0); + if (NULL == proc->out) janet_panic("failed to construct proc"); + } + if (new_err != JANET_HANDLE_NONE) { + proc->err = get_stdio_for_handle(new_err, orig_err, 0); + if (NULL == proc->err) janet_panic("failed to construct proc"); + } + return janet_wrap_abstract(proc); + } else { +#ifdef JANET_EV + os_proc_wait_impl(proc); +#else + return os_proc_wait_impl(proc); +#endif + } +} + +JANET_CORE_FN(os_execute, + "(os/execute args &opt flags env)", + "Execute a program on the system and pass it string arguments. `flags` " + "is a keyword that modifies how the program will execute.\n" + "* :e - enables passing an environment to the program. Without :e, the " + "current environment is inherited.\n" + "* :p - allows searching the current PATH for the binary to execute. " + "Without this flag, binaries must use absolute paths.\n" + "* :x - raise error if exit code is non-zero.\n" + "* :d - Don't try and terminate the process on garbage collection (allow spawning zombies).\n" + "`env` is a table or struct mapping environment variables to values. It can also " + "contain the keys :in, :out, and :err, which allow redirecting stdio in the subprocess. " + ":in, :out, and :err should be core/file values or core/stream values. core/file values and core/stream " + "values passed to :in, :out, and :err should be closed manually because os/execute doesn't close them. " + "Returns the exit code of the program.") { + return os_execute_impl(argc, argv, JANET_EXECUTE_EXECUTE); +} + +JANET_CORE_FN(os_spawn, + "(os/spawn args &opt flags env)", + "Execute a program on the system and return a handle to the process. Otherwise, takes the " + "same arguments as `os/execute`. Does not wait for the process. For each of the :in, :out, and :err keys " + "of the `env` argument, one can also pass in the keyword `:pipe` to get streams for standard IO of the " + "subprocess that can be read from and written to. The returned value `proc` has the fields :in, :out, " + ":err, and the additional field :pid on unix-like platforms. `(os/proc-wait proc)` must be called to " + "rejoin the subprocess. After `(os/proc-wait proc)` finishes, proc gains a new field, :return-code. " + "If :x flag is passed to os/spawn, non-zero exit code will cause os/proc-wait to raise an error. " + "If pipe streams created with :pipe keyword are not closed in time, janet can run out of file " + "descriptors. They can be closed individually, or `os/proc-close` can close all pipe streams on proc. " + "If pipe streams aren't read before `os/proc-wait` finishes, then pipe buffers become full, and the " + "process cannot finish because the process cannot print more on pipe buffers which are already full. " + "If the process cannot finish, os/proc-wait cannot finish, either.") { + return os_execute_impl(argc, argv, JANET_EXECUTE_SPAWN); +} + +JANET_CORE_FN(os_posix_exec, + "(os/posix-exec args &opt flags env)", + "Use the execvpe or execve system calls to replace the current process with an interface similar to os/execute. " + "Hoever, instead of creating a subprocess, the current process is replaced. Is not supported on windows, and " + "does not allow redirection of stdio.") { + return os_execute_impl(argc, argv, JANET_EXECUTE_EXEC); +} + +JANET_CORE_FN(os_posix_fork, + "(os/posix-fork)", + "Make a `fork` system call and create a new process. Return nil if in the new process, otherwise a core/process object (as returned by os/spawn). " + "Not supported on all systems (POSIX only).") { + janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS); + janet_fixarity(argc, 0); + (void) argv; +#ifdef JANET_WINDOWS + janet_panic("not supported"); +#else + pid_t result; + do { + result = fork(); + } while (result == -1 && errno == EINTR); + if (result == -1) { + janet_panic(strerror(errno)); + } + if (result) { + JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc)); + memset(proc, 0, sizeof(JanetProc)); + proc->pid = result; + proc->flags = JANET_PROC_ALLOW_ZOMBIE; + return janet_wrap_abstract(proc); + } + return janet_wrap_nil(); +#endif +} + +#ifdef JANET_EV +/* Runs in a separate thread */ +static JanetEVGenericMessage os_shell_subr(JanetEVGenericMessage args) { + int stat = system((const char *) args.argp); + janet_free(args.argp); + if (args.argi) { + args.tag = JANET_EV_TCTAG_INTEGER; + } else { + args.tag = JANET_EV_TCTAG_BOOLEAN; + } + args.argi = stat; + return args; +} +#endif + +JANET_CORE_FN(os_shell, + "(os/shell str)", + "Pass a command string str directly to the system shell.") { + janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS); + janet_arity(argc, 0, 1); + const char *cmd = argc + ? janet_getcstring(argv, 0) + : NULL; +#ifdef JANET_EV + janet_ev_threaded_await(os_shell_subr, 0, argc, cmd ? strdup(cmd) : NULL); +#else + int stat = system(cmd); + return argc + ? janet_wrap_integer(stat) + : janet_wrap_boolean(stat); +#endif +} + +#endif /* JANET_NO_PROCESSES */ + +JANET_CORE_FN(os_environ, + "(os/environ)", + "Get a copy of the OS environment table.") { + janet_sandbox_assert(JANET_SANDBOX_ENV); + (void) argv; + janet_fixarity(argc, 0); + int32_t nenv = 0; + janet_lock_environ(); + char **env = environ; + while (*env++) + nenv += 1; + JanetTable *t = janet_table(nenv); + for (int32_t i = 0; i < nenv; i++) { + char *e = environ[i]; + char *eq = strchr(e, '='); + if (!eq) { + janet_unlock_environ(); + janet_panic("no '=' in environ"); + } + char *v = eq + 1; + int32_t full_len = (int32_t) strlen(e); + int32_t val_len = (int32_t) strlen(v); + janet_table_put( + t, + janet_stringv((const uint8_t *)e, full_len - val_len - 1), + janet_stringv((const uint8_t *)v, val_len) + ); + } + janet_unlock_environ(); + return janet_wrap_table(t); +} + +JANET_CORE_FN(os_getenv, + "(os/getenv variable &opt dflt)", + "Get the string value of an environment variable.") { + janet_sandbox_assert(JANET_SANDBOX_ENV); + janet_arity(argc, 1, 2); + const char *cstr = janet_getcstring(argv, 0); + janet_lock_environ(); + const char *res = getenv(cstr); + Janet ret = res + ? janet_cstringv(res) + : argc == 2 + ? argv[1] + : janet_wrap_nil(); + janet_unlock_environ(); + return ret; +} + +JANET_CORE_FN(os_setenv, + "(os/setenv variable value)", + "Set an environment variable.") { +#ifdef JANET_WINDOWS +#define SETENV(K,V) _putenv_s(K, V) +#define UNSETENV(K) _putenv_s(K, "") +#else +#define SETENV(K,V) setenv(K, V, 1) +#define UNSETENV(K) unsetenv(K) +#endif + janet_sandbox_assert(JANET_SANDBOX_ENV); + janet_arity(argc, 1, 2); + const char *ks = janet_getcstring(argv, 0); + const char *vs = janet_optcstring(argv, argc, 1, NULL); + janet_lock_environ(); + if (NULL == vs) { + UNSETENV(ks); + } else { + SETENV(ks, vs); + } + janet_unlock_environ(); + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_time, + "(os/time)", + "Get the current time expressed as the number of whole seconds since " + "January 1, 1970, the Unix epoch. Returns a real number.") { + janet_fixarity(argc, 0); + (void) argv; + double dtime = (double)(time(NULL)); + return janet_wrap_number(dtime); +} + +JANET_CORE_FN(os_clock, + "(os/clock &opt source format)", + "Return the current time of the requested clock source.\n\n" + "The `source` argument selects the clock source to use, when not specified the default " + "is `:realtime`:\n" + "- :realtime: Return the real (i.e., wall-clock) time. This clock is affected by discontinuous " + " jumps in the system time\n" + "- :monotonic: Return the number of whole + fractional seconds since some fixed point in " + " time. The clock is guaranteed to be non-decreasing in real time.\n" + "- :cputime: Return the CPU time consumed by this process (i.e. all threads in the process)\n" + "The `format` argument selects the type of output, when not specified the default is `:double`:\n" + "- :double: Return the number of seconds + fractional seconds as a double\n" + "- :int: Return the number of seconds as an integer\n" + "- :tuple: Return a 2 integer tuple [seconds, nanoseconds]\n") { + enum JanetTimeSource source; + janet_sandbox_assert(JANET_SANDBOX_HRTIME); + janet_arity(argc, 0, 2); + + JanetKeyword sourcestr = janet_optkeyword(argv, argc, 0, (const uint8_t *) "realtime"); + if (janet_cstrcmp(sourcestr, "realtime") == 0) { + source = JANET_TIME_REALTIME; + } else if (janet_cstrcmp(sourcestr, "monotonic") == 0) { + source = JANET_TIME_MONOTONIC; + } else if (janet_cstrcmp(sourcestr, "cputime") == 0) { + source = JANET_TIME_CPUTIME; + } else { + janet_panicf("expected :realtime, :monotonic, or :cputime, got %v", argv[0]); + } + + struct timespec tv; + if (janet_gettime(&tv, source)) janet_panic("could not get time"); + + JanetKeyword formatstr = janet_optkeyword(argv, argc, 1, (const uint8_t *) "double"); + if (janet_cstrcmp(formatstr, "double") == 0) { + double dtime = tv.tv_sec + (tv.tv_nsec / 1E9); + return janet_wrap_number(dtime); + } else if (janet_cstrcmp(formatstr, "int") == 0) { + return janet_wrap_number(tv.tv_sec); + } else if (janet_cstrcmp(formatstr, "tuple") == 0) { + Janet tup[2] = {janet_wrap_integer(tv.tv_sec), + janet_wrap_integer(tv.tv_nsec) + }; + return janet_wrap_tuple(janet_tuple_n(tup, 2)); + } else { + janet_panicf("expected :double, :int, or :tuple, got %v", argv[1]); + } +} + +JANET_CORE_FN(os_sleep, + "(os/sleep n)", + "Suspend the program for `n` seconds. `n` can be a real number. Returns " + "nil.") { + janet_fixarity(argc, 1); + double delay = janet_getnumber(argv, 0); + if (delay < 0) janet_panic("invalid argument to sleep"); +#ifdef JANET_WINDOWS + Sleep((DWORD)(delay * 1000)); +#else + int rc; + struct timespec ts; + ts.tv_sec = (time_t) delay; + ts.tv_nsec = (delay <= UINT32_MAX) + ? (long)((delay - ((uint32_t)delay)) * 1000000000) + : 0; + RETRY_EINTR(rc, nanosleep(&ts, &ts)); +#endif + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_isatty, + "(os/isatty &opt file)", + "Returns true if `file` is a terminal. If `file` is not specified, " + "it will default to standard output.") { + janet_arity(argc, 0, 1); + FILE *f = (argc == 1) ? janet_getfile(argv, 0, NULL) : stdout; +#ifdef JANET_WINDOWS + int fd = _fileno(f); + if (fd == -1) janet_panic("not a valid stream"); + return janet_wrap_boolean(_isatty(fd)); +#else + int fd = fileno(f); + if (fd == -1) janet_panic(strerror(errno)); + return janet_wrap_boolean(isatty(fd)); +#endif +} + +JANET_CORE_FN(os_cwd, + "(os/cwd)", + "Returns the current working directory.") { + janet_fixarity(argc, 0); + (void) argv; + char buf[FILENAME_MAX]; + char *ptr; +#ifdef JANET_WINDOWS + ptr = _getcwd(buf, FILENAME_MAX); +#else + ptr = getcwd(buf, FILENAME_MAX); +#endif + if (NULL == ptr) janet_panic("could not get current directory"); + return janet_cstringv(ptr); +} + +JANET_CORE_FN(os_cryptorand, + "(os/cryptorand n &opt buf)", + "Get or append `n` bytes of good quality random data provided by the OS. Returns a new buffer or `buf`.") { + JanetBuffer *buffer; + janet_arity(argc, 1, 2); + int32_t offset; + int32_t n = janet_getinteger(argv, 0); + if (n < 0) janet_panic("expected positive integer"); + if (argc == 2) { + buffer = janet_getbuffer(argv, 1); + offset = buffer->count; + } else { + offset = 0; + buffer = janet_buffer(n); + } + /* We could optimize here by adding setcount_uninit */ + janet_buffer_setcount(buffer, offset + n); + + if (janet_cryptorand(buffer->data + offset, n) != 0) + janet_panic("unable to get sufficient random data"); + + return janet_wrap_buffer(buffer); +} + +/* Helper function to get given or current time as local or UTC struct tm. + * - arg n+0: optional time_t to be converted, uses current time if not given + * - arg n+1: optional truthy to indicate the convnersion uses local time */ +static struct tm *time_to_tm(const Janet *argv, int32_t argc, int32_t n, struct tm *t_infos) { + time_t t; + if (argc > n && !janet_checktype(argv[n], JANET_NIL)) { + int64_t integer = janet_getinteger64(argv, n); + t = (time_t) integer; + } else { + time(&t); + } + struct tm *t_info = NULL; + if (argc > n + 1 && janet_truthy(argv[n + 1])) { + /* local time */ +#ifdef JANET_WINDOWS + _tzset(); + localtime_s(t_infos, &t); + t_info = t_infos; +#else + tzset(); + t_info = localtime_r(&t, t_infos); +#endif + } else { + /* utc time */ +#ifdef JANET_WINDOWS + gmtime_s(t_infos, &t); + t_info = t_infos; +#else + t_info = gmtime_r(&t, t_infos); +#endif + } + return t_info; +} + +JANET_CORE_FN(os_date, + "(os/date &opt time local)", + "Returns the given time as a date struct, or the current time if `time` is not given. " + "Returns a struct with following key values. Note that all numbers are 0-indexed. " + "Date is given in UTC unless `local` is truthy, in which case the date is formatted for " + "the local timezone.\n\n" + "* :seconds - number of seconds [0-61]\n\n" + "* :minutes - number of minutes [0-59]\n\n" + "* :hours - number of hours [0-23]\n\n" + "* :month-day - day of month [0-30]\n\n" + "* :month - month of year [0, 11]\n\n" + "* :year - years since year 0 (e.g. 2019)\n\n" + "* :week-day - day of the week [0-6]\n\n" + "* :year-day - day of the year [0-365]\n\n" + "* :dst - if Day Light Savings is in effect") { + janet_arity(argc, 0, 2); + (void) argv; + struct tm t_infos; + struct tm *t_info = time_to_tm(argv, argc, 0, &t_infos); + JanetKV *st = janet_struct_begin(9); + janet_struct_put(st, janet_ckeywordv("seconds"), janet_wrap_number(t_info->tm_sec)); + janet_struct_put(st, janet_ckeywordv("minutes"), janet_wrap_number(t_info->tm_min)); + janet_struct_put(st, janet_ckeywordv("hours"), janet_wrap_number(t_info->tm_hour)); + janet_struct_put(st, janet_ckeywordv("month-day"), janet_wrap_number(t_info->tm_mday - 1)); + janet_struct_put(st, janet_ckeywordv("month"), janet_wrap_number(t_info->tm_mon)); + janet_struct_put(st, janet_ckeywordv("year"), janet_wrap_number(t_info->tm_year + 1900)); + janet_struct_put(st, janet_ckeywordv("week-day"), janet_wrap_number(t_info->tm_wday)); + janet_struct_put(st, janet_ckeywordv("year-day"), janet_wrap_number(t_info->tm_yday)); + janet_struct_put(st, janet_ckeywordv("dst"), janet_wrap_boolean(t_info->tm_isdst)); + return janet_wrap_struct(janet_struct_end(st)); +} + +#define SIZETIMEFMT 250 + +JANET_CORE_FN(os_strftime, + "(os/strftime fmt &opt time local)", + "Format the given time as a string, or the current time if `time` is not given. " + "The time is formatted according to the same rules as the ISO C89 function strftime(). " + "The time is formatted in UTC unless `local` is truthy, in which case the date is formatted for " + "the local timezone.") { + janet_arity(argc, 1, 3); + const char *fmt = janet_getcstring(argv, 0); + /* ANSI X3.159-1989, section 4.12.3.5 "The strftime function" */ + static const char *valid = "aAbBcdHIjmMpSUwWxXyYZ%"; + const char *p = fmt; + while (*p) { + if (*p++ == '%') { + if (!strchr(valid, *p)) { + janet_panicf("invalid conversion specifier '%%%c'", *p); + } + p++; + } + } + struct tm t_infos; + struct tm *t_info = time_to_tm(argv, argc, 1, &t_infos); + char buf[SIZETIMEFMT]; + (void)strftime(buf, SIZETIMEFMT, fmt, t_info); + return janet_cstringv(buf); +} + +static int entry_getdst(Janet env_entry) { + Janet v; + if (janet_checktype(env_entry, JANET_TABLE)) { + JanetTable *entry = janet_unwrap_table(env_entry); + v = janet_table_get(entry, janet_ckeywordv("dst")); + } else if (janet_checktype(env_entry, JANET_STRUCT)) { + const JanetKV *entry = janet_unwrap_struct(env_entry); + v = janet_struct_get(entry, janet_ckeywordv("dst")); + } else { + v = janet_wrap_nil(); + } + if (janet_checktype(v, JANET_NIL)) { + return -1; + } else { + return janet_truthy(v); + } +} + +#ifdef JANET_WINDOWS +typedef int32_t timeint_t; +#else +typedef int64_t timeint_t; +#endif + +static timeint_t entry_getint(Janet env_entry, char *field) { + Janet i; + if (janet_checktype(env_entry, JANET_TABLE)) { + JanetTable *entry = janet_unwrap_table(env_entry); + i = janet_table_get(entry, janet_ckeywordv(field)); + } else if (janet_checktype(env_entry, JANET_STRUCT)) { + const JanetKV *entry = janet_unwrap_struct(env_entry); + i = janet_struct_get(entry, janet_ckeywordv(field)); + } else { + return 0; + } + + if (janet_checktype(i, JANET_NIL)) { + return 0; + } + +#ifdef JANET_WINDOWS + if (!janet_checkint(i)) { + janet_panicf("bad slot #%s, expected 32 bit signed integer, got %v", + field, i); + } +#else + if (!janet_checkint64(i)) { + janet_panicf("bad slot #%s, expected 64 bit signed integer, got %v", + field, i); + } +#endif + + return (timeint_t)janet_unwrap_number(i); +} + +JANET_CORE_FN(os_mktime, + "(os/mktime date-struct &opt local)", + "Get the broken down date-struct time expressed as the number " + "of seconds since January 1, 1970, the Unix epoch. " + "Returns a real number. " + "Date is given in UTC unless `local` is truthy, in which case the " + "date is computed for the local timezone.\n\n" + "Inverse function to os/date.") { + janet_arity(argc, 1, 2); + time_t t; + struct tm t_info; + + /* Use memset instead of = {0} to silence paranoid warning in macos */ + memset(&t_info, 0, sizeof(t_info)); + + if (!janet_checktype(argv[0], JANET_TABLE) && + !janet_checktype(argv[0], JANET_STRUCT)) + janet_panic_type(argv[0], 0, JANET_TFLAG_DICTIONARY); + + t_info.tm_sec = entry_getint(argv[0], "seconds"); + t_info.tm_min = entry_getint(argv[0], "minutes"); + t_info.tm_hour = entry_getint(argv[0], "hours"); + t_info.tm_mday = entry_getint(argv[0], "month-day") + 1; + t_info.tm_mon = entry_getint(argv[0], "month"); + t_info.tm_year = entry_getint(argv[0], "year") - 1900; + t_info.tm_isdst = entry_getdst(argv[0]); + + if (argc >= 2 && janet_truthy(argv[1])) { + /* local time */ + t = mktime(&t_info); + } else { + /* utc time */ +#ifdef JANET_NO_UTC_MKTIME + janet_panic("os/mktime UTC not supported on this platform"); + return janet_wrap_nil(); +#else + t = timegm(&t_info); +#endif + } + + if (t == (time_t) -1) { + janet_panicf("%s", strerror(errno)); + } + + return janet_wrap_number((double)t); +} + +#ifdef JANET_NO_SYMLINKS +#define j_symlink link +#else +#define j_symlink symlink +#endif + +JANET_CORE_FN(os_link, + "(os/link oldpath newpath &opt symlink)", + "Create a link at newpath that points to oldpath and returns nil. " + "Iff symlink is truthy, creates a symlink. " + "Iff symlink is falsey or not provided, " + "creates a hard link. Does not work on Windows.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_arity(argc, 2, 3); +#ifdef JANET_WINDOWS + (void) argc; + (void) argv; + janet_panic("os/link not supported on Windows"); + return janet_wrap_nil(); +#else + const char *oldpath = janet_getcstring(argv, 0); + const char *newpath = janet_getcstring(argv, 1); + int res = ((argc == 3 && janet_truthy(argv[2])) ? j_symlink : link)(oldpath, newpath); + if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath); + return janet_wrap_nil(); +#endif +} + +JANET_CORE_FN(os_symlink, + "(os/symlink oldpath newpath)", + "Create a symlink from oldpath to newpath, returning nil. Same as `(os/link oldpath newpath true)`.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 2); +#ifdef JANET_WINDOWS + (void) argc; + (void) argv; + janet_panic("os/symlink not supported on Windows"); + return janet_wrap_nil(); +#else + const char *oldpath = janet_getcstring(argv, 0); + const char *newpath = janet_getcstring(argv, 1); + int res = j_symlink(oldpath, newpath); + if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath); + return janet_wrap_nil(); +#endif +} + +#undef j_symlink + +JANET_CORE_FN(os_mkdir, + "(os/mkdir path)", + "Create a new directory. The path will be relative to the current directory if relative, otherwise " + "it will be an absolute path. Returns true if the directory was created, false if the directory already exists, and " + "errors otherwise.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 1); + const char *path = janet_getcstring(argv, 0); +#ifdef JANET_WINDOWS + int res = _mkdir(path); +#else + int res = mkdir(path, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH); +#endif + if (res == 0) return janet_wrap_true(); + if (errno == EEXIST) return janet_wrap_false(); + janet_panicf("%s: %s", strerror(errno), path); +} + +JANET_CORE_FN(os_rmdir, + "(os/rmdir path)", + "Delete a directory. The directory must be empty to succeed.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 1); + const char *path = janet_getcstring(argv, 0); +#ifdef JANET_WINDOWS + int res = _rmdir(path); +#else + int res = rmdir(path); +#endif + if (-1 == res) janet_panicf("%s: %s", strerror(errno), path); + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_cd, + "(os/cd path)", + "Change current directory to path. Returns nil on success, errors on failure.") { + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + janet_fixarity(argc, 1); + const char *path = janet_getcstring(argv, 0); +#ifdef JANET_WINDOWS + int res = _chdir(path); +#else + int res = chdir(path); +#endif + if (-1 == res) janet_panicf("%s: %s", strerror(errno), path); + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_touch, + "(os/touch path &opt actime modtime)", + "Update the access time and modification times for a file. By default, sets " + "times to the current time.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_arity(argc, 1, 3); + const char *path = janet_getcstring(argv, 0); + struct utimbuf timebuf, *bufp; + if (argc >= 2) { + bufp = &timebuf; + timebuf.actime = (time_t) janet_getnumber(argv, 1); + if (argc >= 3) { + timebuf.modtime = (time_t) janet_getnumber(argv, 2); + } else { + timebuf.modtime = timebuf.actime; + } + } else { + bufp = NULL; + } + int res = utime(path, bufp); + if (-1 == res) janet_panic(strerror(errno)); + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_remove, + "(os/rm path)", + "Delete a file. Returns nil.") { + janet_fixarity(argc, 1); + const char *path = janet_getcstring(argv, 0); + int status = remove(path); + if (-1 == status) janet_panicf("%s: %s", strerror(errno), path); + return janet_wrap_nil(); +} + +#ifndef JANET_NO_SYMLINKS +JANET_CORE_FN(os_readlink, + "(os/readlink path)", + "Read the contents of a symbolic link. Does not work on Windows.\n") { + janet_fixarity(argc, 1); +#ifdef JANET_WINDOWS + (void) argc; + (void) argv; + janet_panic("os/readlink not supported on Windows"); + return janet_wrap_nil(); +#else + static char buffer[PATH_MAX]; + const char *path = janet_getcstring(argv, 0); + ssize_t len = readlink(path, buffer, sizeof buffer); + if (len < 0 || (size_t)len >= sizeof buffer) + janet_panicf("%s: %s", strerror(errno), path); + return janet_stringv((const uint8_t *)buffer, len); +#endif +} +#endif + +#ifdef JANET_WINDOWS + +typedef struct _stat jstat_t; +typedef unsigned short jmode_t; + +static int32_t janet_perm_to_unix(unsigned short m) { + int32_t ret = 0; + if (m & S_IEXEC) ret |= 0111; + if (m & S_IWRITE) ret |= 0222; + if (m & S_IREAD) ret |= 0444; + return ret; +} + +static unsigned short janet_perm_from_unix(int32_t x) { + unsigned short m = 0; + if (x & 111) m |= S_IEXEC; + if (x & 222) m |= S_IWRITE; + if (x & 444) m |= S_IREAD; + return m; +} + +static const uint8_t *janet_decode_mode(unsigned short m) { + const char *str = "other"; + if (m & _S_IFREG) str = "file"; + else if (m & _S_IFDIR) str = "directory"; + else if (m & _S_IFCHR) str = "character"; + return janet_ckeyword(str); +} + +static int32_t janet_decode_permissions(jmode_t mode) { + return (int32_t)(mode & (S_IEXEC | S_IWRITE | S_IREAD)); +} + +#else + +typedef struct stat jstat_t; +typedef mode_t jmode_t; + +static int32_t janet_perm_to_unix(mode_t m) { + return (int32_t) m; +} + +static mode_t janet_perm_from_unix(int32_t x) { + return (mode_t) x; +} + +static const uint8_t *janet_decode_mode(mode_t m) { + const char *str = "other"; + if (S_ISREG(m)) str = "file"; + else if (S_ISDIR(m)) str = "directory"; + else if (S_ISFIFO(m)) str = "fifo"; + else if (S_ISBLK(m)) str = "block"; + else if (S_ISSOCK(m)) str = "socket"; + else if (S_ISLNK(m)) str = "link"; + else if (S_ISCHR(m)) str = "character"; + return janet_ckeyword(str); +} + +static int32_t janet_decode_permissions(jmode_t mode) { + return (int32_t)(mode & 0777); +} + +#endif + +static int32_t os_parse_permstring(const uint8_t *perm) { + int32_t m = 0; + if (perm[0] == 'r') m |= 0400; + if (perm[1] == 'w') m |= 0200; + if (perm[2] == 'x') m |= 0100; + if (perm[3] == 'r') m |= 0040; + if (perm[4] == 'w') m |= 0020; + if (perm[5] == 'x') m |= 0010; + if (perm[6] == 'r') m |= 0004; + if (perm[7] == 'w') m |= 0002; + if (perm[8] == 'x') m |= 0001; + return m; +} + +static Janet os_make_permstring(int32_t permissions) { + uint8_t bytes[9] = {0}; + bytes[0] = (permissions & 0400) ? 'r' : '-'; + bytes[1] = (permissions & 0200) ? 'w' : '-'; + bytes[2] = (permissions & 0100) ? 'x' : '-'; + bytes[3] = (permissions & 0040) ? 'r' : '-'; + bytes[4] = (permissions & 0020) ? 'w' : '-'; + bytes[5] = (permissions & 0010) ? 'x' : '-'; + bytes[6] = (permissions & 0004) ? 'r' : '-'; + bytes[7] = (permissions & 0002) ? 'w' : '-'; + bytes[8] = (permissions & 0001) ? 'x' : '-'; + return janet_stringv(bytes, sizeof(bytes)); +} + +static int32_t os_get_unix_mode(const Janet *argv, int32_t n) { + int32_t unix_mode; + if (janet_checkint(argv[n])) { + /* Integer mode */ + int32_t x = janet_unwrap_integer(argv[n]); + if (x < 0 || x > 0777) { + janet_panicf("bad slot #%d, expected integer in range [0, 8r777], got %v", n, argv[n]); + } + unix_mode = x; + } else { + /* Bytes mode */ + JanetByteView bytes = janet_getbytes(argv, n); + if (bytes.len != 9) { + janet_panicf("bad slot #%d: expected byte sequence of length 9, got %v", n, argv[n]); + } + unix_mode = os_parse_permstring(bytes.bytes); + } + return unix_mode; +} + +static jmode_t os_getmode(const Janet *argv, int32_t n) { + return janet_perm_from_unix(os_get_unix_mode(argv, n)); +} + +/* Getters */ +static Janet os_stat_dev(jstat_t *st) { + return janet_wrap_number(st->st_dev); +} +static Janet os_stat_inode(jstat_t *st) { + return janet_wrap_number(st->st_ino); +} +static Janet os_stat_mode(jstat_t *st) { + return janet_wrap_keyword(janet_decode_mode(st->st_mode)); +} +static Janet os_stat_int_permissions(jstat_t *st) { + return janet_wrap_integer(janet_perm_to_unix(janet_decode_permissions(st->st_mode))); +} +static Janet os_stat_permissions(jstat_t *st) { + return os_make_permstring(janet_perm_to_unix(janet_decode_permissions(st->st_mode))); +} +static Janet os_stat_uid(jstat_t *st) { + return janet_wrap_number(st->st_uid); +} +static Janet os_stat_gid(jstat_t *st) { + return janet_wrap_number(st->st_gid); +} +static Janet os_stat_nlink(jstat_t *st) { + return janet_wrap_number(st->st_nlink); +} +static Janet os_stat_rdev(jstat_t *st) { + return janet_wrap_number(st->st_rdev); +} +static Janet os_stat_size(jstat_t *st) { + return janet_wrap_number(st->st_size); +} +static Janet os_stat_accessed(jstat_t *st) { + return janet_wrap_number((double) st->st_atime); +} +static Janet os_stat_modified(jstat_t *st) { + return janet_wrap_number((double) st->st_mtime); +} +static Janet os_stat_changed(jstat_t *st) { + return janet_wrap_number((double) st->st_ctime); +} +#ifdef JANET_WINDOWS +static Janet os_stat_blocks(jstat_t *st) { + (void) st; + return janet_wrap_number(0); +} +static Janet os_stat_blocksize(jstat_t *st) { + (void) st; + return janet_wrap_number(0); +} +#else +static Janet os_stat_blocks(jstat_t *st) { + return janet_wrap_number(st->st_blocks); +} +static Janet os_stat_blocksize(jstat_t *st) { + return janet_wrap_number(st->st_blksize); +} +#endif + +struct OsStatGetter { + const char *name; + Janet(*fn)(jstat_t *st); +}; + +static const struct OsStatGetter os_stat_getters[] = { + {"dev", os_stat_dev}, + {"inode", os_stat_inode}, + {"mode", os_stat_mode}, + {"int-permissions", os_stat_int_permissions}, + {"permissions", os_stat_permissions}, + {"uid", os_stat_uid}, + {"gid", os_stat_gid}, + {"nlink", os_stat_nlink}, + {"rdev", os_stat_rdev}, + {"size", os_stat_size}, + {"blocks", os_stat_blocks}, + {"blocksize", os_stat_blocksize}, + {"accessed", os_stat_accessed}, + {"modified", os_stat_modified}, + {"changed", os_stat_changed}, + {NULL, NULL} +}; + +static Janet os_stat_or_lstat(int do_lstat, int32_t argc, Janet *argv) { + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + janet_arity(argc, 1, 2); + const char *path = janet_getcstring(argv, 0); + JanetTable *tab = NULL; + const uint8_t *key = NULL; + if (argc == 2) { + if (janet_checktype(argv[1], JANET_KEYWORD)) { + key = janet_getkeyword(argv, 1); + } else { + tab = janet_gettable(argv, 1); + } + } else { + tab = janet_table(0); + } + + /* Build result */ + jstat_t st; +#ifdef JANET_WINDOWS + (void) do_lstat; + int res = _stat(path, &st); +#else + int res; + if (do_lstat) { + res = lstat(path, &st); + } else { + res = stat(path, &st); + } +#endif + if (-1 == res) { + return janet_wrap_nil(); + } + + if (NULL == key) { + /* Put results in table */ + for (const struct OsStatGetter *sg = os_stat_getters; sg->name != NULL; sg++) { + janet_table_put(tab, janet_ckeywordv(sg->name), sg->fn(&st)); + } + return janet_wrap_table(tab); + } else { + /* Get one result */ + for (const struct OsStatGetter *sg = os_stat_getters; sg->name != NULL; sg++) { + if (janet_cstrcmp(key, sg->name)) continue; + return sg->fn(&st); + } + janet_panicf("unexpected keyword %v", janet_wrap_keyword(key)); + return janet_wrap_nil(); + } +} + +JANET_CORE_FN(os_stat, + "(os/stat path &opt tab|key)", + "Gets information about a file or directory. Returns a table if the second argument is a keyword, returns " + "only that information from stat. If the file or directory does not exist, returns nil. The keys are:\n\n" + "* :dev - the device that the file is on\n\n" + "* :mode - the type of file, one of :file, :directory, :block, :character, :fifo, :socket, :link, or :other\n\n" + "* :int-permissions - A Unix permission integer like 8r744\n\n" + "* :permissions - A Unix permission string like \"rwxr--r--\"\n\n" + "* :uid - File uid\n\n" + "* :gid - File gid\n\n" + "* :nlink - number of links to file\n\n" + "* :rdev - Real device of file. 0 on Windows\n\n" + "* :size - size of file in bytes\n\n" + "* :blocks - number of blocks in file. 0 on Windows\n\n" + "* :blocksize - size of blocks in file. 0 on Windows\n\n" + "* :accessed - timestamp when file last accessed\n\n" + "* :changed - timestamp when file last changed (permissions changed)\n\n" + "* :modified - timestamp when file last modified (content changed)\n") { + return os_stat_or_lstat(0, argc, argv); +} + +JANET_CORE_FN(os_lstat, + "(os/lstat path &opt tab|key)", + "Like os/stat, but don't follow symlinks.\n") { + return os_stat_or_lstat(1, argc, argv); +} + +JANET_CORE_FN(os_chmod, + "(os/chmod path mode)", + "Change file permissions, where `mode` is a permission string as returned by " + "`os/perm-string`, or an integer as returned by `os/perm-int`. " + "When `mode` is an integer, it is interpreted as a Unix permission value, best specified in octal, like " + "8r666 or 8r400. Windows will not differentiate between user, group, and other permissions, and thus will combine all of these permissions. Returns nil.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 2); + const char *path = janet_getcstring(argv, 0); +#ifdef JANET_WINDOWS + int res = _chmod(path, os_getmode(argv, 1)); +#else + int res = chmod(path, os_getmode(argv, 1)); +#endif + if (-1 == res) janet_panicf("%s: %s", strerror(errno), path); + return janet_wrap_nil(); +} + +#ifndef JANET_NO_UMASK +JANET_CORE_FN(os_umask, + "(os/umask mask)", + "Set a new umask, returns the old umask.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 1); + int mask = (int) os_getmode(argv, 0); +#ifdef JANET_WINDOWS + int res = _umask(mask); +#else + int res = umask(mask); +#endif + return janet_wrap_integer(janet_perm_to_unix(res)); +} +#endif + +JANET_CORE_FN(os_dir, + "(os/dir dir &opt array)", + "Iterate over files and subdirectories in a directory. Returns an array of paths parts, " + "with only the file name or directory name and no prefix.") { + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + janet_arity(argc, 1, 2); + const char *dir = janet_getcstring(argv, 0); + JanetArray *paths = (argc == 2) ? janet_getarray(argv, 1) : janet_array(0); +#ifdef JANET_WINDOWS + /* Read directory items with FindFirstFile / FindNextFile / FindClose */ + struct _finddata_t afile; + char pattern[MAX_PATH + 1]; + if (strlen(dir) > (sizeof(pattern) - 3)) + janet_panicf("path too long: %s", dir); + sprintf(pattern, "%s/*", dir); + intptr_t res = _findfirst(pattern, &afile); + if (-1 == res) janet_panicv(janet_cstringv(strerror(errno))); + do { + if (strcmp(".", afile.name) && strcmp("..", afile.name)) { + janet_array_push(paths, janet_cstringv(afile.name)); + } + } while (_findnext(res, &afile) != -1); + _findclose(res); +#else + /* Read directory items with opendir / readdir / closedir */ + struct dirent *dp; + DIR *dfd = opendir(dir); + if (dfd == NULL) janet_panicf("cannot open directory %s", dir); + while ((dp = readdir(dfd)) != NULL) { + if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) { + continue; + } + janet_array_push(paths, janet_cstringv(dp->d_name)); + } + closedir(dfd); +#endif + return janet_wrap_array(paths); +} + +JANET_CORE_FN(os_rename, + "(os/rename oldname newname)", + "Rename a file on disk to a new path. Returns nil.") { + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + janet_fixarity(argc, 2); + const char *src = janet_getcstring(argv, 0); + const char *dest = janet_getcstring(argv, 1); + int status = rename(src, dest); + if (status) { + janet_panic(strerror(errno)); + } + return janet_wrap_nil(); +} + +JANET_CORE_FN(os_realpath, + "(os/realpath path)", + "Get the absolute path for a given path, following ../, ./, and symlinks. " + "Returns an absolute path as a string.") { + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + janet_fixarity(argc, 1); + const char *src = janet_getcstring(argv, 0); +#ifdef JANET_NO_REALPATH + janet_panic("os/realpath not enabled for this platform"); +#else +#ifdef JANET_WINDOWS + char *dest = _fullpath(NULL, src, _MAX_PATH); +#else + char *dest = realpath(src, NULL); +#endif + if (NULL == dest) janet_panicf("%s: %s", strerror(errno), src); + Janet ret = janet_cstringv(dest); + janet_free(dest); + return ret; +#endif +} + +JANET_CORE_FN(os_permission_string, + "(os/perm-string int)", + "Convert a Unix octal permission value from a permission integer as returned by `os/stat` " + "to a human readable string, that follows the formatting " + "of Unix tools like `ls`. Returns the string as a 9-character string of r, w, x and - characters. Does not " + "include the file/directory/symlink character as rendered by `ls`.") { + janet_fixarity(argc, 1); + return os_make_permstring(os_get_unix_mode(argv, 0)); +} + +JANET_CORE_FN(os_permission_int, + "(os/perm-int bytes)", + "Parse a 9-character permission string and return an integer that can be used by chmod.") { + janet_fixarity(argc, 1); + return janet_wrap_integer(os_get_unix_mode(argv, 0)); +} + +#ifdef JANET_EV + +/* + * Define a few functions on streams the require JANET_EV to be defined. + */ + +static jmode_t os_optmode(int32_t argc, const Janet *argv, int32_t n, int32_t dflt) { + if (argc > n) return os_getmode(argv, n); + return janet_perm_from_unix(dflt); +} + +JANET_CORE_FN(os_open, + "(os/open path &opt flags mode)", + "Create a stream from a file, like the POSIX open system call. Returns a new stream. " + "`mode` should be a file mode as passed to `os/chmod`, but only if the create flag is given. " + "The default mode is 8r666. " + "Allowed flags are as follows:\n\n" + " * :r - open this file for reading\n" + " * :w - open this file for writing\n" + " * :c - create a new file (O\\_CREATE)\n" + " * :e - fail if the file exists (O\\_EXCL)\n" + " * :t - shorten an existing file to length 0 (O\\_TRUNC)\n\n" + "Posix-only flags:\n\n" + " * :a - append to a file (O\\_APPEND)\n" + " * :x - O\\_SYNC\n" + " * :C - O\\_NOCTTY\n\n" + "Windows-only flags:\n\n" + " * :R - share reads (FILE\\_SHARE\\_READ)\n" + " * :W - share writes (FILE\\_SHARE\\_WRITE)\n" + " * :D - share deletes (FILE\\_SHARE\\_DELETE)\n" + " * :H - FILE\\_ATTRIBUTE\\_HIDDEN\n" + " * :O - FILE\\_ATTRIBUTE\\_READONLY\n" + " * :F - FILE\\_ATTRIBUTE\\_OFFLINE\n" + " * :T - FILE\\_ATTRIBUTE\\_TEMPORARY\n" + " * :d - FILE\\_FLAG\\_DELETE\\_ON\\_CLOSE\n" + " * :b - FILE\\_FLAG\\_NO\\_BUFFERING\n") { + janet_arity(argc, 1, 3); + const char *path = janet_getcstring(argv, 0); + const uint8_t *opt_flags = janet_optkeyword(argv, argc, 1, (const uint8_t *) "r"); + jmode_t mode = os_optmode(argc, argv, 2, 0666); + uint32_t stream_flags = 0; + JanetHandle fd; +#ifdef JANET_WINDOWS + (void) mode; + DWORD desiredAccess = 0; + DWORD shareMode = 0; + DWORD creationDisp = 0; + DWORD flagsAndAttributes = FILE_FLAG_OVERLAPPED; + /* We map unix-like open flags to the creationDisp parameter */ + int creatUnix = 0; +#define OCREAT 1 +#define OEXCL 2 +#define OTRUNC 4 + for (const uint8_t *c = opt_flags; *c; c++) { + switch (*c) { + default: + break; + case 'r': + desiredAccess |= GENERIC_READ; + stream_flags |= JANET_STREAM_READABLE; + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + break; + case 'w': + desiredAccess |= GENERIC_WRITE; + stream_flags |= JANET_STREAM_WRITABLE; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + case 'c': + creatUnix |= OCREAT; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + case 'e': + creatUnix |= OEXCL; + break; + case 't': + creatUnix |= OTRUNC; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + /* Windows only flags */ + case 'D': + shareMode |= FILE_SHARE_DELETE; + break; + case 'R': + shareMode |= FILE_SHARE_READ; + break; + case 'W': + shareMode |= FILE_SHARE_WRITE; + break; + case 'H': + flagsAndAttributes |= FILE_ATTRIBUTE_HIDDEN; + break; + case 'O': + flagsAndAttributes |= FILE_ATTRIBUTE_READONLY; + break; + case 'F': + flagsAndAttributes |= FILE_ATTRIBUTE_OFFLINE; + break; + case 'T': + flagsAndAttributes |= FILE_ATTRIBUTE_TEMPORARY; + break; + case 'd': + flagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE; + break; + case 'b': + flagsAndAttributes |= FILE_FLAG_NO_BUFFERING; + break; + /* we could potentially add more here - + * https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea + */ + } + } + switch (creatUnix) { + default: + janet_panic("invalid creation flags"); + case 0: + creationDisp = OPEN_EXISTING; + break; + case OCREAT: + creationDisp = OPEN_ALWAYS; + break; + case OCREAT + OEXCL: + creationDisp = CREATE_NEW; + break; + case OCREAT + OTRUNC: + creationDisp = CREATE_ALWAYS; + break; + case OTRUNC: + creationDisp = TRUNCATE_EXISTING; + break; + } + fd = CreateFileA(path, desiredAccess, shareMode, NULL, creationDisp, flagsAndAttributes, NULL); + if (fd == INVALID_HANDLE_VALUE) janet_panicv(janet_ev_lasterr()); +#else + int open_flags = O_NONBLOCK; +#ifdef JANET_LINUX + open_flags |= O_CLOEXEC; +#endif + int read_flag = 0; + int write_flag = 0; + for (const uint8_t *c = opt_flags; *c; c++) { + switch (*c) { + default: + break; + case 'r': + read_flag = 1; + stream_flags |= JANET_STREAM_READABLE; + janet_sandbox_assert(JANET_SANDBOX_FS_READ); + break; + case 'w': + write_flag = 1; + stream_flags |= JANET_STREAM_WRITABLE; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + case 'c': + open_flags |= O_CREAT; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + case 'e': + open_flags |= O_EXCL; + break; + case 't': + open_flags |= O_TRUNC; + janet_sandbox_assert(JANET_SANDBOX_FS_WRITE); + break; + /* posix only */ + case 'x': + open_flags |= O_SYNC; + break; + case 'C': + open_flags |= O_NOCTTY; + break; + case 'a': + open_flags |= O_APPEND; + break; + } + } + /* If both read and write, fix up to O_RDWR */ + if (read_flag && !write_flag) { + open_flags |= O_RDONLY; + } else if (write_flag && !read_flag) { + open_flags |= O_WRONLY; + } else { + open_flags = O_RDWR; + } + + do { + fd = open(path, open_flags, mode); + } while (fd == -1 && errno == EINTR); + if (fd == -1) janet_panicv(janet_ev_lasterr()); +#endif + return janet_wrap_abstract(janet_stream(fd, stream_flags, NULL)); +} + +JANET_CORE_FN(os_pipe, + "(os/pipe)", + "Create a readable stream and a writable stream that are connected. Returns a two-element " + "tuple where the first element is a readable stream and the second element is the writable " + "stream.") { + (void) argv; + janet_fixarity(argc, 0); + JanetHandle fds[2]; + if (janet_make_pipe(fds, 0)) janet_panicv(janet_ev_lasterr()); + JanetStream *reader = janet_stream(fds[0], JANET_STREAM_READABLE, NULL); + JanetStream *writer = janet_stream(fds[1], JANET_STREAM_WRITABLE, NULL); + Janet tup[2] = {janet_wrap_abstract(reader), janet_wrap_abstract(writer)}; + return janet_wrap_tuple(janet_tuple_n(tup, 2)); +} + +#endif + +#endif /* JANET_REDUCED_OS */ + +/* Module entry point */ +void janet_lib_os(JanetTable *env) { +#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) + /* During start up, the top-most abstract machine (thread) + * in the thread tree sets up the critical section. */ + static volatile long env_lock_initializing = 0; + static volatile long env_lock_initialized = 0; + if (!InterlockedExchange(&env_lock_initializing, 1)) { + InitializeCriticalSection(&env_lock); + InterlockedOr(&env_lock_initialized, 1); + } else { + while (!InterlockedOr(&env_lock_initialized, 0)) { + Sleep(0); + } + } + +#endif +#ifndef JANET_NO_PROCESSES +#endif + JanetRegExt os_cfuns[] = { + JANET_CORE_REG("os/exit", os_exit), + JANET_CORE_REG("os/which", os_which), + JANET_CORE_REG("os/arch", os_arch), + JANET_CORE_REG("os/compiler", os_compiler), +#ifndef JANET_REDUCED_OS + + /* misc (un-sandboxed) */ + JANET_CORE_REG("os/cpu-count", os_cpu_count), + JANET_CORE_REG("os/cwd", os_cwd), + JANET_CORE_REG("os/cryptorand", os_cryptorand), + JANET_CORE_REG("os/perm-string", os_permission_string), + JANET_CORE_REG("os/perm-int", os_permission_int), + JANET_CORE_REG("os/mktime", os_mktime), + JANET_CORE_REG("os/time", os_time), /* not high resolution */ + JANET_CORE_REG("os/date", os_date), /* not high resolution */ + JANET_CORE_REG("os/strftime", os_strftime), + JANET_CORE_REG("os/sleep", os_sleep), + JANET_CORE_REG("os/isatty", os_isatty), + + /* env functions */ + JANET_CORE_REG("os/environ", os_environ), + JANET_CORE_REG("os/getenv", os_getenv), + JANET_CORE_REG("os/setenv", os_setenv), + + /* fs read */ + JANET_CORE_REG("os/dir", os_dir), + JANET_CORE_REG("os/stat", os_stat), + JANET_CORE_REG("os/lstat", os_lstat), + JANET_CORE_REG("os/chmod", os_chmod), + JANET_CORE_REG("os/touch", os_touch), + JANET_CORE_REG("os/realpath", os_realpath), + JANET_CORE_REG("os/cd", os_cd), +#ifndef JANET_NO_UMASK + JANET_CORE_REG("os/umask", os_umask), +#endif +#ifndef JANET_NO_SYMLINKS + JANET_CORE_REG("os/readlink", os_readlink), +#endif + + /* fs write */ + JANET_CORE_REG("os/mkdir", os_mkdir), + JANET_CORE_REG("os/rmdir", os_rmdir), + JANET_CORE_REG("os/rm", os_remove), + JANET_CORE_REG("os/link", os_link), + JANET_CORE_REG("os/rename", os_rename), +#ifndef JANET_NO_SYMLINKS + JANET_CORE_REG("os/symlink", os_symlink), +#endif + + /* processes */ +#ifndef JANET_NO_PROCESSES + JANET_CORE_REG("os/execute", os_execute), + JANET_CORE_REG("os/spawn", os_spawn), + JANET_CORE_REG("os/shell", os_shell), + JANET_CORE_REG("os/posix-fork", os_posix_fork), + JANET_CORE_REG("os/posix-exec", os_posix_exec), + /* no need to sandbox process management if you can't create processes + * (allows for limited functionality if use exposes C-functions to create specific processes) */ + JANET_CORE_REG("os/proc-wait", os_proc_wait), + JANET_CORE_REG("os/proc-kill", os_proc_kill), + JANET_CORE_REG("os/proc-close", os_proc_close), +#endif + + /* high resolution timers */ + JANET_CORE_REG("os/clock", os_clock), + +#ifdef JANET_EV + JANET_CORE_REG("os/open", os_open), /* fs read and write */ + JANET_CORE_REG("os/pipe", os_pipe), + JANET_CORE_REG("os/sigaction", os_sigaction), +#endif +#endif + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, os_cfuns); +} + + +/* src/core/parse.c */ +#line 0 "src/core/parse.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#endif + +#define JANET_PARSER_DEAD 0x1 +#define JANET_PARSER_GENERATED_ERROR 0x2 + +/* Check if a character is whitespace */ +static int is_whitespace(uint8_t c) { + return c == ' ' + || c == '\t' + || c == '\n' + || c == '\r' + || c == '\0' + || c == '\v' + || c == '\f'; +} + +/* Code generated by tools/symcharsgen.c. + * The table contains 256 bits, where each bit is 1 + * if the corresponding ascii code is a symbol char, and 0 + * if not. The upper characters are also considered symbol + * chars and are then checked for utf-8 compliance. */ +static const uint32_t symchars[8] = { + 0x00000000, 0xf7ffec72, 0xc7ffffff, 0x07fffffe, + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff +}; + +/* Check if a character is a valid symbol character + * symbol chars are A-Z, a-z, 0-9, or one of !$&*+-./:<=>@\^_| */ +int janet_is_symbol_char(uint8_t c) { + return symchars[c >> 5] & ((uint32_t)1 << (c & 0x1F)); +} + +/* Validate some utf8. Useful for identifiers. Only validates + * the encoding, does not check for valid code points (they + * are less well defined than the encoding). */ +int janet_valid_utf8(const uint8_t *str, int32_t len) { + int32_t i = 0; + int32_t j; + while (i < len) { + int32_t nexti; + uint8_t c = str[i]; + + /* Check the number of bytes in code point */ + if (c < 0x80) nexti = i + 1; + else if ((c >> 5) == 0x06) nexti = i + 2; + else if ((c >> 4) == 0x0E) nexti = i + 3; + else if ((c >> 3) == 0x1E) nexti = i + 4; + /* Don't allow 5 or 6 byte code points */ + else return 0; + + /* No overflow */ + if (nexti > len) return 0; + + /* Ensure trailing bytes are well formed (10XX XXXX) */ + for (j = i + 1; j < nexti; j++) { + if ((str[j] >> 6) != 2) return 0; + } + + /* Check for overlong encoding */ + if ((nexti == i + 2) && str[i] < 0xC2) return 0; + if ((str[i] == 0xE0) && str[i + 1] < 0xA0) return 0; + if ((str[i] == 0xF0) && str[i + 1] < 0x90) return 0; + + i = nexti; + } + return 1; +} + +/* Get hex digit from a letter */ +static int to_hex(uint8_t c) { + if (c >= '0' && c <= '9') { + return c - '0'; + } else if (c >= 'A' && c <= 'F') { + return 10 + c - 'A'; + } else if (c >= 'a' && c <= 'f') { + return 10 + c - 'a'; + } else { + return -1; + } +} + +typedef int (*Consumer)(JanetParser *p, JanetParseState *state, uint8_t c); +struct JanetParseState { + int32_t counter; + int32_t argn; + int flags; + size_t line; + size_t column; + Consumer consumer; +}; + +/* Define a stack on the main parser struct */ +#define DEF_PARSER_STACK(NAME, T, STACK, STACKCOUNT, STACKCAP) \ +static void NAME(JanetParser *p, T x) { \ + size_t oldcount = p->STACKCOUNT; \ + size_t newcount = oldcount + 1; \ + if (newcount > p->STACKCAP) { \ + T *next; \ + size_t newcap = 2 * newcount; \ + next = janet_realloc(p->STACK, sizeof(T) * newcap); \ + if (NULL == next) { \ + JANET_OUT_OF_MEMORY; \ + } \ + p->STACK = next; \ + p->STACKCAP = newcap; \ + } \ + p->STACK[oldcount] = x; \ + p->STACKCOUNT = newcount; \ +} + +DEF_PARSER_STACK(push_buf, uint8_t, buf, bufcount, bufcap) +DEF_PARSER_STACK(push_arg, Janet, args, argcount, argcap) +DEF_PARSER_STACK(_pushstate, JanetParseState, states, statecount, statecap) + +#undef DEF_PARSER_STACK + +#define PFLAG_CONTAINER 0x100 +#define PFLAG_BUFFER 0x200 +#define PFLAG_PARENS 0x400 +#define PFLAG_SQRBRACKETS 0x800 +#define PFLAG_CURLYBRACKETS 0x1000 +#define PFLAG_STRING 0x2000 +#define PFLAG_LONGSTRING 0x4000 +#define PFLAG_READERMAC 0x8000 +#define PFLAG_ATSYM 0x10000 +#define PFLAG_COMMENT 0x20000 +#define PFLAG_TOKEN 0x40000 + +static void pushstate(JanetParser *p, Consumer consumer, int flags) { + JanetParseState s; + s.counter = 0; + s.argn = 0; + s.flags = flags; + s.consumer = consumer; + s.line = p->line; + s.column = p->column; + _pushstate(p, s); +} + +static void popstate(JanetParser *p, Janet val) { + for (;;) { + JanetParseState top = p->states[--p->statecount]; + JanetParseState *newtop = p->states + p->statecount - 1; + /* Source mapping info */ + if (janet_checktype(val, JANET_TUPLE)) { + janet_tuple_sm_line(janet_unwrap_tuple(val)) = (int32_t) top.line; + janet_tuple_sm_column(janet_unwrap_tuple(val)) = (int32_t) top.column; + } + if (newtop->flags & PFLAG_CONTAINER) { + newtop->argn++; + /* Keep track of number of values in the root state */ + if (p->statecount == 1) { + p->pending++; + /* Root items are always wrapped in a tuple for source map info. */ + const Janet *tup = janet_tuple_n(&val, 1); + janet_tuple_sm_line(tup) = (int32_t) top.line; + janet_tuple_sm_column(tup) = (int32_t) top.column; + val = janet_wrap_tuple(tup); + } + push_arg(p, val); + return; + } else if (newtop->flags & PFLAG_READERMAC) { + Janet *t = janet_tuple_begin(2); + int c = newtop->flags & 0xFF; + const char *which = + (c == '\'') ? "quote" : + (c == ',') ? "unquote" : + (c == ';') ? "splice" : + (c == '|') ? "short-fn" : + (c == '~') ? "quasiquote" : ""; + t[0] = janet_csymbolv(which); + t[1] = val; + /* Quote source mapping info */ + janet_tuple_sm_line(t) = (int32_t) newtop->line; + janet_tuple_sm_column(t) = (int32_t) newtop->column; + val = janet_wrap_tuple(janet_tuple_end(t)); + } else { + return; + } + } +} + +static void delim_error(JanetParser *parser, size_t stack_index, char c, const char *msg) { + JanetParseState *s = parser->states + stack_index; + JanetBuffer *buffer = janet_buffer(40); + if (msg) { + janet_buffer_push_cstring(buffer, msg); + } + if (c) { + janet_buffer_push_u8(buffer, c); + } + if (stack_index > 0) { + janet_buffer_push_cstring(buffer, ", "); + if (s->flags & PFLAG_PARENS) { + janet_buffer_push_u8(buffer, '('); + } else if (s->flags & PFLAG_SQRBRACKETS) { + janet_buffer_push_u8(buffer, '['); + } else if (s->flags & PFLAG_CURLYBRACKETS) { + janet_buffer_push_u8(buffer, '{'); + } else if (s->flags & PFLAG_STRING) { + janet_buffer_push_u8(buffer, '"'); + } else if (s->flags & PFLAG_LONGSTRING) { + int32_t i; + for (i = 0; i < s->argn; i++) { + janet_buffer_push_u8(buffer, '`'); + } + } + janet_formatb(buffer, " opened at line %d, column %d", s->line, s->column); + } + parser->error = (const char *) janet_string(buffer->data, buffer->count); + parser->flag |= JANET_PARSER_GENERATED_ERROR; +} + +static int checkescape(uint8_t c) { + switch (c) { + default: + return -1; + case 'x': + case 'u': + case 'U': + return 1; + case 'n': + return '\n'; + case 't': + return '\t'; + case 'r': + return '\r'; + case '0': + return '\0'; + case 'z': + return '\0'; + case 'f': + return '\f'; + case 'v': + return '\v'; + case 'a': + return '\a'; + case 'b': + return '\b'; + case '\'': + return '\''; + case '?': + return '?'; + case 'e': + return 27; + case '"': + return '"'; + case '\\': + return '\\'; + } +} + +/* Forward declare */ +static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c); + +static void write_codepoint(JanetParser *p, int32_t codepoint) { + if (codepoint <= 0x7F) { + push_buf(p, (uint8_t) codepoint); + } else if (codepoint <= 0x7FF) { + push_buf(p, (uint8_t)((codepoint >> 6) & 0x1F) | 0xC0); + push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); + } else if (codepoint <= 0xFFFF) { + push_buf(p, (uint8_t)((codepoint >> 12) & 0x0F) | 0xE0); + push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); + push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); + } else { + push_buf(p, (uint8_t)((codepoint >> 18) & 0x07) | 0xF0); + push_buf(p, (uint8_t)((codepoint >> 12) & 0x3F) | 0x80); + push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); + push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); + } +} + +static int escapeh(JanetParser *p, JanetParseState *state, uint8_t c) { + int digit = to_hex(c); + if (digit < 0) { + p->error = "invalid hex digit in hex escape"; + return 1; + } + state->argn = (state->argn << 4) + digit; + state->counter--; + if (!state->counter) { + push_buf(p, (uint8_t)(state->argn & 0xFF)); + state->argn = 0; + state->consumer = stringchar; + } + return 1; +} + +static int escapeu(JanetParser *p, JanetParseState *state, uint8_t c) { + int digit = to_hex(c); + if (digit < 0) { + p->error = "invalid hex digit in unicode escape"; + return 1; + } + state->argn = (state->argn << 4) + digit; + state->counter--; + if (!state->counter) { + if (state->argn > 0x10FFFF) { + p->error = "invalid unicode codepoint"; + return 1; + } + write_codepoint(p, state->argn); + state->argn = 0; + state->consumer = stringchar; + } + return 1; +} + +static int escape1(JanetParser *p, JanetParseState *state, uint8_t c) { + int e = checkescape(c); + if (e < 0) { + p->error = "invalid string escape sequence"; + return 1; + } + if (c == 'x') { + state->counter = 2; + state->argn = 0; + state->consumer = escapeh; + } else if (c == 'u' || c == 'U') { + state->counter = c == 'u' ? 4 : 6; + state->argn = 0; + state->consumer = escapeu; + } else { + push_buf(p, (uint8_t) e); + state->consumer = stringchar; + } + return 1; +} + +static int stringend(JanetParser *p, JanetParseState *state) { + Janet ret; + uint8_t *bufstart = p->buf; + int32_t buflen = (int32_t) p->bufcount; + if (state->flags & PFLAG_LONGSTRING) { + /* Post process to remove leading whitespace */ + JanetParseState top = p->states[p->statecount - 1]; + int32_t indent_col = (int32_t) top.column - 1; + uint8_t *r = bufstart, *end = r + buflen; + /* Check if there are any characters before the start column - + * if so, do not reindent. */ + int reindent = 1; + while (reindent && (r < end)) { + if (*r++ == '\n') { + for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++) { + if (*r != ' ') { + reindent = 0; + break; + } + } + } + } + /* Now reindent if able to, otherwise just drop leading newline. */ + if (!reindent) { + if (buflen > 0 && bufstart[0] == '\n') { + buflen--; + bufstart++; + } + } else { + uint8_t *w = bufstart; + r = bufstart; + while (r < end) { + if (*r == '\n') { + if (r == bufstart) { + /* Skip leading newline */ + r++; + } else { + *w++ = *r++; + } + for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++); + } else { + *w++ = *r++; + } + } + buflen = (int32_t)(w - bufstart); + } + /* Check for trailing newline character so we can remove it */ + if (buflen > 0 && bufstart[buflen - 1] == '\n') { + buflen--; + } + } + if (state->flags & PFLAG_BUFFER) { + JanetBuffer *b = janet_buffer(buflen); + janet_buffer_push_bytes(b, bufstart, buflen); + ret = janet_wrap_buffer(b); + } else { + ret = janet_wrap_string(janet_string(bufstart, buflen)); + } + p->bufcount = 0; + popstate(p, ret); + return 1; +} + +static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) { + /* Enter escape */ + if (c == '\\') { + state->consumer = escape1; + return 1; + } + /* String end */ + if (c == '"') { + return stringend(p, state); + } + /* normal char */ + if (c != '\n' && c != '\r') + push_buf(p, c); + return 1; +} + +/* Check for string equality in the buffer */ +static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) { + int32_t index; + for (index = 0; index < len; index++) { + uint8_t c = str[index]; + uint8_t k = ((const uint8_t *)cstr)[index]; + if (c < k) return -1; + if (c > k) return 1; + if (k == '\0') break; + } + return (cstr[index] == '\0') ? 0 : -1; +} + +static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) { + Janet ret; + double numval; + int32_t blen; + if (janet_is_symbol_char(c)) { + push_buf(p, (uint8_t) c); + if (c > 127) state->argn = 1; /* Use to indicate non ascii */ + return 1; + } + /* Token finished */ + blen = (int32_t) p->bufcount; + int start_dig = p->buf[0] >= '0' && p->buf[0] <= '9'; + int start_num = start_dig || p->buf[0] == '-' || p->buf[0] == '+' || p->buf[0] == '.'; + if (p->buf[0] == ':') { + /* Don't do full utf-8 check unless we have seen non ascii characters. */ + int valid = (!state->argn) || janet_valid_utf8(p->buf + 1, blen - 1); + if (!valid) { + p->error = "invalid utf-8 in keyword"; + return 0; + } + ret = janet_keywordv(p->buf + 1, blen - 1); + } else if (start_num && !janet_scan_number(p->buf, blen, &numval)) { + ret = janet_wrap_number(numval); + } else if (!check_str_const("nil", p->buf, blen)) { + ret = janet_wrap_nil(); + } else if (!check_str_const("false", p->buf, blen)) { + ret = janet_wrap_false(); + } else if (!check_str_const("true", p->buf, blen)) { + ret = janet_wrap_true(); + } else { + if (start_dig) { + p->error = "symbol literal cannot start with a digit"; + return 0; + } else { + /* Don't do full utf-8 check unless we have seen non ascii characters. */ + int valid = (!state->argn) || janet_valid_utf8(p->buf, blen); + if (!valid) { + p->error = "invalid utf-8 in symbol"; + return 0; + } + ret = janet_symbolv(p->buf, blen); + } + } + p->bufcount = 0; + popstate(p, ret); + return 0; +} + +static int comment(JanetParser *p, JanetParseState *state, uint8_t c) { + (void) state; + if (c == '\n') { + p->statecount--; + p->bufcount = 0; + } else { + push_buf(p, c); + } + return 1; +} + +static Janet close_tuple(JanetParser *p, JanetParseState *state, int32_t flag) { + Janet *ret = janet_tuple_begin(state->argn); + janet_tuple_flag(ret) |= flag; + for (int32_t i = state->argn - 1; i >= 0; i--) + ret[i] = p->args[--p->argcount]; + return janet_wrap_tuple(janet_tuple_end(ret)); +} + +static Janet close_array(JanetParser *p, JanetParseState *state) { + JanetArray *array = janet_array(state->argn); + for (int32_t i = state->argn - 1; i >= 0; i--) + array->data[i] = p->args[--p->argcount]; + array->count = state->argn; + return janet_wrap_array(array); +} + +static Janet close_struct(JanetParser *p, JanetParseState *state) { + JanetKV *st = janet_struct_begin(state->argn >> 1); + for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { + Janet key = p->args[i]; + Janet value = p->args[i + 1]; + janet_struct_put(st, key, value); + } + p->argcount -= state->argn; + return janet_wrap_struct(janet_struct_end(st)); +} + +static Janet close_table(JanetParser *p, JanetParseState *state) { + JanetTable *table = janet_table(state->argn >> 1); + for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { + Janet key = p->args[i]; + Janet value = p->args[i + 1]; + janet_table_put(table, key, value); + } + p->argcount -= state->argn; + return janet_wrap_table(table); +} + +#define PFLAG_INSTRING 0x100000 +#define PFLAG_END_CANDIDATE 0x200000 +static int longstring(JanetParser *p, JanetParseState *state, uint8_t c) { + if (state->flags & PFLAG_INSTRING) { + /* We are inside the long string */ + if (c == '`') { + state->flags |= PFLAG_END_CANDIDATE; + state->flags &= ~PFLAG_INSTRING; + state->counter = 1; /* Use counter to keep track of number of '=' seen */ + return 1; + } + push_buf(p, c); + return 1; + } else if (state->flags & PFLAG_END_CANDIDATE) { + int i; + /* We are checking a potential end of the string */ + if (state->counter == state->argn) { + stringend(p, state); + return 0; + } + if (c == '`' && state->counter < state->argn) { + state->counter++; + return 1; + } + /* Failed end candidate */ + for (i = 0; i < state->counter; i++) { + push_buf(p, '`'); + } + push_buf(p, c); + state->counter = 0; + state->flags &= ~PFLAG_END_CANDIDATE; + state->flags |= PFLAG_INSTRING; + return 1; + } else { + /* We are at beginning of string */ + state->argn++; + if (c != '`') { + state->flags |= PFLAG_INSTRING; + push_buf(p, c); + } + return 1; + } +} + +static int root(JanetParser *p, JanetParseState *state, uint8_t c); + +static int atsign(JanetParser *p, JanetParseState *state, uint8_t c) { + (void) state; + p->statecount--; + switch (c) { + case '{': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); + return 1; + case '"': + pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING); + return 1; + case '`': + pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING); + return 1; + case '[': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); + return 1; + case '(': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); + return 1; + default: + break; + } + pushstate(p, tokenchar, PFLAG_TOKEN); + push_buf(p, '@'); /* Push the leading at-sign that was dropped */ + return 0; +} + +/* The root state of the parser */ +static int root(JanetParser *p, JanetParseState *state, uint8_t c) { + switch (c) { + default: + if (is_whitespace(c)) return 1; + if (!janet_is_symbol_char(c)) { + p->error = "unexpected character"; + return 1; + } + pushstate(p, tokenchar, PFLAG_TOKEN); + return 0; + case '\'': + case ',': + case ';': + case '~': + case '|': + pushstate(p, root, PFLAG_READERMAC | c); + return 1; + case '"': + pushstate(p, stringchar, PFLAG_STRING); + return 1; + case '#': + pushstate(p, comment, PFLAG_COMMENT); + return 1; + case '@': + pushstate(p, atsign, PFLAG_ATSYM); + return 1; + case '`': + pushstate(p, longstring, PFLAG_LONGSTRING); + return 1; + case ')': + case ']': + case '}': { + Janet ds; + if (p->statecount == 1) { + delim_error(p, 0, c, "unexpected closing delimiter "); + return 1; + } + if ((c == ')' && (state->flags & PFLAG_PARENS)) || + (c == ']' && (state->flags & PFLAG_SQRBRACKETS))) { + if (state->flags & PFLAG_ATSYM) { + ds = close_array(p, state); + } else { + ds = close_tuple(p, state, c == ']' ? JANET_TUPLE_FLAG_BRACKETCTOR : 0); + } + } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) { + if (state->argn & 1) { + p->error = "struct and table literals expect even number of arguments"; + return 1; + } + if (state->flags & PFLAG_ATSYM) { + ds = close_table(p, state); + } else { + ds = close_struct(p, state); + } + } else { + delim_error(p, p->statecount - 1, c, "mismatched delimiter "); + return 1; + } + popstate(p, ds); + } + return 1; + case '(': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS); + return 1; + case '[': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS); + return 1; + case '{': + pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS); + return 1; + } +} + +static void janet_parser_checkdead(JanetParser *parser) { + if (parser->flag) janet_panic("parser is dead, cannot consume"); + if (parser->error) janet_panic("parser has unchecked error, cannot consume"); +} + +/* Public API */ + +void janet_parser_consume(JanetParser *parser, uint8_t c) { + int consumed = 0; + janet_parser_checkdead(parser); + if (c == '\r') { + parser->line++; + parser->column = 0; + } else if (c == '\n') { + parser->column = 0; + if (parser->lookback != '\r') + parser->line++; + } else { + parser->column++; + } + while (!consumed && !parser->error) { + JanetParseState *state = parser->states + parser->statecount - 1; + consumed = state->consumer(parser, state, c); + } + parser->lookback = c; +} + +void janet_parser_eof(JanetParser *parser) { + janet_parser_checkdead(parser); + size_t oldcolumn = parser->column; + size_t oldline = parser->line; + janet_parser_consume(parser, '\n'); + if (parser->statecount > 1) { + delim_error(parser, parser->statecount - 1, 0, "unexpected end of source"); + } + parser->line = oldline; + parser->column = oldcolumn; + parser->flag |= JANET_PARSER_DEAD; +} + +enum JanetParserStatus janet_parser_status(JanetParser *parser) { + if (parser->error) return JANET_PARSE_ERROR; + if (parser->flag) return JANET_PARSE_DEAD; + if (parser->statecount > 1) return JANET_PARSE_PENDING; + return JANET_PARSE_ROOT; +} + +void janet_parser_flush(JanetParser *parser) { + parser->argcount = 0; + parser->statecount = 1; + parser->bufcount = 0; + parser->pending = 0; +} + +const char *janet_parser_error(JanetParser *parser) { + enum JanetParserStatus status = janet_parser_status(parser); + if (status == JANET_PARSE_ERROR) { + const char *e = parser->error; + parser->error = NULL; + parser->flag &= ~JANET_PARSER_GENERATED_ERROR; + janet_parser_flush(parser); + return e; + } + return NULL; +} + +Janet janet_parser_produce(JanetParser *parser) { + Janet ret; + size_t i; + if (parser->pending == 0) return janet_wrap_nil(); + ret = janet_unwrap_tuple(parser->args[0])[0]; + for (i = 1; i < parser->argcount; i++) { + parser->args[i - 1] = parser->args[i]; + } + parser->pending--; + parser->argcount--; + parser->states[0].argn--; + return ret; +} + +Janet janet_parser_produce_wrapped(JanetParser *parser) { + Janet ret; + size_t i; + if (parser->pending == 0) return janet_wrap_nil(); + ret = parser->args[0]; + for (i = 1; i < parser->argcount; i++) { + parser->args[i - 1] = parser->args[i]; + } + parser->pending--; + parser->argcount--; + parser->states[0].argn--; + return ret; +} + +void janet_parser_init(JanetParser *parser) { + parser->args = NULL; + parser->states = NULL; + parser->buf = NULL; + parser->argcount = 0; + parser->argcap = 0; + parser->bufcount = 0; + parser->bufcap = 0; + parser->statecount = 0; + parser->statecap = 0; + parser->error = NULL; + parser->lookback = -1; + parser->line = 1; + parser->column = 0; + parser->pending = 0; + parser->flag = 0; + + pushstate(parser, root, PFLAG_CONTAINER); +} + +void janet_parser_deinit(JanetParser *parser) { + janet_free(parser->args); + janet_free(parser->buf); + janet_free(parser->states); +} + +void janet_parser_clone(const JanetParser *src, JanetParser *dest) { + /* Misc fields */ + dest->flag = src->flag; + dest->pending = src->pending; + dest->lookback = src->lookback; + dest->line = src->line; + dest->column = src->column; + dest->error = src->error; + + /* Keep counts */ + dest->argcount = src->argcount; + dest->bufcount = src->bufcount; + dest->statecount = src->statecount; + + /* Capacities are equal to counts */ + dest->bufcap = dest->bufcount; + dest->statecap = dest->statecount; + dest->argcap = dest->argcount; + + /* Deep cloned fields */ + dest->args = NULL; + dest->states = NULL; + dest->buf = NULL; + if (dest->bufcap) { + dest->buf = janet_malloc(dest->bufcap); + if (!dest->buf) goto nomem; + memcpy(dest->buf, src->buf, dest->bufcap); + } + if (dest->argcap) { + dest->args = janet_malloc(sizeof(Janet) * dest->argcap); + if (!dest->args) goto nomem; + memcpy(dest->args, src->args, dest->argcap * sizeof(Janet)); + } + if (dest->statecap) { + dest->states = janet_malloc(sizeof(JanetParseState) * dest->statecap); + if (!dest->states) goto nomem; + memcpy(dest->states, src->states, dest->statecap * sizeof(JanetParseState)); + } + + return; + +nomem: + JANET_OUT_OF_MEMORY; +} + +int janet_parser_has_more(JanetParser *parser) { + return !!parser->pending; +} + +/* C functions */ + +static int parsermark(void *p, size_t size) { + size_t i; + JanetParser *parser = (JanetParser *)p; + (void) size; + for (i = 0; i < parser->argcount; i++) { + janet_mark(parser->args[i]); + } + if (parser->flag & JANET_PARSER_GENERATED_ERROR) { + janet_mark(janet_wrap_string((const uint8_t *) parser->error)); + } + return 0; +} + +static int parsergc(void *p, size_t size) { + JanetParser *parser = (JanetParser *)p; + (void) size; + janet_parser_deinit(parser); + return 0; +} + +static int parserget(void *p, Janet key, Janet *out); +static Janet parsernext(void *p, Janet key); + +const JanetAbstractType janet_parser_type = { + "core/parser", + parsergc, + parsermark, + parserget, + NULL, /* put */ + NULL, /* marshal */ + NULL, /* unmarshal */ + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + parsernext, + JANET_ATEND_NEXT +}; + +/* C Function parser */ +JANET_CORE_FN(cfun_parse_parser, + "(parser/new)", + "Creates and returns a new parser object. Parsers are state machines " + "that can receive bytes and generate a stream of values.") { + (void) argv; + janet_fixarity(argc, 0); + JanetParser *p = janet_abstract(&janet_parser_type, sizeof(JanetParser)); + janet_parser_init(p); + return janet_wrap_abstract(p); +} + +JANET_CORE_FN(cfun_parse_consume, + "(parser/consume parser bytes &opt index)", + "Input bytes into the parser and parse them. Will not throw errors " + "if there is a parse error. Starts at the byte index given by `index`. Returns " + "the number of bytes read.") { + janet_arity(argc, 2, 3); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + JanetByteView view = janet_getbytes(argv, 1); + if (argc == 3) { + int32_t offset = janet_getinteger(argv, 2); + if (offset < 0 || offset > view.len) + janet_panicf("invalid offset %d out of range [0,%d]", offset, view.len); + view.len -= offset; + view.bytes += offset; + } + int32_t i; + for (i = 0; i < view.len; i++) { + janet_parser_consume(p, view.bytes[i]); + switch (janet_parser_status(p)) { + case JANET_PARSE_ROOT: + case JANET_PARSE_PENDING: + break; + default: + return janet_wrap_integer(i + 1); + } + } + return janet_wrap_integer(i); +} + +JANET_CORE_FN(cfun_parse_eof, + "(parser/eof parser)", + "Indicate to the parser that the end of file was reached. This puts the parser in the :dead state.") { + janet_fixarity(argc, 1); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + janet_parser_eof(p); + return argv[0]; +} + +JANET_CORE_FN(cfun_parse_insert, + "(parser/insert parser value)", + "Insert a value into the parser. This means that the parser state can be manipulated " + "in between chunks of bytes. This would allow a user to add extra elements to arrays " + "and tuples, for example. Returns the parser.") { + janet_fixarity(argc, 2); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + JanetParseState *s = p->states + p->statecount - 1; + if (s->consumer == tokenchar) { + janet_parser_consume(p, ' '); + p->column--; + s = p->states + p->statecount - 1; + } + if (s->flags & PFLAG_COMMENT) s--; + if (s->flags & PFLAG_CONTAINER) { + s->argn++; + if (p->statecount == 1) { + p->pending++; + Janet tup = janet_wrap_tuple(janet_tuple_n(argv + 1, 1)); + push_arg(p, tup); + } else { + push_arg(p, argv[1]); + } + } else if (s->flags & (PFLAG_STRING | PFLAG_LONGSTRING)) { + const uint8_t *str = janet_to_string(argv[1]); + int32_t slen = janet_string_length(str); + size_t newcount = p->bufcount + slen; + if (p->bufcap < newcount) { + size_t newcap = 2 * newcount; + p->buf = janet_realloc(p->buf, newcap); + if (p->buf == NULL) { + JANET_OUT_OF_MEMORY; + } + p->bufcap = newcap; + } + safe_memcpy(p->buf + p->bufcount, str, slen); + p->bufcount = newcount; + } else { + janet_panic("cannot insert value into parser"); + } + return argv[0]; +} + +JANET_CORE_FN(cfun_parse_has_more, + "(parser/has-more parser)", + "Check if the parser has more values in the value queue.") { + janet_fixarity(argc, 1); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + return janet_wrap_boolean(janet_parser_has_more(p)); +} + +JANET_CORE_FN(cfun_parse_byte, + "(parser/byte parser b)", + "Input a single byte `b` into the parser byte stream. Returns the parser.") { + janet_fixarity(argc, 2); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + int32_t i = janet_getinteger(argv, 1); + janet_parser_consume(p, 0xFF & i); + return argv[0]; +} + +JANET_CORE_FN(cfun_parse_status, + "(parser/status parser)", + "Gets the current status of the parser state machine. The status will " + "be one of:\n\n" + "* :pending - a value is being parsed.\n\n" + "* :error - a parsing error was encountered.\n\n" + "* :root - the parser can either read more values or safely terminate.") { + janet_fixarity(argc, 1); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + const char *stat = NULL; + switch (janet_parser_status(p)) { + case JANET_PARSE_PENDING: + stat = "pending"; + break; + case JANET_PARSE_ERROR: + stat = "error"; + break; + case JANET_PARSE_ROOT: + stat = "root"; + break; + case JANET_PARSE_DEAD: + stat = "dead"; + break; + } + return janet_ckeywordv(stat); +} + +JANET_CORE_FN(cfun_parse_error, + "(parser/error parser)", + "If the parser is in the error state, returns the message associated with " + "that error. Otherwise, returns nil. Also flushes the parser state and parser " + "queue, so be sure to handle everything in the queue before calling " + "`parser/error`.") { + janet_fixarity(argc, 1); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + const char *err = janet_parser_error(p); + if (err) { + return (p->flag & JANET_PARSER_GENERATED_ERROR) + ? janet_wrap_string((const uint8_t *) err) + : janet_cstringv(err); + } + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_parse_produce, + "(parser/produce parser &opt wrap)", + "Dequeue the next value in the parse queue. Will return nil if " + "no parsed values are in the queue, otherwise will dequeue the " + "next value. If `wrap` is truthy, will return a 1-element tuple that " + "wraps the result. This tuple can be used for source-mapping " + "purposes.") { + janet_arity(argc, 1, 2); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + if (argc == 2 && janet_truthy(argv[1])) { + return janet_parser_produce_wrapped(p); + } else { + return janet_parser_produce(p); + } +} + +JANET_CORE_FN(cfun_parse_flush, + "(parser/flush parser)", + "Clears the parser state and parse queue. Can be used to reset the parser " + "if an error was encountered. Does not reset the line and column counter, so " + "to begin parsing in a new context, create a new parser.") { + janet_fixarity(argc, 1); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + janet_parser_flush(p); + return argv[0]; +} + +JANET_CORE_FN(cfun_parse_where, + "(parser/where parser &opt line col)", + "Returns the current line number and column of the parser's internal state. If line is " + "provided, the current line number of the parser is first set to that value. If column is " + "also provided, the current column number of the parser is also first set to that value.") { + janet_arity(argc, 1, 3); + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + if (argc > 1) { + int32_t line = janet_getinteger(argv, 1); + if (line < 1) + janet_panicf("invalid line number %d", line); + p->line = (size_t) line; + } + if (argc > 2) { + int32_t column = janet_getinteger(argv, 2); + if (column < 0) + janet_panicf("invalid column number %d", column); + p->column = (size_t) column; + } + Janet *tup = janet_tuple_begin(2); + tup[0] = janet_wrap_integer(p->line); + tup[1] = janet_wrap_integer(p->column); + return janet_wrap_tuple(janet_tuple_end(tup)); +} + +static Janet janet_wrap_parse_state(JanetParseState *s, Janet *args, + uint8_t *buff, uint32_t bufcount) { + JanetTable *state = janet_table(0); + const uint8_t *buffer; + int add_buffer = 0; + const char *type = NULL; + + if (s->flags & PFLAG_CONTAINER) { + JanetArray *container_args = janet_array(s->argn); + for (int32_t i = 0; i < s->argn; i++) { + janet_array_push(container_args, args[i]); + } + janet_table_put(state, janet_ckeywordv("args"), + janet_wrap_array(container_args)); + } + + if (s->flags & PFLAG_PARENS || s->flags & PFLAG_SQRBRACKETS) { + if (s->flags & PFLAG_ATSYM) { + type = "array"; + } else { + type = "tuple"; + } + } else if (s->flags & PFLAG_CURLYBRACKETS) { + if (s->flags & PFLAG_ATSYM) { + type = "table"; + } else { + type = "struct"; + } + } else if (s->flags & PFLAG_STRING || s->flags & PFLAG_LONGSTRING) { + if (s->flags & PFLAG_BUFFER) { + type = "buffer"; + } else { + type = "string"; + } + add_buffer = 1; + } else if (s->flags & PFLAG_COMMENT) { + type = "comment"; + add_buffer = 1; + } else if (s->flags & PFLAG_TOKEN) { + type = "token"; + add_buffer = 1; + } else if (s->flags & PFLAG_ATSYM) { + type = "at"; + } else if (s->flags & PFLAG_READERMAC) { + int c = s->flags & 0xFF; + type = (c == '\'') ? "quote" : + (c == ',') ? "unquote" : + (c == ';') ? "splice" : + (c == '~') ? "quasiquote" : ""; + } else { + type = "root"; + } + + if (type) { + janet_table_put(state, janet_ckeywordv("type"), + janet_ckeywordv(type)); + } + + if (add_buffer) { + buffer = janet_string(buff, bufcount); + janet_table_put(state, janet_ckeywordv("buffer"), janet_wrap_string(buffer)); + } + + janet_table_put(state, janet_ckeywordv("line"), janet_wrap_integer(s->line)); + janet_table_put(state, janet_ckeywordv("column"), janet_wrap_integer(s->column)); + return janet_wrap_table(state); +} + +struct ParserStateGetter { + const char *name; + Janet(*fn)(const JanetParser *p); +}; + +static Janet parser_state_delimiters(const JanetParser *_p) { + JanetParser *p = (JanetParser *)_p; + size_t i; + const uint8_t *str; + size_t oldcount; + oldcount = p->bufcount; + for (i = 0; i < p->statecount; i++) { + JanetParseState *s = p->states + i; + if (s->flags & PFLAG_PARENS) { + push_buf(p, '('); + } else if (s->flags & PFLAG_SQRBRACKETS) { + push_buf(p, '['); + } else if (s->flags & PFLAG_CURLYBRACKETS) { + push_buf(p, '{'); + } else if (s->flags & PFLAG_STRING) { + push_buf(p, '"'); + } else if (s->flags & PFLAG_LONGSTRING) { + int32_t i; + for (i = 0; i < s->argn; i++) { + push_buf(p, '`'); + } + } + } + /* avoid ptr arithmetic on NULL */ + str = janet_string(oldcount ? p->buf + oldcount : p->buf, (int32_t)(p->bufcount - oldcount)); + p->bufcount = oldcount; + return janet_wrap_string(str); +} + +static Janet parser_state_frames(const JanetParser *p) { + int32_t count = (int32_t) p->statecount; + JanetArray *states = janet_array(count); + states->count = count; + uint8_t *buf = p->buf; + /* Iterate arg stack backwards */ + Janet *args = p->argcount ? p->args + p->argcount : p->args; /* avoid ptr arithmetic on NULL */ + for (int32_t i = count - 1; i >= 0; --i) { + JanetParseState *s = p->states + i; + /* avoid ptr arithmetic on args if NULL */ + if ((s->flags & PFLAG_CONTAINER) && s->argn) { + args -= s->argn; + } + states->data[i] = janet_wrap_parse_state(s, args, buf, (uint32_t) p->bufcount); + } + return janet_wrap_array(states); +} + +static const struct ParserStateGetter parser_state_getters[] = { + {"frames", parser_state_frames}, + {"delimiters", parser_state_delimiters}, + {NULL, NULL} +}; + +JANET_CORE_FN(cfun_parse_state, + "(parser/state parser &opt key)", + "Returns a representation of the internal state of the parser. If a key is passed, " + "only that information about the state is returned. Allowed keys are:\n\n" + "* :delimiters - Each byte in the string represents a nested data structure. For example, " + "if the parser state is '([\"', then the parser is in the middle of parsing a " + "string inside of square brackets inside parentheses. Can be used to augment a REPL prompt.\n\n" + "* :frames - Each table in the array represents a 'frame' in the parser state. Frames " + "contain information about the start of the expression being parsed as well as the " + "type of that expression and some type-specific information.") { + janet_arity(argc, 1, 2); + const uint8_t *key = NULL; + JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type); + if (argc == 2) { + key = janet_getkeyword(argv, 1); + } + + if (key) { + /* Get one result */ + for (const struct ParserStateGetter *sg = parser_state_getters; + sg->name != NULL; sg++) { + if (janet_cstrcmp(key, sg->name)) continue; + return sg->fn(p); + } + janet_panicf("unexpected keyword %v", janet_wrap_keyword(key)); + return janet_wrap_nil(); + } else { + /* Put results in table */ + JanetTable *tab = janet_table(0); + for (const struct ParserStateGetter *sg = parser_state_getters; + sg->name != NULL; sg++) { + janet_table_put(tab, janet_ckeywordv(sg->name), sg->fn(p)); + } + return janet_wrap_table(tab); + } +} + +JANET_CORE_FN(cfun_parse_clone, + "(parser/clone p)", + "Creates a deep clone of a parser that is identical to the input parser. " + "This cloned parser can be used to continue parsing from a good checkpoint " + "if parsing later fails. Returns a new parser.") { + janet_fixarity(argc, 1); + JanetParser *src = janet_getabstract(argv, 0, &janet_parser_type); + JanetParser *dest = janet_abstract(&janet_parser_type, sizeof(JanetParser)); + janet_parser_clone(src, dest); + return janet_wrap_abstract(dest); +} + +static const JanetMethod parser_methods[] = { + {"byte", cfun_parse_byte}, + {"clone", cfun_parse_clone}, + {"consume", cfun_parse_consume}, + {"eof", cfun_parse_eof}, + {"error", cfun_parse_error}, + {"flush", cfun_parse_flush}, + {"has-more", cfun_parse_has_more}, + {"insert", cfun_parse_insert}, + {"produce", cfun_parse_produce}, + {"state", cfun_parse_state}, + {"status", cfun_parse_status}, + {"where", cfun_parse_where}, + {NULL, NULL} +}; + +static int parserget(void *p, Janet key, Janet *out) { + (void) p; + if (!janet_checktype(key, JANET_KEYWORD)) return 0; + return janet_getmethod(janet_unwrap_keyword(key), parser_methods, out); +} + +static Janet parsernext(void *p, Janet key) { + (void) p; + return janet_nextmethod(parser_methods, key); +} + +/* Load the library */ +void janet_lib_parse(JanetTable *env) { + JanetRegExt parse_cfuns[] = { + JANET_CORE_REG("parser/new", cfun_parse_parser), + JANET_CORE_REG("parser/clone", cfun_parse_clone), + JANET_CORE_REG("parser/has-more", cfun_parse_has_more), + JANET_CORE_REG("parser/produce", cfun_parse_produce), + JANET_CORE_REG("parser/consume", cfun_parse_consume), + JANET_CORE_REG("parser/byte", cfun_parse_byte), + JANET_CORE_REG("parser/error", cfun_parse_error), + JANET_CORE_REG("parser/status", cfun_parse_status), + JANET_CORE_REG("parser/flush", cfun_parse_flush), + JANET_CORE_REG("parser/state", cfun_parse_state), + JANET_CORE_REG("parser/where", cfun_parse_where), + JANET_CORE_REG("parser/eof", cfun_parse_eof), + JANET_CORE_REG("parser/insert", cfun_parse_insert), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, parse_cfuns); +} + + +/* src/core/peg.c */ +#line 0 "src/core/peg.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include +#include "util.h" +#include "vector.h" +#include "util.h" +#endif + +#ifdef JANET_PEG + +/* + * Runtime + */ + +/* Hold captured patterns and match state */ +typedef struct { + const uint8_t *text_start; + const uint8_t *text_end; + /* text_end can be restricted by some rules, but + outer_text_end will always contain the real end of + input, which we need to generate a line mapping */ + const uint8_t *outer_text_end; + const uint32_t *bytecode; + const Janet *constants; + JanetArray *captures; + JanetBuffer *scratch; + JanetBuffer *tags; + JanetArray *tagged_captures; + const Janet *extrav; + int32_t *linemap; + int32_t extrac; + int32_t depth; + int32_t linemaplen; + int32_t has_backref; + enum { + PEG_MODE_NORMAL, + PEG_MODE_ACCUMULATE + } mode; +} PegState; + +/* Allow backtrack with captures. We need + * to save state at branches, and then reload + * if one branch fails and try a new branch. */ +typedef struct { + int32_t cap; + int32_t tcap; + int32_t scratch; +} CapState; + +/* Save the current capture state */ +static CapState cap_save(PegState *s) { + CapState cs; + cs.scratch = s->scratch->count; + cs.cap = s->captures->count; + cs.tcap = s->tagged_captures->count; + return cs; +} + +/* Load a saved capture state in the case of failure */ +static void cap_load(PegState *s, CapState cs) { + s->scratch->count = cs.scratch; + s->captures->count = cs.cap; + s->tags->count = cs.tcap; + s->tagged_captures->count = cs.tcap; +} + +/* Load a saved capture state in the case of success. Keeps + * tagged captures around for backref. */ +static void cap_load_keept(PegState *s, CapState cs) { + s->scratch->count = cs.scratch; + s->captures->count = cs.cap; +} + +/* Add a capture */ +static void pushcap(PegState *s, Janet capture, uint32_t tag) { + if (s->mode == PEG_MODE_ACCUMULATE) { + janet_to_string_b(s->scratch, capture); + } + if (s->mode == PEG_MODE_NORMAL) { + janet_array_push(s->captures, capture); + } + if (s->has_backref) { + janet_array_push(s->tagged_captures, capture); + janet_buffer_push_u8(s->tags, tag); + } +} + +/* Lazily generate line map to get line and column information for PegState. + * line and column are 1-indexed. */ +typedef struct { + int32_t line; + int32_t col; +} LineCol; +static LineCol get_linecol_from_position(PegState *s, int32_t position) { + /* Generate if not made yet */ + if (s->linemaplen < 0) { + int32_t newline_count = 0; + for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) { + if (*c == '\n') newline_count++; + } + int32_t *mem = janet_smalloc(sizeof(int32_t) * newline_count); + size_t index = 0; + for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) { + if (*c == '\n') mem[index++] = (int32_t)(c - s->text_start); + } + s->linemaplen = newline_count; + s->linemap = mem; + } + /* Do binary search for line. Slightly modified from classic binary search: + * - if we find that our current character is a line break, just return immediately. + * a newline character is consider to be on the same line as the character before + * (\n is line terminator, not line separator). + * - in the not-found case, we still want to find the greatest-indexed newline that + * is before position. we use that to calcuate the line and column. + * - in the case that lo = 0 and s->linemap[0] is still greater than position, we + * are on the first line and our column is position + 1. */ + int32_t hi = s->linemaplen; /* hi is greater than the actual line */ + int32_t lo = 0; /* lo is less than or equal to the actual line */ + LineCol ret; + while (lo + 1 < hi) { + int32_t mid = lo + (hi - lo) / 2; + if (s->linemap[mid] >= position) { + hi = mid; + } else { + lo = mid; + } + } + /* first line case */ + if (s->linemaplen == 0 || (lo == 0 && s->linemap[0] >= position)) { + ret.line = 1; + ret.col = position + 1; + } else { + ret.line = lo + 2; + ret.col = position - s->linemap[lo]; + } + return ret; +} + +/* Convert a uint64_t to a int64_t by wrapping to a maximum number of bytes */ +static int64_t peg_convert_u64_s64(uint64_t from, int width) { + int shift = 8 * (8 - width); + return ((int64_t)(from << shift)) >> shift; +} + +/* Prevent stack overflow */ +#define down1(s) do { \ + if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ +} while (0) +#define up1(s) ((s)->depth++) + +/* Evaluate a peg rule + * Pre-conditions: s is in a valid state + * Post-conditions: If there is a match, returns a pointer to the next text. + * All captures on the capture stack are valid. If there is no match, + * returns NULL. Extra captures from successful child expressions can be + * left on the capture stack. + */ +static const uint8_t *peg_rule( + PegState *s, + const uint32_t *rule, + const uint8_t *text) { +tail: + switch (*rule) { + default: + janet_panic("unexpected opcode"); + return NULL; + + case RULE_LITERAL: { + uint32_t len = rule[1]; + if (text + len > s->text_end) return NULL; + return memcmp(text, rule + 2, len) ? NULL : text + len; + } + + case RULE_NCHAR: { + uint32_t n = rule[1]; + return (text + n > s->text_end) ? NULL : text + n; + } + + case RULE_NOTNCHAR: { + uint32_t n = rule[1]; + return (text + n > s->text_end) ? text : NULL; + } + + case RULE_RANGE: { + uint8_t lo = rule[1] & 0xFF; + uint8_t hi = (rule[1] >> 16) & 0xFF; + return (text < s->text_end && + text[0] >= lo && + text[0] <= hi) + ? text + 1 + : NULL; + } + + case RULE_SET: { + if (text >= s->text_end) return NULL; + uint32_t word = rule[1 + (text[0] >> 5)]; + uint32_t mask = (uint32_t)1 << (text[0] & 0x1F); + return (word & mask) + ? text + 1 + : NULL; + } + + case RULE_LOOK: { + text += ((int32_t *)rule)[1]; + if (text < s->text_start || text > s->text_end) return NULL; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text); + up1(s); + text -= ((int32_t *)rule)[1]; + return result ? text : NULL; + } + + case RULE_CHOICE: { + uint32_t len = rule[1]; + const uint32_t *args = rule + 2; + if (len == 0) return NULL; + down1(s); + CapState cs = cap_save(s); + for (uint32_t i = 0; i < len - 1; i++) { + const uint8_t *result = peg_rule(s, s->bytecode + args[i], text); + if (result) { + up1(s); + return result; + } + cap_load(s, cs); + } + up1(s); + rule = s->bytecode + args[len - 1]; + goto tail; + } + + case RULE_SEQUENCE: { + uint32_t len = rule[1]; + const uint32_t *args = rule + 2; + if (len == 0) return text; + down1(s); + for (uint32_t i = 0; text && i < len - 1; i++) + text = peg_rule(s, s->bytecode + args[i], text); + up1(s); + if (!text) return NULL; + rule = s->bytecode + args[len - 1]; + goto tail; + } + + case RULE_IF: { + const uint32_t *rule_a = s->bytecode + rule[1]; + const uint32_t *rule_b = s->bytecode + rule[2]; + down1(s); + const uint8_t *result = peg_rule(s, rule_a, text); + up1(s); + if (!result) return NULL; + rule = rule_b; + goto tail; + } + case RULE_IFNOT: { + const uint32_t *rule_a = s->bytecode + rule[1]; + const uint32_t *rule_b = s->bytecode + rule[2]; + down1(s); + CapState cs = cap_save(s); + const uint8_t *result = peg_rule(s, rule_a, text); + if (!!result) { + up1(s); + return NULL; + } else { + cap_load(s, cs); + up1(s); + rule = rule_b; + goto tail; + } + } + + case RULE_NOT: { + const uint32_t *rule_a = s->bytecode + rule[1]; + down1(s); + CapState cs = cap_save(s); + const uint8_t *result = peg_rule(s, rule_a, text); + if (result) { + up1(s); + return NULL; + } else { + cap_load(s, cs); + up1(s); + return text; + } + } + + case RULE_THRU: + case RULE_TO: { + const uint32_t *rule_a = s->bytecode + rule[1]; + const uint8_t *next_text = NULL; + CapState cs = cap_save(s); + down1(s); + while (text <= s->text_end) { + CapState cs2 = cap_save(s); + next_text = peg_rule(s, rule_a, text); + if (next_text) { + if (rule[0] == RULE_TO) cap_load(s, cs2); + break; + } + cap_load(s, cs2); + text++; + } + up1(s); + if (text > s->text_end) { + cap_load(s, cs); + return NULL; + } + return rule[0] == RULE_TO ? text : next_text; + } + + case RULE_BETWEEN: { + uint32_t lo = rule[1]; + uint32_t hi = rule[2]; + const uint32_t *rule_a = s->bytecode + rule[3]; + uint32_t captured = 0; + const uint8_t *next_text; + CapState cs = cap_save(s); + down1(s); + while (captured < hi) { + CapState cs2 = cap_save(s); + next_text = peg_rule(s, rule_a, text); + if (!next_text || next_text == text) { + cap_load(s, cs2); + break; + } + captured++; + text = next_text; + } + up1(s); + if (captured < lo) { + cap_load(s, cs); + return NULL; + } + return text; + } + + /* Capturing rules */ + + case RULE_GETTAG: { + uint32_t search = rule[1]; + uint32_t tag = rule[2]; + for (int32_t i = s->tags->count - 1; i >= 0; i--) { + if (s->tags->data[i] == search) { + pushcap(s, s->tagged_captures->data[i], tag); + return text; + } + } + return NULL; + } + + case RULE_POSITION: { + pushcap(s, janet_wrap_number((double)(text - s->text_start)), rule[1]); + return text; + } + + case RULE_LINE: { + LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start)); + pushcap(s, janet_wrap_number((double)(lc.line)), rule[1]); + return text; + } + + case RULE_COLUMN: { + LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start)); + pushcap(s, janet_wrap_number((double)(lc.col)), rule[1]); + return text; + } + + case RULE_ARGUMENT: { + int32_t index = ((int32_t *)rule)[1]; + Janet capture = (index >= s->extrac) ? janet_wrap_nil() : s->extrav[index]; + pushcap(s, capture, rule[2]); + return text; + } + + case RULE_CONSTANT: { + pushcap(s, s->constants[rule[1]], rule[2]); + return text; + } + + case RULE_CAPTURE: { + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + if (!result) return NULL; + /* Specialized pushcap - avoid intermediate string creation */ + if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) { + janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text)); + } else { + uint32_t tag = rule[2]; + pushcap(s, janet_stringv(text, (int32_t)(result - text)), tag); + } + return result; + } + + case RULE_CAPTURE_NUM: { + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + if (!result) return NULL; + /* check number parsing */ + double x = 0.0; + int32_t base = (int32_t) rule[2]; + if (janet_scan_number_base(text, (int32_t)(result - text), base, &x)) return NULL; + /* Specialized pushcap - avoid intermediate string creation */ + if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) { + janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text)); + } else { + uint32_t tag = rule[3]; + pushcap(s, janet_wrap_number(x), tag); + } + return result; + } + + case RULE_ACCUMULATE: { + uint32_t tag = rule[2]; + int oldmode = s->mode; + if (!tag && oldmode == PEG_MODE_ACCUMULATE) { + rule = s->bytecode + rule[1]; + goto tail; + } + CapState cs = cap_save(s); + s->mode = PEG_MODE_ACCUMULATE; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + s->mode = oldmode; + if (!result) return NULL; + Janet cap = janet_stringv(s->scratch->data + cs.scratch, + s->scratch->count - cs.scratch); + cap_load_keept(s, cs); + pushcap(s, cap, tag); + return result; + } + + case RULE_DROP: { + CapState cs = cap_save(s); + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + if (!result) return NULL; + cap_load(s, cs); + return result; + } + + case RULE_GROUP: { + uint32_t tag = rule[2]; + int oldmode = s->mode; + CapState cs = cap_save(s); + s->mode = PEG_MODE_NORMAL; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + s->mode = oldmode; + if (!result) return NULL; + int32_t num_sub_captures = s->captures->count - cs.cap; + JanetArray *sub_captures = janet_array(num_sub_captures); + safe_memcpy(sub_captures->data, + s->captures->data + cs.cap, + sizeof(Janet) * num_sub_captures); + sub_captures->count = num_sub_captures; + cap_load_keept(s, cs); + pushcap(s, janet_wrap_array(sub_captures), tag); + return result; + } + + case RULE_SUB: { + const uint8_t *text_start = text; + const uint32_t *rule_window = s->bytecode + rule[1]; + const uint32_t *rule_subpattern = s->bytecode + rule[2]; + down1(s); + const uint8_t *window_end = peg_rule(s, rule_window, text); + up1(s); + if (!window_end) { + return NULL; + } + const uint8_t *saved_end = s->text_end; + s->text_end = window_end; + down1(s); + const uint8_t *next_text = peg_rule(s, rule_subpattern, text_start); + up1(s); + s->text_end = saved_end; + + if (!next_text) { + return NULL; + } + + return window_end; + } + + case RULE_SPLIT: { + const uint8_t *saved_end = s->text_end; + const uint32_t *rule_separator = s->bytecode + rule[1]; + const uint32_t *rule_subpattern = s->bytecode + rule[2]; + + const uint8_t *separator_end = NULL; + do { + const uint8_t *text_start = text; + CapState cs = cap_save(s); + down1(s); + while (text <= s->text_end) { + separator_end = peg_rule(s, rule_separator, text); + cap_load(s, cs); + if (separator_end) { + break; + } + text++; + } + up1(s); + + if (separator_end) { + s->text_end = text; + text = separator_end; + } + + down1(s); + const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, text_start); + up1(s); + s->text_end = saved_end; + + if (!subpattern_end) { + return NULL; + } + } while (separator_end); + + return s->text_end; + } + + case RULE_REPLACE: + case RULE_MATCHTIME: { + uint32_t tag = rule[3]; + int oldmode = s->mode; + CapState cs = cap_save(s); + s->mode = PEG_MODE_NORMAL; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + s->mode = oldmode; + if (!result) return NULL; + + Janet cap = janet_wrap_nil(); + Janet constant = s->constants[rule[2]]; + switch (janet_type(constant)) { + default: + cap = constant; + break; + case JANET_STRUCT: + if (s->captures->count) { + cap = janet_struct_get(janet_unwrap_struct(constant), + s->captures->data[s->captures->count - 1]); + } + break; + case JANET_TABLE: + if (s->captures->count) { + cap = janet_table_get(janet_unwrap_table(constant), + s->captures->data[s->captures->count - 1]); + } + break; + case JANET_CFUNCTION: + cap = janet_unwrap_cfunction(constant)(s->captures->count - cs.cap, + s->captures->data + cs.cap); + break; + case JANET_FUNCTION: + cap = janet_call(janet_unwrap_function(constant), + s->captures->count - cs.cap, + s->captures->data + cs.cap); + break; + } + cap_load_keept(s, cs); + if (rule[0] == RULE_MATCHTIME && !janet_truthy(cap)) return NULL; + pushcap(s, cap, tag); + return result; + } + + case RULE_ERROR: { + int oldmode = s->mode; + s->mode = PEG_MODE_NORMAL; + int32_t old_cap = s->captures->count; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + s->mode = oldmode; + if (!result) return NULL; + if (s->captures->count > old_cap) { + /* Throw last capture */ + janet_panicv(s->captures->data[s->captures->count - 1]); + } else { + /* Throw generic error */ + int32_t start = (int32_t)(text - s->text_start); + LineCol lc = get_linecol_from_position(s, start); + janet_panicf("match error at line %d, column %d", lc.line, lc.col); + } + return NULL; + } + + case RULE_BACKMATCH: { + uint32_t search = rule[1]; + for (int32_t i = s->tags->count - 1; i >= 0; i--) { + if (s->tags->data[i] == search) { + Janet capture = s->tagged_captures->data[i]; + if (!janet_checktype(capture, JANET_STRING)) + return NULL; + const uint8_t *bytes = janet_unwrap_string(capture); + int32_t len = janet_string_length(bytes); + if (text + len > s->text_end) + return NULL; + return memcmp(text, bytes, len) ? NULL : text + len; + } + } + return NULL; + } + + case RULE_LENPREFIX: { + int oldmode = s->mode; + s->mode = PEG_MODE_NORMAL; + const uint8_t *next_text; + CapState cs = cap_save(s); + down1(s); + next_text = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + if (NULL == next_text) return NULL; + s->mode = oldmode; + int32_t num_sub_captures = s->captures->count - cs.cap; + Janet lencap; + if (num_sub_captures <= 0 || + (lencap = s->captures->data[cs.cap], !janet_checkint(lencap))) { + cap_load(s, cs); + return NULL; + } + int32_t nrep = janet_unwrap_integer(lencap); + /* drop captures from len pattern */ + cap_load(s, cs); + for (int32_t i = 0; i < nrep; i++) { + down1(s); + next_text = peg_rule(s, s->bytecode + rule[2], next_text); + up1(s); + if (NULL == next_text) { + cap_load(s, cs); + return NULL; + } + } + return next_text; + } + + case RULE_READINT: { + uint32_t tag = rule[2]; + uint32_t signedness = rule[1] & 0x10; + uint32_t endianess = rule[1] & 0x20; + int width = (int)(rule[1] & 0xF); + if (text + width > s->text_end) return NULL; + uint64_t accum = 0; + if (endianess) { + /* BE */ + for (int i = 0; i < width; i++) accum = (accum << 8) | text[i]; + } else { + /* LE */ + for (int i = width - 1; i >= 0; i--) accum = (accum << 8) | text[i]; + } + + Janet capture_value; + /* We can only parse integeres of greater than 6 bytes reliable if int-types are enabled. + * Otherwise, we may lose precision, so 6 is the maximum size when int-types are disabled. */ +#ifdef JANET_INT_TYPES + if (width > 6) { + if (signedness) { + capture_value = janet_wrap_s64(peg_convert_u64_s64(accum, width)); + } else { + capture_value = janet_wrap_u64(accum); + } + } else +#endif + { + double double_value; + if (signedness) { + double_value = (double)(peg_convert_u64_s64(accum, width)); + } else { + double_value = (double)accum; + } + capture_value = janet_wrap_number(double_value); + } + + pushcap(s, capture_value, tag); + return text + width; + } + + case RULE_UNREF: { + int32_t tcap = s->tags->count; + down1(s); + const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); + up1(s); + if (!result) return NULL; + int32_t final_tcap = s->tags->count; + /* Truncate tagged captures to not include items of the given tag */ + int32_t w = tcap; + /* If no tag is given, drop ALL tagged captures */ + if (rule[2]) { + for (int32_t i = tcap; i < final_tcap; i++) { + if (s->tags->data[i] != (0xFF & rule[2])) { + s->tags->data[w] = s->tags->data[i]; + s->tagged_captures->data[w] = s->tagged_captures->data[i]; + w++; + } + } + } + s->tags->count = w; + s->tagged_captures->count = w; + return result; + } + + } +} + +/* + * Compilation + */ + +typedef struct { + JanetTable *grammar; + JanetTable *default_grammar; + JanetTable *tags; + Janet *constants; + uint32_t *bytecode; + Janet form; + int depth; + uint32_t nexttag; + int has_backref; +} Builder; + +/* Forward declaration to allow recursion */ +static uint32_t peg_compile1(Builder *b, Janet peg); + +/* + * Errors + */ + +static void builder_cleanup(Builder *b) { + janet_v_free(b->constants); + janet_v_free(b->bytecode); +} + +JANET_NO_RETURN static void peg_panic(Builder *b, const char *msg) { + builder_cleanup(b); + janet_panicf("grammar error in %p, %s", b->form, msg); +} + +#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) + +static void peg_fixarity(Builder *b, int32_t argc, int32_t arity) { + if (argc != arity) { + peg_panicf(b, "expected %d argument%s, got %d", + arity, + arity == 1 ? "" : "s", + argc); + } +} + +static void peg_arity(Builder *b, int32_t arity, int32_t min, int32_t max) { + if (min >= 0 && arity < min) + peg_panicf(b, "arity mismatch, expected at least %d, got %d", min, arity); + if (max >= 0 && arity > max) + peg_panicf(b, "arity mismatch, expected at most %d, got %d", max, arity); +} + +static const uint8_t *peg_getset(Builder *b, Janet x) { + if (!janet_checktype(x, JANET_STRING)) + peg_panic(b, "expected string for character set"); + const uint8_t *str = janet_unwrap_string(x); + return str; +} + +static const uint8_t *peg_getrange(Builder *b, Janet x) { + if (!janet_checktype(x, JANET_STRING)) + peg_panic(b, "expected string for character range"); + const uint8_t *str = janet_unwrap_string(x); + if (janet_string_length(str) != 2) + peg_panicf(b, "expected string to have length 2, got %v", x); + if (str[1] < str[0]) + peg_panicf(b, "range %v is empty", x); + return str; +} + +static int32_t peg_getinteger(Builder *b, Janet x) { + if (!janet_checkint(x)) + peg_panicf(b, "expected integer, got %v", x); + return janet_unwrap_integer(x); +} + +static int32_t peg_getnat(Builder *b, Janet x) { + int32_t i = peg_getinteger(b, x); + if (i < 0) + peg_panicf(b, "expected non-negative integer, got %v", x); + return i; +} + +/* + * Emission + */ + +static uint32_t emit_constant(Builder *b, Janet c) { + uint32_t cindex = (uint32_t) janet_v_count(b->constants); + janet_v_push(b->constants, c); + return cindex; +} + +static uint32_t emit_tag(Builder *b, Janet t) { + if (!janet_checktype(t, JANET_KEYWORD)) + peg_panicf(b, "expected keyword for capture tag, got %v", t); + Janet check = janet_table_get(b->tags, t); + if (janet_checktype(check, JANET_NIL)) { + uint32_t tag = b->nexttag++; + if (tag > 255) { + peg_panic(b, "too many tags - up to 255 tags are supported per peg"); + } + Janet val = janet_wrap_number(tag); + janet_table_put(b->tags, t, val); + return tag; + } else { + return (uint32_t) janet_unwrap_number(check); + } +} + +/* Reserve space in bytecode for a rule. When a special emits a rule, + * it must place that rule immediately on the bytecode stack. This lets + * the compiler know where the rule is going to be before it is complete, + * allowing recursive rules. */ +typedef struct { + Builder *builder; + uint32_t index; + int32_t size; +} Reserve; + +static Reserve reserve(Builder *b, int32_t size) { + Reserve r; + r.index = janet_v_count(b->bytecode); + r.builder = b; + r.size = size; + for (int32_t i = 0; i < size; i++) + janet_v_push(b->bytecode, 0); + return r; +} + +/* Emit a rule in the builder. Returns the index of the new rule */ +static void emit_rule(Reserve r, int32_t op, int32_t n, const uint32_t *body) { + janet_assert(r.size == n + 1, "bad reserve"); + r.builder->bytecode[r.index] = op; + memcpy(r.builder->bytecode + r.index + 1, body, n * sizeof(uint32_t)); +} + +/* For RULE_LITERAL */ +static void emit_bytes(Builder *b, uint32_t op, int32_t len, const uint8_t *bytes) { + uint32_t next_rule = janet_v_count(b->bytecode); + janet_v_push(b->bytecode, op); + janet_v_push(b->bytecode, len); + int32_t words = ((len + 3) >> 2); + for (int32_t i = 0; i < words; i++) + janet_v_push(b->bytecode, 0); + memcpy(b->bytecode + next_rule + 2, bytes, len); +} + +/* For fixed arity rules of arities 1, 2, and 3 */ +static void emit_1(Reserve r, uint32_t op, uint32_t arg) { + emit_rule(r, op, 1, &arg); +} +static void emit_2(Reserve r, uint32_t op, uint32_t arg1, uint32_t arg2) { + uint32_t arr[2] = {arg1, arg2}; + emit_rule(r, op, 2, arr); +} +static void emit_3(Reserve r, uint32_t op, uint32_t arg1, uint32_t arg2, uint32_t arg3) { + uint32_t arr[3] = {arg1, arg2, arg3}; + emit_rule(r, op, 3, arr); +} + +/* + * Specials + */ + +static void bitmap_set(uint32_t *bitmap, uint8_t c) { + bitmap[c >> 5] |= ((uint32_t)1) << (c & 0x1F); +} + +static void spec_range(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 1, -1); + if (argc == 1) { + Reserve r = reserve(b, 2); + const uint8_t *str = peg_getrange(b, argv[0]); + uint32_t arg = str[0] | (str[1] << 16); + emit_1(r, RULE_RANGE, arg); + } else { + /* Compile as a set */ + Reserve r = reserve(b, 9); + uint32_t bitmap[8] = {0}; + for (int32_t i = 0; i < argc; i++) { + const uint8_t *str = peg_getrange(b, argv[i]); + for (uint32_t c = str[0]; c <= str[1]; c++) + bitmap_set(bitmap, c); + } + emit_rule(r, RULE_SET, 8, bitmap); + } +} + +static void spec_set(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 1); + Reserve r = reserve(b, 9); + const uint8_t *str = peg_getset(b, argv[0]); + uint32_t bitmap[8] = {0}; + for (int32_t i = 0; i < janet_string_length(str); i++) + bitmap_set(bitmap, str[i]); + emit_rule(r, RULE_SET, 8, bitmap); +} + +static void spec_look(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 1, 2); + Reserve r = reserve(b, 3); + int32_t rulearg = argc == 2 ? 1 : 0; + int32_t offset = argc == 2 ? peg_getinteger(b, argv[0]) : 0; + uint32_t subrule = peg_compile1(b, argv[rulearg]); + emit_2(r, RULE_LOOK, (uint32_t) offset, subrule); +} + +/* Rule of the form [len, rules...] */ +static void spec_variadic(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { + uint32_t rule = janet_v_count(b->bytecode); + janet_v_push(b->bytecode, op); + janet_v_push(b->bytecode, argc); + for (int32_t i = 0; i < argc; i++) + janet_v_push(b->bytecode, 0); + for (int32_t i = 0; i < argc; i++) { + uint32_t rulei = peg_compile1(b, argv[i]); + b->bytecode[rule + 2 + i] = rulei; + } +} + +static void spec_choice(Builder *b, int32_t argc, const Janet *argv) { + spec_variadic(b, argc, argv, RULE_CHOICE); +} +static void spec_sequence(Builder *b, int32_t argc, const Janet *argv) { + spec_variadic(b, argc, argv, RULE_SEQUENCE); +} + +/* For (if a b) and (if-not a b) */ +static void spec_branch(Builder *b, int32_t argc, const Janet *argv, uint32_t rule) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 3); + uint32_t rule_a = peg_compile1(b, argv[0]); + uint32_t rule_b = peg_compile1(b, argv[1]); + emit_2(r, rule, rule_a, rule_b); +} + +static void spec_if(Builder *b, int32_t argc, const Janet *argv) { + spec_branch(b, argc, argv, RULE_IF); +} +static void spec_ifnot(Builder *b, int32_t argc, const Janet *argv) { + spec_branch(b, argc, argv, RULE_IFNOT); +} +static void spec_lenprefix(Builder *b, int32_t argc, const Janet *argv) { + spec_branch(b, argc, argv, RULE_LENPREFIX); +} + +static void spec_between(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 3); + Reserve r = reserve(b, 4); + int32_t lo = peg_getnat(b, argv[0]); + int32_t hi = peg_getnat(b, argv[1]); + uint32_t subrule = peg_compile1(b, argv[2]); + emit_3(r, RULE_BETWEEN, lo, hi, subrule); +} + +static void spec_repeater(Builder *b, int32_t argc, const Janet *argv, int32_t min) { + peg_fixarity(b, argc, 1); + Reserve r = reserve(b, 4); + uint32_t subrule = peg_compile1(b, argv[0]); + emit_3(r, RULE_BETWEEN, min, UINT32_MAX, subrule); +} + +static void spec_some(Builder *b, int32_t argc, const Janet *argv) { + spec_repeater(b, argc, argv, 1); +} +static void spec_any(Builder *b, int32_t argc, const Janet *argv) { + spec_repeater(b, argc, argv, 0); +} + +static void spec_atleast(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 4); + int32_t n = peg_getnat(b, argv[0]); + uint32_t subrule = peg_compile1(b, argv[1]); + emit_3(r, RULE_BETWEEN, n, UINT32_MAX, subrule); +} + +static void spec_atmost(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 4); + int32_t n = peg_getnat(b, argv[0]); + uint32_t subrule = peg_compile1(b, argv[1]); + emit_3(r, RULE_BETWEEN, 0, n, subrule); +} + +static void spec_opt(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 1); + Reserve r = reserve(b, 4); + uint32_t subrule = peg_compile1(b, argv[0]); + emit_3(r, RULE_BETWEEN, 0, 1, subrule); +} + +static void spec_repeat(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 4); + int32_t n = peg_getnat(b, argv[0]); + uint32_t subrule = peg_compile1(b, argv[1]); + emit_3(r, RULE_BETWEEN, n, n, subrule); +} + +/* Rule of the form [rule] */ +static void spec_onerule(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { + peg_fixarity(b, argc, 1); + Reserve r = reserve(b, 2); + uint32_t rule = peg_compile1(b, argv[0]); + emit_1(r, op, rule); +} + +static void spec_not(Builder *b, int32_t argc, const Janet *argv) { + spec_onerule(b, argc, argv, RULE_NOT); +} +static void spec_error(Builder *b, int32_t argc, const Janet *argv) { + if (argc == 0) { + Reserve r = reserve(b, 2); + uint32_t rule = peg_compile1(b, janet_wrap_number(0)); + emit_1(r, RULE_ERROR, rule); + } else { + spec_onerule(b, argc, argv, RULE_ERROR); + } +} +static void spec_to(Builder *b, int32_t argc, const Janet *argv) { + spec_onerule(b, argc, argv, RULE_TO); +} +static void spec_thru(Builder *b, int32_t argc, const Janet *argv) { + spec_onerule(b, argc, argv, RULE_THRU); +} +static void spec_drop(Builder *b, int32_t argc, const Janet *argv) { + spec_onerule(b, argc, argv, RULE_DROP); +} + +/* Rule of the form [rule, tag] */ +static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { + peg_arity(b, argc, 1, 2); + Reserve r = reserve(b, 3); + uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; + uint32_t rule = peg_compile1(b, argv[0]); + emit_2(r, op, rule, tag); +} + +static void spec_capture(Builder *b, int32_t argc, const Janet *argv) { + spec_cap1(b, argc, argv, RULE_CAPTURE); +} +static void spec_accumulate(Builder *b, int32_t argc, const Janet *argv) { + spec_cap1(b, argc, argv, RULE_ACCUMULATE); +} +static void spec_group(Builder *b, int32_t argc, const Janet *argv) { + spec_cap1(b, argc, argv, RULE_GROUP); +} +static void spec_unref(Builder *b, int32_t argc, const Janet *argv) { + spec_cap1(b, argc, argv, RULE_UNREF); +} + +static void spec_capture_number(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 1, 3); + Reserve r = reserve(b, 4); + uint32_t base = 0; + if (argc >= 2) { + if (!janet_checktype(argv[1], JANET_NIL)) { + if (!janet_checkint(argv[1])) goto error; + base = (uint32_t) janet_unwrap_integer(argv[1]); + if (base < 2 || base > 36) goto error; + } + } + uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0; + uint32_t rule = peg_compile1(b, argv[0]); + emit_3(r, RULE_CAPTURE_NUM, rule, base, tag); + return; +error: + peg_panicf(b, "expected integer between 2 and 36, got %v", argv[1]); +} + +static void spec_reference(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 1, 2); + Reserve r = reserve(b, 3); + uint32_t search = emit_tag(b, argv[0]); + uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; + b->has_backref = 1; + emit_2(r, RULE_GETTAG, search, tag); +} + +static void spec_tag1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { + peg_arity(b, argc, 0, 1); + Reserve r = reserve(b, 2); + uint32_t tag = (argc) ? emit_tag(b, argv[0]) : 0; + (void) argv; + emit_1(r, op, tag); +} + +static void spec_position(Builder *b, int32_t argc, const Janet *argv) { + spec_tag1(b, argc, argv, RULE_POSITION); +} +static void spec_line(Builder *b, int32_t argc, const Janet *argv) { + spec_tag1(b, argc, argv, RULE_LINE); +} +static void spec_column(Builder *b, int32_t argc, const Janet *argv) { + spec_tag1(b, argc, argv, RULE_COLUMN); +} + +static void spec_backmatch(Builder *b, int32_t argc, const Janet *argv) { + b->has_backref = 1; + spec_tag1(b, argc, argv, RULE_BACKMATCH); +} + +static void spec_argument(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 1, 2); + Reserve r = reserve(b, 3); + uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; + int32_t index = peg_getnat(b, argv[0]); + emit_2(r, RULE_ARGUMENT, index, tag); +} + +static void spec_constant(Builder *b, int32_t argc, const Janet *argv) { + janet_arity(argc, 1, 2); + Reserve r = reserve(b, 3); + uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; + emit_2(r, RULE_CONSTANT, emit_constant(b, argv[0]), tag); +} + +static void spec_replace(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 2, 3); + Reserve r = reserve(b, 4); + uint32_t subrule = peg_compile1(b, argv[0]); + uint32_t constant = emit_constant(b, argv[1]); + uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0; + emit_3(r, RULE_REPLACE, subrule, constant, tag); +} + +static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) { + peg_arity(b, argc, 2, 3); + Reserve r = reserve(b, 4); + uint32_t subrule = peg_compile1(b, argv[0]); + Janet fun = argv[1]; + if (!janet_checktype(fun, JANET_FUNCTION) && + !janet_checktype(fun, JANET_CFUNCTION)) { + peg_panicf(b, "expected function or cfunction, got %v", fun); + } + uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0; + uint32_t cindex = emit_constant(b, fun); + emit_3(r, RULE_MATCHTIME, subrule, cindex, tag); +} + +static void spec_sub(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 3); + uint32_t subrule1 = peg_compile1(b, argv[0]); + uint32_t subrule2 = peg_compile1(b, argv[1]); + emit_2(r, RULE_SUB, subrule1, subrule2); +} + +static void spec_split(Builder *b, int32_t argc, const Janet *argv) { + peg_fixarity(b, argc, 2); + Reserve r = reserve(b, 3); + uint32_t subrule1 = peg_compile1(b, argv[0]); + uint32_t subrule2 = peg_compile1(b, argv[1]); + emit_2(r, RULE_SPLIT, subrule1, subrule2); +} + +#ifdef JANET_INT_TYPES +#define JANET_MAX_READINT_WIDTH 8 +#else +#define JANET_MAX_READINT_WIDTH 6 +#endif + +static void spec_readint(Builder *b, int32_t argc, const Janet *argv, uint32_t mask) { + peg_arity(b, argc, 1, 2); + Reserve r = reserve(b, 3); + uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; + int32_t width = peg_getnat(b, argv[0]); + if ((width < 0) || (width > JANET_MAX_READINT_WIDTH)) { + peg_panicf(b, "width must be between 0 and %d, got %d", JANET_MAX_READINT_WIDTH, width); + } + emit_2(r, RULE_READINT, mask | ((uint32_t) width), tag); +} + +static void spec_uint_le(Builder *b, int32_t argc, const Janet *argv) { + spec_readint(b, argc, argv, 0x0u); +} +static void spec_int_le(Builder *b, int32_t argc, const Janet *argv) { + spec_readint(b, argc, argv, 0x10u); +} +static void spec_uint_be(Builder *b, int32_t argc, const Janet *argv) { + spec_readint(b, argc, argv, 0x20u); +} +static void spec_int_be(Builder *b, int32_t argc, const Janet *argv) { + spec_readint(b, argc, argv, 0x30u); +} + +/* Special compiler form */ +typedef void (*Special)(Builder *b, int32_t argc, const Janet *argv); +typedef struct { + const char *name; + Special special; +} SpecialPair; + +/* Keep in lexical order (vim :sort works well) */ +static const SpecialPair peg_specials[] = { + {"!", spec_not}, + {"$", spec_position}, + {"%", spec_accumulate}, + {"*", spec_sequence}, + {"+", spec_choice}, + {"->", spec_reference}, + {"/", spec_replace}, + {"<-", spec_capture}, + {">", spec_look}, + {"?", spec_opt}, + {"accumulate", spec_accumulate}, + {"any", spec_any}, + {"argument", spec_argument}, + {"at-least", spec_atleast}, + {"at-most", spec_atmost}, + {"backmatch", spec_backmatch}, + {"backref", spec_reference}, + {"between", spec_between}, + {"capture", spec_capture}, + {"choice", spec_choice}, + {"cmt", spec_matchtime}, + {"column", spec_column}, + {"constant", spec_constant}, + {"drop", spec_drop}, + {"error", spec_error}, + {"group", spec_group}, + {"if", spec_if}, + {"if-not", spec_ifnot}, + {"int", spec_int_le}, + {"int-be", spec_int_be}, + {"lenprefix", spec_lenprefix}, + {"line", spec_line}, + {"look", spec_look}, + {"not", spec_not}, + {"number", spec_capture_number}, + {"opt", spec_opt}, + {"position", spec_position}, + {"quote", spec_capture}, + {"range", spec_range}, + {"repeat", spec_repeat}, + {"replace", spec_replace}, + {"sequence", spec_sequence}, + {"set", spec_set}, + {"some", spec_some}, + {"split", spec_split}, + {"sub", spec_sub}, + {"thru", spec_thru}, + {"to", spec_to}, + {"uint", spec_uint_le}, + {"uint-be", spec_uint_be}, + {"unref", spec_unref}, +}; + +/* Compile a janet value into a rule and return the rule index. */ +static uint32_t peg_compile1(Builder *b, Janet peg) { + + /* Keep track of the form being compiled for error purposes */ + Janet old_form = b->form; + JanetTable *old_grammar = b->grammar; + b->form = peg; + + /* Resolve keyword references */ + int i = JANET_RECURSION_GUARD; + JanetTable *grammar = old_grammar; + for (; i > 0 && janet_checktype(peg, JANET_KEYWORD); --i) { + Janet nextPeg = janet_table_get_ex(grammar, peg, &grammar); + if (!grammar || janet_checktype(nextPeg, JANET_NIL)) { + nextPeg = (b->default_grammar == NULL) + ? janet_wrap_nil() + : janet_table_get(b->default_grammar, peg); + if (janet_checktype(nextPeg, JANET_NIL)) { + peg_panic(b, "unknown rule"); + } + } + peg = nextPeg; + b->form = peg; + b->grammar = grammar; + } + if (i == 0) + peg_panic(b, "reference chain too deep"); + + /* Check cache - for tuples we check only the local cache, as + * in a different grammar, the same tuple can compile to a different + * rule - for example, (+ :a :b) depends on whatever :a and :b are bound to. */ + Janet check = janet_checktype(peg, JANET_TUPLE) + ? janet_table_rawget(grammar, peg) + : janet_table_get(grammar, peg); + if (!janet_checktype(check, JANET_NIL)) { + b->form = old_form; + b->grammar = old_grammar; + return (uint32_t) janet_unwrap_number(check); + } + + /* Check depth */ + if (b->depth-- == 0) + peg_panic(b, "peg grammar recursed too deeply"); + + /* The final rule to return */ + uint32_t rule = janet_v_count(b->bytecode); + + /* Add to cache. Do not cache structs, as we don't yet know + * what rule they will return! We can just as effectively cache + * the structs main rule. */ + if (!janet_checktype(peg, JANET_STRUCT)) { + JanetTable *which_grammar = grammar; + /* If we are a primitive pattern, add to the global cache (root grammar table) */ + if (!janet_checktype(peg, JANET_TUPLE)) { + while (which_grammar->proto) + which_grammar = which_grammar->proto; + } + janet_table_put(which_grammar, peg, janet_wrap_number(rule)); + } + + switch (janet_type(peg)) { + default: + peg_panic(b, "unexpected peg source"); + return 0; + + case JANET_BOOLEAN: { + int n = janet_unwrap_boolean(peg); + Reserve r = reserve(b, 2); + emit_1(r, n ? RULE_NCHAR : RULE_NOTNCHAR, 0); + break; + } + case JANET_NUMBER: { + int32_t n = peg_getinteger(b, peg); + Reserve r = reserve(b, 2); + if (n < 0) { + emit_1(r, RULE_NOTNCHAR, -n); + } else { + emit_1(r, RULE_NCHAR, n); + } + break; + } + case JANET_STRING: { + const uint8_t *str = janet_unwrap_string(peg); + int32_t len = janet_string_length(str); + emit_bytes(b, RULE_LITERAL, len, str); + break; + } + case JANET_TABLE: { + /* Build grammar table */ + JanetTable *new_grammar = janet_table_clone(janet_unwrap_table(peg)); + new_grammar->proto = grammar; + b->grammar = grammar = new_grammar; + /* Run the main rule */ + Janet main_rule = janet_table_rawget(grammar, janet_ckeywordv("main")); + if (janet_checktype(main_rule, JANET_NIL)) + peg_panic(b, "grammar requires :main rule"); + rule = peg_compile1(b, main_rule); + break; + } + case JANET_STRUCT: { + /* Build grammar table */ + const JanetKV *st = janet_unwrap_struct(peg); + JanetTable *new_grammar = janet_table(2 * janet_struct_capacity(st)); + for (int32_t i = 0; i < janet_struct_capacity(st); i++) { + if (janet_checktype(st[i].key, JANET_KEYWORD)) { + janet_table_put(new_grammar, st[i].key, st[i].value); + } + } + new_grammar->proto = grammar; + b->grammar = grammar = new_grammar; + /* Run the main rule */ + Janet main_rule = janet_table_rawget(grammar, janet_ckeywordv("main")); + if (janet_checktype(main_rule, JANET_NIL)) + peg_panic(b, "grammar requires :main rule"); + rule = peg_compile1(b, main_rule); + break; + } + case JANET_TUPLE: { + const Janet *tup = janet_unwrap_tuple(peg); + int32_t len = janet_tuple_length(tup); + if (len == 0) peg_panic(b, "tuple in grammar must have non-zero length"); + if (janet_checkint(tup[0])) { + int32_t n = janet_unwrap_integer(tup[0]); + if (n < 0) { + peg_panicf(b, "expected non-negative integer, got %d", n); + } + spec_repeat(b, len, tup); + break; + } + if (!janet_checktype(tup[0], JANET_SYMBOL)) + peg_panicf(b, "expected grammar command, found %v", tup[0]); + const uint8_t *sym = janet_unwrap_symbol(tup[0]); + const SpecialPair *sp = janet_strbinsearch( + &peg_specials, + sizeof(peg_specials) / sizeof(SpecialPair), + sizeof(SpecialPair), + sym); + if (sp) { + sp->special(b, len - 1, tup + 1); + } else { + peg_panicf(b, "unknown special %S", sym); + } + break; + } + } + + /* Increase depth again */ + b->depth++; + b->form = old_form; + b->grammar = old_grammar; + return rule; +} + +/* + * Post-Compilation + */ + +static int peg_mark(void *p, size_t size) { + (void) size; + JanetPeg *peg = (JanetPeg *)p; + if (NULL != peg->constants) + for (uint32_t i = 0; i < peg->num_constants; i++) + janet_mark(peg->constants[i]); + return 0; +} + +static void peg_marshal(void *p, JanetMarshalContext *ctx) { + JanetPeg *peg = (JanetPeg *)p; + janet_marshal_size(ctx, peg->bytecode_len); + janet_marshal_int(ctx, (int32_t)peg->num_constants); + janet_marshal_abstract(ctx, p); + for (size_t i = 0; i < peg->bytecode_len; i++) + janet_marshal_int(ctx, (int32_t) peg->bytecode[i]); + for (uint32_t j = 0; j < peg->num_constants; j++) + janet_marshal_janet(ctx, peg->constants[j]); +} + +/* Used to ensure that if we place several arrays in one memory chunk, each + * array will be correctly aligned */ +static size_t size_padded(size_t offset, size_t size) { + size_t x = size + offset - 1; + return x - (x % size); +} + +static void *peg_unmarshal(JanetMarshalContext *ctx) { + size_t bytecode_len = janet_unmarshal_size(ctx); + uint32_t num_constants = (uint32_t) janet_unmarshal_int(ctx); + + /* Calculate offsets. Should match those in make_peg */ + size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t)); + size_t bytecode_size = bytecode_len * sizeof(uint32_t); + size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet)); + size_t total_size = constants_start + sizeof(Janet) * (size_t) num_constants; + + /* DOS prevention? I.E. we could read bytecode and constants before + * hand so we don't allocated a ton of memory on bad, short input */ + + /* Allocate PEG */ + char *mem = janet_unmarshal_abstract(ctx, total_size); + JanetPeg *peg = (JanetPeg *)mem; + uint32_t *bytecode = (uint32_t *)(mem + bytecode_start); + Janet *constants = (Janet *)(mem + constants_start); + peg->bytecode = NULL; + peg->constants = NULL; + peg->bytecode_len = bytecode_len; + peg->num_constants = num_constants; + + for (size_t i = 0; i < peg->bytecode_len; i++) + bytecode[i] = (uint32_t) janet_unmarshal_int(ctx); + for (uint32_t j = 0; j < peg->num_constants; j++) + constants[j] = janet_unmarshal_janet(ctx); + + /* After here, no panics except for the bad: label. */ + + /* Keep track at each index if an instruction was + * reference (0x01) or is in a main bytecode position + * (0x02). This lets us do a linear scan and not + * need to a depth first traversal. It is stricter + * than a dfs by not allowing certain kinds of unused + * bytecode. */ + uint32_t blen = (int32_t) peg->bytecode_len; + uint32_t clen = peg->num_constants; + uint8_t *op_flags = janet_calloc(1, blen); + if (NULL == op_flags) { + JANET_OUT_OF_MEMORY; + } + + /* verify peg bytecode */ + int32_t has_backref = 0; + uint32_t i = 0; + while (i < blen) { + uint32_t instr = bytecode[i]; + uint32_t *rule = bytecode + i; + op_flags[i] |= 0x02; + switch (instr) { + case RULE_LITERAL: + i += 2 + ((rule[1] + 3) >> 2); + break; + case RULE_NCHAR: + case RULE_NOTNCHAR: + case RULE_RANGE: + case RULE_POSITION: + case RULE_LINE: + case RULE_COLUMN: + /* [1 word] */ + i += 2; + break; + case RULE_BACKMATCH: + /* [1 word] */ + i += 2; + has_backref = 1; + break; + case RULE_SET: + /* [8 words] */ + i += 9; + break; + case RULE_LOOK: + /* [offset, rule] */ + if (rule[2] >= blen) goto bad; + op_flags[rule[2]] |= 0x1; + i += 3; + break; + case RULE_CHOICE: + case RULE_SEQUENCE: + /* [len, rules...] */ + { + uint32_t len = rule[1]; + for (uint32_t j = 0; j < len; j++) { + if (rule[2 + j] >= blen) goto bad; + op_flags[rule[2 + j]] |= 0x1; + } + i += 2 + len; + } + break; + case RULE_IF: + case RULE_IFNOT: + case RULE_LENPREFIX: + /* [rule_a, rule_b (b if not a)] */ + if (rule[1] >= blen) goto bad; + if (rule[2] >= blen) goto bad; + op_flags[rule[1]] |= 0x01; + op_flags[rule[2]] |= 0x01; + i += 3; + break; + case RULE_BETWEEN: + /* [lo, hi, rule] */ + if (rule[3] >= blen) goto bad; + op_flags[rule[3]] |= 0x01; + i += 4; + break; + case RULE_ARGUMENT: + /* [searchtag, tag] */ + i += 3; + break; + case RULE_GETTAG: + /* [searchtag, tag] */ + i += 3; + has_backref = 1; + break; + case RULE_CONSTANT: + /* [constant, tag] */ + if (rule[1] >= clen) goto bad; + i += 3; + break; + case RULE_CAPTURE_NUM: + /* [rule, base, tag] */ + if (rule[1] >= blen) goto bad; + op_flags[rule[1]] |= 0x01; + i += 4; + break; + case RULE_ACCUMULATE: + case RULE_GROUP: + case RULE_CAPTURE: + case RULE_UNREF: + /* [rule, tag] */ + if (rule[1] >= blen) goto bad; + op_flags[rule[1]] |= 0x01; + i += 3; + break; + case RULE_REPLACE: + case RULE_MATCHTIME: + /* [rule, constant, tag] */ + if (rule[1] >= blen) goto bad; + if (rule[2] >= clen) goto bad; + op_flags[rule[1]] |= 0x01; + i += 4; + break; + case RULE_SUB: + case RULE_SPLIT: + /* [rule, rule] */ + if (rule[1] >= blen) goto bad; + if (rule[2] >= blen) goto bad; + op_flags[rule[1]] |= 0x01; + op_flags[rule[2]] |= 0x01; + i += 3; + break; + case RULE_ERROR: + case RULE_DROP: + case RULE_NOT: + case RULE_TO: + case RULE_THRU: + /* [rule] */ + if (rule[1] >= blen) goto bad; + op_flags[rule[1]] |= 0x01; + i += 2; + break; + case RULE_READINT: + /* [ width | (endianess << 5) | (signedness << 6), tag ] */ + if (rule[1] > JANET_MAX_READINT_WIDTH) goto bad; + i += 3; + break; + default: + goto bad; + } + } + + /* last instruction cannot overflow */ + if (i != blen) goto bad; + + /* Make sure all referenced instructions are actually + * in instruction positions. */ + for (i = 0; i < blen; i++) + if (op_flags[i] == 0x01) goto bad; + + /* Good return */ + peg->bytecode = bytecode; + peg->constants = constants; + peg->has_backref = has_backref; + janet_free(op_flags); + return peg; + +bad: + janet_free(op_flags); + janet_panic("invalid peg bytecode"); +} + +static int cfun_peg_getter(JanetAbstract a, Janet key, Janet *out); +static Janet peg_next(void *p, Janet key); + +const JanetAbstractType janet_peg_type = { + "core/peg", + NULL, + peg_mark, + cfun_peg_getter, + NULL, /* put */ + peg_marshal, + peg_unmarshal, + NULL, /* tostring */ + NULL, /* compare */ + NULL, /* hash */ + peg_next, + JANET_ATEND_NEXT +}; + +/* Convert Builder to JanetPeg (Janet Abstract Value) */ +static JanetPeg *make_peg(Builder *b) { + size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t)); + size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t); + size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet)); + size_t constants_size = janet_v_count(b->constants) * sizeof(Janet); + size_t total_size = constants_start + constants_size; + char *mem = janet_abstract(&janet_peg_type, total_size); + JanetPeg *peg = (JanetPeg *)mem; + peg->bytecode = (uint32_t *)(mem + bytecode_start); + peg->constants = (Janet *)(mem + constants_start); + peg->num_constants = janet_v_count(b->constants); + safe_memcpy(peg->bytecode, b->bytecode, bytecode_size); + safe_memcpy(peg->constants, b->constants, constants_size); + peg->bytecode_len = janet_v_count(b->bytecode); + peg->has_backref = b->has_backref; + return peg; +} + +/* Compiler entry point */ +static JanetPeg *compile_peg(Janet x) { + Builder builder; + builder.grammar = janet_table(0); + builder.default_grammar = NULL; + { + Janet default_grammarv = janet_dyn("peg-grammar"); + if (janet_checktype(default_grammarv, JANET_TABLE)) { + builder.default_grammar = janet_unwrap_table(default_grammarv); + } + } + builder.tags = janet_table(0); + builder.constants = NULL; + builder.bytecode = NULL; + builder.nexttag = 1; + builder.form = x; + builder.depth = JANET_RECURSION_GUARD; + builder.has_backref = 0; + peg_compile1(&builder, x); + JanetPeg *peg = make_peg(&builder); + builder_cleanup(&builder); + return peg; +} + +/* + * C Functions + */ + +JANET_CORE_FN(cfun_peg_compile, + "(peg/compile peg)", + "Compiles a peg source data structure into a . This will speed up matching " + "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to suppliment " + "the grammar of the peg for otherwise undefined peg keywords.") { + janet_fixarity(argc, 1); + JanetPeg *peg = compile_peg(argv[0]); + return janet_wrap_abstract(peg); +} + +/* Common data for peg cfunctions */ +typedef struct { + JanetPeg *peg; + PegState s; + JanetByteView bytes; + Janet subst; + int32_t start; +} PegCall; + +/* Initialize state for peg cfunctions */ +static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) { + PegCall ret; + int32_t min = get_replace ? 3 : 2; + janet_arity(argc, min, -1); + if (janet_checktype(argv[0], JANET_ABSTRACT) && + janet_abstract_type(janet_unwrap_abstract(argv[0])) == &janet_peg_type) { + ret.peg = janet_unwrap_abstract(argv[0]); + } else { + ret.peg = compile_peg(argv[0]); + } + if (get_replace) { + ret.subst = argv[1]; + ret.bytes = janet_getbytes(argv, 2); + } else { + ret.bytes = janet_getbytes(argv, 1); + } + if (argc > min) { + ret.start = janet_gethalfrange(argv, min, ret.bytes.len, "offset"); + ret.s.extrac = argc - min - 1; + ret.s.extrav = janet_tuple_n(argv + min + 1, argc - min - 1); + } else { + ret.start = 0; + ret.s.extrac = 0; + ret.s.extrav = NULL; + } + ret.s.mode = PEG_MODE_NORMAL; + ret.s.text_start = ret.bytes.bytes; + ret.s.text_end = ret.bytes.bytes + ret.bytes.len; + ret.s.outer_text_end = ret.s.text_end; + ret.s.depth = JANET_RECURSION_GUARD; + ret.s.captures = janet_array(0); + ret.s.tagged_captures = janet_array(0); + ret.s.scratch = janet_buffer(10); + ret.s.tags = janet_buffer(10); + ret.s.constants = ret.peg->constants; + ret.s.bytecode = ret.peg->bytecode; + ret.s.linemap = NULL; + ret.s.linemaplen = -1; + ret.s.has_backref = ret.peg->has_backref; + return ret; +} + +static void peg_call_reset(PegCall *c) { + c->s.depth = JANET_RECURSION_GUARD; + c->s.captures->count = 0; + c->s.tagged_captures->count = 0; + c->s.scratch->count = 0; + c->s.tags->count = 0; +} + +JANET_CORE_FN(cfun_peg_match, + "(peg/match peg text &opt start & args)", + "Match a Parsing Expression Grammar to a byte string and return an array of captured values. " + "Returns nil if text does not match the language defined by peg. The syntax of PEGs is documented on the Janet website.") { + PegCall c = peg_cfun_init(argc, argv, 0); + const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + c.start); + return result ? janet_wrap_array(c.s.captures) : janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_peg_find, + "(peg/find peg text &opt start & args)", + "Find first index where the peg matches in text. Returns an integer, or nil if not found.") { + PegCall c = peg_cfun_init(argc, argv, 0); + for (int32_t i = c.start; i < c.bytes.len; i++) { + peg_call_reset(&c); + if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i)) + return janet_wrap_integer(i); + } + return janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_peg_find_all, + "(peg/find-all peg text &opt start & args)", + "Find all indexes where the peg matches in text. Returns an array of integers.") { + PegCall c = peg_cfun_init(argc, argv, 0); + JanetArray *ret = janet_array(0); + for (int32_t i = c.start; i < c.bytes.len; i++) { + peg_call_reset(&c); + if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i)) + janet_array_push(ret, janet_wrap_integer(i)); + } + return janet_wrap_array(ret); +} + +static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) { + PegCall c = peg_cfun_init(argc, argv, 1); + JanetBuffer *ret = janet_buffer(0); + int32_t trail = 0; + for (int32_t i = c.start; i < c.bytes.len;) { + peg_call_reset(&c); + const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i); + if (NULL != result) { + if (trail < i) { + janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (i - trail)); + trail = i; + } + int32_t nexti = (int32_t)(result - c.bytes.bytes); + JanetByteView subst = janet_text_substitution(&c.subst, c.bytes.bytes + i, nexti - i, c.s.captures); + janet_buffer_push_bytes(ret, subst.bytes, subst.len); + trail = nexti; + if (nexti == i) nexti++; + i = nexti; + if (only_one) break; + } else { + i++; + } + } + if (trail < c.bytes.len) { + janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (c.bytes.len - trail)); + } + return janet_wrap_buffer(ret); +} + +JANET_CORE_FN(cfun_peg_replace_all, + "(peg/replace-all peg subst text &opt start & args)", + "Replace all matches of `peg` in `text` with `subst`, returning a new buffer. " + "The peg does not need to make captures to do replacement. " + "If `subst` is a function, it will be called with the " + "matching text followed by any captures.") { + return cfun_peg_replace_generic(argc, argv, 0); +} + +JANET_CORE_FN(cfun_peg_replace, + "(peg/replace peg subst text &opt start & args)", + "Replace first match of `peg` in `text` with `subst`, returning a new buffer. " + "The peg does not need to make captures to do replacement. " + "If `subst` is a function, it will be called with the " + "matching text followed by any captures. " + "If no matches are found, returns the input string in a new buffer.") { + return cfun_peg_replace_generic(argc, argv, 1); +} + +static JanetMethod peg_methods[] = { + {"match", cfun_peg_match}, + {"find", cfun_peg_find}, + {"find-all", cfun_peg_find_all}, + {"replace", cfun_peg_replace}, + {"replace-all", cfun_peg_replace_all}, + {NULL, NULL} +}; + +static int cfun_peg_getter(JanetAbstract a, Janet key, Janet *out) { + (void) a; + if (!janet_checktype(key, JANET_KEYWORD)) + return 0; + return janet_getmethod(janet_unwrap_keyword(key), peg_methods, out); +} + +static Janet peg_next(void *p, Janet key) { + (void) p; + return janet_nextmethod(peg_methods, key); +} + +/* Load the peg module */ +void janet_lib_peg(JanetTable *env) { + JanetRegExt cfuns[] = { + JANET_CORE_REG("peg/compile", cfun_peg_compile), + JANET_CORE_REG("peg/match", cfun_peg_match), + JANET_CORE_REG("peg/find", cfun_peg_find), + JANET_CORE_REG("peg/find-all", cfun_peg_find_all), + JANET_CORE_REG("peg/replace", cfun_peg_replace), + JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, cfuns); + janet_register_abstract_type(&janet_peg_type); +} + +#endif /* ifdef JANET_PEG */ + + +/* src/core/pp.c */ +#line 0 "src/core/pp.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "state.h" +#include +#endif + +#include +#include +#include +#include + +/* Implements a pretty printer for Janet. The pretty printer + * is simple and not that flexible, but fast. */ + +/* Temporary buffer size */ +#define BUFSIZE 64 + +/* Preprocessor hacks */ +#define STR_HELPER(x) #x +#define STR(x) STR_HELPER(x) + +static void number_to_string_b(JanetBuffer *buffer, double x) { + janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); + const char *fmt = (x == floor(x) && + x <= JANET_INTMAX_DOUBLE && + x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); + int count; + if (x == 0.0) { + /* Prevent printing of '-0' */ + count = 1; + buffer->data[buffer->count] = '0'; + } else { + count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); + } + buffer->count += count; +} + +/* expects non positive x */ +static int count_dig10(int32_t x) { + int result = 1; + for (;;) { + if (x > -10) return result; + if (x > -100) return result + 1; + if (x > -1000) return result + 2; + if (x > -10000) return result + 3; + x /= 10000; + result += 4; + } +} + +static void integer_to_string_b(JanetBuffer *buffer, int32_t x) { + janet_buffer_extra(buffer, BUFSIZE); + uint8_t *buf = buffer->data + buffer->count; + int32_t neg = 0; + int32_t len = 0; + if (x == 0) { + buf[0] = '0'; + buffer->count++; + return; + } + if (x > 0) { + x = -x; + } else { + neg = 1; + *buf++ = '-'; + } + len = count_dig10(x); + buf += len; + while (x) { + uint8_t digit = (uint8_t) - (x % 10); + *(--buf) = '0' + digit; + x /= 10; + } + buffer->count += len + neg; +} + +#define HEX(i) (((uint8_t *) janet_base64)[(i)]) + +/* Returns a string description for a pointer. Truncates + * title to 32 characters */ +static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { + janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); + uint8_t *c = buffer->data + buffer->count; + int32_t i; + union { + uint8_t bytes[sizeof(void *)]; + void *p; + } pbuf; + + pbuf.p = pointer; + *c++ = '<'; + /* Maximum of 32 bytes for abstract type name */ + for (i = 0; i < 32 && title[i]; ++i) + *c++ = ((uint8_t *)title) [i]; + *c++ = ' '; + *c++ = '0'; + *c++ = 'x'; +#if defined(JANET_64) +#define POINTSIZE 6 +#else +#define POINTSIZE (sizeof(void *)) +#endif + for (i = POINTSIZE; i > 0; --i) { + uint8_t byte = pbuf.bytes[i - 1]; + *c++ = HEX(byte >> 4); + *c++ = HEX(byte & 0xF); + } + *c++ = '>'; + buffer->count = (int32_t)(c - buffer->data); +#undef POINTSIZE +} + +static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { + janet_buffer_push_u8(buffer, '"'); + for (int32_t i = 0; i < len; ++i) { + uint8_t c = str[i]; + switch (c) { + case '"': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); + break; + case '\n': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); + break; + case '\r': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); + break; + case '\0': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); + break; + case '\f': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); + break; + case '\v': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); + break; + case '\a': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); + break; + case '\b': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); + break; + case 27: + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); + break; + case '\\': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); + break; + case '\t': + janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); + break; + default: + if (c < 32 || c > 126) { + uint8_t buf[4]; + buf[0] = '\\'; + buf[1] = 'x'; + buf[2] = janet_base64[(c >> 4) & 0xF]; + buf[3] = janet_base64[c & 0xF]; + janet_buffer_push_bytes(buffer, buf, 4); + } else { + janet_buffer_push_u8(buffer, c); + } + break; + } + } + janet_buffer_push_u8(buffer, '"'); +} + +static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { + janet_escape_string_impl(buffer, str, janet_string_length(str)); +} + +static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { + if (bx == buffer) { + /* Ensures buffer won't resize while escaping */ + janet_buffer_ensure(bx, bx->count + 5 * bx->count + 3, 1); + } + janet_buffer_push_u8(buffer, '@'); + janet_escape_string_impl(buffer, bx->data, bx->count); +} + +void janet_to_string_b(JanetBuffer *buffer, Janet x) { + switch (janet_type(x)) { + case JANET_NIL: + janet_buffer_push_cstring(buffer, ""); + break; + case JANET_BOOLEAN: + janet_buffer_push_cstring(buffer, + janet_unwrap_boolean(x) ? "true" : "false"); + break; + case JANET_NUMBER: + number_to_string_b(buffer, janet_unwrap_number(x)); + break; + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + janet_buffer_push_bytes(buffer, + janet_unwrap_string(x), + janet_string_length(janet_unwrap_string(x))); + break; + case JANET_BUFFER: { + JanetBuffer *to = janet_unwrap_buffer(x); + /* Prevent resizing buffer while appending */ + if (buffer == to) janet_buffer_extra(buffer, to->count); + janet_buffer_push_bytes(buffer, to->data, to->count); + break; + } + case JANET_ABSTRACT: { + JanetAbstract p = janet_unwrap_abstract(x); + const JanetAbstractType *t = janet_abstract_type(p); + if (t->tostring != NULL) { + t->tostring(p, buffer); + } else { + string_description_b(buffer, t->name, p); + } + } + return; + case JANET_CFUNCTION: { + JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); + if (NULL != reg) { + janet_buffer_push_cstring(buffer, "name_prefix) { + janet_buffer_push_cstring(buffer, reg->name_prefix); + janet_buffer_push_u8(buffer, '/'); + } + janet_buffer_push_cstring(buffer, reg->name); + janet_buffer_push_u8(buffer, '>'); + break; + } + goto fallthrough; + } + case JANET_FUNCTION: { + JanetFunction *fun = janet_unwrap_function(x); + JanetFuncDef *def = fun->def; + if (def == NULL) { + janet_buffer_push_cstring(buffer, ""); + break; + } + if (def->name) { + const uint8_t *n = def->name; + janet_buffer_push_cstring(buffer, "'); + break; + } + goto fallthrough; + } + fallthrough: + default: + string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); + break; + } +} + +/* See parse.c for full table */ + +/* Check if a symbol or keyword contains no symbol characters */ +static int contains_bad_chars(const uint8_t *sym, int issym) { + int32_t len = janet_string_length(sym); + if (len && issym && sym[0] >= '0' && sym[0] <= '9') return 1; + if (!janet_valid_utf8(sym, len)) return 1; + for (int32_t i = 0; i < len; i++) { + if (!janet_is_symbol_char(sym[i])) return 1; + } + return 0; +} + +void janet_description_b(JanetBuffer *buffer, Janet x) { + switch (janet_type(x)) { + default: + break; + case JANET_NIL: + janet_buffer_push_cstring(buffer, "nil"); + return; + case JANET_KEYWORD: + janet_buffer_push_u8(buffer, ':'); + break; + case JANET_STRING: + janet_escape_string_b(buffer, janet_unwrap_string(x)); + return; + case JANET_BUFFER: { + JanetBuffer *b = janet_unwrap_buffer(x); + janet_escape_buffer_b(buffer, b); + return; + } + case JANET_ABSTRACT: { + JanetAbstract p = janet_unwrap_abstract(x); + const JanetAbstractType *t = janet_abstract_type(p); + if (t->tostring != NULL) { + janet_buffer_push_cstring(buffer, "<"); + janet_buffer_push_cstring(buffer, t->name); + janet_buffer_push_cstring(buffer, " "); + t->tostring(p, buffer); + janet_buffer_push_cstring(buffer, ">"); + } else { + string_description_b(buffer, t->name, p); + } + return; + } + } + janet_to_string_b(buffer, x); +} + +const uint8_t *janet_description(Janet x) { + JanetBuffer b; + janet_buffer_init(&b, 10); + janet_description_b(&b, x); + const uint8_t *ret = janet_string(b.data, b.count); + janet_buffer_deinit(&b); + return ret; +} + +/* Convert any value to a janet string. Similar to description, but + * strings, symbols, and buffers will return their content. */ +const uint8_t *janet_to_string(Janet x) { + switch (janet_type(x)) { + default: { + JanetBuffer b; + janet_buffer_init(&b, 10); + janet_to_string_b(&b, x); + const uint8_t *ret = janet_string(b.data, b.count); + janet_buffer_deinit(&b); + return ret; + } + case JANET_BUFFER: + return janet_string(janet_unwrap_buffer(x)->data, janet_unwrap_buffer(x)->count); + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + return janet_unwrap_string(x); + } +} + +/* Hold state for pretty printer. */ +struct pretty { + JanetBuffer *buffer; + int depth; + int indent; + int flags; + int32_t bufstartlen; + int32_t *keysort_buffer; + int32_t keysort_capacity; + int32_t keysort_start; + JanetTable seen; +}; + +/* Print jdn format */ +static int print_jdn_one(struct pretty *S, Janet x, int depth) { + if (depth == 0) return 1; + switch (janet_type(x)) { + case JANET_NIL: + case JANET_BOOLEAN: + case JANET_BUFFER: + case JANET_STRING: + janet_description_b(S->buffer, x); + break; + case JANET_NUMBER: + janet_buffer_ensure(S->buffer, S->buffer->count + BUFSIZE, 2); + int count = snprintf((char *) S->buffer->data + S->buffer->count, BUFSIZE, "%.17g", janet_unwrap_number(x)); + S->buffer->count += count; + break; + case JANET_SYMBOL: + case JANET_KEYWORD: + if (contains_bad_chars(janet_unwrap_keyword(x), janet_type(x) == JANET_SYMBOL)) return 1; + janet_description_b(S->buffer, x); + break; + case JANET_TUPLE: { + JanetTuple t = janet_unwrap_tuple(x); + int isb = janet_tuple_flag(t) & JANET_TUPLE_FLAG_BRACKETCTOR; + janet_buffer_push_u8(S->buffer, isb ? '[' : '('); + for (int32_t i = 0; i < janet_tuple_length(t); i++) { + if (i) janet_buffer_push_u8(S->buffer, ' '); + if (print_jdn_one(S, t[i], depth - 1)) return 1; + } + janet_buffer_push_u8(S->buffer, isb ? ']' : ')'); + } + break; + case JANET_ARRAY: { + janet_table_put(&S->seen, x, janet_wrap_true()); + JanetArray *a = janet_unwrap_array(x); + janet_buffer_push_cstring(S->buffer, "@["); + for (int32_t i = 0; i < a->count; i++) { + if (i) janet_buffer_push_u8(S->buffer, ' '); + if (print_jdn_one(S, a->data[i], depth - 1)) return 1; + } + janet_buffer_push_u8(S->buffer, ']'); + } + break; + case JANET_TABLE: { + janet_table_put(&S->seen, x, janet_wrap_true()); + JanetTable *tab = janet_unwrap_table(x); + janet_buffer_push_cstring(S->buffer, "@{"); + int isFirst = 1; + for (int32_t i = 0; i < tab->capacity; i++) { + const JanetKV *kv = tab->data + i; + if (janet_checktype(kv->key, JANET_NIL)) continue; + if (!isFirst) janet_buffer_push_u8(S->buffer, ' '); + isFirst = 0; + if (print_jdn_one(S, kv->key, depth - 1)) return 1; + janet_buffer_push_u8(S->buffer, ' '); + if (print_jdn_one(S, kv->value, depth - 1)) return 1; + } + janet_buffer_push_u8(S->buffer, '}'); + } + break; + case JANET_STRUCT: { + JanetStruct st = janet_unwrap_struct(x); + janet_buffer_push_u8(S->buffer, '{'); + int isFirst = 1; + for (int32_t i = 0; i < janet_struct_capacity(st); i++) { + const JanetKV *kv = st + i; + if (janet_checktype(kv->key, JANET_NIL)) continue; + if (!isFirst) janet_buffer_push_u8(S->buffer, ' '); + isFirst = 0; + if (print_jdn_one(S, kv->key, depth - 1)) return 1; + janet_buffer_push_u8(S->buffer, ' '); + if (print_jdn_one(S, kv->value, depth - 1)) return 1; + } + janet_buffer_push_u8(S->buffer, '}'); + } + break; + default: + return 1; + } + return 0; +} + +static void print_newline(struct pretty *S, int just_a_space) { + int i; + if (just_a_space || (S->flags & JANET_PRETTY_ONELINE)) { + janet_buffer_push_u8(S->buffer, ' '); + return; + } + janet_buffer_push_u8(S->buffer, '\n'); + for (i = 0; i < S->indent; i++) { + janet_buffer_push_u8(S->buffer, ' '); + } +} + +/* Color coding for types */ +static const char janet_cycle_color[] = "\x1B[36m"; +static const char janet_class_color[] = "\x1B[34m"; +static const char *janet_pretty_colors[] = { + "\x1B[32m", + "\x1B[36m", + "\x1B[36m", + "\x1B[36m", + "\x1B[35m", + "\x1B[34m", + "\x1B[33m", + "\x1B[36m", + "\x1B[36m", + "\x1B[36m", + "\x1B[36m", + "\x1B[35m", + "\x1B[36m", + "\x1B[36m", + "\x1B[36m", + "\x1B[36m" +}; + +#define JANET_PRETTY_DICT_ONELINE 4 +#define JANET_PRETTY_IND_ONELINE 10 +#define JANET_PRETTY_DICT_LIMIT 30 +#define JANET_PRETTY_ARRAY_LIMIT 160 + +/* Helper for pretty printing */ +static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) { + /* Add to seen */ + switch (janet_type(x)) { + case JANET_NIL: + case JANET_NUMBER: + case JANET_SYMBOL: + case JANET_BOOLEAN: + break; + default: { + Janet seenid = janet_table_get(&S->seen, x); + if (janet_checktype(seenid, JANET_NUMBER)) { + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, janet_cycle_color); + } + janet_buffer_push_cstring(S->buffer, "buffer, janet_unwrap_integer(seenid)); + janet_buffer_push_u8(S->buffer, '>'); + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, "\x1B[0m"); + } + return; + } else { + janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count)); + break; + } + } + } + + switch (janet_type(x)) { + default: { + const char *color = janet_pretty_colors[janet_type(x)]; + if (color && (S->flags & JANET_PRETTY_COLOR)) { + janet_buffer_push_cstring(S->buffer, color); + } + if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) { + janet_buffer_ensure(S->buffer, S->buffer->count + S->bufstartlen * 4 + 3, 1); + janet_buffer_push_u8(S->buffer, '@'); + janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen); + } else { + janet_description_b(S->buffer, x); + } + if (color && (S->flags & JANET_PRETTY_COLOR)) { + janet_buffer_push_cstring(S->buffer, "\x1B[0m"); + } + break; + } + case JANET_ARRAY: + case JANET_TUPLE: { + int32_t i = 0, len = 0; + const Janet *arr = NULL; + int isarray = janet_checktype(x, JANET_ARRAY); + janet_indexed_view(x, &arr, &len); + int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR); + const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "("; + const char endchar = isarray ? ']' : hasbrackets ? ']' : ')'; + janet_buffer_push_cstring(S->buffer, startstr); + S->depth--; + S->indent += 2; + if (S->depth == 0) { + janet_buffer_push_cstring(S->buffer, "..."); + } else { + if (!isarray && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_IND_ONELINE) + janet_buffer_push_u8(S->buffer, ' '); + if (is_dict_value && len >= JANET_PRETTY_IND_ONELINE) print_newline(S, 0); + if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) { + for (i = 0; i < 3; i++) { + if (i) print_newline(S, 0); + janet_pretty_one(S, arr[i], 0); + } + print_newline(S, 0); + janet_buffer_push_cstring(S->buffer, "..."); + for (i = 0; i < 3; i++) { + print_newline(S, 0); + janet_pretty_one(S, arr[len - 3 + i], 0); + } + } else { + for (i = 0; i < len; i++) { + if (i) print_newline(S, len < JANET_PRETTY_IND_ONELINE); + janet_pretty_one(S, arr[i], 0); + } + } + } + S->indent -= 2; + S->depth++; + janet_buffer_push_u8(S->buffer, endchar); + break; + } + case JANET_STRUCT: + case JANET_TABLE: { + int istable = janet_checktype(x, JANET_TABLE); + + /* For object-like tables, print class name */ + if (istable) { + JanetTable *t = janet_unwrap_table(x); + JanetTable *proto = t->proto; + janet_buffer_push_cstring(S->buffer, "@"); + if (NULL != proto) { + Janet name = janet_table_get(proto, janet_ckeywordv("_name")); + const uint8_t *n; + int32_t len; + if (janet_bytes_view(name, &n, &len)) { + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, janet_class_color); + } + janet_buffer_push_bytes(S->buffer, n, len); + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, "\x1B[0m"); + } + } + } + } else { + JanetStruct st = janet_unwrap_struct(x); + JanetStruct proto = janet_struct_proto(st); + if (NULL != proto) { + Janet name = janet_struct_get(proto, janet_ckeywordv("_name")); + const uint8_t *n; + int32_t len; + if (janet_bytes_view(name, &n, &len)) { + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, janet_class_color); + } + janet_buffer_push_bytes(S->buffer, n, len); + if (S->flags & JANET_PRETTY_COLOR) { + janet_buffer_push_cstring(S->buffer, "\x1B[0m"); + } + } + } + } + janet_buffer_push_cstring(S->buffer, "{"); + + S->depth--; + S->indent += 2; + if (S->depth == 0) { + janet_buffer_push_cstring(S->buffer, "..."); + } else { + int32_t i = 0, len = 0, cap = 0; + const JanetKV *kvs = NULL; + janet_dictionary_view(x, &kvs, &len, &cap); + if (!istable && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_DICT_ONELINE) + janet_buffer_push_u8(S->buffer, ' '); + if (is_dict_value && len >= JANET_PRETTY_DICT_ONELINE) print_newline(S, 0); + int32_t ks_start = S->keysort_start; + + /* Ensure buffer is large enough to sort keys. */ + int truncated = 0; + int64_t mincap = (int64_t) len + (int64_t) ks_start; + if (mincap > INT32_MAX) { + truncated = 1; + len = 0; + mincap = ks_start; + } + + if (S->keysort_capacity < mincap) { + if (mincap >= INT32_MAX / 2) { + S->keysort_capacity = INT32_MAX; + } else { + S->keysort_capacity = (int32_t)(mincap * 2); + } + S->keysort_buffer = janet_srealloc(S->keysort_buffer, sizeof(int32_t) * S->keysort_capacity); + if (NULL == S->keysort_buffer) { + JANET_OUT_OF_MEMORY; + } + } + + janet_sorted_keys(kvs, cap, S->keysort_buffer == NULL ? NULL : S->keysort_buffer + ks_start); + S->keysort_start += len; + if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) { + len = JANET_PRETTY_DICT_LIMIT; + truncated = 1; + } + + for (i = 0; i < len; i++) { + if (i) print_newline(S, len < JANET_PRETTY_DICT_ONELINE); + int32_t j = S->keysort_buffer[i + ks_start]; + janet_pretty_one(S, kvs[j].key, 0); + janet_buffer_push_u8(S->buffer, ' '); + janet_pretty_one(S, kvs[j].value, 1); + } + + if (truncated) { + print_newline(S, 0); + janet_buffer_push_cstring(S->buffer, "..."); + } + + S->keysort_start = ks_start; + } + S->indent -= 2; + S->depth++; + janet_buffer_push_u8(S->buffer, '}'); + break; + } + } + /* Remove from seen */ + janet_table_remove(&S->seen, x); + return; +} + +static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Janet x, int32_t startlen) { + struct pretty S; + if (NULL == buffer) { + buffer = janet_buffer(0); + } + S.buffer = buffer; + S.depth = depth; + S.indent = 0; + S.flags = flags; + S.bufstartlen = startlen; + S.keysort_capacity = 0; + S.keysort_buffer = NULL; + S.keysort_start = 0; + janet_table_init(&S.seen, 10); + janet_pretty_one(&S, x, 0); + janet_table_deinit(&S.seen); + return S.buffer; +} + +/* Helper for printing a janet value in a pretty form. Not meant to be used + * for serialization or anything like that. */ +JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x) { + return janet_pretty_(buffer, depth, flags, x, buffer ? buffer->count : 0); +} + +static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen) { + struct pretty S; + if (NULL == buffer) { + buffer = janet_buffer(0); + } + S.buffer = buffer; + S.depth = depth; + S.indent = 0; + S.flags = 0; + S.bufstartlen = startlen; + S.keysort_capacity = 0; + S.keysort_buffer = NULL; + S.keysort_start = 0; + janet_table_init(&S.seen, 10); + int res = print_jdn_one(&S, x, depth); + janet_table_deinit(&S.seen); + if (res) { + janet_panic("could not print to jdn format"); + } + return S.buffer; +} + +JanetBuffer *janet_jdn(JanetBuffer *buffer, int depth, Janet x) { + return janet_jdn_(buffer, depth, x, buffer ? buffer->count : 0); +} + +static const char *typestr(Janet x) { + JanetType t = janet_type(x); + return (t == JANET_ABSTRACT) + ? janet_abstract_type(janet_unwrap_abstract(x))->name + : janet_type_names[t]; +} + +static void pushtypes(JanetBuffer *buffer, int types) { + int first = 1; + int i = 0; + while (types) { + if (1 & types) { + if (first) { + first = 0; + } else { + janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", "); + } + janet_buffer_push_cstring(buffer, janet_type_names[i]); + } + i++; + types >>= 1; + } +} + +/* + * code adapted from lua/lstrlib.c http://lua.org + */ + +#define MAX_ITEM 256 +#define FMT_FLAGS "-+ #0" +#define FMT_REPLACE_INTTYPES "diouxX" +#define MAX_FORMAT 32 + +struct FmtMapping { + char c; + const char *mapping; +}; + +/* Janet uses fixed width integer types for most things, so map + * format specifiers to these fixed sizes */ +static const struct FmtMapping format_mappings[] = { + {'D', PRId64}, + {'I', PRIi64}, + {'d', PRId64}, + {'i', PRIi64}, + {'o', PRIo64}, + {'u', PRIu64}, + {'x', PRIx64}, + {'X', PRIX64}, +}; + +static const char *get_fmt_mapping(char c) { + for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { + if (format_mappings[i].c == c) + return format_mappings[i].mapping; + } + janet_assert(0, "bad format mapping"); +} + +static const char *scanformat( + const char *strfrmt, + char *form, + char width[3], + char precision[3]) { + const char *p = strfrmt; + + /* Parse strfrmt */ + memset(width, '\0', 3); + memset(precision, '\0', 3); + while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) + p++; /* skip flags */ + if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); + if (isdigit((int)(*p))) + width[0] = *p++; /* skip width */ + if (isdigit((int)(*p))) + width[1] = *p++; /* (2 digits at most) */ + if (*p == '.') { + p++; + if (isdigit((int)(*p))) + precision[0] = *p++; /* skip precision */ + if (isdigit((int)(*p))) + precision[1] = *p++; /* (2 digits at most) */ + } + if (isdigit((int)(*p))) + janet_panic("invalid format (width or precision too long)"); + + /* Write to form - replace characters with fixed size stuff */ + *(form++) = '%'; + const char *p2 = strfrmt; + while (p2 <= p) { + char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); + if (loc != NULL && *loc != '\0') { + const char *mapping = get_fmt_mapping(*p2++); + size_t len = strlen(mapping); + strcpy(form, mapping); + form += len; + } else { + *(form++) = *(p2++); + } + } + *form = '\0'; + + return p; +} + +void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { + const char *format_end = format + strlen(format); + const char *c = format; + int32_t startlen = b->count; + while (c < format_end) { + if (*c != '%') { + janet_buffer_push_u8(b, (uint8_t) *c++); + } else if (*++c == '%') { + janet_buffer_push_u8(b, (uint8_t) *c++); + } else { + char form[MAX_FORMAT], item[MAX_ITEM]; + char width[3], precision[3]; + int nb = 0; /* number of bytes in added item */ + c = scanformat(c, form, width, precision); + switch (*c++) { + case 'c': { + int n = va_arg(args, int); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'd': + case 'i': { + int64_t n = (int64_t) va_arg(args, int32_t); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'D': + case 'I': { + int64_t n = va_arg(args, int64_t); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'x': + case 'X': + case 'o': + case 'u': { + uint64_t n = va_arg(args, uint64_t); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'g': + case 'G': { + double d = va_arg(args, double); + nb = snprintf(item, MAX_ITEM, form, d); + break; + } + case 's': + case 'S': { + const char *str = va_arg(args, const char *); + int32_t len = c[-1] == 's' + ? (int32_t) strlen(str) + : janet_string_length((JanetString) str); + if (form[2] == '\0') + janet_buffer_push_bytes(b, (const uint8_t *) str, len); + else { + if (len != (int32_t) strlen((const char *) str)) + janet_panic("string contains zeros"); + if (!strchr(form, '.') && len >= 100) { + janet_panic("no precision and string is too long to be formatted"); + } else { + nb = snprintf(item, MAX_ITEM, form, str); + } + } + break; + } + case 'V': + janet_to_string_b(b, va_arg(args, Janet)); + break; + case 'v': + janet_description_b(b, va_arg(args, Janet)); + break; + case 't': + janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); + break; + case 'T': { + int types = va_arg(args, int); + pushtypes(b, types); + break; + } + case 'M': + case 'm': + case 'N': + case 'n': + case 'Q': + case 'q': + case 'P': + case 'p': { /* janet pretty , precision = depth */ + int depth = atoi(precision); + if (depth < 1) depth = JANET_RECURSION_GUARD; + char d = c[-1]; + int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); + int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); + int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); + int flags = 0; + flags |= has_color ? JANET_PRETTY_COLOR : 0; + flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; + flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; + janet_pretty_(b, depth, flags, va_arg(args, Janet), startlen); + break; + } + case 'j': { + int depth = atoi(precision); + if (depth < 1) + depth = JANET_RECURSION_GUARD; + janet_jdn_(b, depth, va_arg(args, Janet), startlen); + break; + } + default: { + /* also treat cases 'nLlh' */ + janet_panicf("invalid conversion '%s' to 'format'", + form); + } + } + if (nb >= MAX_ITEM) + janet_panic("format buffer overflow"); + if (nb > 0) + janet_buffer_push_bytes(b, (uint8_t *) item, nb); + } + + } +} + +/* Helper function for formatting strings. Useful for generating error messages and the like. + * Similar to printf, but specialized for operating with janet. */ +const uint8_t *janet_formatc(const char *format, ...) { + va_list args; + const uint8_t *ret; + JanetBuffer buffer; + int32_t len = 0; + + /* Calculate length, init buffer and args */ + while (format[len]) len++; + janet_buffer_init(&buffer, len); + va_start(args, format); + + /* Run format */ + janet_formatbv(&buffer, format, args); + + /* Iterate length */ + va_end(args); + + ret = janet_string(buffer.data, buffer.count); + janet_buffer_deinit(&buffer); + return ret; +} + +JanetBuffer *janet_formatb(JanetBuffer *buffer, const char *format, ...) { + va_list args; + va_start(args, format); + janet_formatbv(buffer, format, args); + va_end(args); + return buffer; +} + +/* Shared implementation between string/format and + * buffer/format */ +void janet_buffer_format( + JanetBuffer *b, + const char *strfrmt, + int32_t argstart, + int32_t argc, + Janet *argv) { + size_t sfl = strlen(strfrmt); + const char *strfrmt_end = strfrmt + sfl; + int32_t arg = argstart; + int32_t startlen = b->count; + while (strfrmt < strfrmt_end) { + if (*strfrmt != '%') + janet_buffer_push_u8(b, (uint8_t) * strfrmt++); + else if (*++strfrmt == '%') + janet_buffer_push_u8(b, (uint8_t) * strfrmt++); /* %% */ + else { /* format item */ + char form[MAX_FORMAT], item[MAX_ITEM]; + char width[3], precision[3]; + int nb = 0; /* number of bytes in added item */ + if (++arg >= argc) + janet_panic("not enough values for format"); + strfrmt = scanformat(strfrmt, form, width, precision); + switch (*strfrmt++) { + case 'c': { + nb = snprintf(item, MAX_ITEM, form, (int) + janet_getinteger(argv, arg)); + break; + } + case 'D': + case 'I': + case 'd': + case 'i': { + int64_t n = janet_getinteger64(argv, arg); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'x': + case 'X': + case 'o': + case 'u': { + uint64_t n = janet_getuinteger64(argv, arg); + nb = snprintf(item, MAX_ITEM, form, n); + break; + } + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'g': + case 'G': { + double d = janet_getnumber(argv, arg); + nb = snprintf(item, MAX_ITEM, form, d); + break; + } + case 's': { + JanetByteView bytes = janet_getbytes(argv, arg); + const uint8_t *s = bytes.bytes; + int32_t l = bytes.len; + if (form[2] == '\0') + janet_buffer_push_bytes(b, s, l); + else { + if (l != (int32_t) strlen((const char *) s)) + janet_panic("string contains zeros"); + if (!strchr(form, '.') && l >= 100) { + janet_panic("no precision and string is too long to be formatted"); + } else { + nb = snprintf(item, MAX_ITEM, form, s); + } + } + break; + } + case 'V': { + janet_to_string_b(b, argv[arg]); + break; + } + case 'v': { + janet_description_b(b, argv[arg]); + break; + } + case 't': + janet_buffer_push_cstring(b, typestr(argv[arg])); + break; + case 'M': + case 'm': + case 'N': + case 'n': + case 'Q': + case 'q': + case 'P': + case 'p': { /* janet pretty , precision = depth */ + int depth = atoi(precision); + if (depth < 1) depth = JANET_RECURSION_GUARD; + char d = strfrmt[-1]; + int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); + int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); + int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); + int flags = 0; + flags |= has_color ? JANET_PRETTY_COLOR : 0; + flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; + flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; + janet_pretty_(b, depth, flags, argv[arg], startlen); + break; + } + case 'j': { + int depth = atoi(precision); + if (depth < 1) + depth = JANET_RECURSION_GUARD; + janet_jdn_(b, depth, argv[arg], startlen); + break; + } + default: { + /* also treat cases 'nLlh' */ + janet_panicf("invalid conversion '%s' to 'format'", + form); + } + } + if (nb >= MAX_ITEM) + janet_panic("format buffer overflow"); + if (nb > 0) + janet_buffer_push_bytes(b, (uint8_t *) item, nb); + } + } +} + +#undef HEX +#undef BUFSIZE + + +/* src/core/regalloc.c */ +#line 0 "src/core/regalloc.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "regalloc.h" +#include "util.h" +#endif + +/* The JanetRegisterAllocator is really just a bitset. */ + +void janetc_regalloc_init(JanetcRegisterAllocator *ra) { + ra->chunks = NULL; + ra->count = 0; + ra->capacity = 0; + ra->max = 0; + ra->regtemps = 0; +} + +void janetc_regalloc_deinit(JanetcRegisterAllocator *ra) { + janet_free(ra->chunks); +} + +/* Fallbacks for when ctz not available */ +#ifdef __GNUC__ +#define count_trailing_zeros(x) __builtin_ctz(x) +#define count_trailing_ones(x) __builtin_ctz(~(x)) +#else +static int32_t count_trailing_ones(uint32_t x) { + int32_t ret = 0; + while (x & 1) { + ret++; + x >>= 1; + } + return ret; +} +#define count_trailing_zeros(x) count_trailing_ones(~(x)) +#endif + +/* Get ith bit */ +#define ithbit(I) ((uint32_t)1 << (I)) + +/* Get N bits */ +#define nbits(N) (ithbit(N) - 1) + +/* Copy a register allocator */ +void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocator *src) { + size_t size; + dest->count = src->count; + dest->capacity = src->capacity; + dest->max = src->max; + size = sizeof(uint32_t) * (size_t) dest->capacity; + dest->regtemps = 0; + if (size) { + dest->chunks = janet_malloc(size); + if (!dest->chunks) { + JANET_OUT_OF_MEMORY; + } + memcpy(dest->chunks, src->chunks, size); + } else { + dest->chunks = NULL; + } +} + +/* Allocate one more chunk in chunks */ +static void pushchunk(JanetcRegisterAllocator *ra) { + /* Registers 240-255 are always allocated (reserved) */ + uint32_t chunk = ra->count == 7 ? 0xFFFF0000 : 0; + int32_t newcount = ra->count + 1; + if (newcount > ra->capacity) { + int32_t newcapacity = newcount * 2; + ra->chunks = janet_realloc(ra->chunks, (size_t) newcapacity * sizeof(uint32_t)); + if (!ra->chunks) { + JANET_OUT_OF_MEMORY; + } + ra->capacity = newcapacity; + } + ra->chunks[ra->count] = chunk; + ra->count = newcount; +} + +/* Reallocate a given register */ +void janetc_regalloc_touch(JanetcRegisterAllocator *ra, int32_t reg) { + int32_t chunk = reg >> 5; + int32_t bit = reg & 0x1F; + while (chunk >= ra->count) pushchunk(ra); + ra->chunks[chunk] |= ithbit(bit); +} + +/* Allocate one register. */ +int32_t janetc_regalloc_1(JanetcRegisterAllocator *ra) { + /* Get the nth bit in the array */ + int32_t bit, chunk, nchunks, reg; + bit = -1; + nchunks = ra->count; + for (chunk = 0; chunk < nchunks; chunk++) { + uint32_t block = ra->chunks[chunk]; + if (block == 0xFFFFFFFF) continue; + bit = count_trailing_ones(block); + break; + } + /* No reg found */ + if (bit == -1) { + pushchunk(ra); + bit = 0; + chunk = nchunks; + } + /* set the bit at index bit in chunk */ + ra->chunks[chunk] |= ithbit(bit); + reg = (chunk << 5) + bit; + if (reg > ra->max) + ra->max = reg; + return reg; +} + +/* Free a register. The register must have been previously allocated + * without being freed. */ +void janetc_regalloc_free(JanetcRegisterAllocator *ra, int32_t reg) { + int32_t chunk = reg >> 5; + int32_t bit = reg & 0x1F; + ra->chunks[chunk] &= ~ithbit(bit); +} + +/* Check if a register is set. */ +int janetc_regalloc_check(JanetcRegisterAllocator *ra, int32_t reg) { + int32_t chunk = reg >> 5; + int32_t bit = reg & 0x1F; + while (chunk >= ra->count) pushchunk(ra); + return !!(ra->chunks[chunk] & ithbit(bit)); +} + +/* Get a register that will fit in 8 bits (< 256). Do not call this + * twice with the same value of nth without calling janetc_regalloc_free + * on the returned register before. */ +int32_t janetc_regalloc_temp(JanetcRegisterAllocator *ra, JanetcRegisterTemp nth) { + int32_t oldmax = ra->max; + if (ra->regtemps & (1 << nth)) { + JANET_EXIT("regtemp already allocated"); + } + ra->regtemps |= 1 << nth; + int32_t reg = janetc_regalloc_1(ra); + if (reg > 0xFF) { + reg = 0xF0 + nth; + ra->max = (reg > oldmax) ? reg : oldmax; + } + return reg; +} + +void janetc_regalloc_freetemp(JanetcRegisterAllocator *ra, int32_t reg, JanetcRegisterTemp nth) { + ra->regtemps &= ~(1 << nth); + if (reg < 0xF0) + janetc_regalloc_free(ra, reg); +} + + +/* src/core/run.c */ +#line 0 "src/core/run.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#endif + +/* Run a string */ +int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out) { + JanetParser parser; + int errflags = 0, done = 0; + int32_t index = 0; + Janet ret = janet_wrap_nil(); + JanetFiber *fiber = NULL; + const uint8_t *where = sourcePath ? janet_cstring(sourcePath) : NULL; + + if (where) janet_gcroot(janet_wrap_string(where)); + if (NULL == sourcePath) sourcePath = ""; + janet_parser_init(&parser); + + /* While we haven't seen an error */ + while (!done) { + + /* Evaluate parsed values */ + while (janet_parser_has_more(&parser)) { + Janet form = janet_parser_produce(&parser); + JanetCompileResult cres = janet_compile(form, env, where); + if (cres.status == JANET_COMPILE_OK) { + JanetFunction *f = janet_thunk(cres.funcdef); + fiber = janet_fiber(f, 64, 0, NULL); + fiber->env = env; + JanetSignal status = janet_continue(fiber, janet_wrap_nil(), &ret); + if (status != JANET_SIGNAL_OK && status != JANET_SIGNAL_EVENT) { + janet_stacktrace_ext(fiber, ret, ""); + errflags |= 0x01; + done = 1; + } + } else { + ret = janet_wrap_string(cres.error); + int32_t line = (int32_t) parser.line; + int32_t col = (int32_t) parser.column; + if ((cres.error_mapping.line > 0) && + (cres.error_mapping.column > 0)) { + line = cres.error_mapping.line; + col = cres.error_mapping.column; + } + if (cres.macrofiber) { + janet_eprintf("%s:%d:%d: compile error", sourcePath, + line, col); + janet_stacktrace_ext(cres.macrofiber, ret, ""); + } else { + janet_eprintf("%s:%d:%d: compile error: %s\n", sourcePath, + line, col, (const char *)cres.error); + } + errflags |= 0x02; + done = 1; + } + } + + if (done) break; + + /* Dispatch based on parse state */ + switch (janet_parser_status(&parser)) { + case JANET_PARSE_DEAD: + done = 1; + break; + case JANET_PARSE_ERROR: { + const char *e = janet_parser_error(&parser); + errflags |= 0x04; + ret = janet_cstringv(e); + int32_t line = (int32_t) parser.line; + int32_t col = (int32_t) parser.column; + janet_eprintf("%s:%d:%d: parse error: %s\n", sourcePath, line, col, e); + done = 1; + break; + } + case JANET_PARSE_ROOT: + case JANET_PARSE_PENDING: + if (index >= len) { + janet_parser_eof(&parser); + } else { + janet_parser_consume(&parser, bytes[index++]); + } + break; + } + + } + + /* Clean up and return errors */ + janet_parser_deinit(&parser); + if (where) janet_gcunroot(janet_wrap_string(where)); +#ifdef JANET_EV + /* Enter the event loop if we are not already in it */ + if (janet_vm.stackn == 0) { + if (fiber) { + janet_gcroot(janet_wrap_fiber(fiber)); + } + janet_loop(); + if (fiber) { + janet_gcunroot(janet_wrap_fiber(fiber)); + ret = fiber->last_value; + } + } +#endif + if (out) *out = ret; + return errflags; +} + +int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out) { + int32_t len = 0; + while (str[len]) ++len; + return janet_dobytes(env, (const uint8_t *)str, len, sourcePath, out); +} + +/* Run a fiber to completion (use event loop if enabled). Return the status. */ +int janet_loop_fiber(JanetFiber *fiber) { + int status; +#ifdef JANET_EV + janet_schedule(fiber, janet_wrap_nil()); + janet_loop(); + status = janet_fiber_status(fiber); +#else + Janet out; + status = janet_continue(fiber, janet_wrap_nil(), &out); + if (status != JANET_SIGNAL_OK && status != JANET_SIGNAL_EVENT) { + janet_stacktrace_ext(fiber, out, ""); + } +#endif + return status; +} + + +/* src/core/specials.c */ +#line 0 "src/core/specials.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "compile.h" +#include "util.h" +#include "vector.h" +#include "emit.h" +#endif + +static JanetSlot janetc_quote(JanetFopts opts, int32_t argn, const Janet *argv) { + if (argn != 1) { + janetc_cerror(opts.compiler, "expected 1 argument to quote"); + return janetc_cslot(janet_wrap_nil()); + } + return janetc_cslot(argv[0]); +} + +static JanetSlot janetc_splice(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetSlot ret; + if (!(opts.flags & JANET_FOPTS_ACCEPT_SPLICE)) { + janetc_cerror(opts.compiler, "splice can only be used in function parameters and data constructors, it has no effect here"); + return janetc_cslot(janet_wrap_nil()); + } + if (argn != 1) { + janetc_cerror(opts.compiler, "expected 1 argument to splice"); + return janetc_cslot(janet_wrap_nil()); + } + ret = janetc_value(opts, argv[0]); + ret.flags |= JANET_SLOT_SPLICED; + return ret; +} + +static JanetSlot qq_slots(JanetFopts opts, JanetSlot *slots, int makeop) { + JanetSlot target = janetc_gettarget(opts); + janetc_pushslots(opts.compiler, slots); + janetc_freeslots(opts.compiler, slots); + janetc_emit_s(opts.compiler, makeop, target, 1); + return target; +} + +static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) { + if (depth == 0) { + janetc_cerror(opts.compiler, "quasiquote too deeply nested"); + return janetc_cslot(janet_wrap_nil()); + } + JanetSlot *slots = NULL; + JanetFopts subopts = opts; + subopts.flags &= ~JANET_FOPTS_HINT; + switch (janet_type(x)) { + default: + return janetc_cslot(x); + case JANET_TUPLE: { + int32_t i, len; + const Janet *tup = janet_unwrap_tuple(x); + len = janet_tuple_length(tup); + if (len > 1 && janet_checktype(tup[0], JANET_SYMBOL)) { + const uint8_t *head = janet_unwrap_symbol(tup[0]); + if (!janet_cstrcmp(head, "unquote")) { + if (level == 0) { + JanetFopts subopts = janetc_fopts_default(opts.compiler); + subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; + return janetc_value(subopts, tup[1]); + } else { + level--; + } + } else if (!janet_cstrcmp(head, "quasiquote")) { + level++; + } + } + for (i = 0; i < len; i++) + janet_v_push(slots, quasiquote(subopts, tup[i], depth - 1, level)); + return qq_slots(opts, slots, (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) + ? JOP_MAKE_BRACKET_TUPLE + : JOP_MAKE_TUPLE); + } + case JANET_ARRAY: { + int32_t i; + JanetArray *array = janet_unwrap_array(x); + for (i = 0; i < array->count; i++) + janet_v_push(slots, quasiquote(subopts, array->data[i], depth - 1, level)); + return qq_slots(opts, slots, JOP_MAKE_ARRAY); + } + case JANET_TABLE: + case JANET_STRUCT: { + const JanetKV *kv = NULL, *kvs = NULL; + int32_t len, cap = 0; + janet_dictionary_view(x, &kvs, &len, &cap); + while ((kv = janet_dictionary_next(kvs, cap, kv))) { + JanetSlot key = quasiquote(subopts, kv->key, depth - 1, level); + JanetSlot value = quasiquote(subopts, kv->value, depth - 1, level); + key.flags &= ~JANET_SLOT_SPLICED; + value.flags &= ~JANET_SLOT_SPLICED; + janet_v_push(slots, key); + janet_v_push(slots, value); + } + return qq_slots(opts, slots, + janet_checktype(x, JANET_TABLE) ? JOP_MAKE_TABLE : JOP_MAKE_STRUCT); + } + } +} + +static JanetSlot janetc_quasiquote(JanetFopts opts, int32_t argn, const Janet *argv) { + if (argn != 1) { + janetc_cerror(opts.compiler, "expected 1 argument to quasiquote"); + return janetc_cslot(janet_wrap_nil()); + } + return quasiquote(opts, argv[0], JANET_RECURSION_GUARD, 0); +} + +static JanetSlot janetc_unquote(JanetFopts opts, int32_t argn, const Janet *argv) { + (void) argn; + (void) argv; + janetc_cerror(opts.compiler, "cannot use unquote here"); + return janetc_cslot(janet_wrap_nil()); +} + +/* Perform destructuring. Be careful to + * keep the order registers are freed. + * Returns if the slot 'right' can be freed. */ +static int destructure(JanetCompiler *c, + Janet left, + JanetSlot right, + int (*leaf)(JanetCompiler *c, + const uint8_t *sym, + JanetSlot s, + JanetTable *attr), + JanetTable *attr) { + switch (janet_type(left)) { + default: + janetc_error(c, janet_formatc("unexpected type in destructuring, got %v", left)); + return 1; + case JANET_SYMBOL: + /* Leaf, assign right to left */ + return leaf(c, janet_unwrap_symbol(left), right, attr); + case JANET_TUPLE: + case JANET_ARRAY: { + int32_t len = 0; + const Janet *values = NULL; + janet_indexed_view(left, &values, &len); + for (int32_t i = 0; i < len; i++) { + JanetSlot nextright = janetc_farslot(c); + Janet subval = values[i]; + + if (janet_checktype(subval, JANET_SYMBOL) && !janet_cstrcmp(janet_unwrap_symbol(subval), "&")) { + if (i + 1 >= len) { + janetc_cerror(c, "expected symbol following '& in destructuring pattern"); + return 1; + } + + if (i + 2 < len) { + int32_t num_extra = len - i - 1; + Janet *extra = janet_tuple_begin(num_extra); + janet_tuple_flag(extra) |= JANET_TUPLE_FLAG_BRACKETCTOR; + + for (int32_t j = 0; j < num_extra; ++j) { + extra[j] = values[j + i + 1]; + } + + janetc_error(c, janet_formatc("expected a single symbol follow '& in destructuring pattern, found %q", janet_wrap_tuple(janet_tuple_end(extra)))); + return 1; + } + + if (!janet_checktype(values[i + 1], JANET_SYMBOL)) { + janetc_error(c, janet_formatc("expected symbol following '& in destructuring pattern, found %q", values[i + 1])); + return 1; + } + + JanetSlot argi = janetc_farslot(c); + JanetSlot arg = janetc_farslot(c); + JanetSlot len = janetc_farslot(c); + + janetc_emit_si(c, JOP_LOAD_INTEGER, argi, i, 0); + janetc_emit_ss(c, JOP_LENGTH, len, right, 0); + + /* loop condition - reuse arg slot for the condition result */ + int32_t label_loop_start = janetc_emit_sss(c, JOP_LESS_THAN, arg, argi, len, 0); + int32_t label_loop_cond_jump = janetc_emit_si(c, JOP_JUMP_IF_NOT, arg, 0, 0); + + /* loop body */ + janetc_emit_sss(c, JOP_GET, arg, right, argi, 0); + janetc_emit_s(c, JOP_PUSH, arg, 0); + janetc_emit_ssi(c, JOP_ADD_IMMEDIATE, argi, argi, 1, 0); + + /* loop - jump back to the start of the loop */ + int32_t label_loop_loop = janet_v_count(c->buffer); + janetc_emit(c, JOP_JUMP); + int32_t label_loop_exit = janet_v_count(c->buffer); + + /* avoid shifting negative numbers */ + c->buffer[label_loop_cond_jump] |= (uint32_t)(label_loop_exit - label_loop_cond_jump) << 16; + c->buffer[label_loop_loop] |= (uint32_t)(label_loop_start - label_loop_loop) << 8; + + janetc_freeslot(c, argi); + janetc_freeslot(c, arg); + janetc_freeslot(c, len); + + janetc_emit_s(c, JOP_MAKE_TUPLE, nextright, 1); + + leaf(c, janet_unwrap_symbol(values[i + 1]), nextright, attr); + janetc_freeslot(c, nextright); + break; + } + + if (i < 0x100) { + janetc_emit_ssu(c, JOP_GET_INDEX, nextright, right, (uint8_t) i, 1); + } else { + JanetSlot k = janetc_cslot(janet_wrap_integer(i)); + janetc_emit_sss(c, JOP_IN, nextright, right, k, 1); + } + if (destructure(c, subval, nextright, leaf, attr)) + janetc_freeslot(c, nextright); + } + } + return 1; + case JANET_TABLE: + case JANET_STRUCT: { + const JanetKV *kvs = NULL; + int32_t cap = 0, len = 0; + janet_dictionary_view(left, &kvs, &len, &cap); + for (int32_t i = 0; i < cap; i++) { + if (janet_checktype(kvs[i].key, JANET_NIL)) continue; + JanetSlot nextright = janetc_farslot(c); + JanetSlot k = janetc_value(janetc_fopts_default(c), kvs[i].key); + janetc_emit_sss(c, JOP_IN, nextright, right, k, 1); + if (destructure(c, kvs[i].value, nextright, leaf, attr)) + janetc_freeslot(c, nextright); + } + } + return 1; + } +} + +/* Create a source map for definitions. */ +static const Janet *janetc_make_sourcemap(JanetCompiler *c) { + Janet *tup = janet_tuple_begin(3); + tup[0] = c->source ? janet_wrap_string(c->source) : janet_wrap_nil(); + tup[1] = janet_wrap_integer(c->current_mapping.line); + tup[2] = janet_wrap_integer(c->current_mapping.column); + return janet_tuple_end(tup); +} + +static JanetSlot janetc_varset(JanetFopts opts, int32_t argn, const Janet *argv) { + if (argn != 2) { + janetc_cerror(opts.compiler, "expected 2 arguments to set"); + return janetc_cslot(janet_wrap_nil()); + } + JanetFopts subopts = janetc_fopts_default(opts.compiler); + if (janet_checktype(argv[0], JANET_SYMBOL)) { + /* Normal var - (set a 1) */ + const uint8_t *sym = janet_unwrap_symbol(argv[0]); + JanetSlot dest = janetc_resolve(opts.compiler, sym); + if (!(dest.flags & JANET_SLOT_MUTABLE)) { + janetc_cerror(opts.compiler, "cannot set constant"); + return janetc_cslot(janet_wrap_nil()); + } + subopts.flags = JANET_FOPTS_HINT; + subopts.hint = dest; + JanetSlot ret = janetc_value(subopts, argv[1]); + janetc_copy(opts.compiler, dest, ret); + return ret; + } else if (janet_checktype(argv[0], JANET_TUPLE)) { + /* Set a field (setf behavior) - (set (tab :key) 2) */ + const Janet *tup = janet_unwrap_tuple(argv[0]); + /* Tuple must have 2 elements */ + if (janet_tuple_length(tup) != 2) { + janetc_cerror(opts.compiler, "expected 2 element tuple for l-value to set"); + return janetc_cslot(janet_wrap_nil()); + } + JanetSlot ds = janetc_value(subopts, tup[0]); + JanetSlot key = janetc_value(subopts, tup[1]); + /* Can't be tail position because we will emit a PUT instruction afterwards */ + /* Also can't drop either */ + opts.flags &= ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); + JanetSlot rvalue = janetc_value(opts, argv[1]); + /* Emit the PUT instruction */ + janetc_emit_sss(opts.compiler, JOP_PUT, ds, key, rvalue, 0); + return rvalue; + } else { + /* Error */ + janetc_cerror(opts.compiler, "expected symbol or tuple for l-value to set"); + return janetc_cslot(janet_wrap_nil()); + } +} + +/* Add attributes to a global def or var table */ +static JanetTable *handleattr(JanetCompiler *c, const char *kind, int32_t argn, const Janet *argv) { + int32_t i; + JanetTable *tab = janet_table(2); + const char *binding_name = janet_type(argv[0]) == JANET_SYMBOL + ? ((const char *)janet_unwrap_symbol(argv[0])) + : ""; + if (argn < 2) { + janetc_error(c, janet_formatc("expected at least 2 arguments to %s", kind)); + return NULL; + } + for (i = 1; i < argn - 1; i++) { + Janet attr = argv[i]; + switch (janet_type(attr)) { + case JANET_TUPLE: + janetc_cerror(c, "unexpected form - did you intend to use defn?"); + break; + default: + janetc_error(c, janet_formatc("cannot add metadata %v to binding %s", attr, binding_name)); + break; + case JANET_KEYWORD: + janet_table_put(tab, attr, janet_wrap_true()); + break; + case JANET_STRING: + janet_table_put(tab, janet_ckeywordv("doc"), attr); + break; + case JANET_STRUCT: + janet_table_merge_struct(tab, janet_unwrap_struct(attr)); + break; + } + } + return tab; +} + +typedef struct SlotHeadPair { + Janet lhs; + JanetSlot rhs; +} SlotHeadPair; + +SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopts opts, Janet lhs, Janet rhs) { + + /* Detect if we can do an optimization to avoid some allocations */ + int can_destructure_lhs = janet_checktype(lhs, JANET_TUPLE) + || janet_checktype(lhs, JANET_ARRAY); + int rhs_is_indexed = janet_checktype(rhs, JANET_ARRAY) + || (janet_checktype(rhs, JANET_TUPLE) && (janet_tuple_flag(janet_unwrap_tuple(rhs)) & JANET_TUPLE_FLAG_BRACKETCTOR)); + uint32_t has_drop = opts.flags & JANET_FOPTS_DROP; + + JanetFopts subopts = janetc_fopts_default(c); + subopts.flags = opts.flags & ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); + + if (has_drop && can_destructure_lhs && rhs_is_indexed) { + /* Code is of the form (def [a b] [1 2]), avoid the allocation of two tuples */ + JanetView view_lhs = {0}; + JanetView view_rhs = {0}; + janet_indexed_view(lhs, &view_lhs.items, &view_lhs.len); + janet_indexed_view(rhs, &view_rhs.items, &view_rhs.len); + int found_amp = 0; + for (int32_t i = 0; i < view_lhs.len; i++) { + if (janet_symeq(view_lhs.items[i], "&")) { + found_amp = 1; + /* Good error will be generated later. */ + break; + } + } + if (!found_amp) { + for (int32_t i = 0; i < view_lhs.len; i++) { + Janet sub_rhs = view_rhs.len <= i ? janet_wrap_nil() : view_rhs.items[i]; + into = dohead_destructure(c, into, subopts, view_lhs.items[i], sub_rhs); + } + return into; + } + } + + /* No optimization, do the simple way */ + subopts.hint = opts.hint; + JanetSlot ret = janetc_value(subopts, rhs); + SlotHeadPair shp = {lhs, ret}; + janet_v_push(into, shp); + return into; +} + +/* Def or var a symbol in a local scope */ +static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret) { + int isUnnamedRegister = !(ret.flags & JANET_SLOT_NAMED) && + ret.index > 0 && + ret.envindex >= 0; + /* optimization for `(def x my-def)` - don't emit a movn/movf instruction, we can just alias my-def */ + /* TODO - implement optimization for `(def x my-var)` correctly as well w/ de-aliasing */ + int canAlias = !(flags & JANET_SLOT_MUTABLE) && + !(ret.flags & JANET_SLOT_MUTABLE) && + (ret.flags & JANET_SLOT_NAMED) && + (ret.index >= 0) && + (ret.envindex == -1); + if (canAlias) { + ret.flags &= ~JANET_SLOT_MUTABLE; + isUnnamedRegister = 1; /* don't free slot after use - is an alias for another slot */ + } else if (!isUnnamedRegister) { + /* Slot is not able to be named */ + JanetSlot localslot = janetc_farslot(c); + janetc_copy(c, localslot, ret); + ret = localslot; + } + ret.flags |= flags; + janetc_nameslot(c, head, ret); + return !isUnnamedRegister; +} + +static int varleaf( + JanetCompiler *c, + const uint8_t *sym, + JanetSlot s, + JanetTable *reftab) { + if (c->scope->flags & JANET_SCOPE_TOP) { + /* Global var, generate var */ + JanetSlot refslot; + JanetTable *entry = janet_table_clone(reftab); + + Janet redef_kw = janet_ckeywordv("redef"); + int is_redef = janet_truthy(janet_table_get(c->env, redef_kw)); + + JanetArray *ref; + JanetBinding old_binding; + if (is_redef && (old_binding = janet_resolve_ext(c->env, sym), + old_binding.type == JANET_BINDING_VAR)) { + ref = janet_unwrap_array(old_binding.value); + } else { + ref = janet_array(1); + janet_array_push(ref, janet_wrap_nil()); + } + + janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); + janet_table_put(entry, janet_ckeywordv("source-map"), + janet_wrap_tuple(janetc_make_sourcemap(c))); + janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); + refslot = janetc_cslot(janet_wrap_array(ref)); + janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0); + return 1; + } else { + return namelocal(c, sym, JANET_SLOT_MUTABLE, s); + } +} + +static JanetSlot janetc_var(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + JanetTable *attr_table = handleattr(c, "var", argn, argv); + if (c->result.status == JANET_COMPILE_ERROR) { + return janetc_cslot(janet_wrap_nil()); + } + SlotHeadPair *into = NULL; + into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]); + if (c->result.status == JANET_COMPILE_ERROR) { + janet_v_free(into); + return janetc_cslot(janet_wrap_nil()); + } + JanetSlot ret; + janet_assert(janet_v_count(into) > 0, "bad destructure"); + for (int32_t i = 0; i < janet_v_count(into); i++) { + destructure(c, into[i].lhs, into[i].rhs, varleaf, attr_table); + ret = into[i].rhs; + } + janet_v_free(into); + return ret; +} + +static int defleaf( + JanetCompiler *c, + const uint8_t *sym, + JanetSlot s, + JanetTable *tab) { + if (c->scope->flags & JANET_SCOPE_TOP) { + JanetTable *entry = janet_table_clone(tab); + janet_table_put(entry, janet_ckeywordv("source-map"), + janet_wrap_tuple(janetc_make_sourcemap(c))); + + Janet redef_kw = janet_ckeywordv("redef"); + int is_redef = janet_truthy(janet_table_get(c->env, redef_kw)); + if (is_redef) janet_table_put(entry, redef_kw, janet_wrap_true()); + + if (is_redef) { + JanetBinding binding = janet_resolve_ext(c->env, sym); + JanetArray *ref; + if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { + ref = janet_unwrap_array(binding.value); + } else { + ref = janet_array(1); + janet_array_push(ref, janet_wrap_nil()); + } + janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); + JanetSlot refslot = janetc_cslot(janet_wrap_array(ref)); + janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0); + } else { + JanetSlot valsym = janetc_cslot(janet_ckeywordv("value")); + JanetSlot tabslot = janetc_cslot(janet_wrap_table(entry)); + janetc_emit_sss(c, JOP_PUT, tabslot, valsym, s, 0); + } + + /* Add env entry to env */ + janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); + } + return namelocal(c, sym, 0, s); +} + +static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + JanetTable *attr_table = handleattr(c, "def", argn, argv); + if (c->result.status == JANET_COMPILE_ERROR) { + return janetc_cslot(janet_wrap_nil()); + } + opts.flags &= ~JANET_FOPTS_HINT; + SlotHeadPair *into = NULL; + into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]); + if (c->result.status == JANET_COMPILE_ERROR) { + janet_v_free(into); + return janetc_cslot(janet_wrap_nil()); + } + JanetSlot ret; + janet_assert(janet_v_count(into) > 0, "bad destructure"); + for (int32_t i = 0; i < janet_v_count(into); i++) { + destructure(c, into[i].lhs, into[i].rhs, defleaf, attr_table); + ret = into[i].rhs; + } + janet_v_free(into); + return ret; +} + +/* Check if a form matches the pattern (= nil _) or (not= nil _) */ +static int janetc_check_nil_form(Janet x, Janet *capture, uint32_t fun_tag) { + if (!janet_checktype(x, JANET_TUPLE)) return 0; + JanetTuple tup = janet_unwrap_tuple(x); + if (3 != janet_tuple_length(tup)) return 0; + Janet op1 = tup[0]; + if (!janet_checktype(op1, JANET_FUNCTION)) return 0; + JanetFunction *fun = janet_unwrap_function(op1); + uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG; + if (tag != fun_tag) return 0; + if (janet_checktype(tup[1], JANET_NIL)) { + *capture = tup[2]; + return 1; + } else if (janet_checktype(tup[2], JANET_NIL)) { + *capture = tup[1]; + return 1; + } + return 0; +} + +/* + * :condition + * ... + * jump-if-not condition :right + * :left + * ... + * jump done (only if not tail) + * :right + * ... + * :done + */ +static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + int32_t labelr, labeljr, labeld, labeljd; + JanetFopts condopts, bodyopts; + JanetSlot cond, left, right, target; + Janet truebody, falsebody; + JanetScope condscope, tempscope; + const int tail = opts.flags & JANET_FOPTS_TAIL; + const int drop = opts.flags & JANET_FOPTS_DROP; + uint8_t ifnjmp = JOP_JUMP_IF_NOT; + + if (argn < 2 || argn > 3) { + janetc_cerror(c, "expected 2 or 3 arguments to if"); + return janetc_cslot(janet_wrap_nil()); + } + + /* Get the bodies of the if expression */ + truebody = argv[1]; + falsebody = argn > 2 ? argv[2] : janet_wrap_nil(); + + /* Get options */ + condopts = janetc_fopts_default(c); + bodyopts = opts; + bodyopts.flags &= ~JANET_FOPTS_ACCEPT_SPLICE; + + /* Set target for compilation */ + target = (drop || tail) + ? janetc_cslot(janet_wrap_nil()) + : janetc_gettarget(opts); + + /* Compile condition */ + janetc_scope(&condscope, c, 0, "if"); + + Janet condform = argv[0]; + if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) { + ifnjmp = JOP_JUMP_IF_NOT_NIL; + } else if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) { + ifnjmp = JOP_JUMP_IF_NIL; + } + + cond = janetc_value(condopts, condform); + + /* Check constant condition. */ + /* TODO: Use type info for more short circuits */ + if (cond.flags & JANET_SLOT_CONSTANT) { + int swap_condition = 0; + if (ifnjmp == JOP_JUMP_IF_NOT && !janet_truthy(cond.constant)) swap_condition = 1; + if (ifnjmp == JOP_JUMP_IF_NIL && janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1; + if (ifnjmp == JOP_JUMP_IF_NOT_NIL && !janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1; + if (swap_condition) { + /* Swap the true and false bodies */ + Janet temp = falsebody; + falsebody = truebody; + truebody = temp; + } + janetc_scope(&tempscope, c, 0, "if-true"); + right = janetc_value(bodyopts, truebody); + if (!drop && !tail) janetc_copy(c, target, right); + janetc_popscope(c); + if (!janet_checktype(falsebody, JANET_NIL)) { + janetc_throwaway(bodyopts, falsebody); + } + janetc_popscope(c); + return target; + } + + /* Compile jump to right */ + labeljr = janetc_emit_si(c, ifnjmp, cond, 0, 0); + + /* Condition left body */ + janetc_scope(&tempscope, c, 0, "if-true"); + left = janetc_value(bodyopts, truebody); + if (!drop && !tail) janetc_copy(c, target, left); + janetc_popscope(c); + + /* Compile jump to done */ + labeljd = janet_v_count(c->buffer); + if (!tail && !(drop && janet_checktype(falsebody, JANET_NIL))) janetc_emit(c, JOP_JUMP); + + /* Compile right body */ + labelr = janet_v_count(c->buffer); + janetc_scope(&tempscope, c, 0, "if-false"); + right = janetc_value(bodyopts, falsebody); + if (!drop && !tail) janetc_copy(c, target, right); + janetc_popscope(c); + + /* Pop main scope */ + janetc_popscope(c); + + /* Write jumps - only add jump lengths if jump actually emitted */ + labeld = janet_v_count(c->buffer); + c->buffer[labeljr] |= (labelr - labeljr) << 16; + if (!tail) c->buffer[labeljd] |= (labeld - labeljd) << 8; + + if (tail) target.flags |= JANET_SLOT_RETURNED; + return target; +} + +/* Compile a do form. Do forms execute their body sequentially and + * evaluate to the last expression in the body. */ +static JanetSlot janetc_do(JanetFopts opts, int32_t argn, const Janet *argv) { + int32_t i; + JanetSlot ret = janetc_cslot(janet_wrap_nil()); + JanetCompiler *c = opts.compiler; + JanetFopts subopts = janetc_fopts_default(c); + JanetScope tempscope; + janetc_scope(&tempscope, c, 0, "do"); + for (i = 0; i < argn; i++) { + if (i != argn - 1) { + subopts.flags = JANET_FOPTS_DROP; + } else { + subopts = opts; + subopts.flags &= ~JANET_FOPTS_ACCEPT_SPLICE; + } + ret = janetc_value(subopts, argv[i]); + if (i != argn - 1) { + janetc_freeslot(c, ret); + } + } + janetc_popscope_keepslot(c, ret); + return ret; +} + +/* Compile an upscope form. Upscope forms execute their body sequentially and + * evaluate to the last expression in the body, but without lexical scope. */ +static JanetSlot janetc_upscope(JanetFopts opts, int32_t argn, const Janet *argv) { + int32_t i; + JanetSlot ret = janetc_cslot(janet_wrap_nil()); + JanetCompiler *c = opts.compiler; + JanetFopts subopts = janetc_fopts_default(c); + for (i = 0; i < argn; i++) { + if (i != argn - 1) { + subopts.flags = JANET_FOPTS_DROP; + } else { + subopts = opts; + subopts.flags &= ~JANET_FOPTS_ACCEPT_SPLICE; + } + ret = janetc_value(subopts, argv[i]); + if (i != argn - 1) { + janetc_freeslot(c, ret); + } + } + return ret; +} + +/* Add a funcdef to the top most function scope */ +static int32_t janetc_addfuncdef(JanetCompiler *c, JanetFuncDef *def) { + JanetScope *scope = c->scope; + while (scope) { + if (scope->flags & JANET_SCOPE_FUNCTION) + break; + scope = scope->parent; + } + janet_assert(scope, "could not add funcdef"); + janet_v_push(scope->defs, def); + return janet_v_count(scope->defs) - 1; +} + +/* + * break + * + * jump :end or retn if in function + */ +static JanetSlot janetc_break(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + JanetScope *scope = c->scope; + if (argn > 1) { + janetc_cerror(c, "expected at most 1 argument"); + return janetc_cslot(janet_wrap_nil()); + } + + /* Find scope to break from */ + while (scope) { + if (scope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_WHILE)) + break; + scope = scope->parent; + } + if (NULL == scope) { + janetc_cerror(c, "break must occur in while loop or closure"); + return janetc_cslot(janet_wrap_nil()); + } + + /* Emit code to break from that scope */ + JanetFopts subopts = janetc_fopts_default(c); + if (scope->flags & JANET_SCOPE_FUNCTION) { + if (!(scope->flags & JANET_SCOPE_WHILE) && argn) { + /* Closure body with return argument */ + subopts.flags |= JANET_FOPTS_TAIL; + janetc_value(subopts, argv[0]); + return janetc_cslot(janet_wrap_nil()); + } else { + /* while loop IIFE or no argument */ + if (argn) { + subopts.flags |= JANET_FOPTS_DROP; + janetc_value(subopts, argv[0]); + } + janetc_emit(c, JOP_RETURN_NIL); + return janetc_cslot(janet_wrap_nil()); + } + } else { + if (argn) { + subopts.flags |= JANET_FOPTS_DROP; + janetc_value(subopts, argv[0]); + } + /* Tag the instruction so the while special can turn it into a proper jump */ + janetc_emit(c, 0x80 | JOP_JUMP); + return janetc_cslot(janet_wrap_nil()); + } +} + +/* + * :whiletop + * ... + * :condition + * jump-if-not cond :done + * ... + * jump :whiletop + * :done + */ +static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + JanetSlot cond; + JanetFopts subopts = janetc_fopts_default(c); + JanetScope tempscope; + int32_t labelwt, labeld, labeljt, labelc, i; + int infinite = 0; + int is_nil_form = 0; + int is_notnil_form = 0; + uint8_t ifjmp = JOP_JUMP_IF; + uint8_t ifnjmp = JOP_JUMP_IF_NOT; + + if (argn < 1) { + janetc_cerror(c, "expected at least 1 argument to while"); + return janetc_cslot(janet_wrap_nil()); + } + + labelwt = janet_v_count(c->buffer); + + janetc_scope(&tempscope, c, JANET_SCOPE_WHILE, "while"); + + /* Check for `(= nil _)` or `(not= nil _)` in condition, and if so, use the + * jmpnl or jmpnn instructions. This let's us implement `(each ...)` + * more efficiently. */ + Janet condform = argv[0]; + if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) { + is_nil_form = 1; + ifjmp = JOP_JUMP_IF_NIL; + ifnjmp = JOP_JUMP_IF_NOT_NIL; + } + if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) { + is_notnil_form = 1; + ifjmp = JOP_JUMP_IF_NOT_NIL; + ifnjmp = JOP_JUMP_IF_NIL; + } + + /* Compile condition */ + cond = janetc_value(subopts, condform); + + /* Check for constant condition */ + if (cond.flags & JANET_SLOT_CONSTANT) { + /* Loop never executes */ + int never_executes = is_nil_form + ? !janet_checktype(cond.constant, JANET_NIL) + : is_notnil_form + ? janet_checktype(cond.constant, JANET_NIL) + : !janet_truthy(cond.constant); + if (never_executes) { + janetc_popscope(c); + return janetc_cslot(janet_wrap_nil()); + } + /* Infinite loop */ + infinite = 1; + } + + /* Infinite loop does not need to check condition */ + labelc = infinite + ? 0 + : janetc_emit_si(c, ifnjmp, cond, 0, 0); + + /* Compile body */ + for (i = 1; i < argn; i++) { + subopts.flags = JANET_FOPTS_DROP; + janetc_freeslot(c, janetc_value(subopts, argv[i])); + } + + /* Check if closure created in while scope. If so, + * recompile in a function scope. */ + if (tempscope.flags & JANET_SCOPE_CLOSURE) { + subopts = janetc_fopts_default(c); + tempscope.flags |= JANET_SCOPE_UNUSED; + janetc_popscope(c); + if (c->buffer) janet_v__cnt(c->buffer) = labelwt; + if (c->mapbuffer) janet_v__cnt(c->mapbuffer) = labelwt; + + janetc_scope(&tempscope, c, JANET_SCOPE_FUNCTION, "while-iife"); + + /* Recompile in the function scope */ + cond = janetc_value(subopts, condform); + if (!(cond.flags & JANET_SLOT_CONSTANT)) { + /* If not an infinite loop, return nil when condition false */ + janetc_emit_si(c, ifjmp, cond, 2, 0); + janetc_emit(c, JOP_RETURN_NIL); + } + for (i = 1; i < argn; i++) { + subopts.flags = JANET_FOPTS_DROP; + janetc_freeslot(c, janetc_value(subopts, argv[i])); + } + /* But now add tail recursion */ + int32_t tempself = janetc_regalloc_temp(&tempscope.ra, JANETC_REGTEMP_0); + janetc_emit(c, JOP_LOAD_SELF | (tempself << 8)); + janetc_emit(c, JOP_TAILCALL | (tempself << 8)); + janetc_regalloc_freetemp(&c->scope->ra, tempself, JANETC_REGTEMP_0); + /* Compile function */ + JanetFuncDef *def = janetc_pop_funcdef(c); + def->name = janet_cstring("_while"); + janet_def_addflags(def); + int32_t defindex = janetc_addfuncdef(c, def); + /* And then load the closure and call it. */ + int32_t cloreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_0); + janetc_emit(c, JOP_CLOSURE | (cloreg << 8) | (defindex << 16)); + janetc_emit(c, JOP_CALL | (cloreg << 8) | (cloreg << 16)); + janetc_regalloc_freetemp(&c->scope->ra, cloreg, JANETC_REGTEMP_0); + c->scope->flags |= JANET_SCOPE_CLOSURE; + return janetc_cslot(janet_wrap_nil()); + } + + /* Compile jump to :whiletop */ + labeljt = janet_v_count(c->buffer); + janetc_emit(c, JOP_JUMP); + + /* Calculate jumps */ + labeld = janet_v_count(c->buffer); + if (!infinite) c->buffer[labelc] |= (uint32_t)(labeld - labelc) << 16; + c->buffer[labeljt] |= (uint32_t)(labelwt - labeljt) << 8; + + /* Calculate breaks */ + for (int32_t i = labelwt; i < labeld; i++) { + if (c->buffer[i] == (0x80 | JOP_JUMP)) { + c->buffer[i] = JOP_JUMP | ((labeld - i) << 8); + } + } + + /* Pop scope and return nil slot */ + janetc_popscope(c); + + return janetc_cslot(janet_wrap_nil()); +} + +static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) { + JanetCompiler *c = opts.compiler; + JanetFuncDef *def; + JanetSlot ret; + Janet head; + JanetScope fnscope; + int32_t paramcount, argi, parami, arity, min_arity = 0, max_arity, defindex, i; + JanetFopts subopts = janetc_fopts_default(c); + const Janet *params; + const char *errmsg = NULL; + + /* Function flags */ + int vararg = 0; + int structarg = 0; + int allow_extra = 0; + int selfref = 0; + int seenamp = 0; + int seenopt = 0; + int namedargs = 0; + + /* Begin function */ + c->scope->flags |= JANET_SCOPE_CLOSURE; + janetc_scope(&fnscope, c, JANET_SCOPE_FUNCTION, "function"); + + if (argn == 0) { + errmsg = "expected at least 1 argument to function literal"; + goto error; + } + + /* Read function parameters */ + parami = 0; + head = argv[0]; + if (janet_checktype(head, JANET_SYMBOL)) { + selfref = 1; + parami = 1; + } + if (parami >= argn || !janet_checktype(argv[parami], JANET_TUPLE)) { + errmsg = "expected function parameters"; + goto error; + } + + /* Keep track of destructured parameters */ + JanetSlot *destructed_params = NULL; + JanetSlot *named_params = NULL; + JanetTable *named_table = NULL; + JanetSlot named_slot; + + /* Compile function parameters */ + params = janet_unwrap_tuple(argv[parami]); + paramcount = janet_tuple_length(params); + arity = paramcount; + for (i = 0; i < paramcount; i++) { + Janet param = params[i]; + if (namedargs) { + arity--; + if (!janet_checktype(param, JANET_SYMBOL)) { + errmsg = "only named arguments can follow &named"; + goto error; + } + Janet key = janet_wrap_keyword(janet_unwrap_symbol(param)); + janet_table_put(named_table, key, param); + janet_v_push(named_params, janetc_farslot(c)); + } else if (janet_checktype(param, JANET_SYMBOL)) { + /* Check for varargs and unfixed arity */ + const uint8_t *sym = janet_unwrap_symbol(param); + if (sym[0] == '&') { + if (!janet_cstrcmp(sym, "&")) { + if (seenamp) { + errmsg = "& in unexpected location"; + goto error; + } else if (i == paramcount - 1) { + allow_extra = 1; + arity--; + } else if (i == paramcount - 2) { + vararg = 1; + arity -= 2; + } else { + errmsg = "& in unexpected location"; + goto error; + } + seenamp = 1; + } else if (!janet_cstrcmp(sym, "&opt")) { + if (seenopt) { + errmsg = "only one &opt allowed"; + goto error; + } else if (i == paramcount - 1) { + errmsg = "&opt cannot be last item in parameter list"; + goto error; + } + min_arity = i; + arity--; + seenopt = 1; + } else if (!janet_cstrcmp(sym, "&keys")) { + if (seenamp) { + errmsg = "&keys in unexpected location"; + goto error; + } else if (i == paramcount - 2) { + vararg = 1; + structarg = 1; + arity -= 2; + } else { + errmsg = "&keys in unexpected location"; + goto error; + } + seenamp = 1; + } else if (!janet_cstrcmp(sym, "&named")) { + if (seenamp) { + errmsg = "&named in unexpected location"; + goto error; + } + vararg = 1; + structarg = 1; + arity--; + seenamp = 1; + namedargs = 1; + named_table = janet_table(10); + named_slot = janetc_farslot(c); + } else { + janetc_nameslot(c, sym, janetc_farslot(c)); + } + } else { + janetc_nameslot(c, sym, janetc_farslot(c)); + } + } else { + janet_v_push(destructed_params, janetc_farslot(c)); + } + } + + /* Compile destructed params */ + int32_t j = 0; + for (i = 0; i < paramcount; i++) { + Janet param = params[i]; + if (!janet_checktype(param, JANET_SYMBOL)) { + janet_assert(janet_v_count(destructed_params) > j, "out of bounds"); + JanetSlot reg = destructed_params[j++]; + destructure(c, param, reg, defleaf, NULL); + janetc_freeslot(c, reg); + } + } + janet_v_free(destructed_params); + + /* Compile named arguments */ + if (namedargs) { + Janet param = janet_wrap_table(named_table); + destructure(c, param, named_slot, defleaf, NULL); + janetc_freeslot(c, named_slot); + janet_v_free(named_params); + } + + max_arity = (vararg || allow_extra) ? INT32_MAX : arity; + if (!seenopt) min_arity = arity; + + /* Check for self ref (also avoid if arguments shadow own name) */ + if (selfref) { + /* Check if the parameters shadow the function name. If so, don't + * emit JOP_LOAD_SELF and add a binding since that most users + * seem to expect that function parameters take precedence over the + * function name */ + const uint8_t *sym = janet_unwrap_symbol(head); + int32_t len = janet_v_count(c->scope->syms); + int found = 0; + for (int32_t i = 0; i < len; i++) { + if (c->scope->syms[i].sym == sym) { + found = 1; + } + } + if (!found) { + JanetSlot slot = janetc_farslot(c); + slot.flags = JANET_SLOT_NAMED | JANET_FUNCTION; + janetc_emit_s(c, JOP_LOAD_SELF, slot, 1); + janetc_nameslot(c, sym, slot); + } + } + + /* Compile function body */ + if (parami + 1 == argn) { + janetc_emit(c, JOP_RETURN_NIL); + } else { + for (argi = parami + 1; argi < argn; argi++) { + subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP; + janetc_value(subopts, argv[argi]); + if (c->result.status == JANET_COMPILE_ERROR) + goto error2; + } + } + + /* Build function */ + def = janetc_pop_funcdef(c); + def->arity = arity; + def->min_arity = min_arity; + def->max_arity = max_arity; + if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG; + if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG; + + if (selfref) def->name = janet_unwrap_symbol(head); + janet_def_addflags(def); + defindex = janetc_addfuncdef(c, def); + + /* Ensure enough slots for vararg function. */ + if (arity + vararg > def->slotcount) def->slotcount = arity + vararg; + + /* Instantiate closure */ + ret = janetc_gettarget(opts); + janetc_emit_su(c, JOP_CLOSURE, ret, defindex, 1); + return ret; + +error: + janetc_cerror(c, errmsg); +error2: + janetc_popscope(c); + return janetc_cslot(janet_wrap_nil()); +} + +/* Keep in lexicographic order */ +static const JanetSpecial janetc_specials[] = { + {"break", janetc_break}, + {"def", janetc_def}, + {"do", janetc_do}, + {"fn", janetc_fn}, + {"if", janetc_if}, + {"quasiquote", janetc_quasiquote}, + {"quote", janetc_quote}, + {"set", janetc_varset}, + {"splice", janetc_splice}, + {"unquote", janetc_unquote}, + {"upscope", janetc_upscope}, + {"var", janetc_var}, + {"while", janetc_while} +}; + +/* Find a special */ +const JanetSpecial *janetc_special(const uint8_t *name) { + return janet_strbinsearch( + &janetc_specials, + sizeof(janetc_specials) / sizeof(JanetSpecial), + sizeof(JanetSpecial), + name); +} + + +/* src/core/state.c */ +#line 0 "src/core/state.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "util.h" +#endif + +#ifdef JANET_WINDOWS +#include +#endif + +JANET_THREAD_LOCAL JanetVM janet_vm; + +JanetVM *janet_local_vm(void) { + return &janet_vm; +} + +JanetVM *janet_vm_alloc(void) { + JanetVM *mem = janet_malloc(sizeof(JanetVM)); + if (NULL == mem) { + JANET_OUT_OF_MEMORY; + } + return mem; +} + +void janet_vm_free(JanetVM *vm) { + janet_free(vm); +} + +void janet_vm_save(JanetVM *into) { + *into = janet_vm; +} + +void janet_vm_load(JanetVM *from) { + janet_vm = *from; +} + +/* Trigger suspension of the Janet vm by trying to + * exit the interpeter loop when convenient. You can optionally + * use NULL to interrupt the current VM when convenient */ +void janet_interpreter_interrupt(JanetVM *vm) { + vm = vm ? vm : &janet_vm; + janet_atomic_inc(&vm->auto_suspend); +} + +void janet_interpreter_interrupt_handled(JanetVM *vm) { + vm = vm ? vm : &janet_vm; + janet_atomic_dec(&vm->auto_suspend); +} + + +/* src/core/string.c */ +#line 0 "src/core/string.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include "state.h" +#endif + +#include + +/* Begin building a string */ +uint8_t *janet_string_begin(int32_t length) { + JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) length + 1); + head->length = length; + uint8_t *data = (uint8_t *)head->data; + data[length] = 0; + return data; +} + +/* Finish building a string */ +const uint8_t *janet_string_end(uint8_t *str) { + janet_string_hash(str) = janet_string_calchash(str, janet_string_length(str)); + return str; +} + +/* Load a buffer as a string */ +const uint8_t *janet_string(const uint8_t *buf, int32_t len) { + JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); + head->length = len; + head->hash = janet_string_calchash(buf, len); + uint8_t *data = (uint8_t *)head->data; + safe_memcpy(data, buf, len); + data[len] = 0; + return data; +} + +/* Compare two strings */ +int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { + int32_t xlen = janet_string_length(lhs); + int32_t ylen = janet_string_length(rhs); + int32_t len = xlen > ylen ? ylen : xlen; + int res = memcmp(lhs, rhs, len); + if (res) return res > 0 ? 1 : -1; + if (xlen == ylen) return 0; + return xlen < ylen ? -1 : 1; +} + +/* Compare a janet string with a piece of memory */ +int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { + int32_t lhash = janet_string_hash(lhs); + int32_t llen = janet_string_length(lhs); + if (lhs == rhs) + return 1; + if (lhash != rhash || llen != rlen) + return 0; + return !memcmp(lhs, rhs, rlen); +} + +/* Check if two strings are equal */ +int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { + return janet_string_equalconst(lhs, rhs, + janet_string_length(rhs), janet_string_hash(rhs)); +} + +/* Load a c string */ +const uint8_t *janet_cstring(const char *str) { + return janet_string((const uint8_t *)str, (int32_t)strlen(str)); +} + +/* Knuth Morris Pratt Algorithm */ + +struct kmp_state { + int32_t i; + int32_t j; + int32_t textlen; + int32_t patlen; + int32_t *lookup; + const uint8_t *text; + const uint8_t *pat; +}; + +static void kmp_init( + struct kmp_state *s, + const uint8_t *text, int32_t textlen, + const uint8_t *pat, int32_t patlen) { + if (patlen == 0) { + janet_panic("expected non-empty pattern"); + } + int32_t *lookup = janet_calloc(patlen, sizeof(int32_t)); + if (!lookup) { + JANET_OUT_OF_MEMORY; + } + s->lookup = lookup; + s->i = 0; + s->j = 0; + s->text = text; + s->pat = pat; + s->textlen = textlen; + s->patlen = patlen; + /* Init state machine */ + { + int32_t i, j; + for (i = 1, j = 0; i < patlen; i++) { + while (j && pat[j] != pat[i]) j = lookup[j - 1]; + if (pat[j] == pat[i]) j++; + lookup[i] = j; + } + } +} + +static void kmp_deinit(struct kmp_state *state) { + janet_free(state->lookup); +} + +static void kmp_seti(struct kmp_state *state, int32_t i) { + state->i = i; + state->j = 0; +} + +static int32_t kmp_next(struct kmp_state *state) { + int32_t i = state->i; + int32_t j = state->j; + int32_t textlen = state->textlen; + int32_t patlen = state->patlen; + const uint8_t *text = state->text; + const uint8_t *pat = state->pat; + int32_t *lookup = state->lookup; + while (i < textlen) { + if (text[i] == pat[j]) { + if (j == patlen - 1) { + state->i = i + 1; + state->j = lookup[j]; + return i - j; + } else { + i++; + j++; + } + } else { + if (j > 0) { + j = lookup[j - 1]; + } else { + i++; + } + } + } + return -1; +} + +/* CFuns */ + +JANET_CORE_FN(cfun_string_slice, + "(string/slice bytes &opt start end)", + "Returns a substring from a byte sequence. The substring is from " + "index `start` inclusive to index `end`, exclusive. All indexing " + "is from 0. `start` and `end` can also be negative to indicate indexing " + "from the end of the string. Note that if `start` is negative it is " + "exclusive, and if `end` is negative it is inclusive, to allow a full " + "negative slice range.") { + JanetByteView view = janet_getbytes(argv, 0); + JanetRange range = janet_getslice(argc, argv); + return janet_stringv(view.bytes + range.start, range.end - range.start); +} + +JANET_CORE_FN(cfun_symbol_slice, + "(symbol/slice bytes &opt start end)", + "Same as string/slice, but returns a symbol.") { + JanetByteView view = janet_getbytes(argv, 0); + JanetRange range = janet_getslice(argc, argv); + return janet_symbolv(view.bytes + range.start, range.end - range.start); +} + +JANET_CORE_FN(cfun_keyword_slice, + "(keyword/slice bytes &opt start end)", + "Same as string/slice, but returns a keyword.") { + JanetByteView view = janet_getbytes(argv, 0); + JanetRange range = janet_getslice(argc, argv); + return janet_keywordv(view.bytes + range.start, range.end - range.start); +} + +JANET_CORE_FN(cfun_string_repeat, + "(string/repeat bytes n)", + "Returns a string that is `n` copies of `bytes` concatenated.") { + janet_fixarity(argc, 2); + JanetByteView view = janet_getbytes(argv, 0); + int32_t rep = janet_getinteger(argv, 1); + if (rep < 0) janet_panic("expected non-negative number of repetitions"); + if (rep == 0) return janet_cstringv(""); + int64_t mulres = (int64_t) rep * view.len; + if (mulres > INT32_MAX) janet_panic("result string is too long"); + uint8_t *newbuf = janet_string_begin((int32_t) mulres); + uint8_t *end = newbuf + mulres; + for (uint8_t *p = newbuf; p < end; p += view.len) { + safe_memcpy(p, view.bytes, view.len); + } + return janet_wrap_string(janet_string_end(newbuf)); +} + +JANET_CORE_FN(cfun_string_bytes, + "(string/bytes str)", + "Returns a tuple of integers that are the byte values of the string.") { + janet_fixarity(argc, 1); + JanetByteView view = janet_getbytes(argv, 0); + Janet *tup = janet_tuple_begin(view.len); + int32_t i; + for (i = 0; i < view.len; i++) { + tup[i] = janet_wrap_integer((int32_t) view.bytes[i]); + } + return janet_wrap_tuple(janet_tuple_end(tup)); +} + +JANET_CORE_FN(cfun_string_frombytes, + "(string/from-bytes & byte-vals)", + "Creates a string from integer parameters with byte values. All integers " + "will be coerced to the range of 1 byte 0-255.") { + int32_t i; + uint8_t *buf = janet_string_begin(argc); + for (i = 0; i < argc; i++) { + int32_t c = janet_getinteger(argv, i); + buf[i] = c & 0xFF; + } + return janet_wrap_string(janet_string_end(buf)); +} + +JANET_CORE_FN(cfun_string_asciilower, + "(string/ascii-lower str)", + "Returns a new string where all bytes are replaced with the " + "lowercase version of themselves in ASCII. Does only a very simple " + "case check, meaning no unicode support.") { + janet_fixarity(argc, 1); + JanetByteView view = janet_getbytes(argv, 0); + uint8_t *buf = janet_string_begin(view.len); + for (int32_t i = 0; i < view.len; i++) { + uint8_t c = view.bytes[i]; + if (c >= 65 && c <= 90) { + buf[i] = c + 32; + } else { + buf[i] = c; + } + } + return janet_wrap_string(janet_string_end(buf)); +} + +JANET_CORE_FN(cfun_string_asciiupper, + "(string/ascii-upper str)", + "Returns a new string where all bytes are replaced with the " + "uppercase version of themselves in ASCII. Does only a very simple " + "case check, meaning no unicode support.") { + janet_fixarity(argc, 1); + JanetByteView view = janet_getbytes(argv, 0); + uint8_t *buf = janet_string_begin(view.len); + for (int32_t i = 0; i < view.len; i++) { + uint8_t c = view.bytes[i]; + if (c >= 97 && c <= 122) { + buf[i] = c - 32; + } else { + buf[i] = c; + } + } + return janet_wrap_string(janet_string_end(buf)); +} + +JANET_CORE_FN(cfun_string_reverse, + "(string/reverse str)", + "Returns a string that is the reversed version of `str`.") { + janet_fixarity(argc, 1); + JanetByteView view = janet_getbytes(argv, 0); + uint8_t *buf = janet_string_begin(view.len); + int32_t i, j; + for (i = 0, j = view.len - 1; i < view.len; i++, j--) { + buf[i] = view.bytes[j]; + } + return janet_wrap_string(janet_string_end(buf)); +} + +static void findsetup(int32_t argc, Janet *argv, struct kmp_state *s, int32_t extra) { + janet_arity(argc, 2, 3 + extra); + JanetByteView pat = janet_getbytes(argv, 0); + JanetByteView text = janet_getbytes(argv, 1); + int32_t start = 0; + if (argc >= 3) { + start = janet_getinteger(argv, 2); + if (start < 0) janet_panic("expected non-negative start index"); + } + kmp_init(s, text.bytes, text.len, pat.bytes, pat.len); + s->i = start; +} + +JANET_CORE_FN(cfun_string_find, + "(string/find patt str &opt start-index)", + "Searches for the first instance of pattern `patt` in string " + "`str`. Returns the index of the first character in `patt` if found, " + "otherwise returns nil.") { + int32_t result; + struct kmp_state state; + findsetup(argc, argv, &state, 0); + result = kmp_next(&state); + kmp_deinit(&state); + return result < 0 + ? janet_wrap_nil() + : janet_wrap_integer(result); +} + +JANET_CORE_FN(cfun_string_hasprefix, + "(string/has-prefix? pfx str)", + "Tests whether `str` starts with `pfx`.") { + janet_fixarity(argc, 2); + JanetByteView prefix = janet_getbytes(argv, 0); + JanetByteView str = janet_getbytes(argv, 1); + return str.len < prefix.len + ? janet_wrap_false() + : janet_wrap_boolean(memcmp(prefix.bytes, str.bytes, prefix.len) == 0); +} + +JANET_CORE_FN(cfun_string_hassuffix, + "(string/has-suffix? sfx str)", + "Tests whether `str` ends with `sfx`.") { + janet_fixarity(argc, 2); + JanetByteView suffix = janet_getbytes(argv, 0); + JanetByteView str = janet_getbytes(argv, 1); + return str.len < suffix.len + ? janet_wrap_false() + : janet_wrap_boolean(memcmp(suffix.bytes, + str.bytes + str.len - suffix.len, + suffix.len) == 0); +} + +JANET_CORE_FN(cfun_string_findall, + "(string/find-all patt str &opt start-index)", + "Searches for all instances of pattern `patt` in string " + "`str`. Returns an array of all indices of found patterns. Overlapping " + "instances of the pattern are counted individually, meaning a byte in `str` " + "may contribute to multiple found patterns.") { + int32_t result; + struct kmp_state state; + findsetup(argc, argv, &state, 0); + JanetArray *array = janet_array(0); + while ((result = kmp_next(&state)) >= 0) { + janet_array_push(array, janet_wrap_integer(result)); + } + kmp_deinit(&state); + return janet_wrap_array(array); +} + +struct replace_state { + struct kmp_state kmp; + Janet subst; +}; + +static void replacesetup(int32_t argc, Janet *argv, struct replace_state *s) { + janet_arity(argc, 3, 4); + JanetByteView pat = janet_getbytes(argv, 0); + Janet subst = argv[1]; + JanetByteView text = janet_getbytes(argv, 2); + int32_t start = 0; + if (argc == 4) { + start = janet_getinteger(argv, 3); + if (start < 0) janet_panic("expected non-negative start index"); + } + kmp_init(&s->kmp, text.bytes, text.len, pat.bytes, pat.len); + s->kmp.i = start; + s->subst = subst; +} + +JANET_CORE_FN(cfun_string_replace, + "(string/replace patt subst str)", + "Replace the first occurrence of `patt` with `subst` in the string `str`. " + "If `subst` is a function, it will be called with `patt` only if a match is found, " + "and should return the actual replacement text to use. " + "Will return the new string if `patt` is found, otherwise returns `str`.") { + int32_t result; + struct replace_state s; + uint8_t *buf; + replacesetup(argc, argv, &s); + result = kmp_next(&s.kmp); + if (result < 0) { + kmp_deinit(&s.kmp); + return janet_stringv(s.kmp.text, s.kmp.textlen); + } + JanetByteView subst = janet_text_substitution(&s.subst, s.kmp.text + result, s.kmp.patlen, NULL); + buf = janet_string_begin(s.kmp.textlen - s.kmp.patlen + subst.len); + safe_memcpy(buf, s.kmp.text, result); + safe_memcpy(buf + result, subst.bytes, subst.len); + safe_memcpy(buf + result + subst.len, + s.kmp.text + result + s.kmp.patlen, + s.kmp.textlen - result - s.kmp.patlen); + kmp_deinit(&s.kmp); + return janet_wrap_string(janet_string_end(buf)); +} + +JANET_CORE_FN(cfun_string_replaceall, + "(string/replace-all patt subst str)", + "Replace all instances of `patt` with `subst` in the string `str`. Overlapping " + "matches will not be counted, only the first match in such a span will be replaced. " + "If `subst` is a function, it will be called with `patt` once for each match, " + "and should return the actual replacement text to use. " + "Will return the new string if `patt` is found, otherwise returns `str`.") { + int32_t result; + struct replace_state s; + JanetBuffer b; + int32_t lastindex = 0; + replacesetup(argc, argv, &s); + janet_buffer_init(&b, s.kmp.textlen); + while ((result = kmp_next(&s.kmp)) >= 0) { + JanetByteView subst = janet_text_substitution(&s.subst, s.kmp.text + result, s.kmp.patlen, NULL); + janet_buffer_push_bytes(&b, s.kmp.text + lastindex, result - lastindex); + janet_buffer_push_bytes(&b, subst.bytes, subst.len); + lastindex = result + s.kmp.patlen; + kmp_seti(&s.kmp, lastindex); + } + janet_buffer_push_bytes(&b, s.kmp.text + lastindex, s.kmp.textlen - lastindex); + const uint8_t *ret = janet_string(b.data, b.count); + janet_buffer_deinit(&b); + kmp_deinit(&s.kmp); + return janet_wrap_string(ret); +} + +JANET_CORE_FN(cfun_string_split, + "(string/split delim str &opt start limit)", + "Splits a string `str` with delimiter `delim` and returns an array of " + "substrings. The substrings will not contain the delimiter `delim`. If `delim` " + "is not found, the returned array will have one element. Will start searching " + "for `delim` at the index `start` (if provided), and return up to a maximum " + "of `limit` results (if provided).") { + int32_t result; + JanetArray *array; + struct kmp_state state; + int32_t limit = -1, lastindex = 0; + if (argc == 4) { + limit = janet_getinteger(argv, 3); + } + findsetup(argc, argv, &state, 1); + array = janet_array(0); + while ((result = kmp_next(&state)) >= 0 && --limit) { + const uint8_t *slice = janet_string(state.text + lastindex, result - lastindex); + janet_array_push(array, janet_wrap_string(slice)); + lastindex = result + state.patlen; + kmp_seti(&state, lastindex); + } + const uint8_t *slice = janet_string(state.text + lastindex, state.textlen - lastindex); + janet_array_push(array, janet_wrap_string(slice)); + kmp_deinit(&state); + return janet_wrap_array(array); +} + +JANET_CORE_FN(cfun_string_checkset, + "(string/check-set set str)", + "Checks that the string `str` only contains bytes that appear in the string `set`. " + "Returns true if all bytes in `str` appear in `set`, false if some bytes in `str` do " + "not appear in `set`.") { + uint32_t bitset[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + janet_fixarity(argc, 2); + JanetByteView set = janet_getbytes(argv, 0); + JanetByteView str = janet_getbytes(argv, 1); + /* Populate set */ + for (int32_t i = 0; i < set.len; i++) { + int index = set.bytes[i] >> 5; + uint32_t mask = 1 << (set.bytes[i] & 0x1F); + bitset[index] |= mask; + } + /* Check set */ + for (int32_t i = 0; i < str.len; i++) { + int index = str.bytes[i] >> 5; + uint32_t mask = 1 << (str.bytes[i] & 0x1F); + if (!(bitset[index] & mask)) { + return janet_wrap_false(); + } + } + return janet_wrap_true(); +} + +JANET_CORE_FN(cfun_string_join, + "(string/join parts &opt sep)", + "Joins an array of strings into one string, optionally separated by " + "a separator string `sep`.") { + janet_arity(argc, 1, 2); + JanetView parts = janet_getindexed(argv, 0); + JanetByteView joiner; + if (argc == 2) { + joiner = janet_getbytes(argv, 1); + } else { + joiner.bytes = NULL; + joiner.len = 0; + } + /* Check args */ + int32_t i; + int64_t finallen = 0; + for (i = 0; i < parts.len; i++) { + const uint8_t *chunk; + int32_t chunklen = 0; + if (!janet_bytes_view(parts.items[i], &chunk, &chunklen)) { + janet_panicf("item %d of parts is not a byte sequence, got %v", i, parts.items[i]); + } + if (i) finallen += joiner.len; + finallen += chunklen; + if (finallen > INT32_MAX) + janet_panic("result string too long"); + } + uint8_t *buf, *out; + out = buf = janet_string_begin((int32_t) finallen); + for (i = 0; i < parts.len; i++) { + const uint8_t *chunk = NULL; + int32_t chunklen = 0; + if (i) { + safe_memcpy(out, joiner.bytes, joiner.len); + out += joiner.len; + } + janet_bytes_view(parts.items[i], &chunk, &chunklen); + safe_memcpy(out, chunk, chunklen); + out += chunklen; + } + return janet_wrap_string(janet_string_end(buf)); +} + +JANET_CORE_FN(cfun_string_format, + "(string/format format & values)", + "Similar to C's `snprintf`, but specialized for operating with Janet values. Returns " + "a new string.\n\n" + "The following conversion specifiers are supported, where the upper case specifiers generate " + "upper case output:\n" + "- `c`: ASCII character.\n" + "- `d`, `i`: integer, formatted as a decimal number.\n" + "- `x`, `X`: integer, formatted as a hexadecimal number.\n" + "- `o`: integer, formatted as an octal number.\n" + "- `f`, `F`: floating point number, formatted as a decimal number.\n" + "- `e`, `E`: floating point number, formatted in scientific notation.\n" + "- `g`, `G`: floating point number, formatted in its shortest form.\n" + "- `a`, `A`: floating point number, formatted as a hexadecimal number.\n" + "- `s`: formatted as a string, precision indicates padding and maximum length.\n" + "- `t`: emit the type of the given value.\n" + "- `v`: format with (describe x)\n" + "- `V`: format with (string x)\n" + "- `j`: format to jdn (Janet data notation).\n" + "\n" + "The following conversion specifiers are used for \"pretty-printing\", where the upper-case " + "variants generate colored output. These specifiers can take a precision " + "argument to specify the maximum nesting depth to print.\n" + "- `p`, `P`: pretty format, truncating if necessary\n" + "- `m`, `M`: pretty format without truncating.\n" + "- `q`, `Q`: pretty format on one line, truncating if necessary.\n" + "- `n`, `N`: pretty format on one line without truncation.\n") { + janet_arity(argc, 1, -1); + JanetBuffer *buffer = janet_buffer(0); + const char *strfrmt = (const char *) janet_getstring(argv, 0); + janet_buffer_format(buffer, strfrmt, 0, argc, argv); + return janet_stringv(buffer->data, buffer->count); +} + +static int trim_help_checkset(JanetByteView set, uint8_t x) { + for (int32_t j = 0; j < set.len; j++) + if (set.bytes[j] == x) + return 1; + return 0; +} + +static int32_t trim_help_leftedge(JanetByteView str, JanetByteView set) { + for (int32_t i = 0; i < str.len; i++) + if (!trim_help_checkset(set, str.bytes[i])) + return i; + return str.len; +} + +static int32_t trim_help_rightedge(JanetByteView str, JanetByteView set) { + for (int32_t i = str.len - 1; i >= 0; i--) + if (!trim_help_checkset(set, str.bytes[i])) + return i + 1; + return 0; +} + +static void trim_help_args(int32_t argc, Janet *argv, JanetByteView *str, JanetByteView *set) { + janet_arity(argc, 1, 2); + *str = janet_getbytes(argv, 0); + if (argc >= 2) { + *set = janet_getbytes(argv, 1); + } else { + set->bytes = (const uint8_t *)(" \t\r\n\v\f"); + set->len = 6; + } +} + +JANET_CORE_FN(cfun_string_trim, + "(string/trim str &opt set)", + "Trim leading and trailing whitespace from a byte sequence. If the argument " + "`set` is provided, consider only characters in `set` to be whitespace.") { + JanetByteView str, set; + trim_help_args(argc, argv, &str, &set); + int32_t left_edge = trim_help_leftedge(str, set); + int32_t right_edge = trim_help_rightedge(str, set); + if (right_edge < left_edge) + return janet_stringv(NULL, 0); + return janet_stringv(str.bytes + left_edge, right_edge - left_edge); +} + +JANET_CORE_FN(cfun_string_triml, + "(string/triml str &opt set)", + "Trim leading whitespace from a byte sequence. If the argument " + "`set` is provided, consider only characters in `set` to be whitespace.") { + JanetByteView str, set; + trim_help_args(argc, argv, &str, &set); + int32_t left_edge = trim_help_leftedge(str, set); + return janet_stringv(str.bytes + left_edge, str.len - left_edge); +} + +JANET_CORE_FN(cfun_string_trimr, + "(string/trimr str &opt set)", + "Trim trailing whitespace from a byte sequence. If the argument " + "`set` is provided, consider only characters in `set` to be whitespace.") { + JanetByteView str, set; + trim_help_args(argc, argv, &str, &set); + int32_t right_edge = trim_help_rightedge(str, set); + return janet_stringv(str.bytes, right_edge); +} + +/* Module entry point */ +void janet_lib_string(JanetTable *env) { + JanetRegExt string_cfuns[] = { + JANET_CORE_REG("string/slice", cfun_string_slice), + JANET_CORE_REG("keyword/slice", cfun_keyword_slice), + JANET_CORE_REG("symbol/slice", cfun_symbol_slice), + JANET_CORE_REG("string/repeat", cfun_string_repeat), + JANET_CORE_REG("string/bytes", cfun_string_bytes), + JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), + JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), + JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), + JANET_CORE_REG("string/reverse", cfun_string_reverse), + JANET_CORE_REG("string/find", cfun_string_find), + JANET_CORE_REG("string/find-all", cfun_string_findall), + JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), + JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), + JANET_CORE_REG("string/replace", cfun_string_replace), + JANET_CORE_REG("string/replace-all", cfun_string_replaceall), + JANET_CORE_REG("string/split", cfun_string_split), + JANET_CORE_REG("string/check-set", cfun_string_checkset), + JANET_CORE_REG("string/join", cfun_string_join), + JANET_CORE_REG("string/format", cfun_string_format), + JANET_CORE_REG("string/trim", cfun_string_trim), + JANET_CORE_REG("string/triml", cfun_string_triml), + JANET_CORE_REG("string/trimr", cfun_string_trimr), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, string_cfuns); +} + + +/* src/core/strtod.c */ +#line 0 "src/core/strtod.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +/* Use a custom double parser instead of libc's strtod for better portability + * and control. + * + * This version has been modified for much greater flexibility in parsing, such + * as choosing the radix and supporting scientific notation with any radix. + * + * Numbers are of the form [-+]R[rR]I.F[eE&][-+]X in pseudo-regex form, where R + * is the radix, I is the integer part, F is the fractional part, and X is the + * exponent. All signs, radix, decimal point, fractional part, and exponent can + * be omitted. The radix is assumed to be 10 if omitted, and the E or e + * separator for the exponent can only be used when the radix is 10. This is + * because E is a valid digit in bases 15 or greater. For bases greater than + * 10, the letters are used as digits. A through Z correspond to the digits 10 + * through 35, and the lowercase letters have the same values. The radix number + * is always in base 10. For example, a hexidecimal number could be written + * '16rdeadbeef'. janet_scan_number also supports some c style syntax for + * hexidecimal literals. The previous number could also be written + * '0xdeadbeef'. + */ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#endif + +#include +#include + +/* Lookup table for getting values of characters when parsing numbers. Handles + * digits 0-9 and a-z (and A-Z). A-Z have values of 10 to 35. */ +static uint8_t digit_lookup[128] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 0xff, 0xff, 0xff, 0xff, 0xff +}; + +#define BIGNAT_NBIT 31 +#define BIGNAT_BASE 0x80000000U + +/* Allow for large mantissa. BigNat is a natural number. */ +struct BigNat { + uint32_t first_digit; /* First digit so we don't need to allocate when not needed. */ + int32_t n; /* n digits */ + int32_t cap; /* allocated digit capacity */ + uint32_t *digits; /* Each digit is base (2 ^ 31). Digits are least significant first. */ +}; + +/* Initialize a bignat to 0 */ +static void bignat_zero(struct BigNat *x) { + x->first_digit = 0; + x->n = 0; + x->cap = 0; + x->digits = NULL; +} + +/* Allocate n more digits for mant. Return a pointer to these digits. */ +static uint32_t *bignat_extra(struct BigNat *mant, int32_t n) { + int32_t oldn = mant->n; + int32_t newn = oldn + n; + if (mant->cap < newn) { + int32_t newcap = 2 * newn; + uint32_t *mem = janet_realloc(mant->digits, (size_t) newcap * sizeof(uint32_t)); + if (NULL == mem) { + JANET_OUT_OF_MEMORY; + } + mant->cap = newcap; + mant->digits = mem; + } + mant->n = newn; + return mant->digits + oldn; +} + +/* Append a digit */ +static void bignat_append(struct BigNat *mant, uint32_t dig) { + bignat_extra(mant, 1)[0] = dig; +} + +/* Multiply the mantissa mant by a factor and the add a term + * in one operation. factor will be between 2 and 36^4, + * term will be between 0 and 36. */ +static void bignat_muladd(struct BigNat *mant, uint32_t factor, uint32_t term) { + int32_t i; + uint64_t carry = ((uint64_t) mant->first_digit) * factor + term; + mant->first_digit = carry % BIGNAT_BASE; + carry /= BIGNAT_BASE; + for (i = 0; i < mant->n; i++) { + carry += ((uint64_t) mant->digits[i]) * factor; + mant->digits[i] = carry % BIGNAT_BASE; + carry /= BIGNAT_BASE; + } + if (carry) bignat_append(mant, (uint32_t) carry); +} + +/* Divide the mantissa mant by a factor. Drop the remainder. */ +static void bignat_div(struct BigNat *mant, uint32_t divisor) { + int32_t i; + uint32_t quotient, remainder; + uint64_t dividend; + remainder = 0, quotient = 0; + for (i = mant->n - 1; i >= 0; i--) { + dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->digits[i]; + if (i < mant->n - 1) mant->digits[i + 1] = quotient; + quotient = (uint32_t)(dividend / divisor); + remainder = (uint32_t)(dividend % divisor); + mant->digits[i] = remainder; + } + dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->first_digit; + if (mant->n && mant->digits[mant->n - 1] == 0) mant->n--; + mant->first_digit = (uint32_t)(dividend / divisor); +} + +/* Shift left by a multiple of BIGNAT_NBIT */ +static void bignat_lshift_n(struct BigNat *mant, int n) { + if (!n) return; + int32_t oldn = mant->n; + bignat_extra(mant, n); + memmove(mant->digits + n, mant->digits, sizeof(uint32_t) * oldn); + memset(mant->digits, 0, sizeof(uint32_t) * (n - 1)); + mant->digits[n - 1] = mant->first_digit; + mant->first_digit = 0; +} + +#ifdef __GNUC__ +#define clz(x) __builtin_clz(x) +#else +static int clz(uint32_t x) { + int n = 0; + if (x <= 0x0000ffff) n += 16, x <<= 16; + if (x <= 0x00ffffff) n += 8, x <<= 8; + if (x <= 0x0fffffff) n += 4, x <<= 4; + if (x <= 0x3fffffff) n += 2, x <<= 2; + if (x <= 0x7fffffff) n ++; + return n; +} +#endif + +/* Extract double value from mantissa */ +static double bignat_extract(struct BigNat *mant, int32_t exponent2) { + uint64_t top53; + int32_t n = mant->n; + /* Get most significant 53 bits from mant. Bit 52 (0 indexed) should + * always be 1. This is essentially a large right shift on mant.*/ + if (n) { + /* Two or more digits */ + uint64_t d1 = mant->digits[n - 1]; /* MSD (non-zero) */ + uint64_t d2 = (n == 1) ? mant->first_digit : mant->digits[n - 2]; + uint64_t d3 = (n > 2) ? mant->digits[n - 3] : (n == 2) ? mant->first_digit : 0; + int lz = clz((uint32_t) d1); + int nbits = 32 - lz; + /* First get 54 bits */ + top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54)); + top53 >>= nbits; + top53 |= (d1 << (54 - nbits)); + /* Rounding based on lowest bit of 54 */ + if (top53 & 1) top53++; + top53 >>= 1; + if (top53 > 0x1FffffFFFFffffUL) { + top53 >>= 1; + exponent2++; + } + /* Correct exponent - to correct for large right shift to mantissa. */ + exponent2 += (nbits - 53) + BIGNAT_NBIT * n; + } else { + /* One digit */ + top53 = mant->first_digit; + } + return ldexp((double)top53, exponent2); +} + +/* Read in a mantissa and exponent of a certain base, and give + * back the double value. Should properly handle 0s, infinities, and + * denormalized numbers. (When the exponent values are too large or small) */ +static double convert( + int negative, + struct BigNat *mant, + int32_t base, + int32_t exponent) { + + int32_t exponent2 = 0; + + /* Approximate exponent in base 2 of mant and exponent. This should get us a good estimate of the final size of the + * number, within * 2^32 or so. */ + int64_t mant_exp2_approx = mant->n * 32 + 16; + int64_t exp_exp2_approx = (int64_t)(floor(log2(base) * exponent)); + int64_t exp2_approx = mant_exp2_approx + exp_exp2_approx; + + /* Short circuit zero, huge, and small numbers. We use the exponent range of valid IEEE754 doubles (-1022, 1023) + * with a healthy buffer to allow for inaccuracies in the approximation and denormailzed numbers. */ + if (mant->n == 0 && mant->first_digit == 0) + return negative ? -0.0 : 0.0; + if (exp2_approx > 1176) + return negative ? -INFINITY : INFINITY; + if (exp2_approx < -1175) + return negative ? -0.0 : 0.0; + + /* Final value is X = mant * base ^ exponent * 2 ^ exponent2 + * Get exponent to zero while holding X constant. */ + + /* Positive exponents are simple */ + for (; exponent > 3; exponent -= 4) bignat_muladd(mant, base * base * base * base, 0); + for (; exponent > 1; exponent -= 2) bignat_muladd(mant, base * base, 0); + for (; exponent > 0; exponent -= 1) bignat_muladd(mant, base, 0); + + /* Negative exponents are tricky - we don't want to loose bits + * from integer division, so we need to premultiply. */ + if (exponent < 0) { + int32_t shamt = 5 - exponent / 4; + bignat_lshift_n(mant, shamt); + exponent2 -= shamt * BIGNAT_NBIT; + for (; exponent < -3; exponent += 4) bignat_div(mant, base * base * base * base); + for (; exponent < -1; exponent += 2) bignat_div(mant, base * base); + for (; exponent < 0; exponent += 1) bignat_div(mant, base); + } + + return negative + ? -bignat_extract(mant, exponent2) + : bignat_extract(mant, exponent2); +} + +/* Scan a real (double) from a string. If the string cannot be converted into + * and integer, return 0. */ +int janet_scan_number_base( + const uint8_t *str, + int32_t len, + int32_t base, + double *out) { + const uint8_t *end = str + len; + int seenadigit = 0; + int ex = 0; + int seenpoint = 0; + int foundexp = 0; + int neg = 0; + struct BigNat mant; + bignat_zero(&mant); + + /* Prevent some kinds of overflow bugs relating to the exponent + * overflowing. For example, if a string was passed 2GB worth of 0s after + * the decimal point, exponent could wrap around and become positive. It's + * easier to reject ridiculously large inputs than to check for overflows. + * */ + if (len > INT32_MAX / 40) goto error; + + /* Get sign */ + if (str >= end) goto error; + if (*str == '-') { + neg = 1; + str++; + } else if (*str == '+') { + str++; + } + + /* Check for leading 0x or digit digit r */ + if (base == 0) { + if (str + 1 < end && str[0] == '0' && str[1] == 'x') { + base = 16; + str += 2; + } else if (str + 1 < end && + str[0] >= '0' && str[0] <= '9' && + str[1] == 'r') { + base = str[0] - '0'; + str += 2; + } else if (str + 2 < end && + str[0] >= '0' && str[0] <= '9' && + str[1] >= '0' && str[1] <= '9' && + str[2] == 'r') { + base = 10 * (str[0] - '0') + (str[1] - '0'); + if (base < 2 || base > 36) goto error; + str += 3; + } + } + + /* If still base is 0, set to default (10) */ + if (base == 0) { + base = 10; + } + + /* Skip leading zeros */ + while (str < end && (*str == '0' || *str == '.')) { + if (seenpoint) ex--; + if (*str == '.') { + if (seenpoint) goto error; + seenpoint = 1; + } else { + seenadigit = 1; + } + str++; + } + + /* Parse significant digits */ + while (str < end) { + if (*str == '.') { + if (seenpoint) goto error; + seenpoint = 1; + } else if (*str == '&') { + foundexp = 1; + break; + } else if (base == 10 && (*str == 'E' || *str == 'e')) { + foundexp = 1; + break; + } else if (*str == '_') { + if (!seenadigit) goto error; + } else { + int digit = digit_lookup[*str & 0x7F]; + if (*str > 127 || digit >= base) goto error; + if (seenpoint) ex--; + bignat_muladd(&mant, base, digit); + seenadigit = 1; + } + str++; + } + + if (!seenadigit) + goto error; + + /* Read exponent */ + if (str < end && foundexp) { + int eneg = 0; + int32_t ee = 0; + seenadigit = 0; + str++; + if (str >= end) goto error; + if (*str == '-') { + eneg = 1; + str++; + } else if (*str == '+') { + str++; + } + /* Skip leading 0s in exponent */ + while (str < end && *str == '0') { + str++; + seenadigit = 1; + } + while (str < end) { + int digit = digit_lookup[*str & 0x7F]; + if (*str > 127 || digit >= base) goto error; + if (ee < (INT32_MAX / 40)) { + ee = base * ee + digit; + } + str++; + seenadigit = 1; + } + if (eneg) ex -= ee; + else ex += ee; + } + + if (!seenadigit) + goto error; + + *out = convert(neg, &mant, base, ex); + janet_free(mant.digits); + return 0; + +error: + janet_free(mant.digits); + return 1; +} + +int janet_scan_number( + const uint8_t *str, + int32_t len, + double *out) { + return janet_scan_number_base(str, len, 0, out); +} + +#ifdef JANET_INT_TYPES + +static int scan_uint64( + const uint8_t *str, + int32_t len, + uint64_t *out, + int *neg) { + const uint8_t *end = str + len; + int seenadigit = 0; + int base = 10; + *neg = 0; + *out = 0; + uint64_t accum = 0; + /* len max is INT64_MAX in base 2 with _ between each bits */ + /* '2r' + 64 bits + 63 _ + sign = 130 => 150 for some leading */ + /* zeros */ + if (len > 150) return 0; + /* Get sign */ + if (str >= end) return 0; + if (*str == '-') { + *neg = 1; + str++; + } else if (*str == '+') { + str++; + } + /* Check for leading 0x or digit digit r */ + if (str + 1 < end && str[0] == '0' && str[1] == 'x') { + base = 16; + str += 2; + } else if (str + 1 < end && + str[0] >= '0' && str[0] <= '9' && + str[1] == 'r') { + base = str[0] - '0'; + str += 2; + } else if (str + 2 < end && + str[0] >= '0' && str[0] <= '9' && + str[1] >= '0' && str[1] <= '9' && + str[2] == 'r') { + base = 10 * (str[0] - '0') + (str[1] - '0'); + if (base < 2 || base > 36) return 0; + str += 3; + } + + /* Skip leading zeros */ + while (str < end && *str == '0') { + seenadigit = 1; + str++; + } + /* Parse significant digits */ + while (str < end) { + if (*str == '_') { + if (!seenadigit) return 0; + } else { + int digit = digit_lookup[*str & 0x7F]; + if (*str > 127 || digit >= base) return 0; + if (accum > (UINT64_MAX - digit) / base) return 0; + accum = accum * base + digit; + seenadigit = 1; + } + str++; + } + + if (!seenadigit) return 0; + *out = accum; + return 1; +} + +int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) { + int neg; + uint64_t bi; + if (scan_uint64(str, len, &bi, &neg)) { + if (neg && bi <= ((UINT64_MAX / 2) + 1)) { + if (bi > INT64_MAX) { + *out = INT64_MIN; + } else { + *out = -((int64_t) bi); + } + return 1; + } + if (!neg && bi <= INT64_MAX) { + *out = (int64_t) bi; + return 1; + } + } + return 0; +} + +int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) { + int neg; + uint64_t bi; + if (scan_uint64(str, len, &bi, &neg)) { + if (!neg) { + *out = bi; + return 1; + } + } + return 0; +} + +#endif + + +/* src/core/struct.c */ +#line 0 "src/core/struct.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include +#endif + +/* Begin creation of a struct */ +JanetKV *janet_struct_begin(int32_t count) { + /* Calculate capacity as power of 2 after 2 * count. */ + int32_t capacity = janet_tablen(2 * count); + if (capacity < 0) capacity = janet_tablen(count + 1); + + size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); + JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); + head->length = count; + head->capacity = capacity; + head->hash = 0; + head->proto = NULL; + + JanetKV *st = (JanetKV *)(head->data); + janet_memempty(st, capacity); + return st; +} + +/* Find an item in a struct without looking for prototypes. Should be similar to janet_dict_find, but + * specialized to structs (slightly more compact). */ +const JanetKV *janet_struct_find(const JanetKV *st, Janet key) { + int32_t cap = janet_struct_capacity(st); + int32_t index = janet_maphash(cap, janet_hash(key)); + int32_t i; + for (i = index; i < cap; i++) + if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key)) + return st + i; + for (i = 0; i < index; i++) + if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key)) + return st + i; + return NULL; +} + +/* Put a kv pair into a struct that has not yet been fully constructed. + * Nil keys and values are ignored, extra keys are ignore, and duplicate keys are + * ignored. + * + * Runs will be in sorted order, as the collisions resolver essentially + * preforms an in-place insertion sort. This ensures the internal structure of the + * hash map is independent of insertion order. + */ +void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { + int32_t cap = janet_struct_capacity(st); + int32_t hash = janet_hash(key); + int32_t index = janet_maphash(cap, hash); + int32_t i, j, dist; + int32_t bounds[4] = {index, cap, 0, index}; + if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; + if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; + /* Avoid extra items */ + if (janet_struct_hash(st) == janet_struct_length(st)) return; + for (dist = 0, j = 0; j < 4; j += 2) + for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { + int status; + int32_t otherhash; + int32_t otherindex, otherdist; + JanetKV *kv = st + i; + /* We found an empty slot, so just add key and value */ + if (janet_checktype(kv->key, JANET_NIL)) { + kv->key = key; + kv->value = value; + /* Update the temporary count */ + janet_struct_hash(st)++; + return; + } + /* Robinhood hashing - check if colliding kv pair + * is closer to their source than current. We use robinhood + * hashing to ensure that equivalent structs that are constructed + * with different order have the same internal layout, and therefor + * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. + * Collisions are resolved via an insertion sort insertion. */ + otherhash = janet_hash(kv->key); + otherindex = janet_maphash(cap, otherhash); + otherdist = (i + cap - otherindex) & (cap - 1); + if (dist < otherdist) + status = -1; + else if (otherdist < dist) + status = 1; + else if (hash < otherhash) + status = -1; + else if (otherhash < hash) + status = 1; + else + status = janet_compare(key, kv->key); + /* If other is closer to their ideal slot */ + if (status == 1) { + /* Swap current kv pair with pair in slot */ + JanetKV temp = *kv; + kv->key = key; + kv->value = value; + key = temp.key; + value = temp.value; + /* Save dist and hash of new kv pair */ + dist = otherdist; + hash = otherhash; + } else if (status == 0) { + if (replace) { + /* A key was added to the struct more than once - replace old value */ + kv->value = value; + } + return; + } + } +} + +void janet_struct_put(JanetKV *st, Janet key, Janet value) { + janet_struct_put_ext(st, key, value, 1); +} + +/* Finish building a struct */ +const JanetKV *janet_struct_end(JanetKV *st) { + if (janet_struct_hash(st) != janet_struct_length(st)) { + /* Error building struct, probably duplicate values. We need to rebuild + * the struct using only the values that went in. The second creation should always + * succeed. */ + JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); + for (int32_t i = 0; i < janet_struct_capacity(st); i++) { + JanetKV *kv = st + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_struct_put(newst, kv->key, kv->value); + } + } + janet_struct_proto(newst) = janet_struct_proto(st); + st = newst; + } + janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); + if (janet_struct_proto(st)) { + janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); + } + return (const JanetKV *)st; +} + +/* Get an item from a struct without looking into prototypes. */ +Janet janet_struct_rawget(const JanetKV *st, Janet key) { + const JanetKV *kv = janet_struct_find(st, key); + return kv ? kv->value : janet_wrap_nil(); +} + +/* Get an item from a struct */ +Janet janet_struct_get(const JanetKV *st, Janet key) { + for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) { + const JanetKV *kv = janet_struct_find(st, key); + if (NULL != kv && !janet_checktype(kv->key, JANET_NIL)) { + return kv->value; + } + } + return janet_wrap_nil(); +} + +/* Get an item from a struct, and record which prototype the item came from. */ +Janet janet_struct_get_ex(const JanetKV *st, Janet key, JanetStruct *which) { + for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) { + const JanetKV *kv = janet_struct_find(st, key); + if (NULL != kv && !janet_checktype(kv->key, JANET_NIL)) { + *which = st; + return kv->value; + } + } + return janet_wrap_nil(); +} + +/* Convert struct to table */ +JanetTable *janet_struct_to_table(const JanetKV *st) { + JanetTable *table = janet_table(janet_struct_capacity(st)); + int32_t i; + for (i = 0; i < janet_struct_capacity(st); i++) { + const JanetKV *kv = st + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_table_put(table, kv->key, kv->value); + } + } + return table; +} + +/* C Functions */ + +JANET_CORE_FN(cfun_struct_with_proto, + "(struct/with-proto proto & kvs)", + "Create a structure, as with the usual struct constructor but set the " + "struct prototype as well.") { + janet_arity(argc, 1, -1); + JanetStruct proto = janet_optstruct(argv, argc, 0, NULL); + if (!(argc & 1)) + janet_panic("expected odd number of arguments"); + JanetKV *st = janet_struct_begin(argc / 2); + for (int32_t i = 1; i < argc; i += 2) { + janet_struct_put(st, argv[i], argv[i + 1]); + } + janet_struct_proto(st) = proto; + return janet_wrap_struct(janet_struct_end(st)); +} + +JANET_CORE_FN(cfun_struct_getproto, + "(struct/getproto st)", + "Return the prototype of a struct, or nil if it doesn't have one.") { + janet_fixarity(argc, 1); + JanetStruct st = janet_getstruct(argv, 0); + return janet_struct_proto(st) + ? janet_wrap_struct(janet_struct_proto(st)) + : janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_struct_flatten, + "(struct/proto-flatten st)", + "Convert a struct with prototypes to a struct with no prototypes by merging " + "all key value pairs from recursive prototypes into one new struct.") { + janet_fixarity(argc, 1); + JanetStruct st = janet_getstruct(argv, 0); + + /* get an upper bounds on the number of items in the final struct */ + int64_t pair_count = 0; + JanetStruct cursor = st; + while (cursor) { + pair_count += janet_struct_length(cursor); + cursor = janet_struct_proto(cursor); + } + + if (pair_count > INT32_MAX) { + janet_panic("struct too large"); + } + + JanetKV *accum = janet_struct_begin((int32_t) pair_count); + cursor = st; + while (cursor) { + for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) { + const JanetKV *kv = cursor + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_struct_put_ext(accum, kv->key, kv->value, 0); + } + } + cursor = janet_struct_proto(cursor); + } + return janet_wrap_struct(janet_struct_end(accum)); +} + +JANET_CORE_FN(cfun_struct_to_table, + "(struct/to-table st &opt recursive)", + "Convert a struct to a table. If recursive is true, also convert the " + "table's prototypes into the new struct's prototypes as well.") { + janet_arity(argc, 1, 2); + JanetStruct st = janet_getstruct(argv, 0); + int recursive = argc > 1 && janet_truthy(argv[1]); + JanetTable *tab = NULL; + JanetStruct cursor = st; + JanetTable *tab_cursor = tab; + do { + if (tab) { + tab_cursor->proto = janet_table(janet_struct_length(cursor)); + tab_cursor = tab_cursor->proto; + } else { + tab = janet_table(janet_struct_length(cursor)); + tab_cursor = tab; + } + /* TODO - implement as memcpy since struct memory should be compatible + * with table memory */ + for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) { + const JanetKV *kv = cursor + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_table_put(tab_cursor, kv->key, kv->value); + } + } + cursor = janet_struct_proto(cursor); + } while (recursive && cursor); + return janet_wrap_table(tab); +} + +/* Load the struct module */ +void janet_lib_struct(JanetTable *env) { + JanetRegExt struct_cfuns[] = { + JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), + JANET_CORE_REG("struct/getproto", cfun_struct_getproto), + JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), + JANET_CORE_REG("struct/to-table", cfun_struct_to_table), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, struct_cfuns); +} + + +/* src/core/symcache.c */ +#line 0 "src/core/symcache.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +/* The symbol cache is an open hashtable with all active symbols in the program + * stored in it. As the primary use of symbols is table lookups and equality + * checks, all symbols are interned so that there is a single copy of it in the + * whole program. Equality is then just a pointer check. */ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "gc.h" +#include "util.h" +#include "symcache.h" +#endif + +#include + +/* Initialize the cache (allocate cache memory) */ +void janet_symcache_init() { + janet_vm.cache_capacity = 1024; + janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); + if (NULL == janet_vm.cache) { + JANET_OUT_OF_MEMORY; + } + memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); + janet_vm.gensym_counter[0] = '_'; + janet_vm.cache_count = 0; + janet_vm.cache_deleted = 0; +} + +/* Deinitialize the cache (free the cache memory) */ +void janet_symcache_deinit() { + janet_free((void *)janet_vm.cache); + janet_vm.cache = NULL; + janet_vm.cache_capacity = 0; + janet_vm.cache_count = 0; + janet_vm.cache_deleted = 0; +} + +/* Mark an entry in the table as deleted. */ +static const uint8_t JANET_SYMCACHE_DELETED[1] = {0}; + +/* Find an item in the cache and return its location. + * If the item is not found, return the location + * where one would put it. */ +static const uint8_t **janet_symcache_findmem( + const uint8_t *str, + int32_t len, + int32_t hash, + int *success) { + uint32_t bounds[4]; + uint32_t i, j, index; + const uint8_t **firstEmpty = NULL; + + /* We will search two ranges - index to the end, + * and 0 to the index. */ + index = (uint32_t)hash & (janet_vm.cache_capacity - 1); + bounds[0] = index; + bounds[1] = janet_vm.cache_capacity; + bounds[2] = 0; + bounds[3] = index; + for (j = 0; j < 4; j += 2) + for (i = bounds[j]; i < bounds[j + 1]; ++i) { + const uint8_t *test = janet_vm.cache[i]; + /* Check empty spots */ + if (NULL == test) { + if (NULL == firstEmpty) + firstEmpty = janet_vm.cache + i; + goto notfound; + } + /* Check for marked deleted */ + if (JANET_SYMCACHE_DELETED == test) { + if (firstEmpty == NULL) + firstEmpty = janet_vm.cache + i; + continue; + } + if (janet_string_equalconst(test, str, len, hash)) { + /* Replace first deleted */ + *success = 1; + if (firstEmpty != NULL) { + *firstEmpty = test; + janet_vm.cache[i] = JANET_SYMCACHE_DELETED; + return firstEmpty; + } + return janet_vm.cache + i; + } + } +notfound: + *success = 0; + janet_assert(firstEmpty != NULL, "symcache failed to get memory"); + return firstEmpty; +} + +#define janet_symcache_find(str, success) \ + janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) + +/* Resize the cache. */ +static void janet_cache_resize(uint32_t newCapacity) { + uint32_t i, oldCapacity; + const uint8_t **oldCache = janet_vm.cache; + const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); + if (newCache == NULL) { + JANET_OUT_OF_MEMORY; + } + oldCapacity = janet_vm.cache_capacity; + janet_vm.cache = newCache; + janet_vm.cache_capacity = newCapacity; + janet_vm.cache_deleted = 0; + /* Add all of the old cache entries back */ + for (i = 0; i < oldCapacity; ++i) { + int status; + const uint8_t **bucket; + const uint8_t *x = oldCache[i]; + if (x != NULL && x != JANET_SYMCACHE_DELETED) { + bucket = janet_symcache_find(x, &status); + if (status || bucket == NULL) { + /* there was a problem with the algorithm. */ + break; + } + *bucket = x; + } + } + /* Free the old cache */ + janet_free((void *)oldCache); +} + +/* Add an item to the cache */ +static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { + if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { + int status; + janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); + bucket = janet_symcache_find(x, &status); + } + /* Add x to the cache */ + janet_vm.cache_count++; + *bucket = x; +} + +/* Remove a symbol from the symcache */ +void janet_symbol_deinit(const uint8_t *sym) { + int status = 0; + const uint8_t **bucket = janet_symcache_find(sym, &status); + if (status) { + janet_vm.cache_count--; + janet_vm.cache_deleted++; + *bucket = JANET_SYMCACHE_DELETED; + } +} + +/* Create a symbol from a byte string */ +const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { + int32_t hash = janet_string_calchash(str, len); + uint8_t *newstr; + int success = 0; + const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); + if (success) + return *bucket; + JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); + head->hash = hash; + head->length = len; + newstr = (uint8_t *)(head->data); + safe_memcpy(newstr, str, len); + newstr[len] = 0; + janet_symcache_put((const uint8_t *)newstr, bucket); + return newstr; +} + +/* Get a symbol from a cstring */ +const uint8_t *janet_csymbol(const char *cstr) { + return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); +} + +/* Increment the gensym buffer */ +static void inc_gensym(void) { + for (int i = sizeof(janet_vm.gensym_counter) - 2; i; i--) { + if (janet_vm.gensym_counter[i] == '9') { + janet_vm.gensym_counter[i] = 'a'; + break; + } else if (janet_vm.gensym_counter[i] == 'z') { + janet_vm.gensym_counter[i] = 'A'; + break; + } else if (janet_vm.gensym_counter[i] == 'Z') { + janet_vm.gensym_counter[i] = '0'; + } else { + janet_vm.gensym_counter[i]++; + break; + } + } +} + +/* Generate a unique symbol. This is used in the library function gensym. The + * symbol will be of the format _XXXXXX, where X is a base64 digit, and + * prefix is the argument passed. No prefix for speed. */ +const uint8_t *janet_symbol_gen(void) { + const uint8_t **bucket = NULL; + uint8_t *sym; + int32_t hash = 0; + int status; + /* Leave spaces for 6 base 64 digits and two dashes. That means 64^6 possible suffixes, which + * is enough for resolving collisions. */ + do { + hash = janet_string_calchash( + janet_vm.gensym_counter, + sizeof(janet_vm.gensym_counter) - 1); + bucket = janet_symcache_findmem( + janet_vm.gensym_counter, + sizeof(janet_vm.gensym_counter) - 1, + hash, + &status); + } while (status && (inc_gensym(), 1)); + JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + sizeof(janet_vm.gensym_counter)); + head->length = sizeof(janet_vm.gensym_counter) - 1; + head->hash = hash; + sym = (uint8_t *)(head->data); + memcpy(sym, janet_vm.gensym_counter, sizeof(janet_vm.gensym_counter)); + sym[head->length] = 0; + janet_symcache_put((const uint8_t *)sym, bucket); + return (const uint8_t *)sym; +} + + +/* src/core/table.c */ +#line 0 "src/core/table.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "gc.h" +#include "util.h" +#include +#endif + +#define JANET_TABLE_FLAG_STACK 0x10000 + +static void *janet_memalloc_empty_local(int32_t count) { + int32_t i; + void *mem = janet_smalloc((size_t) count * sizeof(JanetKV)); + JanetKV *mmem = (JanetKV *)mem; + for (i = 0; i < count; i++) { + JanetKV *kv = mmem + i; + kv->key = janet_wrap_nil(); + kv->value = janet_wrap_nil(); + } + return mem; +} + +static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { + JanetKV *data; + capacity = janet_tablen(capacity); + if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; + if (capacity) { + if (stackalloc) { + data = janet_memalloc_empty_local(capacity); + } else { + data = (JanetKV *) janet_memalloc_empty(capacity); + if (NULL == data) { + JANET_OUT_OF_MEMORY; + } + } + table->data = data; + table->capacity = capacity; + } else { + table->data = NULL; + table->capacity = 0; + } + table->count = 0; + table->deleted = 0; + table->proto = NULL; + return table; +} + +/* Initialize a table (for use withs scratch memory) */ +JanetTable *janet_table_init(JanetTable *table, int32_t capacity) { + return janet_table_init_impl(table, capacity, 1); +} + +/* Initialize a table without using scratch memory */ +JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { + return janet_table_init_impl(table, capacity, 0); +} + +/* Deinitialize a table */ +void janet_table_deinit(JanetTable *table) { + if (table->gc.flags & JANET_TABLE_FLAG_STACK) { + janet_sfree(table->data); + } else { + janet_free(table->data); + } +} + +/* Create a new table */ + +JanetTable *janet_table(int32_t capacity) { + JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); + return janet_table_init_impl(table, capacity, 0); +} + +JanetTable *janet_table_weakk(int32_t capacity) { + JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable)); + return janet_table_init_impl(table, capacity, 0); +} + +JanetTable *janet_table_weakv(int32_t capacity) { + JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable)); + return janet_table_init_impl(table, capacity, 0); +} + +JanetTable *janet_table_weakkv(int32_t capacity) { + JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable)); + return janet_table_init_impl(table, capacity, 0); +} + +/* Find the bucket that contains the given key. Will also return + * bucket where key should go if not in the table. */ +JanetKV *janet_table_find(JanetTable *t, Janet key) { + return (JanetKV *) janet_dict_find(t->data, t->capacity, key); +} + +/* Resize the dictionary table. */ +static void janet_table_rehash(JanetTable *t, int32_t size) { + JanetKV *olddata = t->data; + JanetKV *newdata; + int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; + if (islocal) { + newdata = (JanetKV *) janet_memalloc_empty_local(size); + } else { + newdata = (JanetKV *) janet_memalloc_empty(size); + if (NULL == newdata) { + JANET_OUT_OF_MEMORY; + } + } + int32_t oldcapacity = t->capacity; + t->data = newdata; + t->capacity = size; + t->deleted = 0; + for (int32_t i = 0; i < oldcapacity; i++) { + JanetKV *kv = olddata + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + JanetKV *newkv = janet_table_find(t, kv->key); + *newkv = *kv; + } + } + if (islocal) { + janet_sfree(olddata); + } else { + janet_free(olddata); + } +} + +/* Get a value out of the table */ +Janet janet_table_get(JanetTable *t, Janet key) { + for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) + return bucket->value; + } + return janet_wrap_nil(); +} + +/* Get a value out of the table, and record which prototype it was from. */ +Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which) { + for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { + *which = t; + return bucket->value; + } + } + return janet_wrap_nil(); +} + +/* Get a value out of the table. Don't check prototype tables. */ +Janet janet_table_rawget(JanetTable *t, Janet key) { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) + return bucket->value; + else + return janet_wrap_nil(); +} + +/* Remove an entry from the dictionary. Return the value that + * was removed. */ +Janet janet_table_remove(JanetTable *t, Janet key) { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { + Janet ret = bucket->value; + t->count--; + t->deleted++; + bucket->key = janet_wrap_nil(); + bucket->value = janet_wrap_false(); + return ret; + } else { + return janet_wrap_nil(); + } +} + +/* Put a value into the object */ +void janet_table_put(JanetTable *t, Janet key, Janet value) { + if (janet_checktype(key, JANET_NIL)) return; + if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; + if (janet_checktype(value, JANET_NIL)) { + janet_table_remove(t, key); + } else { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { + bucket->value = value; + } else { + if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { + janet_table_rehash(t, janet_tablen(2 * t->count + 2)); + } + bucket = janet_table_find(t, key); + if (janet_checktype(bucket->value, JANET_BOOLEAN)) + --t->deleted; + bucket->key = key; + bucket->value = value; + ++t->count; + } + } +} + +/* Used internally so don't check arguments + * Put into a table, but if the key already exists do nothing. */ +static void janet_table_put_no_overwrite(JanetTable *t, Janet key, Janet value) { + JanetKV *bucket = janet_table_find(t, key); + if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) + return; + if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { + janet_table_rehash(t, janet_tablen(2 * t->count + 2)); + } + bucket = janet_table_find(t, key); + if (janet_checktype(bucket->value, JANET_BOOLEAN)) + --t->deleted; + bucket->key = key; + bucket->value = value; + ++t->count; +} + +/* Clear a table */ +void janet_table_clear(JanetTable *t) { + int32_t capacity = t->capacity; + JanetKV *data = t->data; + janet_memempty(data, capacity); + t->count = 0; + t->deleted = 0; +} + +/* Clone a table. */ +JanetTable *janet_table_clone(JanetTable *table) { + JanetTable *newTable = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); + newTable->count = table->count; + newTable->capacity = table->capacity; + newTable->deleted = table->deleted; + newTable->proto = table->proto; + newTable->data = janet_malloc(newTable->capacity * sizeof(JanetKV)); + if (NULL == newTable->data) { + JANET_OUT_OF_MEMORY; + } + memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV)); + return newTable; +} + +/* Merge a table or struct into a table */ +static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t cap) { + int32_t i; + for (i = 0; i < cap; i++) { + const JanetKV *kv = kvs + i; + if (!janet_checktype(kv->key, JANET_NIL)) { + janet_table_put(table, kv->key, kv->value); + } + } +} + +/* Merge a table into another table */ +void janet_table_merge_table(JanetTable *table, JanetTable *other) { + janet_table_mergekv(table, other->data, other->capacity); +} + +/* Merge a struct into a table */ +void janet_table_merge_struct(JanetTable *table, const JanetKV *other) { + janet_table_mergekv(table, other, janet_struct_capacity(other)); +} + +/* Convert table to struct */ +const JanetKV *janet_table_to_struct(JanetTable *t) { + JanetKV *st = janet_struct_begin(t->count); + JanetKV *kv = t->data; + JanetKV *end = t->data + t->capacity; + while (kv < end) { + if (!janet_checktype(kv->key, JANET_NIL)) + janet_struct_put(st, kv->key, kv->value); + kv++; + } + return janet_struct_end(st); +} + +JanetTable *janet_table_proto_flatten(JanetTable *t) { + JanetTable *newTable = janet_table(0); + while (t) { + JanetKV *kv = t->data; + JanetKV *end = t->data + t->capacity; + while (kv < end) { + if (!janet_checktype(kv->key, JANET_NIL)) + janet_table_put_no_overwrite(newTable, kv->key, kv->value); + kv++; + } + t = t->proto; + } + return newTable; +} + +/* C Functions */ + +JANET_CORE_FN(cfun_table_new, + "(table/new capacity)", + "Creates a new empty table with pre-allocated memory " + "for `capacity` entries. This means that if one knows the number of " + "entries going into a table on creation, extra memory allocation " + "can be avoided. " + "Returns the new table.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getnat(argv, 0); + return janet_wrap_table(janet_table(cap)); +} +/* + uint32_t flags = janet_getflags(argv, 1, "kv"); + if (flags == 0) return janet_wrap_table(janet_table(cap)); + if (flags == 1) return janet_wrap_table(janet_table_weakk(cap)); + if (flags == 2) return janet_wrap_table(janet_table_weakv(cap)); + return janet_wrap_table(janet_table_weakkv(cap)); + */ + +JANET_CORE_FN(cfun_table_weak, + "(table/weak capacity)", + "Creates a new empty table with weak references to keys and values. Similar to `table/new`. " + "Returns the new table.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getnat(argv, 0); + return janet_wrap_table(janet_table_weakkv(cap)); +} + +JANET_CORE_FN(cfun_table_weak_keys, + "(table/weak-keys capacity)", + "Creates a new empty table with weak references to keys and normal references to values. Similar to `table/new`. " + "Returns the new table.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getnat(argv, 0); + return janet_wrap_table(janet_table_weakk(cap)); +} + +JANET_CORE_FN(cfun_table_weak_values, + "(table/weak-values capacity)", + "Creates a new empty table with normal references to keys and weak references to values. Similar to `table/new`. " + "Returns the new table.") { + janet_fixarity(argc, 1); + int32_t cap = janet_getnat(argv, 0); + return janet_wrap_table(janet_table_weakv(cap)); +} + +JANET_CORE_FN(cfun_table_getproto, + "(table/getproto tab)", + "Get the prototype table of a table. Returns nil if the table " + "has no prototype, otherwise returns the prototype.") { + janet_fixarity(argc, 1); + JanetTable *t = janet_gettable(argv, 0); + return t->proto + ? janet_wrap_table(t->proto) + : janet_wrap_nil(); +} + +JANET_CORE_FN(cfun_table_setproto, + "(table/setproto tab proto)", + "Set the prototype of a table. Returns the original table `tab`.") { + janet_fixarity(argc, 2); + JanetTable *table = janet_gettable(argv, 0); + JanetTable *proto = NULL; + if (!janet_checktype(argv[1], JANET_NIL)) { + proto = janet_gettable(argv, 1); + } + table->proto = proto; + return argv[0]; +} + +JANET_CORE_FN(cfun_table_tostruct, + "(table/to-struct tab)", + "Convert a table to a struct. Returns a new struct. This function " + "does not take into account prototype tables.") { + janet_fixarity(argc, 1); + JanetTable *t = janet_gettable(argv, 0); + return janet_wrap_struct(janet_table_to_struct(t)); +} + +JANET_CORE_FN(cfun_table_rawget, + "(table/rawget tab key)", + "Gets a value from a table `tab` without looking at the prototype table. " + "If `tab` does not contain the key directly, the function will return " + "nil without checking the prototype. Returns the value in the table.") { + janet_fixarity(argc, 2); + JanetTable *table = janet_gettable(argv, 0); + return janet_table_rawget(table, argv[1]); +} + +JANET_CORE_FN(cfun_table_clone, + "(table/clone tab)", + "Create a copy of a table. Updates to the new table will not change the old table, " + "and vice versa.") { + janet_fixarity(argc, 1); + JanetTable *table = janet_gettable(argv, 0); + return janet_wrap_table(janet_table_clone(table)); +} + +JANET_CORE_FN(cfun_table_clear, + "(table/clear tab)", + "Remove all key-value pairs in a table and return the modified table `tab`.") { + janet_fixarity(argc, 1); + JanetTable *table = janet_gettable(argv, 0); + janet_table_clear(table); + return janet_wrap_table(table); +} + +JANET_CORE_FN(cfun_table_proto_flatten, + "(table/proto-flatten tab)", + "Create a new table that is the result of merging all prototypes into a new table.") { + janet_fixarity(argc, 1); + JanetTable *table = janet_gettable(argv, 0); + return janet_wrap_table(janet_table_proto_flatten(table)); +} + +/* Load the table module */ +void janet_lib_table(JanetTable *env) { + JanetRegExt table_cfuns[] = { + JANET_CORE_REG("table/new", cfun_table_new), + JANET_CORE_REG("table/weak", cfun_table_weak), + JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), + JANET_CORE_REG("table/weak-values", cfun_table_weak_values), + JANET_CORE_REG("table/to-struct", cfun_table_tostruct), + JANET_CORE_REG("table/getproto", cfun_table_getproto), + JANET_CORE_REG("table/setproto", cfun_table_setproto), + JANET_CORE_REG("table/rawget", cfun_table_rawget), + JANET_CORE_REG("table/clone", cfun_table_clone), + JANET_CORE_REG("table/clear", cfun_table_clear), + JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, table_cfuns); +} + + +/* src/core/tuple.c */ +#line 0 "src/core/tuple.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "symcache.h" +#include "gc.h" +#include "util.h" +#endif + +/* Create a new empty tuple of the given size. This will return memory + * which should be filled with Janets. The memory will not be collected until + * janet_tuple_end is called. */ +Janet *janet_tuple_begin(int32_t length) { + size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); + JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); + head->sm_line = -1; + head->sm_column = -1; + head->length = length; + return (Janet *)(head->data); +} + +/* Finish building a tuple */ +const Janet *janet_tuple_end(Janet *tuple) { + janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); + return (const Janet *)tuple; +} + +/* Build a tuple with n values */ +const Janet *janet_tuple_n(const Janet *values, int32_t n) { + Janet *t = janet_tuple_begin(n); + safe_memcpy(t, values, sizeof(Janet) * n); + return janet_tuple_end(t); +} + +/* C Functions */ + +JANET_CORE_FN(cfun_tuple_brackets, + "(tuple/brackets & xs)", + "Creates a new bracketed tuple containing the elements xs.") { + const Janet *tup = janet_tuple_n(argv, argc); + janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; + return janet_wrap_tuple(tup); +} + +JANET_CORE_FN(cfun_tuple_slice, + "(tuple/slice arrtup [,start=0 [,end=(length arrtup)]])", + "Take a sub-sequence of an array or tuple from index `start` " + "inclusive to index `end` exclusive. If `start` or `end` are not provided, " + "they default to 0 and the length of `arrtup`, respectively. " + "`start` and `end` can also be negative to indicate indexing " + "from the end of the input. Note that if `start` is negative it is " + "exclusive, and if `end` is negative it is inclusive, to allow a full " + "negative slice range. Returns the new tuple.") { + JanetView view = janet_getindexed(argv, 0); + JanetRange range = janet_getslice(argc, argv); + return janet_wrap_tuple(janet_tuple_n(view.items + range.start, range.end - range.start)); +} + +JANET_CORE_FN(cfun_tuple_type, + "(tuple/type tup)", + "Checks how the tuple was constructed. Will return the keyword " + ":brackets if the tuple was parsed with brackets, and :parens " + "otherwise. The two types of tuples will behave the same most of " + "the time, but will print differently and be treated differently by " + "the compiler.") { + janet_fixarity(argc, 1); + const Janet *tup = janet_gettuple(argv, 0); + if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { + return janet_ckeywordv("brackets"); + } else { + return janet_ckeywordv("parens"); + } +} + +JANET_CORE_FN(cfun_tuple_sourcemap, + "(tuple/sourcemap tup)", + "Returns the sourcemap metadata attached to a tuple, " + "which is another tuple (line, column).") { + janet_fixarity(argc, 1); + const Janet *tup = janet_gettuple(argv, 0); + Janet contents[2]; + contents[0] = janet_wrap_integer(janet_tuple_head(tup)->sm_line); + contents[1] = janet_wrap_integer(janet_tuple_head(tup)->sm_column); + return janet_wrap_tuple(janet_tuple_n(contents, 2)); +} + +JANET_CORE_FN(cfun_tuple_setmap, + "(tuple/setmap tup line column)", + "Set the sourcemap metadata on a tuple. line and column indicate " + "should be integers.") { + janet_fixarity(argc, 3); + const Janet *tup = janet_gettuple(argv, 0); + janet_tuple_head(tup)->sm_line = janet_getinteger(argv, 1); + janet_tuple_head(tup)->sm_column = janet_getinteger(argv, 2); + return argv[0]; +} + +/* Load the tuple module */ +void janet_lib_tuple(JanetTable *env) { + JanetRegExt tuple_cfuns[] = { + JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), + JANET_CORE_REG("tuple/slice", cfun_tuple_slice), + JANET_CORE_REG("tuple/type", cfun_tuple_type), + JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), + JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), + JANET_REG_END + }; + janet_core_cfuns_ext(env, NULL, tuple_cfuns); +} + + +/* src/core/util.c */ +#line 0 "src/core/util.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "util.h" +#include "state.h" +#include "gc.h" +#ifdef JANET_WINDOWS +#include +#else +#include +#include +#include +#include +#endif +#endif + +#ifdef JANET_WINDOWS +#ifdef JANET_DYNAMIC_MODULES +#include +#ifdef JANET_MSVC +#pragma comment (lib, "Psapi.lib") +#endif +#endif +#endif + +#ifdef JANET_APPLE +#include +#endif + +#include + +/* Base 64 lookup table for digits */ +const char janet_base64[65] = + "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "_="; + +/* The JANET value types in order. These types can be used as + * mnemonics instead of a bit pattern for type checking */ +const char *const janet_type_names[16] = { + "number", + "nil", + "boolean", + "fiber", + "string", + "symbol", + "keyword", + "array", + "tuple", + "table", + "struct", + "buffer", + "function", + "cfunction", + "abstract", + "pointer" +}; + +const char *const janet_signal_names[14] = { + "ok", + "error", + "debug", + "yield", + "user0", + "user1", + "user2", + "user3", + "user4", + "user5", + "user6", + "user7", + "interrupt", + "await" +}; + +const char *const janet_status_names[16] = { + "dead", + "error", + "debug", + "pending", + "user0", + "user1", + "user2", + "user3", + "user4", + "user5", + "user6", + "user7", + "interrupted", + "suspended", + "new", + "alive" +}; + +#ifndef JANET_PRF + +int32_t janet_string_calchash(const uint8_t *str, int32_t len) { + if (NULL == str) return 5381; + const uint8_t *end = str + len; + uint32_t hash = 5381; + while (str < end) + hash = (hash << 5) + hash + *str++; + return (int32_t) hash; +} + +#else + +/* + Public domain siphash implementation sourced from: + + https://raw.githubusercontent.com/veorq/SipHash/master/halfsiphash.c + + We have made a few alterations, such as hardcoding the output size + and then removing dead code. +*/ +#define cROUNDS 2 +#define dROUNDS 4 + +#define ROTL(x, b) (uint32_t)(((x) << (b)) | ((x) >> (32 - (b)))) + +#define U8TO32_LE(p) \ + (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ + ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) + +#define SIPROUND \ + do { \ + v0 += v1; \ + v1 = ROTL(v1, 5); \ + v1 ^= v0; \ + v0 = ROTL(v0, 16); \ + v2 += v3; \ + v3 = ROTL(v3, 8); \ + v3 ^= v2; \ + v0 += v3; \ + v3 = ROTL(v3, 7); \ + v3 ^= v0; \ + v2 += v1; \ + v1 = ROTL(v1, 13); \ + v1 ^= v2; \ + v2 = ROTL(v2, 16); \ + } while (0) + +static uint32_t halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k) { + + uint32_t v0 = 0; + uint32_t v1 = 0; + uint32_t v2 = UINT32_C(0x6c796765); + uint32_t v3 = UINT32_C(0x74656462); + uint32_t k0 = U8TO32_LE(k); + uint32_t k1 = U8TO32_LE(k + 4); + uint32_t m; + int i; + const uint8_t *end = in + inlen - (inlen % sizeof(uint32_t)); + const int left = inlen & 3; + uint32_t b = ((uint32_t)inlen) << 24; + v3 ^= k1; + v2 ^= k0; + v1 ^= k1; + v0 ^= k0; + + for (; in != end; in += 4) { + m = U8TO32_LE(in); + v3 ^= m; + + for (i = 0; i < cROUNDS; ++i) + SIPROUND; + + v0 ^= m; + } + + switch (left) { + case 3: + b |= ((uint32_t)in[2]) << 16; + /* fallthrough */ + case 2: + b |= ((uint32_t)in[1]) << 8; + /* fallthrough */ + case 1: + b |= ((uint32_t)in[0]); + break; + case 0: + break; + } + + v3 ^= b; + + for (i = 0; i < cROUNDS; ++i) + SIPROUND; + + v0 ^= b; + + v2 ^= 0xff; + + for (i = 0; i < dROUNDS; ++i) + SIPROUND; + + b = v1 ^ v3; + return b; +} +/* end of siphash */ + +static uint8_t hash_key[JANET_HASH_KEY_SIZE] = {0}; + +void janet_init_hash_key(uint8_t new_key[JANET_HASH_KEY_SIZE]) { + memcpy(hash_key, new_key, sizeof(hash_key)); +} + +/* Calculate hash for string */ + +int32_t janet_string_calchash(const uint8_t *str, int32_t len) { + uint32_t hash; + hash = halfsiphash(str, len, hash_key); + return (int32_t)hash; +} + +#endif + +uint32_t janet_hash_mix(uint32_t input, uint32_t more) { + uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); + return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); +} + +/* Computes hash of an array of values */ +int32_t janet_array_calchash(const Janet *array, int32_t len) { + const Janet *end = array + len; + uint32_t hash = 33; + while (array < end) { + hash = janet_hash_mix(hash, janet_hash(*array++)); + } + return (int32_t) hash; +} + +/* Computes hash of an array of values */ +int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { + const JanetKV *end = kvs + len; + uint32_t hash = 33; + while (kvs < end) { + hash = janet_hash_mix(hash, janet_hash(kvs->key)); + hash = janet_hash_mix(hash, janet_hash(kvs->value)); + kvs++; + } + return (int32_t) hash; +} + +/* Calculate next power of 2. May overflow. If n is 0, + * will return 0. */ +int32_t janet_tablen(int32_t n) { + if (n < 0) return 0; + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + return n + 1; +} + +/* Avoid some undefined behavior that was common in the code base. */ +void safe_memcpy(void *dest, const void *src, size_t len) { + if (!len) return; + memcpy(dest, src, len); +} + +/* Helper to find a value in a Janet struct or table. Returns the bucket + * containing the key, or the first empty bucket if there is no such key. */ +const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { + int32_t index = janet_maphash(cap, janet_hash(key)); + int32_t i; + const JanetKV *first_bucket = NULL; + /* Higher half */ + for (i = index; i < cap; i++) { + const JanetKV *kv = buckets + i; + if (janet_checktype(kv->key, JANET_NIL)) { + if (janet_checktype(kv->value, JANET_NIL)) { + return kv; + } else if (NULL == first_bucket) { + first_bucket = kv; + } + } else if (janet_equals(kv->key, key)) { + return buckets + i; + } + } + /* Lower half */ + for (i = 0; i < index; i++) { + const JanetKV *kv = buckets + i; + if (janet_checktype(kv->key, JANET_NIL)) { + if (janet_checktype(kv->value, JANET_NIL)) { + return kv; + } else if (NULL == first_bucket) { + first_bucket = kv; + } + } else if (janet_equals(kv->key, key)) { + return buckets + i; + } + } + return first_bucket; +} + +/* Get a value from a janet struct or table. */ +Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) { + const JanetKV *kv = janet_dict_find(data, cap, key); + if (kv && !janet_checktype(kv->key, JANET_NIL)) { + return kv->value; + } + return janet_wrap_nil(); +} + +/* Iterate through a struct or dictionary generically */ +const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv) { + const JanetKV *end = kvs + cap; + kv = (kv == NULL) ? kvs : kv + 1; + while (kv < end) { + if (!janet_checktype(kv->key, JANET_NIL)) + return kv; + kv++; + } + return NULL; +} + +/* Compare a janet string with a cstring. More efficient than loading + * c string as a janet string. */ +int janet_cstrcmp(const uint8_t *str, const char *other) { + int32_t len = janet_string_length(str); + int32_t index; + for (index = 0; index < len; index++) { + uint8_t c = str[index]; + uint8_t k = ((const uint8_t *)other)[index]; + if (c < k) return -1; + if (c > k) return 1; + if (k == '\0') break; + } + return (other[index] == '\0') ? 0 : -1; +} + +/* Do a binary search on a static array of structs. Each struct must + * have a string as its first element, and the struct must be sorted + * lexicographically by that element. */ +const void *janet_strbinsearch( + const void *tab, + size_t tabcount, + size_t itemsize, + const uint8_t *key) { + size_t low = 0; + size_t hi = tabcount; + const char *t = (const char *)tab; + while (low < hi) { + size_t mid = low + ((hi - low) / 2); + const char **item = (const char **)(t + mid * itemsize); + const char *name = *item; + int comp = janet_cstrcmp(key, name); + if (comp < 0) { + hi = mid; + } else if (comp > 0) { + low = mid + 1; + } else { + return (const void *)item; + } + } + return NULL; +} + +/* Add sourcemapping and documentation to a binding table */ +static void janet_add_meta(JanetTable *table, const char *doc, const char *source_file, int32_t source_line) { + if (doc) { + janet_table_put(table, janet_ckeywordv("doc"), janet_cstringv(doc)); + } + if (source_file && source_line) { + Janet triple[3]; + triple[0] = janet_cstringv(source_file); + triple[1] = janet_wrap_integer(source_line); + triple[2] = janet_wrap_integer(1); + Janet value = janet_wrap_tuple(janet_tuple_n(triple, 3)); + janet_table_put(table, janet_ckeywordv("source-map"), value); + } +} + +/* Add a def to an environment */ +void janet_def_sm(JanetTable *env, const char *name, Janet val, const char *doc, const char *source_file, int32_t source_line) { + JanetTable *subt = janet_table(2); + janet_table_put(subt, janet_ckeywordv("value"), val); + janet_add_meta(subt, doc, source_file, source_line); + janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt)); +} +void janet_def(JanetTable *env, const char *name, Janet value, const char *doc) { + janet_def_sm(env, name, value, doc, NULL, 0); +} + +/* Add a var to the environment */ +void janet_var_sm(JanetTable *env, const char *name, Janet val, const char *doc, const char *source_file, int32_t source_line) { + JanetArray *array = janet_array(1); + JanetTable *subt = janet_table(2); + janet_array_push(array, val); + janet_table_put(subt, janet_ckeywordv("ref"), janet_wrap_array(array)); + janet_add_meta(subt, doc, source_file, source_line); + janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt)); +} +void janet_var(JanetTable *env, const char *name, Janet val, const char *doc) { + janet_var_sm(env, name, val, doc, NULL, 0); +} + +/* Registry functions */ + +/* Put the registry in sorted order. */ +static void janet_registry_sort(void) { + for (size_t i = 1; i < janet_vm.registry_count; i++) { + JanetCFunRegistry reg = janet_vm.registry[i]; + size_t j; + for (j = i; j > 0; j--) { + if ((void *)(janet_vm.registry[j - 1].cfun) < (void *)(reg.cfun)) break; + janet_vm.registry[j] = janet_vm.registry[j - 1]; + } + janet_vm.registry[j] = reg; + } + janet_vm.registry_dirty = 0; +} + +void janet_registry_put( + JanetCFunction key, + const char *name, + const char *name_prefix, + const char *source_file, + int32_t source_line) { + if (janet_vm.registry_count == janet_vm.registry_cap) { + size_t newcap = (janet_vm.registry_count + 1) * 2; + /* Size it nicely with core by default */ + if (newcap < 512) { + newcap = 512; + } + void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); + if (NULL == newmem) { + JANET_OUT_OF_MEMORY; + } + janet_vm.registry = newmem; + janet_vm.registry_cap = newcap; + } + JanetCFunRegistry value = { + key, + name, + name_prefix, + source_file, + source_line + }; + janet_vm.registry[janet_vm.registry_count++] = value; + janet_vm.registry_dirty = 1; +} + +JanetCFunRegistry *janet_registry_get(JanetCFunction key) { + if (janet_vm.registry_dirty) { + janet_registry_sort(); + } + for (size_t i = 0; i < janet_vm.registry_count; i++) { + if (janet_vm.registry[i].cfun == key) { + return janet_vm.registry + i; + } + } + JanetCFunRegistry *lo = janet_vm.registry; + JanetCFunRegistry *hi = lo + janet_vm.registry_count; + while (lo < hi) { + JanetCFunRegistry *mid = lo + (hi - lo) / 2; + if (mid->cfun == key) { + return mid; + } + if ((void *)(mid->cfun) > (void *)(key)) { + hi = mid; + } else { + lo = mid + 1; + } + } + return NULL; +} + +typedef struct { + char *buf; + size_t plen; +} NameBuf; + +static void namebuf_init(NameBuf *namebuf, const char *prefix) { + size_t plen = strlen(prefix); + namebuf->plen = plen; + namebuf->buf = janet_smalloc(namebuf->plen + 256); + if (NULL == namebuf->buf) { + JANET_OUT_OF_MEMORY; + } + memcpy(namebuf->buf, prefix, plen); + namebuf->buf[plen] = '/'; +} + +static void namebuf_deinit(NameBuf *namebuf) { + janet_sfree(namebuf->buf); +} + +static char *namebuf_name(NameBuf *namebuf, const char *suffix) { + size_t slen = strlen(suffix); + namebuf->buf = janet_srealloc(namebuf->buf, namebuf->plen + 2 + slen); + if (NULL == namebuf->buf) { + JANET_OUT_OF_MEMORY; + } + memcpy(namebuf->buf + namebuf->plen + 1, suffix, slen); + namebuf->buf[namebuf->plen + 1 + slen] = '\0'; + return (char *)(namebuf->buf); +} + +void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) { + while (cfuns->name) { + Janet fun = janet_wrap_cfunction(cfuns->cfun); + if (env) janet_def(env, cfuns->name, fun, cfuns->documentation); + janet_registry_put(cfuns->cfun, cfuns->name, regprefix, NULL, 0); + cfuns++; + } +} + +void janet_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { + while (cfuns->name) { + Janet fun = janet_wrap_cfunction(cfuns->cfun); + if (env) janet_def_sm(env, cfuns->name, fun, cfuns->documentation, cfuns->source_file, cfuns->source_line); + janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); + cfuns++; + } +} + +void janet_cfuns_prefix(JanetTable *env, const char *regprefix, const JanetReg *cfuns) { + NameBuf nb; + if (env) namebuf_init(&nb, regprefix); + while (cfuns->name) { + Janet fun = janet_wrap_cfunction(cfuns->cfun); + if (env) janet_def(env, namebuf_name(&nb, cfuns->name), fun, cfuns->documentation); + janet_registry_put(cfuns->cfun, cfuns->name, regprefix, NULL, 0); + cfuns++; + } + if (env) namebuf_deinit(&nb); +} + +void janet_cfuns_ext_prefix(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { + NameBuf nb; + if (env) namebuf_init(&nb, regprefix); + while (cfuns->name) { + Janet fun = janet_wrap_cfunction(cfuns->cfun); + if (env) janet_def_sm(env, namebuf_name(&nb, cfuns->name), fun, cfuns->documentation, cfuns->source_file, cfuns->source_line); + janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); + cfuns++; + } + if (env) namebuf_deinit(&nb); +} + +/* Register a value in the global registry */ +void janet_register(const char *name, JanetCFunction cfun) { + janet_registry_put(cfun, name, NULL, NULL, 0); +} + +/* Abstract type introspection */ + +void janet_register_abstract_type(const JanetAbstractType *at) { + Janet sym = janet_csymbolv(at->name); + Janet check = janet_table_get(janet_vm.abstract_registry, sym); + if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { + janet_panicf("cannot register abstract type %s, " + "a type with the same name exists", at->name); + } + janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); +} + +const JanetAbstractType *janet_get_abstract_type(Janet key) { + Janet wrapped = janet_table_get(janet_vm.abstract_registry, key); + if (janet_checktype(wrapped, JANET_NIL)) { + return NULL; + } + return (JanetAbstractType *)(janet_unwrap_pointer(wrapped)); +} + +#ifndef JANET_BOOTSTRAP +void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { + (void) sf; + (void) sl; + (void) p; + Janet key = janet_csymbolv(name); + janet_table_put(env, key, x); + if (janet_checktype(x, JANET_CFUNCTION)) { + janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0); + } +} + +void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { + (void) regprefix; + while (cfuns->name) { + Janet fun = janet_wrap_cfunction(cfuns->cfun); + janet_table_put(env, janet_csymbolv(cfuns->name), fun); + janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); + cfuns++; + } +} +#endif + +JanetBinding janet_binding_from_entry(Janet entry) { + JanetTable *entry_table; + JanetBinding binding = { + JANET_BINDING_NONE, + janet_wrap_nil(), + JANET_BINDING_DEP_NONE + }; + + /* Check environment for entry */ + if (!janet_checktype(entry, JANET_TABLE)) + return binding; + entry_table = janet_unwrap_table(entry); + + /* deprecation check */ + Janet deprecate = janet_table_get(entry_table, janet_ckeywordv("deprecated")); + if (janet_checktype(deprecate, JANET_KEYWORD)) { + JanetKeyword depkw = janet_unwrap_keyword(deprecate); + if (!janet_cstrcmp(depkw, "relaxed")) { + binding.deprecation = JANET_BINDING_DEP_RELAXED; + } else if (!janet_cstrcmp(depkw, "normal")) { + binding.deprecation = JANET_BINDING_DEP_NORMAL; + } else if (!janet_cstrcmp(depkw, "strict")) { + binding.deprecation = JANET_BINDING_DEP_STRICT; + } + } else if (!janet_checktype(deprecate, JANET_NIL)) { + binding.deprecation = JANET_BINDING_DEP_NORMAL; + } + + int macro = janet_truthy(janet_table_get(entry_table, janet_ckeywordv("macro"))); + Janet value = janet_table_get(entry_table, janet_ckeywordv("value")); + Janet ref = janet_table_get(entry_table, janet_ckeywordv("ref")); + int ref_is_valid = janet_checktype(ref, JANET_ARRAY); + int redef = ref_is_valid && janet_truthy(janet_table_get(entry_table, janet_ckeywordv("redef"))); + + if (macro) { + binding.value = redef ? ref : value; + binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; + return binding; + } + + if (ref_is_valid) { + binding.value = ref; + binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; + } else { + binding.value = value; + binding.type = JANET_BINDING_DEF; + } + + return binding; +} + +/* If the value at the given address can be coerced to a byte view, + return that byte view. If it can't, replace the value at the address + with the result of janet_to_string, and return a byte view over that + string. */ +static JanetByteView memoize_byte_view(Janet *value) { + JanetByteView result; + if (!janet_bytes_view(*value, &result.bytes, &result.len)) { + JanetString str = janet_to_string(*value); + *value = janet_wrap_string(str); + result.bytes = str; + result.len = janet_string_length(str); + } + return result; +} + +static JanetByteView to_byte_view(Janet value) { + JanetByteView result; + if (!janet_bytes_view(value, &result.bytes, &result.len)) { + JanetString str = janet_to_string(value); + result.bytes = str; + result.len = janet_string_length(str); + } + return result; +} + +JanetByteView janet_text_substitution( + Janet *subst, + const uint8_t *bytes, + uint32_t len, + JanetArray *extra_argv) { + int32_t extra_argc = extra_argv == NULL ? 0 : extra_argv->count; + JanetType type = janet_type(*subst); + switch (type) { + case JANET_FUNCTION: + case JANET_CFUNCTION: { + int32_t argc = 1 + extra_argc; + Janet *argv = janet_tuple_begin(argc); + argv[0] = janet_stringv(bytes, len); + for (int32_t i = 0; i < extra_argc; i++) { + argv[i + 1] = extra_argv->data[i]; + } + janet_tuple_end(argv); + if (type == JANET_FUNCTION) { + return to_byte_view(janet_call(janet_unwrap_function(*subst), argc, argv)); + } else { + return to_byte_view(janet_unwrap_cfunction(*subst)(argc, argv)); + } + } + default: + return memoize_byte_view(subst); + } +} + +JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { + Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); + return janet_binding_from_entry(entry); +} + +JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { + JanetBinding binding = janet_resolve_ext(env, sym); + if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { + *out = janet_array_peek(janet_unwrap_array(binding.value)); + } else { + *out = binding.value; + } + return binding.type; +} + +/* Resolve a symbol in the core environment. */ +Janet janet_resolve_core(const char *name) { + JanetTable *env = janet_core_env(NULL); + Janet out = janet_wrap_nil(); + janet_resolve(env, janet_csymbol(name), &out); + return out; +} + +/* Read both tuples and arrays as c pointers + int32_t length. Return 1 if the + * view can be constructed, 0 if an invalid type. */ +int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) { + if (janet_checktype(seq, JANET_ARRAY)) { + *data = janet_unwrap_array(seq)->data; + *len = janet_unwrap_array(seq)->count; + return 1; + } else if (janet_checktype(seq, JANET_TUPLE)) { + *data = janet_unwrap_tuple(seq); + *len = janet_tuple_length(janet_unwrap_tuple(seq)); + return 1; + } + return 0; +} + +/* Read both strings and buffer as unsigned character array + int32_t len. + * Returns 1 if the view can be constructed and 0 if the type is invalid. */ +int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) { + JanetType t = janet_type(str); + if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) { + *data = janet_unwrap_string(str); + *len = janet_string_length(janet_unwrap_string(str)); + return 1; + } else if (t == JANET_BUFFER) { + *data = janet_unwrap_buffer(str)->data; + *len = janet_unwrap_buffer(str)->count; + return 1; + } else if (t == JANET_ABSTRACT) { + void *abst = janet_unwrap_abstract(str); + const JanetAbstractType *atype = janet_abstract_type(abst); + if (NULL == atype->bytes) { + return 0; + } + JanetByteView view = atype->bytes(abst, janet_abstract_size(abst)); + *data = view.bytes; + *len = view.len; + return 1; + } + return 0; +} + +/* Read both structs and tables as the entries of a hashtable with + * identical structure. Returns 1 if the view can be constructed and + * 0 if the type is invalid. */ +int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) { + if (janet_checktype(tab, JANET_TABLE)) { + *data = janet_unwrap_table(tab)->data; + *cap = janet_unwrap_table(tab)->capacity; + *len = janet_unwrap_table(tab)->count; + return 1; + } else if (janet_checktype(tab, JANET_STRUCT)) { + *data = janet_unwrap_struct(tab); + *cap = janet_struct_capacity(janet_unwrap_struct(tab)); + *len = janet_struct_length(janet_unwrap_struct(tab)); + return 1; + } + return 0; +} + +int janet_checkint(Janet x) { + if (!janet_checktype(x, JANET_NUMBER)) + return 0; + double dval = janet_unwrap_number(x); + return janet_checkintrange(dval); +} + +int janet_checkuint(Janet x) { + if (!janet_checktype(x, JANET_NUMBER)) + return 0; + double dval = janet_unwrap_number(x); + return janet_checkuintrange(dval); +} + +int janet_checkint64(Janet x) { + if (!janet_checktype(x, JANET_NUMBER)) + return 0; + double dval = janet_unwrap_number(x); + return janet_checkint64range(dval); +} + +int janet_checkuint64(Janet x) { + if (!janet_checktype(x, JANET_NUMBER)) + return 0; + double dval = janet_unwrap_number(x); + return janet_checkuint64range(dval); +} + +int janet_checksize(Janet x) { + if (!janet_checktype(x, JANET_NUMBER)) + return 0; + double dval = janet_unwrap_number(x); + if (dval != (double)((size_t) dval)) return 0; + if (SIZE_MAX > JANET_INTMAX_INT64) { + return dval <= JANET_INTMAX_INT64; + } else { + return dval <= SIZE_MAX; + } +} + +JanetTable *janet_get_core_table(const char *name) { + JanetTable *env = janet_core_env(NULL); + Janet out = janet_wrap_nil(); + JanetBindingType bt = janet_resolve(env, janet_csymbol(name), &out); + if (bt == JANET_BINDING_NONE) return NULL; + if (!janet_checktype(out, JANET_TABLE)) return NULL; + return janet_unwrap_table(out); +} + +/* Sort keys of a dictionary type */ +int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) { + + /* First, put populated indices into index_buffer */ + int32_t next_index = 0; + for (int32_t i = 0; i < cap; i++) { + if (!janet_checktype(dict[i].key, JANET_NIL)) { + index_buffer[next_index++] = i; + } + } + + /* Next, sort those (simple insertion sort here for now) */ + for (int32_t i = 1; i < next_index; i++) { + int32_t index_to_insert = index_buffer[i]; + Janet lhs = dict[index_to_insert].key; + for (int32_t j = i - 1; j >= 0; j--) { + index_buffer[j + 1] = index_buffer[j]; + Janet rhs = dict[index_buffer[j]].key; + if (janet_compare(lhs, rhs) >= 0) { + index_buffer[j + 1] = index_to_insert; + break; + } else if (j == 0) { + index_buffer[0] = index_to_insert; + } + } + } + + /* Return number of indices found */ + return next_index; + +} + +/* Clock shims for various platforms */ +#ifdef JANET_GETTIME +#ifdef JANET_WINDOWS +#include +int janet_gettime(struct timespec *spec, enum JanetTimeSource source) { + if (source == JANET_TIME_REALTIME) { + FILETIME ftime; + GetSystemTimeAsFileTime(&ftime); + int64_t wintime = (int64_t)(ftime.dwLowDateTime) | ((int64_t)(ftime.dwHighDateTime) << 32); + /* Windows epoch is January 1, 1601 apparently */ + wintime -= 116444736000000000LL; + spec->tv_sec = wintime / 10000000LL; + /* Resolution is 100 nanoseconds. */ + spec->tv_nsec = wintime % 10000000LL * 100; + } else if (source == JANET_TIME_MONOTONIC) { + LARGE_INTEGER count; + LARGE_INTEGER perf_freq; + QueryPerformanceCounter(&count); + QueryPerformanceFrequency(&perf_freq); + spec->tv_sec = count.QuadPart / perf_freq.QuadPart; + spec->tv_nsec = (long)((count.QuadPart % perf_freq.QuadPart) * 1000000000 / perf_freq.QuadPart); + } else if (source == JANET_TIME_CPUTIME) { + FILETIME creationTime, exitTime, kernelTime, userTime; + GetProcessTimes(GetCurrentProcess(), &creationTime, &exitTime, &kernelTime, &userTime); + int64_t tmp = ((int64_t)userTime.dwHighDateTime << 32) + userTime.dwLowDateTime; + spec->tv_sec = tmp / 10000000LL; + spec->tv_nsec = tmp % 10000000LL * 100; + } + return 0; +} +/* clock_gettime() wasn't available on Mac until 10.12. */ +#elif defined(JANET_APPLE) && !defined(MAC_OS_X_VERSION_10_12) +#include +#include +int janet_gettime(struct timespec *spec, enum JanetTimeSource source) { + if (source == JANET_TIME_REALTIME) { + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); + clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + spec->tv_sec = mts.tv_sec; + spec->tv_nsec = mts.tv_nsec; + } else if (source == JANET_TIME_MONOTONIC) { + clock_serv_t cclock; + int nsecs; + mach_msg_type_number_t count; + host_get_clock_service(mach_host_self(), clock, &cclock); + clock_get_attributes(cclock, CLOCK_GET_TIME_RES, (clock_attr_t)&nsecs, &count); + mach_port_deallocate(mach_task_self(), cclock); + clock_getres(CLOCK_MONOTONIC, spec); + } + if (source == JANET_TIME_CPUTIME) { + clock_t tmp = clock(); + spec->tv_sec = tmp; + spec->tv_nsec = (tmp - spec->tv_sec) * 1.0e9; + } + return 0; +} +#else +int janet_gettime(struct timespec *spec, enum JanetTimeSource source) { + clockid_t cid = CLOCK_REALTIME; + if (source == JANET_TIME_REALTIME) { + cid = CLOCK_REALTIME; + } else if (source == JANET_TIME_MONOTONIC) { + cid = CLOCK_MONOTONIC; + } else if (source == JANET_TIME_CPUTIME) { + cid = CLOCK_PROCESS_CPUTIME_ID; + } + return clock_gettime(cid, spec); +} +#endif +#endif + +/* Setting C99 standard makes this not available, but it should + * work/link properly if we detect a BSD */ +#if defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7) +void arc4random_buf(void *buf, size_t nbytes); +#endif + +int janet_cryptorand(uint8_t *out, size_t n) { +#ifndef JANET_NO_CRYPTORAND +#ifdef JANET_WINDOWS + for (size_t i = 0; i < n; i += sizeof(unsigned int)) { + unsigned int v; + if (rand_s(&v)) + return -1; + for (int32_t j = 0; (j < (int32_t) sizeof(unsigned int)) && (i + j < n); j++) { + out[i + j] = v & 0xff; + v = v >> 8; + } + } + return 0; +#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7) + arc4random_buf(out, n); + return 0; +#else + /* We should be able to call getrandom on linux, but it doesn't seem + to be uniformly supported on linux distros. + On Mac, arc4random_buf wasn't available on until 10.7. + In these cases, use this fallback path for now... */ + int rc; + int randfd; + RETRY_EINTR(randfd, open("/dev/urandom", O_RDONLY | O_CLOEXEC)); + if (randfd < 0) + return -1; + while (n > 0) { + ssize_t nread; + RETRY_EINTR(nread, read(randfd, out, n)); + if (nread <= 0) { + RETRY_EINTR(rc, close(randfd)); + return -1; + } + out += nread; + n -= nread; + } + RETRY_EINTR(rc, close(randfd)); + return 0; +#endif +#else + (void) out; + (void) n; + return -1; +#endif +} + +/* Dynamic library loading */ + +char *get_processed_name(const char *name) { + if (name[0] == '.') return (char *) name; + const char *c; + for (c = name; *c; c++) { + if (*c == '/') return (char *) name; + } + size_t l = (size_t)(c - name); + char *ret = janet_malloc(l + 3); + if (NULL == ret) { + JANET_OUT_OF_MEMORY; + } + ret[0] = '.'; + ret[1] = '/'; + memcpy(ret + 2, name, l + 1); + return ret; +} + +#if defined(JANET_NO_DYNAMIC_MODULES) + +const char *error_clib(void) { + return "dynamic modules not supported"; +} + +#else +#if defined(JANET_WINDOWS) + +static char error_clib_buf[256]; +char *error_clib(void) { + FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + error_clib_buf, sizeof(error_clib_buf), NULL); + error_clib_buf[strlen(error_clib_buf) - 1] = '\0'; + return error_clib_buf; +} + +Clib load_clib(const char *name) { + if (name == NULL) { + return GetModuleHandle(NULL); + } else { + return LoadLibrary(name); + } +} + +void free_clib(HINSTANCE clib) { + if (clib != GetModuleHandle(NULL)) { + FreeLibrary(clib); + } +} + +void *symbol_clib(HINSTANCE clib, const char *sym) { + if (clib != GetModuleHandle(NULL)) { + return GetProcAddress(clib, sym); + } else { + /* Look up symbols from all loaded modules */ + HMODULE hMods[1024]; + DWORD needed = 0; + if (EnumProcessModules(GetCurrentProcess(), hMods, sizeof(hMods), &needed)) { + needed /= sizeof(HMODULE); + for (DWORD i = 0; i < needed; i++) { + void *address = GetProcAddress(hMods[i], sym); + if (NULL != address) { + return address; + } + } + } else { + janet_panicf("ffi: %s", error_clib()); + } + return NULL; + } +} + +#endif +#endif + +/* Alloc function macro fills */ +void *(janet_malloc)(size_t size) { + return janet_malloc(size); +} + +void (janet_free)(void *ptr) { + janet_free(ptr); +} + +void *(janet_calloc)(size_t nmemb, size_t size) { + return janet_calloc(nmemb, size); +} + +void *(janet_realloc)(void *ptr, size_t size) { + return janet_realloc(ptr, size); +} + + +/* src/core/value.c */ +#line 0 "src/core/value.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include "util.h" +#include "state.h" +#include "gc.h" +#include "fiber.h" +#include +#endif + +#include + +static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { + JanetTraversalNode node; + node.self = (JanetGCObject *) lhs; + node.other = (JanetGCObject *) rhs; + node.index = 0; + node.index2 = index2; + int is_new = janet_vm.traversal_base == NULL; + if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { + size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); + size_t newsize = 2 * oldsize + 1; + if (newsize < 128) { + newsize = 128; + } + JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); + if (tn == NULL) { + JANET_OUT_OF_MEMORY; + } + janet_vm.traversal_base = tn; + janet_vm.traversal_top = janet_vm.traversal_base + newsize; + janet_vm.traversal = janet_vm.traversal_base + oldsize; + } + *(++janet_vm.traversal) = node; +} + +/* + * Used for travsersing structs and tuples without recursion + * Returns: + * 0 - next node found + * 1 - early stop - lhs < rhs + * 2 - no next node found + * 3 - early stop - lhs > rhs + */ +static int traversal_next(Janet *x, Janet *y) { + JanetTraversalNode *t = janet_vm.traversal; + while (t && t > janet_vm.traversal_base) { + JanetGCObject *self = t->self; + JanetTupleHead *tself = (JanetTupleHead *)self; + JanetStructHead *sself = (JanetStructHead *)self; + JanetGCObject *other = t->other; + JanetTupleHead *tother = (JanetTupleHead *)other; + JanetStructHead *sother = (JanetStructHead *)other; + if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { + /* Node is a tuple at index t->index */ + if (t->index < tself->length && t->index < tother->length) { + int32_t index = t->index++; + *x = tself->data[index]; + *y = tother->data[index]; + janet_vm.traversal = t; + return 0; + } + if (t->index2 && tself->length != tother->length) { + return tself->length > tother->length ? 3 : 1; + } + } else { + /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ + if (t->index2) { + t->index2 = 0; + int32_t index = t->index++; + *x = sself->data[index].value; + *y = sother->data[index].value; + janet_vm.traversal = t; + return 0; + } + for (int32_t i = t->index; i < sself->capacity; i++) { + t->index2 = 1; + *x = sself->data[t->index].key; + *y = sother->data[t->index].key; + janet_vm.traversal = t; + return 0; + } + /* Traverse prototype */ + JanetStruct sproto = sself->proto; + JanetStruct oproto = sother->proto; + if (sproto && !oproto) return 3; + if (!sproto && oproto) return 1; + if (oproto && sproto) { + *x = janet_wrap_struct(sproto); + *y = janet_wrap_struct(oproto); + janet_vm.traversal = t - 1; + return 0; + } + } + t--; + } + janet_vm.traversal = t; + return 2; +} + +/* + * Define a number of functions that can be used internally on ANY Janet. + */ + +Janet janet_next(Janet ds, Janet key) { + return janet_next_impl(ds, key, 0); +} + +Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) { + JanetType t = janet_type(ds); + switch (t) { + default: + janet_panicf("expected iterable type, got %v", ds); + case JANET_TABLE: + case JANET_STRUCT: { + const JanetKV *start; + int32_t cap; + if (t == JANET_TABLE) { + JanetTable *tab = janet_unwrap_table(ds); + cap = tab->capacity; + start = tab->data; + } else { + JanetStruct st = janet_unwrap_struct(ds); + cap = janet_struct_capacity(st); + start = st; + } + const JanetKV *end = start + cap; + const JanetKV *kv = janet_checktype(key, JANET_NIL) + ? start + : janet_dict_find(start, cap, key) + 1; + while (kv < end) { + if (!janet_checktype(kv->key, JANET_NIL)) return kv->key; + kv++; + } + break; + } + case JANET_STRING: + case JANET_KEYWORD: + case JANET_SYMBOL: + case JANET_BUFFER: + case JANET_ARRAY: + case JANET_TUPLE: { + int32_t i; + if (janet_checktype(key, JANET_NIL)) { + i = 0; + } else if (janet_checkint(key)) { + i = janet_unwrap_integer(key) + 1; + } else { + break; + } + int32_t len; + if (t == JANET_BUFFER) { + len = janet_unwrap_buffer(ds)->count; + } else if (t == JANET_ARRAY) { + len = janet_unwrap_array(ds)->count; + } else if (t == JANET_TUPLE) { + len = janet_tuple_length(janet_unwrap_tuple(ds)); + } else { + len = janet_string_length(janet_unwrap_string(ds)); + } + if (i < len && i >= 0) { + return janet_wrap_integer(i); + } + break; + } + case JANET_ABSTRACT: { + JanetAbstract abst = janet_unwrap_abstract(ds); + const JanetAbstractType *at = janet_abstract_type(abst); + if (NULL == at->next) break; + return at->next(abst, key); + } + case JANET_FIBER: { + JanetFiber *child = janet_unwrap_fiber(ds); + Janet retreg; + JanetFiberStatus status = janet_fiber_status(child); + if (status == JANET_STATUS_ALIVE || + status == JANET_STATUS_DEAD || + status == JANET_STATUS_ERROR || + status == JANET_STATUS_USER0 || + status == JANET_STATUS_USER1 || + status == JANET_STATUS_USER2 || + status == JANET_STATUS_USER3 || + status == JANET_STATUS_USER4) { + return janet_wrap_nil(); + } + janet_vm.fiber->child = child; + JanetSignal sig = janet_continue(child, janet_wrap_nil(), &retreg); + if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { + if (is_interpreter) { + janet_signalv(sig, retreg); + } else { + janet_vm.fiber->child = NULL; + janet_panicv(retreg); + } + } + janet_vm.fiber->child = NULL; + if (sig == JANET_SIGNAL_OK || + sig == JANET_SIGNAL_ERROR || + sig == JANET_SIGNAL_USER0 || + sig == JANET_SIGNAL_USER1 || + sig == JANET_SIGNAL_USER2 || + sig == JANET_SIGNAL_USER3 || + sig == JANET_SIGNAL_USER4) { + /* Fiber cannot be resumed, so discard last value. */ + return janet_wrap_nil(); + } else { + return janet_wrap_integer(0); + } + } + } + return janet_wrap_nil(); +} + +/* Compare two abstract values */ +static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { + if (xx == yy) return 0; + const JanetAbstractType *xt = janet_abstract_type(xx); + const JanetAbstractType *yt = janet_abstract_type(yy); + if (xt != yt) { + return xt > yt ? 1 : -1; + } + if (xt->compare == NULL) { + return xx > yy ? 1 : -1; + } + return xt->compare(xx, yy); +} + +int janet_equals(Janet x, Janet y) { + janet_vm.traversal = janet_vm.traversal_base; + do { + if (janet_type(x) != janet_type(y)) return 0; + switch (janet_type(x)) { + case JANET_NIL: + break; + case JANET_BOOLEAN: + if (janet_unwrap_boolean(x) != janet_unwrap_boolean(y)) return 0; + break; + case JANET_NUMBER: + if (janet_unwrap_number(x) != janet_unwrap_number(y)) return 0; + break; + case JANET_STRING: + if (!janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y))) return 0; + break; + case JANET_ABSTRACT: + if (janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y))) return 0; + break; + default: + if (janet_unwrap_pointer(x) != janet_unwrap_pointer(y)) return 0; + break; + case JANET_TUPLE: { + const Janet *t1 = janet_unwrap_tuple(x); + const Janet *t2 = janet_unwrap_tuple(y); + if (t1 == t2) break; + if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; + if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; + if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; + push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); + break; + } + break; + case JANET_STRUCT: { + const JanetKV *s1 = janet_unwrap_struct(x); + const JanetKV *s2 = janet_unwrap_struct(y); + if (s1 == s2) break; + if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; + if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; + if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; + if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; + push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); + break; + } + break; + } + } while (!traversal_next(&x, &y)); + return 1; +} + +static uint64_t murmur64(uint64_t h) { + h ^= h >> 33; + h *= 0xff51afd7ed558ccdUL; + h ^= h >> 33; + h *= 0xc4ceb9fe1a85ec53UL; + h ^= h >> 33; + return h; +} + +/* Computes a hash value for a function */ +int32_t janet_hash(Janet x) { + int32_t hash = 0; + switch (janet_type(x)) { + case JANET_NIL: + hash = 0; + break; + case JANET_BOOLEAN: + hash = janet_unwrap_boolean(x); + break; + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + hash = janet_string_hash(janet_unwrap_string(x)); + break; + case JANET_TUPLE: + hash = janet_tuple_hash(janet_unwrap_tuple(x)); + hash += (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; + break; + case JANET_STRUCT: + hash = janet_struct_hash(janet_unwrap_struct(x)); + break; + case JANET_NUMBER: { + union { + double d; + uint64_t u; + } as; + as.d = janet_unwrap_number(x); + as.d += 0.0; /* normalize negative 0 */ + uint32_t lo = (uint32_t)(as.u & 0xFFFFFFFF); + uint32_t hi = (uint32_t)(as.u >> 32); + uint32_t hilo = (hi ^ lo) * 2654435769u; + hash = (int32_t)((hilo << 16) | (hilo >> 16)); + break; + } + case JANET_ABSTRACT: { + JanetAbstract xx = janet_unwrap_abstract(x); + const JanetAbstractType *at = janet_abstract_type(xx); + if (at->hash != NULL) { + hash = at->hash(xx, janet_abstract_size(xx)); + break; + } + } + /* fallthrough */ + default: + if (sizeof(double) == sizeof(void *)) { + /* Assuming 8 byte pointer (8 byte aligned) */ + uint64_t i = murmur64(janet_u64(x)); + hash = (int32_t)(i >> 32); + } else { + /* Assuming 4 byte pointer (or smaller) */ + uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); + uint32_t hilo = (uint32_t) diff * 2654435769u; + hash = (int32_t)((hilo << 16) | (hilo >> 16)); + } + break; + } + return hash; +} + +/* Compares x to y. If they are equal returns 0. If x is less, returns -1. + * If y is less, returns 1. All types are comparable + * and should have strict ordering, excepts NaNs. */ +int janet_compare(Janet x, Janet y) { + janet_vm.traversal = janet_vm.traversal_base; + int status; + do { + JanetType tx = janet_type(x); + JanetType ty = janet_type(y); + if (tx != ty) return tx < ty ? -1 : 1; + switch (tx) { + case JANET_NIL: + break; + case JANET_BOOLEAN: { + int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); + if (diff) return diff; + break; + } + case JANET_NUMBER: { + double xx = janet_unwrap_number(x); + double yy = janet_unwrap_number(y); + if (xx == yy) { + break; + } else { + return (xx < yy) ? -1 : 1; + } + } + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: { + int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); + if (diff) return diff; + break; + } + case JANET_ABSTRACT: { + int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); + if (diff) return diff; + break; + } + default: { + if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { + break; + } else { + return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; + } + } + case JANET_TUPLE: { + const Janet *lhs = janet_unwrap_tuple(x); + const Janet *rhs = janet_unwrap_tuple(y); + if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { + return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; + } + push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); + break; + } + case JANET_STRUCT: { + const JanetKV *lhs = janet_unwrap_struct(x); + const JanetKV *rhs = janet_unwrap_struct(y); + int32_t llen = janet_struct_capacity(lhs); + int32_t rlen = janet_struct_capacity(rhs); + int32_t lhash = janet_struct_hash(lhs); + int32_t rhash = janet_struct_hash(rhs); + if (llen < rlen) return -1; + if (llen > rlen) return 1; + if (lhash < rhash) return -1; + if (lhash > rhash) return 1; + push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); + break; + } + } + } while (!(status = traversal_next(&x, &y))); + return status - 2; +} + +static int32_t getter_checkint(JanetType type, Janet key, int32_t max) { + if (!janet_checkint(key)) goto bad; + int32_t ret = janet_unwrap_integer(key); + if (ret < 0) goto bad; + if (ret >= max) goto bad; + return ret; +bad: + janet_panicf("expected integer key for %s in range [0, %d), got %v", janet_type_names[type], max, key); +} + +/* Gets a value and returns. Can panic. */ +Janet janet_in(Janet ds, Janet key) { + Janet value; + JanetType type = janet_type(ds); + switch (type) { + default: + janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds); + break; + case JANET_STRUCT: + value = janet_struct_get(janet_unwrap_struct(ds), key); + break; + case JANET_TABLE: + value = janet_table_get(janet_unwrap_table(ds), key); + break; + case JANET_ARRAY: { + JanetArray *array = janet_unwrap_array(ds); + int32_t index = getter_checkint(type, key, array->count); + value = array->data[index]; + break; + } + case JANET_TUPLE: { + const Janet *tuple = janet_unwrap_tuple(ds); + int32_t len = janet_tuple_length(tuple); + value = tuple[getter_checkint(type, key, len)]; + break; + } + case JANET_BUFFER: { + JanetBuffer *buffer = janet_unwrap_buffer(ds); + int32_t index = getter_checkint(type, key, buffer->count); + value = janet_wrap_integer(buffer->data[index]); + break; + } + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: { + const uint8_t *str = janet_unwrap_string(ds); + int32_t index = getter_checkint(type, key, janet_string_length(str)); + value = janet_wrap_integer(str[index]); + break; + } + case JANET_ABSTRACT: { + JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); + if (type->get) { + if (!(type->get)(janet_unwrap_abstract(ds), key, &value)) + janet_panicf("key %v not found in %v ", key, ds); + } else { + janet_panicf("no getter for %v ", ds); + } + break; + } + case JANET_FIBER: { + /* Bit of a hack to allow iterating over fibers. */ + if (janet_equals(key, janet_wrap_integer(0))) { + return janet_unwrap_fiber(ds)->last_value; + } else { + janet_panicf("expected key 0, got %v", key); + } + } + } + return value; +} + +Janet janet_get(Janet ds, Janet key) { + JanetType t = janet_type(ds); + switch (t) { + default: + return janet_wrap_nil(); + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: { + if (!janet_checkint(key)) return janet_wrap_nil(); + int32_t index = janet_unwrap_integer(key); + if (index < 0) return janet_wrap_nil(); + const uint8_t *str = janet_unwrap_string(ds); + if (index >= janet_string_length(str)) return janet_wrap_nil(); + return janet_wrap_integer(str[index]); + } + case JANET_ABSTRACT: { + Janet value; + void *abst = janet_unwrap_abstract(ds); + JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(abst); + if (!type->get) return janet_wrap_nil(); + if ((type->get)(abst, key, &value)) + return value; + return janet_wrap_nil(); + } + case JANET_ARRAY: + case JANET_TUPLE: + case JANET_BUFFER: { + if (!janet_checkint(key)) return janet_wrap_nil(); + int32_t index = janet_unwrap_integer(key); + if (index < 0) return janet_wrap_nil(); + if (t == JANET_ARRAY) { + JanetArray *a = janet_unwrap_array(ds); + if (index >= a->count) return janet_wrap_nil(); + return a->data[index]; + } else if (t == JANET_BUFFER) { + JanetBuffer *b = janet_unwrap_buffer(ds); + if (index >= b->count) return janet_wrap_nil(); + return janet_wrap_integer(b->data[index]); + } else { + const Janet *t = janet_unwrap_tuple(ds); + if (index >= janet_tuple_length(t)) return janet_wrap_nil(); + return t[index]; + } + } + case JANET_TABLE: { + return janet_table_get(janet_unwrap_table(ds), key); + } + case JANET_STRUCT: { + const JanetKV *st = janet_unwrap_struct(ds); + return janet_struct_get(st, key); + } + case JANET_FIBER: { + /* Bit of a hack to allow iterating over fibers. */ + if (janet_equals(key, janet_wrap_integer(0))) { + return janet_unwrap_fiber(ds)->last_value; + } else { + return janet_wrap_nil(); + } + } + } +} + +Janet janet_getindex(Janet ds, int32_t index) { + Janet value; + if (index < 0) janet_panic("expected non-negative index"); + switch (janet_type(ds)) { + default: + janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds); + break; + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + if (index >= janet_string_length(janet_unwrap_string(ds))) { + value = janet_wrap_nil(); + } else { + value = janet_wrap_integer(janet_unwrap_string(ds)[index]); + } + break; + case JANET_ARRAY: + if (index >= janet_unwrap_array(ds)->count) { + value = janet_wrap_nil(); + } else { + value = janet_unwrap_array(ds)->data[index]; + } + break; + case JANET_BUFFER: + if (index >= janet_unwrap_buffer(ds)->count) { + value = janet_wrap_nil(); + } else { + value = janet_wrap_integer(janet_unwrap_buffer(ds)->data[index]); + } + break; + case JANET_TUPLE: + if (index >= janet_tuple_length(janet_unwrap_tuple(ds))) { + value = janet_wrap_nil(); + } else { + value = janet_unwrap_tuple(ds)[index]; + } + break; + case JANET_TABLE: + value = janet_table_get(janet_unwrap_table(ds), janet_wrap_integer(index)); + break; + case JANET_STRUCT: + value = janet_struct_get(janet_unwrap_struct(ds), janet_wrap_integer(index)); + break; + case JANET_ABSTRACT: { + JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); + if (type->get) { + if (!(type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index), &value)) + value = janet_wrap_nil(); + } else { + janet_panicf("no getter for %v ", ds); + } + break; + } + case JANET_FIBER: { + if (index == 0) { + value = janet_unwrap_fiber(ds)->last_value; + } else { + value = janet_wrap_nil(); + } + break; + } + } + return value; +} + +int32_t janet_length(Janet x) { + switch (janet_type(x)) { + default: + janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x); + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + return janet_string_length(janet_unwrap_string(x)); + case JANET_ARRAY: + return janet_unwrap_array(x)->count; + case JANET_BUFFER: + return janet_unwrap_buffer(x)->count; + case JANET_TUPLE: + return janet_tuple_length(janet_unwrap_tuple(x)); + case JANET_STRUCT: + return janet_struct_length(janet_unwrap_struct(x)); + case JANET_TABLE: + return janet_unwrap_table(x)->count; + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(x); + const JanetAbstractType *type = janet_abstract_type(abst); + if (type->length != NULL) { + size_t len = type->length(abst, janet_abstract_size(abst)); + if (len > INT32_MAX) { + janet_panicf("invalid integer length %u", len); + } + return (int32_t)(len); + } + Janet argv[1] = { x }; + Janet len = janet_mcall("length", 1, argv); + if (!janet_checkint(len)) + janet_panicf("invalid integer length %v", len); + return janet_unwrap_integer(len); + } + } +} + +Janet janet_lengthv(Janet x) { + switch (janet_type(x)) { + default: + janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x); + case JANET_STRING: + case JANET_SYMBOL: + case JANET_KEYWORD: + return janet_wrap_integer(janet_string_length(janet_unwrap_string(x))); + case JANET_ARRAY: + return janet_wrap_integer(janet_unwrap_array(x)->count); + case JANET_BUFFER: + return janet_wrap_integer(janet_unwrap_buffer(x)->count); + case JANET_TUPLE: + return janet_wrap_integer(janet_tuple_length(janet_unwrap_tuple(x))); + case JANET_STRUCT: + return janet_wrap_integer(janet_struct_length(janet_unwrap_struct(x))); + case JANET_TABLE: + return janet_wrap_integer(janet_unwrap_table(x)->count); + case JANET_ABSTRACT: { + void *abst = janet_unwrap_abstract(x); + const JanetAbstractType *type = janet_abstract_type(abst); + if (type->length != NULL) { + size_t len = type->length(abst, janet_abstract_size(abst)); + /* If len is always less then double, we can never overflow */ +#ifdef JANET_32 + return janet_wrap_number(len); +#else + if (len < (size_t) JANET_INTMAX_INT64) { + return janet_wrap_number((double) len); + } else { + janet_panicf("integer length %u too large", len); + } +#endif + } + Janet argv[1] = { x }; + return janet_mcall("length", 1, argv); + } + } +} + +void janet_putindex(Janet ds, int32_t index, Janet value) { + switch (janet_type(ds)) { + default: + janet_panicf("expected %T, got %v", + JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); + case JANET_ARRAY: { + JanetArray *array = janet_unwrap_array(ds); + if (index >= array->count) { + janet_array_ensure(array, index + 1, 2); + array->count = index + 1; + } + array->data[index] = value; + break; + } + case JANET_BUFFER: { + JanetBuffer *buffer = janet_unwrap_buffer(ds); + if (!janet_checkint(value)) + janet_panicf("can only put integers in buffers, got %v", value); + if (index >= buffer->count) { + janet_buffer_ensure(buffer, index + 1, 2); + buffer->count = index + 1; + } + buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF); + break; + } + case JANET_TABLE: { + JanetTable *table = janet_unwrap_table(ds); + janet_table_put(table, janet_wrap_integer(index), value); + break; + } + case JANET_ABSTRACT: { + JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); + if (type->put) { + (type->put)(janet_unwrap_abstract(ds), janet_wrap_integer(index), value); + } else { + janet_panicf("no setter for %v ", ds); + } + break; + } + } +} + +void janet_put(Janet ds, Janet key, Janet value) { + JanetType type = janet_type(ds); + switch (type) { + default: + janet_panicf("expected %T, got %v", + JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); + case JANET_ARRAY: { + JanetArray *array = janet_unwrap_array(ds); + int32_t index = getter_checkint(type, key, INT32_MAX - 1); + if (index >= array->count) { + janet_array_setcount(array, index + 1); + } + array->data[index] = value; + break; + } + case JANET_BUFFER: { + JanetBuffer *buffer = janet_unwrap_buffer(ds); + int32_t index = getter_checkint(type, key, INT32_MAX - 1); + if (!janet_checkint(value)) + janet_panicf("can only put integers in buffers, got %v", value); + if (index >= buffer->count) { + janet_buffer_setcount(buffer, index + 1); + } + buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF); + break; + } + case JANET_TABLE: + janet_table_put(janet_unwrap_table(ds), key, value); + break; + case JANET_ABSTRACT: { + JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); + if (type->put) { + (type->put)(janet_unwrap_abstract(ds), key, value); + } else { + janet_panicf("no setter for %v ", ds); + } + break; + } + } +} + + +/* src/core/vector.c */ +#line 0 "src/core/vector.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include "vector.h" +#include "util.h" +#endif + +/* Grow the buffer dynamically. Used for push operations. */ +void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { + int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; + int32_t min_needed = janet_v_count(v) + increment; + int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; + size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; + int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); + if (!v) p[1] = 0; + p[0] = m; + return p + 2; +} + +/* Convert a buffer to normal allocated memory (forget capacity) */ +void *janet_v_flattenmem(void *v, int32_t itemsize) { + char *p; + if (NULL == v) return NULL; + size_t size = (size_t) itemsize * janet_v__cnt(v); + p = janet_malloc(size); + if (NULL != p) { + safe_memcpy(p, v, size); + return p; + } else { + JANET_OUT_OF_MEMORY; + } +} + + + +/* src/core/vm.c */ +#line 0 "src/core/vm.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include "state.h" +#include "fiber.h" +#include "gc.h" +#include "symcache.h" +#include "util.h" +#endif + +#include + +/* Virtual registers + * + * One instruction word + * CC | BB | AA | OP + * DD | DD | DD | OP + * EE | EE | AA | OP + */ +#define A ((*pc >> 8) & 0xFF) +#define B ((*pc >> 16) & 0xFF) +#define C (*pc >> 24) +#define D (*pc >> 8) +#define E (*pc >> 16) + +/* Signed interpretations of registers */ +#define CS (*((int32_t *)pc) >> 24) +#define DS (*((int32_t *)pc) >> 8) +#define ES (*((int32_t *)pc) >> 16) + +/* How we dispatch instructions. By default, we use + * a switch inside an infinite loop. For GCC/clang, we use + * computed gotos. */ +#if defined(__GNUC__) && !defined(__EMSCRIPTEN__) +#define JANET_USE_COMPUTED_GOTOS +#endif + +#ifdef JANET_USE_COMPUTED_GOTOS +#define VM_START() { goto *op_lookup[first_opcode]; +#define VM_END() } +#define VM_OP(op) label_##op : +#define VM_DEFAULT() label_unknown_op: +#define vm_next() goto *op_lookup[*pc & 0xFF] +#define opcode (*pc & 0xFF) +#else +#define VM_START() uint8_t opcode = first_opcode; for (;;) {switch(opcode) { +#define VM_END() }} +#define VM_OP(op) case op : +#define VM_DEFAULT() default: +#define vm_next() opcode = *pc & 0xFF; continue +#endif + +/* Commit and restore VM state before possible longjmp */ +#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) +#define vm_restore() do { \ + stack = fiber->data + fiber->frame; \ + pc = janet_stack_frame(stack)->pc; \ + func = janet_stack_frame(stack)->func; \ +} while (0) +#define vm_return(sig, val) do { \ + janet_vm.return_reg[0] = (val); \ + vm_commit(); \ + return (sig); \ +} while (0) +#define vm_return_no_restore(sig, val) do { \ + janet_vm.return_reg[0] = (val); \ + return (sig); \ +} while (0) + +/* Next instruction variations */ +#define maybe_collect() do {\ + if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) +#define vm_checkgc_next() maybe_collect(); vm_next() +#define vm_pcnext() pc++; vm_next() +#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() + +/* Handle certain errors in main vm loop */ +#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) +#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) +#define vm_assert_type(X, T) do { \ + if (!(janet_checktype((X), (T)))) { \ + vm_commit(); \ + janet_panicf("expected %T, got %v", (1 << (T)), (X)); \ + } \ +} while (0) +#define vm_assert_types(X, TS) do { \ + if (!(janet_checktypes((X), (TS)))) { \ + vm_commit(); \ + janet_panicf("expected %T, got %v", (TS), (X)); \ + } \ +} while (0) +#ifdef JANET_NO_INTERPRETER_INTERRUPT +#define vm_maybe_auto_suspend(COND) +#else +#define vm_maybe_auto_suspend(COND) do { \ + if ((COND) && janet_vm.auto_suspend) { \ + fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ + vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ + } \ +} while (0) +#endif + +/* Templates for certain patterns in opcodes */ +#define vm_binop_immediate(op)\ + {\ + Janet op1 = stack[B];\ + if (!janet_checktype(op1, JANET_NUMBER)) {\ + vm_commit();\ + Janet _argv[2] = { op1, janet_wrap_number(CS) };\ + stack[A] = janet_mcall(#op, 2, _argv);\ + vm_checkgc_pcnext();\ + } else {\ + double x1 = janet_unwrap_number(op1);\ + stack[A] = janet_wrap_number(x1 op CS);\ + vm_pcnext();\ + }\ + } +#define _vm_bitop_immediate(op, type1, rangecheck, msg)\ + {\ + Janet op1 = stack[B];\ + if (!janet_checktype(op1, JANET_NUMBER)) {\ + vm_commit();\ + Janet _argv[2] = { op1, janet_wrap_number(CS) };\ + stack[A] = janet_mcall(#op, 2, _argv);\ + vm_checkgc_pcnext();\ + } else {\ + double y1 = janet_unwrap_number(op1);\ + if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ + type1 x1 = (type1) y1;\ + stack[A] = janet_wrap_number((type1) (x1 op CS));\ + vm_pcnext();\ + }\ + } +#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t, janet_checkintrange, "32-bit signed integers"); +#define vm_bitopu_immediate(op) _vm_bitop_immediate(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers"); +#define _vm_binop(op, wrap)\ + {\ + Janet op1 = stack[B];\ + Janet op2 = stack[C];\ + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ + double x1 = janet_unwrap_number(op1);\ + double x2 = janet_unwrap_number(op2);\ + stack[A] = wrap(x1 op x2);\ + vm_pcnext();\ + } else {\ + vm_commit();\ + stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\ + vm_checkgc_pcnext();\ + }\ + } +#define vm_binop(op) _vm_binop(op, janet_wrap_number) +#define _vm_bitop(op, type1, rangecheck, msg)\ + {\ + Janet op1 = stack[B];\ + Janet op2 = stack[C];\ + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ + double y1 = janet_unwrap_number(op1);\ + double y2 = janet_unwrap_number(op2);\ + if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ + if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ + type1 x1 = (type1) y1;\ + int32_t x2 = (int32_t) y2;\ + stack[A] = janet_wrap_number((type1) (x1 op x2));\ + vm_pcnext();\ + } else {\ + vm_commit();\ + stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\ + vm_checkgc_pcnext();\ + }\ + } +#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") +#define vm_bitopu(op) _vm_bitop(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers") +#define vm_compop(op) \ + {\ + Janet op1 = stack[B];\ + Janet op2 = stack[C];\ + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ + double x1 = janet_unwrap_number(op1);\ + double x2 = janet_unwrap_number(op2);\ + stack[A] = janet_wrap_boolean(x1 op x2);\ + vm_pcnext();\ + } else {\ + vm_commit();\ + stack[A] = janet_wrap_boolean(janet_compare(op1, op2) op 0);\ + vm_checkgc_pcnext();\ + }\ + } +#define vm_compop_imm(op) \ + {\ + Janet op1 = stack[B];\ + if (janet_checktype(op1, JANET_NUMBER)) {\ + double x1 = janet_unwrap_number(op1);\ + double x2 = (double) CS; \ + stack[A] = janet_wrap_boolean(x1 op x2);\ + vm_pcnext();\ + } else {\ + vm_commit();\ + stack[A] = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\ + vm_checkgc_pcnext();\ + }\ + } + +/* Trace a function call */ +static void vm_do_trace(JanetFunction *func, int32_t argc, const Janet *argv) { + if (func->def->name) { + janet_eprintf("trace (%S", func->def->name); + } else { + janet_eprintf("trace (%p", janet_wrap_function(func)); + } + for (int32_t i = 0; i < argc; i++) { + janet_eprintf(" %p", argv[i]); + } + janet_eprintf(")\n"); +} + +/* Invoke a method once we have looked it up */ +static Janet janet_method_invoke(Janet method, int32_t argc, Janet *argv) { + switch (janet_type(method)) { + case JANET_CFUNCTION: + return (janet_unwrap_cfunction(method))(argc, argv); + case JANET_FUNCTION: { + JanetFunction *fun = janet_unwrap_function(method); + return janet_call(fun, argc, argv); + } + case JANET_ABSTRACT: { + JanetAbstract abst = janet_unwrap_abstract(method); + const JanetAbstractType *at = janet_abstract_type(abst); + if (NULL != at->call) { + return at->call(abst, argc, argv); + } + } + /* fallthrough */ + case JANET_STRING: + case JANET_BUFFER: + case JANET_TABLE: + case JANET_STRUCT: + case JANET_ARRAY: + case JANET_TUPLE: { + if (argc != 1) { + janet_panicf("%v called with %d arguments, possibly expected 1", method, argc); + } + return janet_in(method, argv[0]); + } + default: { + if (argc != 1) { + janet_panicf("%v called with %d arguments, possibly expected 1", method, argc); + } + return janet_in(argv[0], method); + } + } +} + +/* Call a non function type from a JOP_CALL or JOP_TAILCALL instruction. + * Assumes that the arguments are on the fiber stack. */ +static Janet call_nonfn(JanetFiber *fiber, Janet callee) { + int32_t argc = fiber->stacktop - fiber->stackstart; + fiber->stacktop = fiber->stackstart; + return janet_method_invoke(callee, argc, fiber->data + fiber->stacktop); +} + +/* Method lookup could potentially handle tables specially... */ +static Janet method_to_fun(Janet method, Janet obj) { + return janet_get(obj, method); +} + +/* Get a callable from a keyword method name and ensure that it is valid. */ +static Janet resolve_method(Janet name, JanetFiber *fiber) { + int32_t argc = fiber->stacktop - fiber->stackstart; + if (argc < 1) janet_panicf("method call (%v) takes at least 1 argument, got 0", name); + Janet callee = method_to_fun(name, fiber->data[fiber->stackstart]); + if (janet_checktype(callee, JANET_NIL)) + janet_panicf("unknown method %v invoked on %v", name, fiber->data[fiber->stackstart]); + return callee; +} + +/* Lookup method on value x */ +static Janet janet_method_lookup(Janet x, const char *name) { + return method_to_fun(janet_ckeywordv(name), x); +} + +static Janet janet_unary_call(const char *method, Janet arg) { + Janet m = janet_method_lookup(arg, method); + if (janet_checktype(m, JANET_NIL)) { + janet_panicf("could not find method :%s for %v", method, arg); + } else { + Janet argv[1] = { arg }; + return janet_method_invoke(m, 1, argv); + } +} + +/* Call a method first on the righthand side, and then on the left hand side with a prefix */ +static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lhs, Janet rhs) { + Janet lm = janet_method_lookup(lhs, lmethod); + if (janet_checktype(lm, JANET_NIL)) { + /* Invert order for rmethod */ + Janet lr = janet_method_lookup(rhs, rmethod); + Janet argv[2] = { rhs, lhs }; + if (janet_checktype(lr, JANET_NIL)) { + janet_panicf("could not find method :%s for %v, or :%s for %v", + lmethod, lhs, + rmethod, rhs); + } + return janet_method_invoke(lr, 2, argv); + } else { + Janet argv[2] = { lhs, rhs }; + return janet_method_invoke(lm, 2, argv); + } +} + +/* Forward declaration */ +static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel); +static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out); + +/* Interpreter main loop */ +static JanetSignal run_vm(JanetFiber *fiber, Janet in) { + + /* opcode -> label lookup if using clang/GCC */ +#ifdef JANET_USE_COMPUTED_GOTOS + static void *op_lookup[255] = { + &&label_JOP_NOOP, + &&label_JOP_ERROR, + &&label_JOP_TYPECHECK, + &&label_JOP_RETURN, + &&label_JOP_RETURN_NIL, + &&label_JOP_ADD_IMMEDIATE, + &&label_JOP_ADD, + &&label_JOP_SUBTRACT_IMMEDIATE, + &&label_JOP_SUBTRACT, + &&label_JOP_MULTIPLY_IMMEDIATE, + &&label_JOP_MULTIPLY, + &&label_JOP_DIVIDE_IMMEDIATE, + &&label_JOP_DIVIDE, + &&label_JOP_DIVIDE_FLOOR, + &&label_JOP_MODULO, + &&label_JOP_REMAINDER, + &&label_JOP_BAND, + &&label_JOP_BOR, + &&label_JOP_BXOR, + &&label_JOP_BNOT, + &&label_JOP_SHIFT_LEFT, + &&label_JOP_SHIFT_LEFT_IMMEDIATE, + &&label_JOP_SHIFT_RIGHT, + &&label_JOP_SHIFT_RIGHT_IMMEDIATE, + &&label_JOP_SHIFT_RIGHT_UNSIGNED, + &&label_JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, + &&label_JOP_MOVE_FAR, + &&label_JOP_MOVE_NEAR, + &&label_JOP_JUMP, + &&label_JOP_JUMP_IF, + &&label_JOP_JUMP_IF_NOT, + &&label_JOP_JUMP_IF_NIL, + &&label_JOP_JUMP_IF_NOT_NIL, + &&label_JOP_GREATER_THAN, + &&label_JOP_GREATER_THAN_IMMEDIATE, + &&label_JOP_LESS_THAN, + &&label_JOP_LESS_THAN_IMMEDIATE, + &&label_JOP_EQUALS, + &&label_JOP_EQUALS_IMMEDIATE, + &&label_JOP_COMPARE, + &&label_JOP_LOAD_NIL, + &&label_JOP_LOAD_TRUE, + &&label_JOP_LOAD_FALSE, + &&label_JOP_LOAD_INTEGER, + &&label_JOP_LOAD_CONSTANT, + &&label_JOP_LOAD_UPVALUE, + &&label_JOP_LOAD_SELF, + &&label_JOP_SET_UPVALUE, + &&label_JOP_CLOSURE, + &&label_JOP_PUSH, + &&label_JOP_PUSH_2, + &&label_JOP_PUSH_3, + &&label_JOP_PUSH_ARRAY, + &&label_JOP_CALL, + &&label_JOP_TAILCALL, + &&label_JOP_RESUME, + &&label_JOP_SIGNAL, + &&label_JOP_PROPAGATE, + &&label_JOP_IN, + &&label_JOP_GET, + &&label_JOP_PUT, + &&label_JOP_GET_INDEX, + &&label_JOP_PUT_INDEX, + &&label_JOP_LENGTH, + &&label_JOP_MAKE_ARRAY, + &&label_JOP_MAKE_BUFFER, + &&label_JOP_MAKE_STRING, + &&label_JOP_MAKE_STRUCT, + &&label_JOP_MAKE_TABLE, + &&label_JOP_MAKE_TUPLE, + &&label_JOP_MAKE_BRACKET_TUPLE, + &&label_JOP_GREATER_THAN_EQUAL, + &&label_JOP_LESS_THAN_EQUAL, + &&label_JOP_NEXT, + &&label_JOP_NOT_EQUALS, + &&label_JOP_NOT_EQUALS_IMMEDIATE, + &&label_JOP_CANCEL, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op, + &&label_unknown_op + }; +#endif + + /* Interpreter state */ + register Janet *stack; + register uint32_t *pc; + register JanetFunction *func; + + if (fiber->flags & JANET_FIBER_RESUME_SIGNAL) { + JanetSignal sig = (fiber->gc.flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; + fiber->gc.flags &= ~JANET_FIBER_STATUS_MASK; + fiber->flags &= ~(JANET_FIBER_RESUME_SIGNAL | JANET_FIBER_FLAG_MASK); + janet_vm.return_reg[0] = in; + return sig; + } + + vm_restore(); + + if (fiber->flags & JANET_FIBER_DID_LONGJUMP) { + if (janet_fiber_frame(fiber)->func == NULL) { + /* Inside a c function */ + janet_fiber_popframe(fiber); + vm_restore(); + } + /* Check if we were at a tail call instruction. If so, do implicit return */ + if ((*pc & 0xFF) == JOP_TAILCALL) { + /* Tail call resume */ + int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; + janet_fiber_popframe(fiber); + if (entrance_frame) { + fiber->flags &= ~JANET_FIBER_FLAG_MASK; + vm_return(JANET_SIGNAL_OK, in); + } + vm_restore(); + } + } + + if (!(fiber->flags & JANET_FIBER_RESUME_NO_USEVAL)) stack[A] = in; + if (!(fiber->flags & JANET_FIBER_RESUME_NO_SKIP)) pc++; + + uint8_t first_opcode = *pc & ((fiber->flags & JANET_FIBER_BREAKPOINT) ? 0x7F : 0xFF); + + fiber->flags &= ~JANET_FIBER_FLAG_MASK; + + /* Main interpreter loop. Semantically is a switch on + * (*pc & 0xFF) inside of an infinite loop. */ + VM_START(); + + VM_DEFAULT(); + fiber->flags |= JANET_FIBER_BREAKPOINT | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; + vm_return(JANET_SIGNAL_DEBUG, janet_wrap_nil()); + + VM_OP(JOP_NOOP) + vm_pcnext(); + + VM_OP(JOP_ERROR) + vm_return(JANET_SIGNAL_ERROR, stack[A]); + + VM_OP(JOP_TYPECHECK) + vm_assert_types(stack[A], E); + vm_pcnext(); + + VM_OP(JOP_RETURN) { + Janet retval = stack[D]; + int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; + janet_fiber_popframe(fiber); + if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval); + vm_restore(); + stack[A] = retval; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_RETURN_NIL) { + Janet retval = janet_wrap_nil(); + int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; + janet_fiber_popframe(fiber); + if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval); + vm_restore(); + stack[A] = retval; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_ADD_IMMEDIATE) + vm_binop_immediate(+); + + VM_OP(JOP_ADD) + vm_binop(+); + + VM_OP(JOP_SUBTRACT_IMMEDIATE) + vm_binop_immediate(-); + + VM_OP(JOP_SUBTRACT) + vm_binop(-); + + VM_OP(JOP_MULTIPLY_IMMEDIATE) + vm_binop_immediate(*); + + VM_OP(JOP_MULTIPLY) + vm_binop(*); + + VM_OP(JOP_DIVIDE_IMMEDIATE) + vm_binop_immediate( /); + + VM_OP(JOP_DIVIDE) + vm_binop( /); + + VM_OP(JOP_DIVIDE_FLOOR) { + Janet op1 = stack[B]; + Janet op2 = stack[C]; + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { + double x1 = janet_unwrap_number(op1); + double x2 = janet_unwrap_number(op2); + stack[A] = janet_wrap_number(floor(x1 / x2)); + vm_pcnext(); + } else { + vm_commit(); + stack[A] = janet_binop_call("div", "rdiv", op1, op2); + vm_checkgc_pcnext(); + } + } + + VM_OP(JOP_MODULO) { + Janet op1 = stack[B]; + Janet op2 = stack[C]; + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { + double x1 = janet_unwrap_number(op1); + double x2 = janet_unwrap_number(op2); + if (x2 == 0) { + stack[A] = janet_wrap_number(x1); + } else { + double intres = x2 * floor(x1 / x2); + stack[A] = janet_wrap_number(x1 - intres); + } + vm_pcnext(); + } else { + vm_commit(); + stack[A] = janet_binop_call("mod", "rmod", op1, op2); + vm_checkgc_pcnext(); + } + } + + VM_OP(JOP_REMAINDER) { + Janet op1 = stack[B]; + Janet op2 = stack[C]; + if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { + double x1 = janet_unwrap_number(op1); + double x2 = janet_unwrap_number(op2); + stack[A] = janet_wrap_number(fmod(x1, x2)); + vm_pcnext(); + } else { + vm_commit(); + stack[A] = janet_binop_call("%", "r%", op1, op2); + vm_checkgc_pcnext(); + } + } + + VM_OP(JOP_BAND) + vm_bitop(&); + + VM_OP(JOP_BOR) + vm_bitop( |); + + VM_OP(JOP_BXOR) + vm_bitop(^); + + VM_OP(JOP_BNOT) { + Janet op = stack[E]; + if (janet_checktype(op, JANET_NUMBER)) { + stack[A] = janet_wrap_integer(~janet_unwrap_integer(op)); + vm_pcnext(); + } else { + vm_commit(); + stack[A] = janet_unary_call("~", op); + vm_checkgc_pcnext(); + } + } + + VM_OP(JOP_SHIFT_RIGHT_UNSIGNED) + vm_bitopu( >>); + + VM_OP(JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE) + vm_bitopu_immediate( >>); + + VM_OP(JOP_SHIFT_RIGHT) + vm_bitop( >>); + + VM_OP(JOP_SHIFT_RIGHT_IMMEDIATE) + vm_bitop_immediate( >>); + + VM_OP(JOP_SHIFT_LEFT) + vm_bitop( <<); + + VM_OP(JOP_SHIFT_LEFT_IMMEDIATE) + vm_bitop_immediate( <<); + + VM_OP(JOP_MOVE_NEAR) + stack[A] = stack[E]; + vm_pcnext(); + + VM_OP(JOP_MOVE_FAR) + stack[E] = stack[A]; + vm_pcnext(); + + VM_OP(JOP_JUMP) + pc += DS; + vm_maybe_auto_suspend(DS <= 0); + vm_next(); + + VM_OP(JOP_JUMP_IF) + if (janet_truthy(stack[A])) { + pc += ES; + vm_maybe_auto_suspend(ES <= 0); + } else { + pc++; + } + vm_next(); + + VM_OP(JOP_JUMP_IF_NOT) + if (janet_truthy(stack[A])) { + pc++; + } else { + pc += ES; + vm_maybe_auto_suspend(ES <= 0); + } + vm_next(); + + VM_OP(JOP_JUMP_IF_NIL) + if (janet_checktype(stack[A], JANET_NIL)) { + pc += ES; + vm_maybe_auto_suspend(ES <= 0); + } else { + pc++; + } + vm_next(); + + VM_OP(JOP_JUMP_IF_NOT_NIL) + if (janet_checktype(stack[A], JANET_NIL)) { + pc++; + } else { + pc += ES; + vm_maybe_auto_suspend(ES <= 0); + } + vm_next(); + + VM_OP(JOP_LESS_THAN) + vm_compop( <); + + VM_OP(JOP_LESS_THAN_EQUAL) + vm_compop( <=); + + VM_OP(JOP_LESS_THAN_IMMEDIATE) + vm_compop_imm( <); + + VM_OP(JOP_GREATER_THAN) + vm_compop( >); + + VM_OP(JOP_GREATER_THAN_EQUAL) + vm_compop( >=); + + VM_OP(JOP_GREATER_THAN_IMMEDIATE) + vm_compop_imm( >); + + VM_OP(JOP_EQUALS) + stack[A] = janet_wrap_boolean(janet_equals(stack[B], stack[C])); + vm_pcnext(); + + VM_OP(JOP_EQUALS_IMMEDIATE) + stack[A] = janet_wrap_boolean(janet_checktype(stack[B], JANET_NUMBER) && (janet_unwrap_number(stack[B]) == (double) CS)); + vm_pcnext(); + + VM_OP(JOP_NOT_EQUALS) + stack[A] = janet_wrap_boolean(!janet_equals(stack[B], stack[C])); + vm_pcnext(); + + VM_OP(JOP_NOT_EQUALS_IMMEDIATE) + stack[A] = janet_wrap_boolean(!janet_checktype(stack[B], JANET_NUMBER) || (janet_unwrap_number(stack[B]) != (double) CS)); + vm_pcnext(); + + VM_OP(JOP_COMPARE) + stack[A] = janet_wrap_integer(janet_compare(stack[B], stack[C])); + vm_pcnext(); + + VM_OP(JOP_NEXT) + vm_commit(); + { + Janet temp = janet_next_impl(stack[B], stack[C], 1); + vm_restore(); + stack[A] = temp; + } + vm_pcnext(); + + VM_OP(JOP_LOAD_NIL) + stack[D] = janet_wrap_nil(); + vm_pcnext(); + + VM_OP(JOP_LOAD_TRUE) + stack[D] = janet_wrap_true(); + vm_pcnext(); + + VM_OP(JOP_LOAD_FALSE) + stack[D] = janet_wrap_false(); + vm_pcnext(); + + VM_OP(JOP_LOAD_INTEGER) + stack[A] = janet_wrap_integer(ES); + vm_pcnext(); + + VM_OP(JOP_LOAD_CONSTANT) { + int32_t cindex = (int32_t)E; + vm_assert(cindex < func->def->constants_length, "invalid constant"); + stack[A] = func->def->constants[cindex]; + vm_pcnext(); + } + + VM_OP(JOP_LOAD_SELF) + stack[D] = janet_wrap_function(func); + vm_pcnext(); + + VM_OP(JOP_LOAD_UPVALUE) { + int32_t eindex = B; + int32_t vindex = C; + JanetFuncEnv *env; + vm_assert(func->def->environments_length > eindex, "invalid upvalue environment"); + env = func->envs[eindex]; + vm_assert(env->length > vindex, "invalid upvalue index"); + vm_assert(janet_env_valid(env), "invalid upvalue environment"); + if (env->offset > 0) { + /* On stack */ + stack[A] = env->as.fiber->data[env->offset + vindex]; + } else { + /* Off stack */ + stack[A] = env->as.values[vindex]; + } + vm_pcnext(); + } + + VM_OP(JOP_SET_UPVALUE) { + int32_t eindex = B; + int32_t vindex = C; + JanetFuncEnv *env; + vm_assert(func->def->environments_length > eindex, "invalid upvalue environment"); + env = func->envs[eindex]; + vm_assert(env->length > vindex, "invalid upvalue index"); + vm_assert(janet_env_valid(env), "invalid upvalue environment"); + if (env->offset > 0) { + env->as.fiber->data[env->offset + vindex] = stack[A]; + } else { + env->as.values[vindex] = stack[A]; + } + vm_pcnext(); + } + + VM_OP(JOP_CLOSURE) { + JanetFuncDef *fd; + JanetFunction *fn; + int32_t elen; + int32_t defindex = (int32_t)E; + vm_assert(defindex < func->def->defs_length, "invalid funcdef"); + fd = func->def->defs[defindex]; + elen = fd->environments_length; + fn = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + ((size_t) elen * sizeof(JanetFuncEnv *))); + fn->def = fd; + { + int32_t i; + for (i = 0; i < elen; ++i) { + int32_t inherit = fd->environments[i]; + if (inherit == -1 || inherit >= func->def->environments_length) { + JanetStackFrame *frame = janet_stack_frame(stack); + if (!frame->env) { + /* Lazy capture of current stack frame */ + JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); + env->offset = fiber->frame; + env->as.fiber = fiber; + env->length = func->def->slotcount; + frame->env = env; + } + fn->envs[i] = frame->env; + } else { + fn->envs[i] = func->envs[inherit]; + } + } + } + stack[A] = janet_wrap_function(fn); + vm_checkgc_pcnext(); + } + + VM_OP(JOP_PUSH) + janet_fiber_push(fiber, stack[D]); + stack = fiber->data + fiber->frame; + vm_checkgc_pcnext(); + + VM_OP(JOP_PUSH_2) + janet_fiber_push2(fiber, stack[A], stack[E]); + stack = fiber->data + fiber->frame; + vm_checkgc_pcnext(); + + VM_OP(JOP_PUSH_3) + janet_fiber_push3(fiber, stack[A], stack[B], stack[C]); + stack = fiber->data + fiber->frame; + vm_checkgc_pcnext(); + + VM_OP(JOP_PUSH_ARRAY) { + const Janet *vals; + int32_t len; + if (janet_indexed_view(stack[D], &vals, &len)) { + janet_fiber_pushn(fiber, vals, len); + } else { + janet_panicf("expected %T, got %v", JANET_TFLAG_INDEXED, stack[D]); + } + } + stack = fiber->data + fiber->frame; + vm_checkgc_pcnext(); + + VM_OP(JOP_CALL) { + vm_maybe_auto_suspend(1); + Janet callee = stack[E]; + if (fiber->stacktop > fiber->maxstack) { + vm_throw("stack overflow"); + } + if (janet_checktype(callee, JANET_KEYWORD)) { + vm_commit(); + callee = resolve_method(callee, fiber); + } + if (janet_checktype(callee, JANET_FUNCTION)) { + func = janet_unwrap_function(callee); + if (func->gc.flags & JANET_FUNCFLAG_TRACE) { + vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart); + } + vm_commit(); + if (janet_fiber_funcframe(fiber, func)) { + int32_t n = fiber->stacktop - fiber->stackstart; + janet_panicf("%v called with %d argument%s, expected %d", + callee, n, n == 1 ? "" : "s", func->def->arity); + } + stack = fiber->data + fiber->frame; + pc = func->def->bytecode; + vm_checkgc_next(); + } else if (janet_checktype(callee, JANET_CFUNCTION)) { + vm_commit(); + int32_t argc = fiber->stacktop - fiber->stackstart; + janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee)); + Janet ret = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame); + janet_fiber_popframe(fiber); + stack = fiber->data + fiber->frame; + stack[A] = ret; + vm_checkgc_pcnext(); + } else { + vm_commit(); + stack[A] = call_nonfn(fiber, callee); + vm_pcnext(); + } + } + + VM_OP(JOP_TAILCALL) { + vm_maybe_auto_suspend(1); + Janet callee = stack[D]; + if (fiber->stacktop > fiber->maxstack) { + vm_throw("stack overflow"); + } + if (janet_checktype(callee, JANET_KEYWORD)) { + vm_commit(); + callee = resolve_method(callee, fiber); + } + if (janet_checktype(callee, JANET_FUNCTION)) { + func = janet_unwrap_function(callee); + if (func->gc.flags & JANET_FUNCFLAG_TRACE) { + vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart); + } + if (janet_fiber_funcframe_tail(fiber, func)) { + janet_stack_frame(fiber->data + fiber->frame)->pc = pc; + int32_t n = fiber->stacktop - fiber->stackstart; + janet_panicf("%v called with %d argument%s, expected %d", + callee, n, n == 1 ? "" : "s", func->def->arity); + } + stack = fiber->data + fiber->frame; + pc = func->def->bytecode; + vm_checkgc_next(); + } else { + Janet retreg; + int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; + vm_commit(); + if (janet_checktype(callee, JANET_CFUNCTION)) { + int32_t argc = fiber->stacktop - fiber->stackstart; + janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee)); + retreg = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame); + janet_fiber_popframe(fiber); + } else { + retreg = call_nonfn(fiber, callee); + } + janet_fiber_popframe(fiber); + if (entrance_frame) { + vm_return_no_restore(JANET_SIGNAL_OK, retreg); + } + vm_restore(); + stack[A] = retreg; + vm_checkgc_pcnext(); + } + } + + VM_OP(JOP_RESUME) { + Janet retreg; + vm_maybe_auto_suspend(1); + vm_assert_type(stack[B], JANET_FIBER); + JanetFiber *child = janet_unwrap_fiber(stack[B]); + if (janet_check_can_resume(child, &retreg, 0)) { + vm_commit(); + janet_panicv(retreg); + } + fiber->child = child; + JanetSignal sig = janet_continue_no_check(child, stack[C], &retreg); + if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { + vm_return(sig, retreg); + } + fiber->child = NULL; + stack = fiber->data + fiber->frame; + stack[A] = retreg; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_SIGNAL) { + int32_t s = C; + if (s > JANET_SIGNAL_USER9) s = JANET_SIGNAL_USER9; + if (s < 0) s = 0; + vm_return(s, stack[B]); + } + + VM_OP(JOP_PROPAGATE) { + Janet fv = stack[C]; + vm_assert_type(fv, JANET_FIBER); + JanetFiber *f = janet_unwrap_fiber(fv); + JanetFiberStatus sub_status = janet_fiber_status(f); + if (sub_status > JANET_STATUS_USER9) { + vm_commit(); + janet_panicf("cannot propagate from fiber with status :%s", + janet_status_names[sub_status]); + } + fiber->child = f; + vm_return((int) sub_status, stack[B]); + } + + VM_OP(JOP_CANCEL) { + Janet retreg; + vm_assert_type(stack[B], JANET_FIBER); + JanetFiber *child = janet_unwrap_fiber(stack[B]); + if (janet_check_can_resume(child, &retreg, 1)) { + vm_commit(); + janet_panicv(retreg); + } + fiber->child = child; + JanetSignal sig = janet_continue_signal(child, stack[C], &retreg, JANET_SIGNAL_ERROR); + if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { + vm_return(sig, retreg); + } + fiber->child = NULL; + stack = fiber->data + fiber->frame; + stack[A] = retreg; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_PUT) + vm_commit(); + fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL; + janet_put(stack[A], stack[B], stack[C]); + fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL; + vm_checkgc_pcnext(); + + VM_OP(JOP_PUT_INDEX) + vm_commit(); + fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL; + janet_putindex(stack[A], C, stack[B]); + fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL; + vm_checkgc_pcnext(); + + VM_OP(JOP_IN) + vm_commit(); + stack[A] = janet_in(stack[B], stack[C]); + vm_pcnext(); + + VM_OP(JOP_GET) + vm_commit(); + stack[A] = janet_get(stack[B], stack[C]); + vm_pcnext(); + + VM_OP(JOP_GET_INDEX) + vm_commit(); + stack[A] = janet_getindex(stack[B], C); + vm_pcnext(); + + VM_OP(JOP_LENGTH) + vm_commit(); + stack[A] = janet_lengthv(stack[E]); + vm_pcnext(); + + VM_OP(JOP_MAKE_ARRAY) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + stack[D] = janet_wrap_array(janet_array_n(mem, count)); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_MAKE_TUPLE) + /* fallthrough */ + VM_OP(JOP_MAKE_BRACKET_TUPLE) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + const Janet *tup = janet_tuple_n(mem, count); + if (opcode == JOP_MAKE_BRACKET_TUPLE) + janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; + stack[D] = janet_wrap_tuple(tup); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_MAKE_TABLE) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + if (count & 1) { + vm_commit(); + janet_panicf("expected even number of arguments to table constructor, got %d", count); + } + JanetTable *table = janet_table(count / 2); + for (int32_t i = 0; i < count; i += 2) + janet_table_put(table, mem[i], mem[i + 1]); + stack[D] = janet_wrap_table(table); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_MAKE_STRUCT) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + if (count & 1) { + vm_commit(); + janet_panicf("expected even number of arguments to struct constructor, got %d", count); + } + JanetKV *st = janet_struct_begin(count / 2); + for (int32_t i = 0; i < count; i += 2) + janet_struct_put(st, mem[i], mem[i + 1]); + stack[D] = janet_wrap_struct(janet_struct_end(st)); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_MAKE_STRING) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + JanetBuffer buffer; + janet_buffer_init(&buffer, 10 * count); + for (int32_t i = 0; i < count; i++) + janet_to_string_b(&buffer, mem[i]); + stack[D] = janet_stringv(buffer.data, buffer.count); + janet_buffer_deinit(&buffer); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_OP(JOP_MAKE_BUFFER) { + int32_t count = fiber->stacktop - fiber->stackstart; + Janet *mem = fiber->data + fiber->stackstart; + JanetBuffer *buffer = janet_buffer(10 * count); + for (int32_t i = 0; i < count; i++) + janet_to_string_b(buffer, mem[i]); + stack[D] = janet_wrap_buffer(buffer); + fiber->stacktop = fiber->stackstart; + vm_checkgc_pcnext(); + } + + VM_END() +} + +/* + * Execute a single instruction in the fiber. Does this by inspecting + * the fiber, setting a breakpoint at the next instruction, executing, and + * reseting breakpoints to how they were prior. Yes, it's a bit hacky. + */ +JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out) { + /* No finished or currently alive fibers. */ + JanetFiberStatus status = janet_fiber_status(fiber); + if (status == JANET_STATUS_ALIVE || + status == JANET_STATUS_DEAD || + status == JANET_STATUS_ERROR) { + janet_panicf("cannot step fiber with status :%s", janet_status_names[status]); + } + + /* Get PC for setting breakpoints */ + uint32_t *pc = janet_stack_frame(fiber->data + fiber->frame)->pc; + + /* Check current opcode (sans debug flag). This tells us where the next or next two candidate + * instructions will be. Usually it's the next instruction in memory, + * but for branching instructions it is also the target of the branch. */ + uint32_t *nexta = NULL, *nextb = NULL, olda = 0, oldb = 0; + + /* Set temporary breakpoints */ + switch (*pc & 0x7F) { + default: + nexta = pc + 1; + break; + /* These we just ignore for now. Supporting them means + * we could step into and out of functions (including JOP_CALL). */ + case JOP_RETURN_NIL: + case JOP_RETURN: + case JOP_ERROR: + case JOP_TAILCALL: + break; + case JOP_JUMP: + nexta = pc + DS; + break; + case JOP_JUMP_IF: + case JOP_JUMP_IF_NOT: + nexta = pc + 1; + nextb = pc + ES; + break; + } + if (nexta) { + olda = *nexta; + *nexta |= 0x80; + } + if (nextb) { + oldb = *nextb; + *nextb |= 0x80; + } + + /* Go */ + JanetSignal signal = janet_continue(fiber, in, out); + + /* Restore */ + if (nexta) *nexta = olda; + if (nextb) *nextb = oldb; + + return signal; +} + +static Janet void_cfunction(int32_t argc, Janet *argv) { + (void) argc; + (void) argv; + janet_panic("placeholder"); +} + +Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) { + /* Check entry conditions */ + if (!janet_vm.fiber) + janet_panic("janet_call failed because there is no current fiber"); + if (janet_vm.stackn >= JANET_RECURSION_GUARD) + janet_panic("C stack recursed too deeply"); + + /* Dirty stack */ + int32_t dirty_stack = janet_vm.fiber->stacktop - janet_vm.fiber->stackstart; + if (dirty_stack) { + janet_fiber_cframe(janet_vm.fiber, void_cfunction); + } + + /* Tracing */ + if (fun->gc.flags & JANET_FUNCFLAG_TRACE) { + janet_vm.stackn++; + vm_do_trace(fun, argc, argv); + janet_vm.stackn--; + } + + /* Push frame */ + janet_fiber_pushn(janet_vm.fiber, argv, argc); + if (janet_fiber_funcframe(janet_vm.fiber, fun)) { + int32_t min = fun->def->min_arity; + int32_t max = fun->def->max_arity; + Janet funv = janet_wrap_function(fun); + if (min == max && min != argc) + janet_panicf("arity mismatch in %v, expected %d, got %d", funv, min, argc); + if (min >= 0 && argc < min) + janet_panicf("arity mismatch in %v, expected at least %d, got %d", funv, min, argc); + janet_panicf("arity mismatch in %v, expected at most %d, got %d", funv, max, argc); + } + janet_fiber_frame(janet_vm.fiber)->flags |= JANET_STACKFRAME_ENTRANCE; + + /* Set up */ + int32_t oldn = janet_vm.stackn++; + int handle = janet_gclock(); + + /* Run vm */ + janet_vm.fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; + JanetSignal signal = run_vm(janet_vm.fiber, janet_wrap_nil()); + + /* Teardown */ + janet_vm.stackn = oldn; + janet_gcunlock(handle); + if (dirty_stack) { + janet_fiber_popframe(janet_vm.fiber); + janet_vm.fiber->stacktop += dirty_stack; + } + + if (signal != JANET_SIGNAL_OK) { + janet_panicv(*janet_vm.return_reg); + } + + return *janet_vm.return_reg; +} + +static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel) { + /* Check conditions */ + JanetFiberStatus old_status = janet_fiber_status(fiber); + if (janet_vm.stackn >= JANET_RECURSION_GUARD) { + janet_fiber_set_status(fiber, JANET_STATUS_ERROR); + *out = janet_cstringv("C stack recursed too deeply"); + return JANET_SIGNAL_ERROR; + } + /* If a "task" fiber is trying to be used as a normal fiber, detect that. See bug #920. + * Fibers must be marked as root fibers manually, or by the ev scheduler. */ + if (janet_vm.fiber != NULL && (fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) { +#ifdef JANET_EV + *out = janet_cstringv(is_cancel + ? "cannot cancel root fiber, use ev/cancel" + : "cannot resume root fiber, use ev/go"); +#else + *out = janet_cstringv(is_cancel + ? "cannot cancel root fiber" + : "cannot resume root fiber"); +#endif + return JANET_SIGNAL_ERROR; + } + if (old_status == JANET_STATUS_ALIVE || + old_status == JANET_STATUS_DEAD || + (old_status >= JANET_STATUS_USER0 && old_status <= JANET_STATUS_USER4) || + old_status == JANET_STATUS_ERROR) { + const uint8_t *str = janet_formatc("cannot resume fiber with status :%s", + janet_status_names[old_status]); + *out = janet_wrap_string(str); + return JANET_SIGNAL_ERROR; + } + return JANET_SIGNAL_OK; +} + +void janet_try_init(JanetTryState *state) { + state->stackn = janet_vm.stackn++; + state->gc_handle = janet_vm.gc_suspend; + state->vm_fiber = janet_vm.fiber; + state->vm_jmp_buf = janet_vm.signal_buf; + state->vm_return_reg = janet_vm.return_reg; + janet_vm.return_reg = &(state->payload); + janet_vm.signal_buf = &(state->buf); +} + +void janet_restore(JanetTryState *state) { + janet_vm.stackn = state->stackn; + janet_vm.gc_suspend = state->gc_handle; + janet_vm.fiber = state->vm_fiber; + janet_vm.signal_buf = state->vm_jmp_buf; + janet_vm.return_reg = state->vm_return_reg; +} + +static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) { + + JanetFiberStatus old_status = janet_fiber_status(fiber); + +#ifdef JANET_EV + janet_fiber_did_resume(fiber); +#endif + + /* Clear last value */ + fiber->last_value = janet_wrap_nil(); + + /* Continue child fiber if it exists */ + if (fiber->child) { + if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber; + JanetFiber *child = fiber->child; + uint32_t instr = (janet_stack_frame(fiber->data + fiber->frame)->pc)[0]; + janet_vm.stackn++; + JanetSignal sig = janet_continue(child, in, &in); + janet_vm.stackn--; + if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL; + if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { + *out = in; + janet_fiber_set_status(fiber, sig); + fiber->last_value = child->last_value; + return sig; + } + /* Check if we need any special handling for certain opcodes */ + switch (instr & 0x7F) { + default: + break; + case JOP_NEXT: { + if (sig == JANET_SIGNAL_OK || + sig == JANET_SIGNAL_ERROR || + sig == JANET_SIGNAL_USER0 || + sig == JANET_SIGNAL_USER1 || + sig == JANET_SIGNAL_USER2 || + sig == JANET_SIGNAL_USER3 || + sig == JANET_SIGNAL_USER4) { + in = janet_wrap_nil(); + } else { + in = janet_wrap_integer(0); + } + break; + } + } + fiber->child = NULL; + } + + /* Handle new fibers being resumed with a non-nil value */ + if (old_status == JANET_STATUS_NEW && !janet_checktype(in, JANET_NIL)) { + Janet *stack = fiber->data + fiber->frame; + JanetFunction *func = janet_stack_frame(stack)->func; + if (func) { + if (func->def->arity > 0) { + stack[0] = in; + } else if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { + stack[0] = janet_wrap_tuple(janet_tuple_n(&in, 1)); + } + } + } + + /* Save global state */ + JanetTryState tstate; + JanetSignal sig = janet_try(&tstate); + if (!sig) { + /* Normal setup */ + if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber; + janet_vm.fiber = fiber; + janet_fiber_set_status(fiber, JANET_STATUS_ALIVE); + sig = run_vm(fiber, in); + } + + /* Restore */ + if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL; + janet_fiber_set_status(fiber, sig); + janet_restore(&tstate); + fiber->last_value = tstate.payload; + *out = tstate.payload; + + return sig; +} + +/* Enter the main vm loop */ +JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) { + /* Check conditions */ + JanetSignal tmp_signal = janet_check_can_resume(fiber, out, 0); + if (tmp_signal) return tmp_signal; + return janet_continue_no_check(fiber, in, out); +} + +/* Enter the main vm loop but immediately raise a signal */ +JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig) { + JanetSignal tmp_signal = janet_check_can_resume(fiber, out, sig != JANET_SIGNAL_OK); + if (tmp_signal) return tmp_signal; + if (sig != JANET_SIGNAL_OK) { + JanetFiber *child = fiber; + while (child->child) child = child->child; + child->gc.flags &= ~JANET_FIBER_STATUS_MASK; + child->gc.flags |= sig << JANET_FIBER_STATUS_OFFSET; + child->flags |= JANET_FIBER_RESUME_SIGNAL; + } + return janet_continue_no_check(fiber, in, out); +} + +JanetSignal janet_pcall( + JanetFunction *fun, + int32_t argc, + const Janet *argv, + Janet *out, + JanetFiber **f) { + JanetFiber *fiber; + if (f && *f) { + fiber = janet_fiber_reset(*f, fun, argc, argv); + } else { + fiber = janet_fiber(fun, 64, argc, argv); + } + if (f) *f = fiber; + if (NULL == fiber) { + *out = janet_cstringv("arity mismatch"); + return JANET_SIGNAL_ERROR; + } + return janet_continue(fiber, janet_wrap_nil(), out); +} + +Janet janet_mcall(const char *name, int32_t argc, Janet *argv) { + /* At least 1 argument */ + if (argc < 1) { + janet_panicf("method :%s expected at least 1 argument", name); + } + /* Find method */ + Janet method = janet_method_lookup(argv[0], name); + if (janet_checktype(method, JANET_NIL)) { + janet_panicf("could not find method :%s for %v", name, argv[0]); + } + /* Invoke method */ + return janet_method_invoke(method, argc, argv); +} + +/* Setup VM */ +int janet_init(void) { + + /* Garbage collection */ + janet_vm.blocks = NULL; + janet_vm.weak_blocks = NULL; + janet_vm.next_collection = 0; + janet_vm.gc_interval = 0x400000; + janet_vm.block_count = 0; + janet_vm.gc_mark_phase = 0; + + janet_symcache_init(); + + /* Initialize gc roots */ + janet_vm.roots = NULL; + janet_vm.root_count = 0; + janet_vm.root_capacity = 0; + + /* Scratch memory */ + janet_vm.user = NULL; + janet_vm.scratch_mem = NULL; + janet_vm.scratch_len = 0; + janet_vm.scratch_cap = 0; + + /* Sandbox flags */ + janet_vm.sandbox_flags = 0; + + /* Initialize registry */ + janet_vm.registry = NULL; + janet_vm.registry_cap = 0; + janet_vm.registry_count = 0; + janet_vm.registry_dirty = 0; + + /* Intialize abstract registry */ + janet_vm.abstract_registry = janet_table(0); + janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); + + /* Traversal */ + janet_vm.traversal = NULL; + janet_vm.traversal_base = NULL; + janet_vm.traversal_top = NULL; + + /* Core env */ + janet_vm.core_env = NULL; + + /* Auto suspension */ + janet_vm.auto_suspend = 0; + + /* Dynamic bindings */ + janet_vm.top_dyns = NULL; + + /* Seed RNG */ + janet_rng_seed(janet_default_rng(), 0); + + /* Fibers */ + janet_vm.fiber = NULL; + janet_vm.root_fiber = NULL; + janet_vm.stackn = 0; + +#ifdef JANET_EV + janet_ev_init(); +#endif +#ifdef JANET_NET + janet_net_init(); +#endif + return 0; +} + +/* Disable some features at runtime with no way to re-enable them */ +void janet_sandbox(uint32_t flags) { + janet_sandbox_assert(JANET_SANDBOX_SANDBOX); + janet_vm.sandbox_flags |= flags; +} + +void janet_sandbox_assert(uint32_t forbidden_flags) { + if (forbidden_flags & janet_vm.sandbox_flags) { + janet_panic("operation forbidden by sandbox"); + } +} + +/* Clear all memory associated with the VM */ +void janet_deinit(void) { + janet_clear_memory(); + janet_symcache_deinit(); + janet_free(janet_vm.roots); + janet_vm.roots = NULL; + janet_vm.root_count = 0; + janet_vm.root_capacity = 0; + janet_vm.abstract_registry = NULL; + janet_vm.core_env = NULL; + janet_vm.top_dyns = NULL; + janet_vm.user = NULL; + janet_free(janet_vm.traversal_base); + janet_vm.fiber = NULL; + janet_vm.root_fiber = NULL; + janet_free(janet_vm.registry); + janet_vm.registry = NULL; +#ifdef JANET_EV + janet_ev_deinit(); +#endif +#ifdef JANET_NET + janet_net_deinit(); +#endif +} + + +/* src/core/wrap.c */ +#line 0 "src/core/wrap.c" + +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +#ifndef JANET_AMALG +#include "features.h" +#include +#include +#include "util.h" +#include "state.h" +#endif + +/* Macro fills */ + +JanetType(janet_type)(Janet x) { + return janet_type(x); +} +int (janet_checktype)(Janet x, JanetType type) { + return janet_checktype(x, type); +} +int (janet_checktypes)(Janet x, int typeflags) { + return janet_checktypes(x, typeflags); +} +int (janet_truthy)(Janet x) { + return janet_truthy(x); +} + +JanetStruct(janet_unwrap_struct)(Janet x) { + return janet_unwrap_struct(x); +} +JanetTuple(janet_unwrap_tuple)(Janet x) { + return janet_unwrap_tuple(x); +} +JanetFiber *(janet_unwrap_fiber)(Janet x) { + return janet_unwrap_fiber(x); +} +JanetArray *(janet_unwrap_array)(Janet x) { + return janet_unwrap_array(x); +} +JanetTable *(janet_unwrap_table)(Janet x) { + return janet_unwrap_table(x); +} +JanetBuffer *(janet_unwrap_buffer)(Janet x) { + return janet_unwrap_buffer(x); +} +JanetString(janet_unwrap_string)(Janet x) { + return janet_unwrap_string(x); +} +JanetSymbol(janet_unwrap_symbol)(Janet x) { + return janet_unwrap_symbol(x); +} +JanetKeyword(janet_unwrap_keyword)(Janet x) { + return janet_unwrap_keyword(x); +} +JanetAbstract(janet_unwrap_abstract)(Janet x) { + return janet_unwrap_abstract(x); +} +void *(janet_unwrap_pointer)(Janet x) { + return janet_unwrap_pointer(x); +} +JanetFunction *(janet_unwrap_function)(Janet x) { + return janet_unwrap_function(x); +} +JanetCFunction(janet_unwrap_cfunction)(Janet x) { + return janet_unwrap_cfunction(x); +} +int (janet_unwrap_boolean)(Janet x) { + return janet_unwrap_boolean(x); +} +int32_t (janet_unwrap_integer)(Janet x) { + return janet_unwrap_integer(x); +} + +#if defined(JANET_NANBOX_32) || defined(JANET_NANBOX_64) +Janet(janet_wrap_nil)(void) { + return janet_wrap_nil(); +} +Janet(janet_wrap_true)(void) { + return janet_wrap_true(); +} +Janet(janet_wrap_false)(void) { + return janet_wrap_false(); +} +Janet(janet_wrap_boolean)(int x) { + return janet_wrap_boolean(x); +} +Janet(janet_wrap_string)(JanetString x) { + return janet_wrap_string(x); +} +Janet(janet_wrap_symbol)(JanetSymbol x) { + return janet_wrap_symbol(x); +} +Janet(janet_wrap_keyword)(JanetKeyword x) { + return janet_wrap_keyword(x); +} +Janet(janet_wrap_array)(JanetArray *x) { + return janet_wrap_array(x); +} +Janet(janet_wrap_tuple)(JanetTuple x) { + return janet_wrap_tuple(x); +} +Janet(janet_wrap_struct)(JanetStruct x) { + return janet_wrap_struct(x); +} +Janet(janet_wrap_fiber)(JanetFiber *x) { + return janet_wrap_fiber(x); +} +Janet(janet_wrap_buffer)(JanetBuffer *x) { + return janet_wrap_buffer(x); +} +Janet(janet_wrap_function)(JanetFunction *x) { + return janet_wrap_function(x); +} +Janet(janet_wrap_cfunction)(JanetCFunction x) { + return janet_wrap_cfunction(x); +} +Janet(janet_wrap_table)(JanetTable *x) { + return janet_wrap_table(x); +} +Janet(janet_wrap_abstract)(JanetAbstract x) { + return janet_wrap_abstract(x); +} +Janet(janet_wrap_pointer)(void *x) { + return janet_wrap_pointer(x); +} +Janet(janet_wrap_integer)(int32_t x) { + return janet_wrap_integer(x); +} +#endif + +#ifndef JANET_NANBOX_32 +double (janet_unwrap_number)(Janet x) { + return janet_unwrap_number(x); +} +#endif + +#ifdef JANET_NANBOX_64 +Janet(janet_wrap_number)(double x) { + return janet_wrap_number(x); +} +#endif + +/*****/ + +void *janet_memalloc_empty(int32_t count) { + int32_t i; + void *mem = janet_malloc((size_t) count * sizeof(JanetKV)); + janet_vm.next_collection += (size_t) count * sizeof(JanetKV); + if (NULL == mem) { + JANET_OUT_OF_MEMORY; + } + JanetKV *mmem = (JanetKV *)mem; + for (i = 0; i < count; i++) { + JanetKV *kv = mmem + i; + kv->key = janet_wrap_nil(); + kv->value = janet_wrap_nil(); + } + return mem; +} + +void janet_memempty(JanetKV *mem, int32_t count) { + int32_t i; + for (i = 0; i < count; i++) { + mem[i].key = janet_wrap_nil(); + mem[i].value = janet_wrap_nil(); + } +} + +#ifdef JANET_NANBOX_64 + +Janet janet_wrap_number_safe(double d) { + Janet ret; + ret.number = isnan(d) ? NAN : d; + return ret; +} + +void *janet_nanbox_to_pointer(Janet x) { + x.i64 &= JANET_NANBOX_PAYLOADBITS; + return x.pointer; +} + +Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { + Janet ret; + ret.pointer = p; + ret.u64 |= tagmask; + return ret; +} + +Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { + Janet ret; + ret.pointer = (void *)p; + ret.u64 |= tagmask; + return ret; +} + +Janet janet_nanbox_from_double(double d) { + Janet ret; + ret.number = d; + return ret; +} + +Janet janet_nanbox_from_bits(uint64_t bits) { + Janet ret; + ret.u64 = bits; + return ret; +} + +#elif defined(JANET_NANBOX_32) + +Janet janet_wrap_number(double x) { + Janet ret; + ret.number = x; + ret.tagged.type += JANET_DOUBLE_OFFSET; + return ret; +} + +Janet janet_wrap_number_safe(double d) { + double x = isnan(d) ? NAN : d; + return janet_wrap_number(x); +} + +Janet janet_nanbox32_from_tagi(uint32_t tag, int32_t integer) { + Janet ret; + ret.tagged.type = tag; + ret.tagged.payload.integer = integer; + return ret; +} + +Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer) { + Janet ret; + ret.tagged.type = tag; + ret.tagged.payload.pointer = pointer; + return ret; +} + +double janet_unwrap_number(Janet x) { + x.tagged.type -= JANET_DOUBLE_OFFSET; + return x.number; +} + +#else + +Janet janet_wrap_number_safe(double d) { + return janet_wrap_number(d); +} + +Janet janet_wrap_nil(void) { + Janet y; + y.type = JANET_NIL; + y.as.u64 = 0; + return y; +} + +Janet janet_wrap_true(void) { + Janet y; + y.type = JANET_BOOLEAN; + y.as.u64 = 1; + return y; +} + +Janet janet_wrap_false(void) { + Janet y; + y.type = JANET_BOOLEAN; + y.as.u64 = 0; + return y; +} + +Janet janet_wrap_boolean(int x) { + Janet y; + y.type = JANET_BOOLEAN; + y.as.u64 = !!x; + return y; +} + +#define JANET_WRAP_DEFINE(NAME, TYPE, DTYPE, UM)\ +Janet janet_wrap_##NAME(TYPE x) {\ + Janet y;\ + y.type = DTYPE;\ + y.as.u64 = 0; /* zero other bits in case of 32 bit integer */ \ + y.as.UM = x;\ + return y;\ +} + +JANET_WRAP_DEFINE(number, double, JANET_NUMBER, number) +JANET_WRAP_DEFINE(string, const uint8_t *, JANET_STRING, cpointer) +JANET_WRAP_DEFINE(symbol, const uint8_t *, JANET_SYMBOL, cpointer) +JANET_WRAP_DEFINE(keyword, const uint8_t *, JANET_KEYWORD, cpointer) +JANET_WRAP_DEFINE(array, JanetArray *, JANET_ARRAY, pointer) +JANET_WRAP_DEFINE(tuple, const Janet *, JANET_TUPLE, cpointer) +JANET_WRAP_DEFINE(struct, const JanetKV *, JANET_STRUCT, cpointer) +JANET_WRAP_DEFINE(fiber, JanetFiber *, JANET_FIBER, pointer) +JANET_WRAP_DEFINE(buffer, JanetBuffer *, JANET_BUFFER, pointer) +JANET_WRAP_DEFINE(function, JanetFunction *, JANET_FUNCTION, pointer) +JANET_WRAP_DEFINE(cfunction, JanetCFunction, JANET_CFUNCTION, pointer) +JANET_WRAP_DEFINE(table, JanetTable *, JANET_TABLE, pointer) +JANET_WRAP_DEFINE(abstract, void *, JANET_ABSTRACT, pointer) +JANET_WRAP_DEFINE(pointer, void *, JANET_POINTER, pointer) + +#undef JANET_WRAP_DEFINE + +#endif + +static const unsigned char janet_core_image_bytes[] = { + 0xD3, 0x82, 0x92, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0xD3, 0x03, 0xD0, + 0x0A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6D, 0x61, 0x70, 0xD2, 0x03, 0x00, 0xCE, 0x0D, + 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x6F, 0x73, 0x2E, 0x63, 0x86, 0x2B, 0x01, + 0xD0, 0x05, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, 0x63, + 0x6B, 0xD0, 0x03, 0x64, 0x6F, 0x63, 0xCE, 0x83, 0x42, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, + 0x63, 0x6B, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x20, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2E, 0x0A, 0x0A, + 0x54, 0x68, 0x65, 0x20, 0x60, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x60, 0x20, 0x61, 0x72, 0x67, + 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, + 0x6F, 0x20, 0x75, 0x73, 0x65, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x60, 0x3A, 0x72, 0x65, 0x61, 0x6C, 0x74, + 0x69, 0x6D, 0x65, 0x60, 0x3A, 0x0A, 0x2D, 0x20, 0x3A, 0x72, 0x65, 0x61, 0x6C, 0x74, 0x69, 0x6D, + 0x65, 0x3A, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x61, 0x6C, 0x20, 0x28, 0x69, 0x2E, 0x65, 0x2E, 0x2C, 0x20, 0x77, 0x61, 0x6C, 0x6C, 0x2D, 0x63, + 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x64, 0x69, 0x73, 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, + 0x6F, 0x75, 0x73, 0x20, 0x20, 0x20, 0x6A, 0x75, 0x6D, 0x70, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x0A, 0x2D, + 0x20, 0x3A, 0x6D, 0x6F, 0x6E, 0x6F, 0x74, 0x6F, 0x6E, 0x69, 0x63, 0x3A, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x77, 0x68, 0x6F, 0x6C, 0x65, 0x20, 0x2B, 0x20, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x73, 0x69, 0x6E, + 0x63, 0x65, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x20, 0x70, 0x6F, + 0x69, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x20, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x67, 0x75, 0x61, 0x72, + 0x61, 0x6E, 0x74, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6E, 0x6F, 0x6E, + 0x2D, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x72, + 0x65, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0x0A, 0x2D, 0x20, 0x3A, 0x63, 0x70, 0x75, + 0x74, 0x69, 0x6D, 0x65, 0x3A, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x43, 0x50, 0x55, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, + 0x73, 0x73, 0x20, 0x20, 0x28, 0x69, 0x2E, 0x65, 0x2E, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x63, 0x65, 0x73, 0x73, 0x29, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0x60, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x65, 0x6C, 0x65, + 0x63, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x60, 0x3A, 0x64, 0x6F, 0x75, 0x62, + 0x6C, 0x65, 0x60, 0x3A, 0x0A, 0x2D, 0x20, 0x3A, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x3A, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x2B, 0x20, 0x66, + 0x72, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, + 0x73, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x0A, 0x2D, 0x20, + 0x3A, 0x69, 0x6E, 0x74, 0x3A, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, + 0x64, 0x73, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x0A, 0x2D, 0x20, 0x3A, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x3A, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x61, 0x20, 0x32, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x20, 0x5B, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x6E, 0x61, + 0x6E, 0x6F, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x5D, 0x0A, 0xCF, 0x08, 0x66, 0x66, 0x69, + 0x2F, 0x72, 0x65, 0x61, 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x73, 0x72, + 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x66, 0x66, 0x69, 0x2E, 0x63, 0x85, 0x7F, 0x01, 0xDA, + 0x06, 0xD8, 0x08, 0x66, 0x66, 0x69, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x08, 0xCE, 0x80, 0xE5, + 0x28, 0x66, 0x66, 0x69, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x66, 0x69, 0x2D, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6F, 0x66, + 0x66, 0x73, 0x65, 0x74, 0x29, 0x0A, 0x0A, 0x50, 0x61, 0x72, 0x73, 0x65, 0x20, 0x61, 0x20, 0x6E, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6F, 0x75, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x6E, + 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x66, 0x66, + 0x69, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x60, 0x2E, 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, + 0x72, 0x61, 0x77, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2C, 0x20, 0x61, 0x6C, 0x74, + 0x68, 0x6F, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x75, 0x6E, + 0x73, 0x61, 0x66, 0x65, 0x2E, 0xCF, 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, + 0x65, 0x2F, 0x6E, 0x65, 0x74, 0x2E, 0x63, 0x83, 0x7F, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x6E, 0x65, + 0x74, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xDA, 0x08, 0xCE, 0x80, 0xED, 0x28, 0x6E, 0x65, 0x74, + 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, + 0x0A, 0x0A, 0x57, 0x72, 0x69, 0x74, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2C, 0x20, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6E, + 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x73, + 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, + 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, + 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, + 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0xCF, 0x0A, 0x68, 0x61, 0x73, 0x2D, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x3F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0A, 0x62, 0x6F, + 0x6F, 0x74, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x84, 0xCC, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x01, 0x06, 0x00, 0x03, 0xCE, 0x0A, 0x68, 0x61, + 0x73, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x3F, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x0A, 0x03, 0x02, 0x03, 0x00, 0x0F, 0x00, 0x06, 0xCE, 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x2D, 0x6F, 0x66, 0xDA, 0x18, 0x00, 0x0F, 0x00, 0xCF, 0x01, 0x78, 0x00, 0x0F, 0x01, 0xCF, 0x03, + 0x69, 0x6E, 0x64, 0x00, 0x0F, 0x02, 0xCF, 0x04, 0x64, 0x66, 0x6C, 0x74, 0x00, 0x0F, 0x03, 0xCF, + 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2D, 0x6F, 0x66, 0x02, 0x0F, 0x05, 0xCF, 0x01, 0x6B, 0x03, + 0x0F, 0x06, 0xCF, 0x03, 0x72, 0x65, 0x74, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x01, 0x05, 0x1B, + 0x05, 0x04, 0x00, 0x1B, 0x06, 0x02, 0x00, 0x28, 0x08, 0x00, 0x00, 0x4A, 0x07, 0x08, 0x05, 0x1E, + 0x07, 0x08, 0x00, 0x3A, 0x08, 0x01, 0x05, 0x25, 0x09, 0x08, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, + 0x06, 0x05, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x05, 0x01, 0x05, 0x1C, 0xF7, 0xFF, 0xFF, 0x03, + 0x06, 0x00, 0x00, 0x84, 0x35, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x01, 0x0A, 0x00, 0x0A, + 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0B, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x28, 0x01, 0x0C, 0xBF, 0xFE, + 0x03, 0xBF, 0xF9, 0x01, 0x00, 0x06, 0x00, 0xCF, 0x02, 0x64, 0x73, 0x00, 0x06, 0x01, 0xCF, 0x05, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x00, 0x06, 0x02, 0xDA, 0x16, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x04, + 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x28, 0x05, 0x00, 0x00, 0x4A, 0x04, 0x05, 0x03, 0x03, 0x04, + 0x00, 0x00, 0x84, 0xCF, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, + 0x08, 0xCE, 0x80, 0x84, 0x28, 0x68, 0x61, 0x73, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x3F, 0x20, + 0x64, 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x60, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x60, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x70, 0x6F, 0x72, 0x74, 0x69, 0x6F, + 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x60, 0x64, 0x73, 0x60, 0x2E, 0xCF, 0x06, 0x62, 0x79, 0x74, 0x65, 0x73, 0x3F, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x12, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, + 0x65, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x6C, 0x69, 0x62, 0x2E, 0x63, 0x82, 0x98, 0x01, 0xDA, 0x06, + 0xD8, 0x06, 0x62, 0x79, 0x74, 0x65, 0x73, 0x3F, 0xDA, 0x08, 0xCE, 0x3F, 0x28, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, + 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, + 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2C, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2C, + 0x20, 0x6F, 0x72, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x02, 0x2B, 0x3D, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x8C, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, + 0xCE, 0x02, 0x2B, 0x3D, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x09, 0x06, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x01, 0x2B, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, + 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, + 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x06, 0x03, + 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, + 0x00, 0x05, 0x06, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, + 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x03, 0x73, 0x65, 0x74, 0x00, 0x08, 0x00, 0xDA, 0x1E, + 0x00, 0x08, 0x01, 0xCF, 0x02, 0x6E, 0x73, 0x00, 0x08, 0x02, 0xDA, 0x2D, 0x2C, 0x04, 0x00, 0x00, + 0x32, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, + 0x33, 0x05, 0x00, 0x03, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0x8C, 0x34, 0x00, + 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0xDA, 0x08, 0xCE, + 0x27, 0x28, 0x2B, 0x3D, 0x20, 0x78, 0x20, 0x26, 0x20, 0x6E, 0x73, 0x29, 0x0A, 0x0A, 0x49, 0x6E, + 0x63, 0x72, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, + 0x20, 0x78, 0x20, 0x62, 0x79, 0x20, 0x6E, 0x2E, 0xD0, 0x05, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xCB, + 0xCF, 0x0F, 0x65, 0x76, 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x6C, 0x6F, 0x63, + 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0D, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x65, 0x76, 0x2E, 0x63, 0x8C, 0x07, 0x01, 0xDA, 0x06, 0xD8, 0x0F, 0x65, 0x76, + 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x08, 0xCE, + 0x80, 0xFD, 0x28, 0x65, 0x76, 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x6C, 0x6F, + 0x63, 0x6B, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x41, 0x63, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x20, 0x61, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x72, 0x65, + 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2E, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6E, 0x74, 0x69, 0x72, 0x65, 0x20, 0x74, 0x68, 0x72, + 0x65, 0x61, 0x64, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, + 0x63, 0x6B, 0x20, 0x62, 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, + 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6F, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0xCF, + 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8E, 0xDB, 0x03, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, + 0x0A, 0x04, 0x02, 0x04, 0x02, 0x0A, 0x00, 0x01, 0x06, 0xCE, 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0xDA, 0x18, 0xD8, 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x69, 0x73, + 0x74, 0x65, 0x6E, 0xD8, 0x05, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0x00, 0x0A, 0x00, 0xCF, 0x04, 0x68, + 0x6F, 0x73, 0x74, 0x00, 0x0A, 0x01, 0xCF, 0x04, 0x70, 0x6F, 0x72, 0x74, 0x00, 0x0A, 0x02, 0xCF, + 0x07, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x00, 0x0A, 0x03, 0xCF, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x00, 0x0A, 0x04, 0xDA, 0x3E, 0x03, 0x0A, 0x06, 0xCF, 0x01, 0x73, 0x33, 0x00, 0x01, 0x03, + 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x02, 0x05, 0x00, + 0x30, 0x07, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x35, 0x08, 0x09, 0x00, + 0x03, 0x06, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x05, 0x01, + 0x06, 0xDA, 0x18, 0xD8, 0x0F, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, + 0x6C, 0x6F, 0x6F, 0x70, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x45, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x46, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x47, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x48, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x3E, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x49, 0x2D, 0x00, 0x00, 0x06, 0x2D, 0x01, 0x00, 0x02, + 0x32, 0x00, 0x01, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8E, 0xE0, + 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x8E, 0xDE, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x05, 0x01, 0x05, 0x01, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFB, 0x03, 0x44, + 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, 0x8F, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, + 0x0A, 0x0A, 0x53, 0x74, 0x61, 0x72, 0x74, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x20, 0x61, 0x73, 0x79, 0x6E, 0x63, 0x68, 0x72, 0x6F, 0x6E, 0x6F, 0x75, 0x73, 0x6C, 0x79, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x69, 0x73, 0x74, 0x65, 0x6E, + 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, + 0x74, 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0xCF, 0x06, 0x61, 0x73, 0x73, 0x65, 0x72, 0x74, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x92, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x09, 0x02, 0x01, 0x02, 0x07, 0x19, 0x00, 0x04, 0xCE, 0x06, 0x61, 0x73, + 0x73, 0x65, 0x72, 0x74, 0xDA, 0x18, 0xD8, 0x06, 0x67, 0x65, 0x6E, 0x73, 0x79, 0x6D, 0xCF, 0x03, + 0x64, 0x65, 0x66, 0xCE, 0x14, 0x61, 0x73, 0x73, 0x65, 0x72, 0x74, 0x20, 0x66, 0x61, 0x69, 0x6C, + 0x75, 0x72, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x25, 0x6A, 0xD8, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x01, 0xCE, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x01, 0x00, 0x00, 0x00, + 0xCF, 0x02, 0x69, 0x66, 0xCF, 0x02, 0x64, 0x6F, 0x00, 0x19, 0x00, 0xDA, 0x1E, 0x00, 0x19, 0x01, + 0xCF, 0x03, 0x65, 0x72, 0x72, 0x00, 0x19, 0x02, 0xDA, 0x4C, 0x02, 0x19, 0x04, 0xCF, 0x01, 0x76, + 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x06, 0x01, 0x00, + 0x33, 0x06, 0x04, 0x00, 0x45, 0x05, 0x00, 0x00, 0x1E, 0x01, 0x03, 0x00, 0x1B, 0x06, 0x01, 0x00, + 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x32, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, + 0x35, 0x07, 0x08, 0x00, 0x1B, 0x06, 0x07, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x32, 0x08, 0x06, 0x00, + 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x33, 0x08, 0x04, 0x04, 0x31, 0x07, 0x00, 0x00, + 0x45, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x33, 0x08, 0x05, 0x06, 0x45, 0x07, 0x00, 0x00, + 0x03, 0x07, 0x00, 0x00, 0x80, 0x95, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x04, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, + 0x11, 0xBF, 0xFC, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x5F, 0x28, 0x61, 0x73, 0x73, + 0x65, 0x72, 0x74, 0x20, 0x78, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, 0x72, 0x72, 0x29, 0x0A, + 0x0A, 0x54, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x74, 0x72, 0x75, 0x74, + 0x68, 0x79, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x65, 0x76, 0x61, + 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x60, 0x65, 0x72, 0x72, 0x60, 0x20, 0x69, 0x66, 0x20, 0x78, + 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x0C, + 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0x3D, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x0C, 0x03, 0x02, 0x03, 0x04, 0x1D, 0x00, 0x09, 0xCE, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x2F, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xDA, 0x18, 0xDA, 0x06, 0xD0, 0x03, 0x72, 0x65, 0x66, + 0xD0, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x06, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3F, + 0xDA, 0x18, 0xD8, 0x04, 0x74, 0x79, 0x70, 0x65, 0xD0, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0x00, + 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x06, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3F, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, + 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x6E, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2C, 0x00, + 0x2C, 0x00, 0x2C, 0x00, 0x1D, 0x00, 0xCF, 0x06, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x00, 0x1D, + 0x01, 0xCF, 0x03, 0x73, 0x79, 0x6D, 0x00, 0x1D, 0x02, 0xCF, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, + 0x74, 0x65, 0x00, 0x1D, 0x03, 0xDA, 0x5C, 0x01, 0x1D, 0x05, 0xCF, 0x05, 0x65, 0x6E, 0x74, 0x72, + 0x79, 0x05, 0x1C, 0x07, 0xDA, 0x5A, 0x08, 0x1C, 0x08, 0xCF, 0x01, 0x72, 0x0B, 0x1C, 0x09, 0xCF, + 0x01, 0x70, 0x0F, 0x17, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x56, 0x3B, 0x04, + 0x00, 0x01, 0x1B, 0x05, 0x04, 0x00, 0x1E, 0x05, 0x1A, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x3A, 0x06, + 0x05, 0x07, 0x1B, 0x07, 0x06, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x3A, 0x06, 0x05, 0x08, 0x1B, 0x08, + 0x06, 0x00, 0x2C, 0x09, 0x02, 0x00, 0x3A, 0x06, 0x05, 0x09, 0x1B, 0x09, 0x06, 0x00, 0x1E, 0x09, + 0x04, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1E, 0x08, + 0x06, 0x00, 0x31, 0x08, 0x00, 0x00, 0x2C, 0x0B, 0x03, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x06, + 0x0A, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x08, 0x00, 0x1E, 0x06, 0x04, 0x00, 0x2B, 0x0B, + 0x00, 0x00, 0x3B, 0x0A, 0x08, 0x0B, 0x03, 0x0A, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x8B, 0x42, 0x0E, 0x00, 0x03, 0x01, 0x03, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x01, + 0x0D, 0x00, 0x0D, 0xBF, 0xFF, 0x05, 0x02, 0x0D, 0x00, 0x0D, 0xBF, 0xFE, 0x05, 0x03, 0x07, 0x00, + 0x0D, 0x00, 0x0D, 0x00, 0x1D, 0x01, 0x0B, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x07, 0xBF, 0xFB, + 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xCF, 0x28, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x73, 0x79, 0x6D, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x29, 0x0A, 0x0A, 0x47, 0x69, + 0x76, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2C, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, + 0x62, 0x6F, 0x6C, 0x20, 0x60, 0x73, 0x79, 0x6D, 0x60, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x70, + 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x60, 0x20, 0x69, 0x73, 0x0A, 0x74, 0x72, 0x75, 0x74, 0x68, + 0x79, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x72, 0x65, 0x73, + 0x6F, 0x6C, 0x76, 0x65, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x6D, 0x6F, 0x64, + 0x75, 0x6C, 0x65, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x6E, 0x6F, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, + 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x0A, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x0D, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x69, 0x67, 0x6E, 0x61, + 0x74, 0x75, 0x72, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x83, 0x01, 0x01, + 0xDA, 0x06, 0xD8, 0x0D, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, + 0x65, 0xDA, 0x08, 0xCE, 0x80, 0x96, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x69, 0x67, 0x6E, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x2D, 0x63, 0x6F, 0x6E, + 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x72, 0x65, 0x74, 0x2D, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, + 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x72, 0x61, 0x77, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x73, 0x2E, 0xCF, 0x09, 0x6E, 0x65, + 0x74, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, + 0x83, 0xA5, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, + 0xDA, 0x08, 0xCE, 0x80, 0xB5, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x6B, 0x65, 0x20, 0x73, 0x75, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, + 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x72, 0x69, 0x6C, 0x79, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x4E, 0x61, 0x67, 0x6C, 0x65, 0x27, 0x73, 0x20, 0x61, 0x6C, + 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x73, 0x75, 0x72, 0x65, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x73, 0x65, 0x6E, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x6F, 0x75, 0x74, 0x20, 0x64, 0x65, 0x6C, 0x61, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0xCF, 0x03, 0x69, 0x6E, 0x63, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x88, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x02, 0x00, 0x02, 0xCE, 0x03, 0x69, 0x6E, + 0x63, 0xDA, 0x18, 0x00, 0x02, 0x00, 0xDA, 0x1E, 0x00, 0x02, 0x01, 0xDA, 0x7A, 0x05, 0x02, 0x00, + 0x01, 0x03, 0x02, 0x00, 0x00, 0x80, 0x88, 0x20, 0x00, 0x20, 0xDA, 0x08, 0xCE, 0x17, 0x28, 0x69, + 0x6E, 0x63, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x78, + 0x20, 0x2B, 0x20, 0x31, 0x2E, 0xCF, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, + 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x31, 0x36, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xCE, 0x11, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2E, 0x63, 0x81, 0x72, 0x01, 0xDA, 0x06, 0xD8, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x31, 0x36, 0xDA, 0x08, 0xCE, 0x80, + 0x84, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x75, 0x69, + 0x6E, 0x74, 0x31, 0x36, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x64, 0x65, + 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x61, 0x20, + 0x31, 0x36, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, + 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6F, 0x6E, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x06, 0x69, 0x66, 0x2D, 0x6C, 0x65, 0x74, 0xD3, 0x04, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x9F, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, + 0x00, 0x00, 0x0B, 0x03, 0x02, 0x03, 0x04, 0x1D, 0x00, 0x01, 0x07, 0xCE, 0x06, 0x69, 0x66, 0x2D, + 0x6C, 0x65, 0x74, 0xDA, 0x18, 0xCE, 0x1B, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, + 0x61, 0x74, 0x20, 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x31, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x00, 0x05, 0x00, + 0x02, 0xCE, 0x04, 0x6F, 0x64, 0x64, 0x3F, 0xDA, 0x18, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, + 0x01, 0xCF, 0x04, 0x6F, 0x64, 0x64, 0x3F, 0x2B, 0x03, 0x02, 0x00, 0x0E, 0x02, 0x00, 0x03, 0x2B, + 0x04, 0x01, 0x00, 0x25, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, 0x00, 0x78, 0x15, 0x00, 0x15, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0xCE, 0x23, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, + 0x61, 0x6E, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xD1, 0x01, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x0A, 0x02, 0x01, 0x02, 0x03, 0x16, 0x00, 0x06, 0xCE, 0x05, 0x6D, 0x61, 0x63, + 0x65, 0x78, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x1F, 0x02, 0x01, 0x02, 0x17, + 0x67, 0x00, 0x08, 0x0E, 0xCE, 0x06, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, 0xDA, 0x18, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x73, + 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xD0, 0x06, 0x73, 0x79, 0x6D, 0x62, + 0x6F, 0x6C, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x07, 0x73, 0x79, 0x6D, 0x62, + 0x6F, 0x6C, 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x67, 0x30, 0x00, 0x30, 0x00, + 0x30, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0xCF, 0x0A, 0x71, 0x75, 0x61, 0x73, 0x69, 0x71, 0x75, + 0x6F, 0x74, 0x65, 0xDA, 0x58, 0xDA, 0x34, 0xCF, 0x05, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x52, + 0xDA, 0x57, 0xCF, 0x02, 0x66, 0x6E, 0xCF, 0x03, 0x76, 0x61, 0x72, 0xCF, 0x07, 0x75, 0x70, 0x73, + 0x63, 0x6F, 0x70, 0x65, 0xCF, 0x05, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xCF, 0x05, 0x71, 0x75, 0x6F, + 0x74, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, + 0x02, 0xCE, 0x08, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79, 0xDA, 0x18, 0x00, 0x01, 0x00, + 0xDA, 0x1E, 0x00, 0x01, 0x01, 0xCF, 0x08, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79, 0x03, + 0x00, 0x00, 0x00, 0x82, 0xC8, 0x01, 0xDA, 0x65, 0xD0, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xD8, + 0x0A, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x74, 0x79, 0x70, 0x65, 0xD0, 0x08, 0x62, 0x72, 0x61, + 0x63, 0x6B, 0x65, 0x74, 0x73, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x17, 0x02, 0x02, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x80, 0xA9, 0x00, 0x2A, 0xCE, 0x03, 0x6D, 0x61, 0x70, 0xDA, 0x18, + 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0xD8, 0x10, 0x61, 0x72, + 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x00, 0x80, + 0xA9, 0x00, 0xCF, 0x01, 0x66, 0x00, 0x80, 0xA9, 0x01, 0xDA, 0x1F, 0x00, 0x80, 0xA9, 0x02, 0xCF, + 0x04, 0x69, 0x6E, 0x64, 0x73, 0x00, 0x80, 0xA9, 0x03, 0xCF, 0x03, 0x6D, 0x61, 0x70, 0x01, 0x80, + 0xA9, 0x05, 0xCF, 0x03, 0x72, 0x65, 0x73, 0x03, 0x80, 0xA8, 0x07, 0xCF, 0x05, 0x6E, 0x69, 0x6E, + 0x64, 0x73, 0x03, 0x80, 0xA8, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x05, + 0x13, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x47, 0x08, 0x13, 0x09, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x0B, 0x13, 0x0A, 0xDA, 0x1E, 0x17, 0x2C, 0x0A, 0xCF, + 0x04, 0x69, 0x6E, 0x64, 0x30, 0x18, 0x2C, 0x09, 0xCF, 0x04, 0x6B, 0x65, 0x79, 0x30, 0x18, 0x2C, + 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x49, 0x1B, 0x2C, 0x0C, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x48, 0x1E, 0x2C, 0x0D, 0xDA, 0x1E, 0x30, 0x4E, 0x0B, 0xDA, 0x80, + 0xB2, 0x32, 0x4E, 0x0C, 0xCF, 0x04, 0x69, 0x6E, 0x64, 0x31, 0x33, 0x4E, 0x0A, 0xDA, 0x80, 0xB3, + 0x34, 0x4E, 0x0D, 0xCF, 0x04, 0x6B, 0x65, 0x79, 0x31, 0x34, 0x4E, 0x01, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x4B, 0x37, 0x4E, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x4A, 0x3A, 0x4E, 0x10, 0xDA, 0x1E, 0x52, 0x7A, 0x0C, 0xDA, 0x80, 0xB2, 0x54, 0x7A, 0x0D, 0xDA, + 0x80, 0xB6, 0x56, 0x7A, 0x0E, 0xCF, 0x04, 0x69, 0x6E, 0x64, 0x32, 0x57, 0x7A, 0x0B, 0xDA, 0x80, + 0xB3, 0x58, 0x7A, 0x0F, 0xDA, 0x80, 0xB7, 0x59, 0x7A, 0x10, 0xCF, 0x04, 0x6B, 0x65, 0x79, 0x32, + 0x59, 0x7A, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x4D, 0x5C, 0x7A, 0x12, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x4C, 0x5F, 0x7A, 0x13, 0xDA, 0x1E, 0x7E, 0x80, 0xA8, + 0x0C, 0xCF, 0x09, 0x69, 0x74, 0x65, 0x72, 0x2D, 0x6B, 0x65, 0x79, 0x73, 0x80, 0x82, 0x80, 0xA8, + 0x0D, 0xCF, 0x0B, 0x63, 0x61, 0x6C, 0x6C, 0x2D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x80, 0x83, + 0x80, 0xA8, 0x0B, 0xCF, 0x04, 0x64, 0x6F, 0x6E, 0x65, 0x80, 0x83, 0x80, 0xA8, 0x01, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x4F, 0x80, 0x86, 0x80, 0xA8, 0x0F, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x4E, 0x80, 0x89, 0x80, 0xA8, 0x10, 0xDA, 0x1E, 0x80, 0x8A, 0x80, 0x9E, + 0x0E, 0xCF, 0x01, 0x69, 0x80, 0x8A, 0x80, 0x9E, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x50, 0x80, 0x8E, 0x80, 0x9C, 0x13, 0xCF, 0x07, 0x6F, 0x6C, 0x64, 0x2D, 0x6B, 0x65, 0x79, + 0x80, 0x90, 0x80, 0x9C, 0x14, 0xCF, 0x02, 0x69, 0x69, 0x80, 0x92, 0x80, 0x9C, 0x15, 0xCF, 0x07, + 0x6E, 0x65, 0x77, 0x2D, 0x6B, 0x65, 0x79, 0x40, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3F, + 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x26, 0x06, 0x07, 0x00, 0x1E, 0x06, 0x0F, 0x00, 0x28, + 0x09, 0x00, 0x00, 0x49, 0x08, 0x01, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x1F, 0x09, 0x0A, 0x00, 0x3A, + 0x08, 0x01, 0x09, 0x1B, 0x0A, 0x08, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x08, 0x00, 0x00, 0x32, + 0x05, 0x08, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x49, 0x09, 0x01, 0x09, 0x1C, + 0xF7, 0xFF, 0xFF, 0x1C, 0x95, 0x00, 0x00, 0x26, 0x08, 0x07, 0x01, 0x1E, 0x08, 0x18, 0x00, 0x3D, + 0x09, 0x02, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x49, + 0x0B, 0x01, 0x0C, 0x1B, 0x0C, 0x0B, 0x00, 0x1F, 0x0C, 0x10, 0x00, 0x3A, 0x0B, 0x01, 0x0C, 0x1B, + 0x0D, 0x0B, 0x00, 0x49, 0x09, 0x0A, 0x09, 0x28, 0x0E, 0x00, 0x00, 0x25, 0x0B, 0x0E, 0x09, 0x1E, + 0x0B, 0x02, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x3A, 0x0B, 0x0A, 0x09, 0x32, 0x0D, 0x0B, 0x00, 0x35, + 0x0E, 0x00, 0x00, 0x32, 0x05, 0x0E, 0x00, 0x2C, 0x0F, 0x00, 0x00, 0x35, 0x0B, 0x0F, 0x00, 0x49, + 0x0C, 0x01, 0x0C, 0x1C, 0xF1, 0xFF, 0xFF, 0x1C, 0x7C, 0x00, 0x00, 0x26, 0x09, 0x07, 0x02, 0x1E, + 0x09, 0x21, 0x00, 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, + 0x0C, 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, + 0x0E, 0x01, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x16, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, + 0x10, 0x0E, 0x00, 0x49, 0x0A, 0x0B, 0x0A, 0x28, 0x11, 0x00, 0x00, 0x25, 0x0E, 0x11, 0x0A, 0x1E, + 0x0E, 0x02, 0x00, 0x1C, 0x0F, 0x00, 0x00, 0x49, 0x0D, 0x0C, 0x0D, 0x28, 0x11, 0x00, 0x00, 0x25, + 0x0E, 0x11, 0x0D, 0x1E, 0x0E, 0x02, 0x00, 0x1C, 0x0A, 0x00, 0x00, 0x3A, 0x0E, 0x0B, 0x0A, 0x3A, + 0x11, 0x0C, 0x0D, 0x33, 0x10, 0x0E, 0x11, 0x35, 0x12, 0x00, 0x00, 0x32, 0x05, 0x12, 0x00, 0x2C, + 0x11, 0x00, 0x00, 0x35, 0x0E, 0x11, 0x00, 0x49, 0x0F, 0x01, 0x0F, 0x1C, 0xEB, 0xFF, 0xFF, 0x1C, + 0x5A, 0x00, 0x00, 0x26, 0x0A, 0x07, 0x03, 0x1E, 0x0A, 0x2B, 0x00, 0x3D, 0x0B, 0x02, 0x00, 0x1B, + 0x0C, 0x0B, 0x00, 0x3D, 0x0B, 0x02, 0x01, 0x1B, 0x0D, 0x0B, 0x00, 0x3D, 0x0B, 0x02, 0x02, 0x1B, + 0x0E, 0x0B, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x28, + 0x12, 0x00, 0x00, 0x49, 0x11, 0x01, 0x12, 0x1B, 0x12, 0x11, 0x00, 0x1F, 0x12, 0x1D, 0x00, 0x3A, + 0x11, 0x01, 0x12, 0x1B, 0x13, 0x11, 0x00, 0x49, 0x0B, 0x0C, 0x0B, 0x28, 0x14, 0x00, 0x00, 0x25, + 0x11, 0x14, 0x0B, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x16, 0x00, 0x00, 0x49, 0x0F, 0x0D, 0x0F, 0x28, + 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x0F, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x49, + 0x10, 0x0E, 0x10, 0x28, 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x10, 0x1E, 0x11, 0x02, 0x00, 0x1C, + 0x0C, 0x00, 0x00, 0x3A, 0x11, 0x0C, 0x0B, 0x3A, 0x14, 0x0D, 0x0F, 0x3A, 0x15, 0x0E, 0x10, 0x33, + 0x13, 0x11, 0x14, 0x31, 0x15, 0x00, 0x00, 0x35, 0x16, 0x00, 0x00, 0x32, 0x05, 0x16, 0x00, 0x2C, + 0x14, 0x00, 0x00, 0x35, 0x11, 0x14, 0x00, 0x49, 0x12, 0x01, 0x12, 0x1C, 0xE4, 0xFF, 0xFF, 0x1C, + 0x2E, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, + 0x0C, 0x0B, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0D, 0x01, 0x00, 0x35, 0x0B, 0x0D, 0x00, 0x1B, + 0x0D, 0x0B, 0x00, 0x2A, 0x0B, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0E, 0x01, 0x0F, 0x1B, + 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x21, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, 0x10, 0x0E, 0x00, 0x2B, + 0x0E, 0x00, 0x00, 0x23, 0x11, 0x0E, 0x07, 0x1E, 0x11, 0x12, 0x00, 0x3A, 0x12, 0x0C, 0x0E, 0x1B, + 0x13, 0x12, 0x00, 0x3A, 0x12, 0x02, 0x0E, 0x1B, 0x14, 0x12, 0x00, 0x49, 0x12, 0x14, 0x13, 0x1B, + 0x15, 0x12, 0x00, 0x28, 0x16, 0x00, 0x00, 0x25, 0x12, 0x16, 0x15, 0x1E, 0x12, 0x04, 0x00, 0x29, + 0x0B, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0C, 0x0E, 0x15, 0x3A, + 0x16, 0x14, 0x15, 0x3C, 0x0D, 0x0E, 0x16, 0x05, 0x0E, 0x0E, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, + 0x0B, 0x02, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x34, 0x0D, 0x00, 0x00, 0x35, + 0x0E, 0x00, 0x00, 0x32, 0x05, 0x0E, 0x00, 0x2C, 0x12, 0x00, 0x00, 0x35, 0x11, 0x12, 0x00, 0x49, + 0x0F, 0x01, 0x0F, 0x1C, 0xE0, 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, 0x83, 0xEB, 0x03, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xD8, + 0x0E, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0xDA, + 0x66, 0xD0, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD8, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2F, 0x74, 0x6F, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD0, 0x05, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x00, 0x67, 0x00, 0xDA, 0x1E, 0x00, 0x67, 0x01, 0xCF, 0x0A, 0x6F, 0x6E, 0x2D, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x00, 0x67, 0x02, 0xCF, 0x06, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, + 0x09, 0x67, 0x04, 0xCF, 0x05, 0x72, 0x65, 0x63, 0x75, 0x72, 0x0B, 0x67, 0x06, 0xCF, 0x07, 0x64, + 0x6F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x0D, 0x67, 0x08, 0xCF, 0x0F, 0x65, 0x78, 0x70, 0x61, 0x6E, + 0x64, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x0F, 0x67, 0x0A, 0xCF, 0x09, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x64, 0x65, 0x66, 0x11, 0x67, 0x0C, 0xCF, 0x09, 0x65, 0x78, 0x70, + 0x61, 0x6E, 0x64, 0x61, 0x6C, 0x6C, 0x13, 0x67, 0x0E, 0xCF, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, + 0x64, 0x66, 0x6E, 0x15, 0x67, 0x10, 0xCF, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x71, 0x71, + 0x2B, 0x67, 0x12, 0xCF, 0x05, 0x73, 0x70, 0x65, 0x63, 0x73, 0x2D, 0x67, 0x14, 0xCF, 0x05, 0x64, + 0x6F, 0x74, 0x75, 0x70, 0x31, 0x65, 0x16, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x4B, + 0x65, 0x67, 0x16, 0xDA, 0x23, 0x2E, 0x02, 0x00, 0x00, 0x1E, 0x01, 0x07, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x03, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x36, 0x01, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x30, 0x05, 0x01, + 0x00, 0x1B, 0x06, 0x05, 0x00, 0x30, 0x07, 0x02, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x30, 0x09, 0x03, + 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x30, 0x0B, 0x04, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x30, 0x0D, 0x05, + 0x00, 0x1B, 0x0E, 0x0D, 0x00, 0x30, 0x0F, 0x06, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x2C, 0x11, 0x01, + 0x00, 0x2C, 0x12, 0x02, 0x00, 0x33, 0x11, 0x10, 0x12, 0x2C, 0x11, 0x03, 0x00, 0x33, 0x0C, 0x11, + 0x0A, 0x2C, 0x11, 0x04, 0x00, 0x2C, 0x12, 0x05, 0x00, 0x33, 0x11, 0x0C, 0x12, 0x2C, 0x11, 0x06, + 0x00, 0x33, 0x0A, 0x11, 0x0C, 0x2C, 0x11, 0x07, 0x00, 0x2C, 0x12, 0x08, 0x00, 0x33, 0x11, 0x0E, + 0x12, 0x2C, 0x11, 0x09, 0x00, 0x33, 0x0A, 0x11, 0x0C, 0x2C, 0x11, 0x0A, 0x00, 0x2C, 0x12, 0x0B, + 0x00, 0x33, 0x11, 0x0C, 0x12, 0x2C, 0x11, 0x0C, 0x00, 0x31, 0x11, 0x00, 0x00, 0x43, 0x11, 0x00, + 0x00, 0x1B, 0x12, 0x11, 0x00, 0x30, 0x13, 0x07, 0x00, 0x1B, 0x14, 0x13, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x16, 0x0D, 0x00, 0x35, 0x15, 0x16, 0x00, 0x1B, 0x16, 0x15, 0x00, 0x2C, 0x18, 0x0E, + 0x00, 0x25, 0x17, 0x16, 0x18, 0x1E, 0x17, 0x14, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x1A, 0x0F, + 0x00, 0x35, 0x19, 0x1A, 0x00, 0x2C, 0x1B, 0x10, 0x00, 0x25, 0x1A, 0x19, 0x1B, 0x1E, 0x1A, 0x09, + 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x1B, 0x11, 0x00, 0x35, 0x19, 0x1B, 0x00, 0x34, 0x19, 0x00, + 0x00, 0x2C, 0x1C, 0x12, 0x00, 0x35, 0x1B, 0x1C, 0x00, 0x1B, 0x18, 0x1B, 0x00, 0x1C, 0x04, 0x00, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x35, 0x19, 0x14, 0x00, 0x1B, 0x18, 0x19, 0x00, 0x1B, 0x15, 0x18, + 0x00, 0x1C, 0x1E, 0x00, 0x00, 0x2C, 0x1A, 0x13, 0x00, 0x25, 0x19, 0x16, 0x1A, 0x1E, 0x19, 0x06, + 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x1B, 0x11, 0x00, 0x35, 0x1A, 0x1B, 0x00, 0x1B, 0x18, 0x1A, + 0x00, 0x1C, 0x15, 0x00, 0x00, 0x2C, 0x1C, 0x14, 0x00, 0x25, 0x1B, 0x16, 0x1C, 0x1E, 0x1B, 0x08, + 0x00, 0x32, 0x00, 0x04, 0x00, 0x35, 0x1C, 0x06, 0x00, 0x31, 0x1C, 0x00, 0x00, 0x2C, 0x1E, 0x15, + 0x00, 0x35, 0x1D, 0x1E, 0x00, 0x1B, 0x1A, 0x1D, 0x00, 0x1C, 0x0A, 0x00, 0x00, 0x2C, 0x1E, 0x16, + 0x00, 0x25, 0x1D, 0x16, 0x1E, 0x1E, 0x1D, 0x05, 0x00, 0x32, 0x00, 0x04, 0x00, 0x35, 0x1E, 0x06, + 0x00, 0x1B, 0x1C, 0x1E, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x1C, 0x00, 0x00, 0x1B, 0x1A, 0x1C, + 0x00, 0x1B, 0x18, 0x1A, 0x00, 0x1B, 0x15, 0x18, 0x00, 0x1B, 0x16, 0x15, 0x00, 0x03, 0x16, 0x00, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x04, 0x01, 0x05, 0xCE, 0x05, + 0x72, 0x65, 0x63, 0x75, 0x72, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, + 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x80, 0xCD, 0x00, 0x04, 0x00, 0xCF, 0x01, + 0x79, 0x00, 0x04, 0x01, 0xDA, 0x80, 0xCE, 0x2D, 0x02, 0x00, 0x01, 0x32, 0x00, 0x02, 0x00, 0x2D, + 0x02, 0x00, 0x02, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x88, 0x0D, 0x13, 0x00, 0x13, 0x00, 0x13, + 0x00, 0x13, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x02, 0x02, 0x02, 0x00, 0x12, 0x01, 0x09, 0xCE, + 0x07, 0x64, 0x6F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x80, 0xCE, 0x00, 0x12, 0x00, 0xCF, 0x01, 0x74, 0x00, 0x12, 0x01, 0xCF, 0x08, + 0x6F, 0x6E, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x00, 0x12, 0x02, 0xDA, 0x80, 0xCF, 0x01, 0x12, + 0x04, 0xCF, 0x04, 0x6E, 0x65, 0x77, 0x74, 0x04, 0x12, 0x06, 0xCF, 0x03, 0x6B, 0x65, 0x79, 0x44, + 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, 0x06, 0x1B, + 0x06, 0x05, 0x00, 0x28, 0x08, 0x00, 0x00, 0x4A, 0x07, 0x08, 0x06, 0x1E, 0x07, 0x0A, 0x00, 0x31, + 0x06, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x04, 0x35, 0x08, 0x09, 0x00, 0x3A, 0x09, 0x00, 0x06, 0x31, + 0x09, 0x00, 0x00, 0x35, 0x0A, 0x01, 0x00, 0x3C, 0x04, 0x08, 0x0A, 0x49, 0x06, 0x00, 0x06, 0x1C, + 0xF5, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x88, 0x10, 0x05, 0x00, 0x05, 0x01, 0x0E, + 0x00, 0x0E, 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x27, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x07, 0x01, 0x10, 0xBF, 0xFE, 0x05, 0xBF, 0xFD, 0x03, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x01, 0x01, 0x08, 0x26, 0x01, 0x08, 0xCE, 0x0F, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x18, + 0xDA, 0x65, 0xDA, 0x66, 0xDA, 0x80, 0xA6, 0xDA, 0x80, 0xA3, 0xD8, 0x0B, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x80, 0xCB, 0xDA, 0x80, 0xC9, 0xDA, 0x80, 0xCA, + 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, + 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, 0xDA, + 0x80, 0xCF, 0x00, 0x26, 0x00, 0xDA, 0x1E, 0x00, 0x26, 0x01, 0xDA, 0x80, 0xD0, 0x04, 0x26, 0x03, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x48, 0x2E, 0x01, 0x00, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x04, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x02, + 0x00, 0x36, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x25, 0x04, 0x03, 0x05, 0x1E, 0x04, 0x07, + 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, + 0x00, 0x2C, 0x06, 0x04, 0x00, 0x36, 0x06, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x25, 0x05, 0x03, + 0x06, 0x1E, 0x05, 0x04, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2D, 0x06, 0x00, 0x06, 0x36, 0x06, 0x00, + 0x00, 0x2C, 0x07, 0x06, 0x00, 0x25, 0x06, 0x03, 0x07, 0x1E, 0x06, 0x07, 0x00, 0x32, 0x00, 0x01, + 0x00, 0x2D, 0x08, 0x00, 0x06, 0x35, 0x07, 0x08, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x07, + 0x00, 0x36, 0x08, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x07, 0x00, 0x04, 0x36, 0x07, 0x00, + 0x00, 0xBF, 0xFF, 0x88, 0x17, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x02, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFE, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x03, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFD, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x04, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x07, 0x00, + 0x07, 0x00, 0x07, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x01, 0x01, 0x02, 0x1E, 0x01, 0x0A, + 0xCE, 0x09, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x64, 0x65, 0x66, 0xDA, 0x18, 0xDA, 0x80, 0xE0, + 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0xBF, 0xFF, + 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x80, 0xCF, + 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, 0x00, 0x1E, 0x00, 0xDA, 0x80, 0xDB, 0x00, 0x1E, 0x01, + 0xDA, 0x80, 0xD1, 0x03, 0x1E, 0x03, 0xCF, 0x04, 0x6C, 0x61, 0x73, 0x74, 0x06, 0x1E, 0x05, 0xCF, + 0x05, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x3F, 0x02, 0x00, 0x00, 0x07, 0x03, 0x02, 0x01, 0x3A, 0x02, + 0x00, 0x03, 0x1B, 0x03, 0x02, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x1B, 0x05, + 0x04, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x3A, 0x06, 0x00, 0x07, 0x31, 0x05, 0x00, 0x00, 0x2D, 0x08, + 0x00, 0x08, 0x35, 0x07, 0x08, 0x00, 0x32, 0x06, 0x07, 0x00, 0x40, 0x06, 0x00, 0x00, 0x2B, 0x07, + 0x02, 0x00, 0x2B, 0x08, 0xFE, 0xFF, 0x33, 0x00, 0x07, 0x08, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x07, + 0x08, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x04, 0x35, 0x08, 0x09, 0x00, 0x31, 0x08, + 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x33, 0x06, 0x07, 0x08, 0x2C, 0x0A, 0x01, 0x00, 0x35, 0x09, + 0x0A, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0xBF, 0xFF, + 0x88, 0x20, 0x18, 0x00, 0x15, 0x00, 0x0F, 0x00, 0x05, 0x01, 0x10, 0x00, 0x10, 0x00, 0x05, 0x03, + 0x0B, 0x00, 0x0B, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x02, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFD, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x03, 0x0F, 0x01, 0x0A, 0xCE, 0x09, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x61, 0x6C, 0x6C, 0xDA, 0x18, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xA6, + 0xD8, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, + 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, + 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x80, 0xCF, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, + 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x80, 0xD1, 0x00, 0x0F, 0x00, 0xDA, 0x80, 0xDB, 0x00, 0x0F, 0x01, + 0xDA, 0x80, 0xD2, 0x08, 0x0F, 0x02, 0xCF, 0x04, 0x61, 0x72, 0x67, 0x73, 0x2B, 0x02, 0x01, 0x00, + 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2D, 0x03, 0x00, 0x04, + 0x32, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, + 0x2B, 0x05, 0x00, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x31, 0x04, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, + 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0x88, 0x29, 0x1A, 0x00, 0x1A, 0x00, + 0x1A, 0x00, 0x1A, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x01, 0x0C, 0x00, + 0x0C, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, + 0x01, 0x01, 0x05, 0x25, 0x01, 0x0D, 0xCE, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x66, 0x6E, + 0xDA, 0x18, 0xDA, 0x80, 0x95, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xA6, 0xDA, 0x80, 0x9B, 0xDA, 0x80, + 0xE7, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x80, 0xCF, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x80, + 0xD1, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x80, 0xD2, 0x00, 0x25, 0x00, 0xDA, 0x80, 0xDB, 0x00, 0x25, + 0x01, 0xDA, 0x80, 0xD3, 0x02, 0x25, 0x03, 0xCF, 0x02, 0x74, 0x31, 0x0F, 0x17, 0x05, 0xDA, 0x80, + 0xE8, 0x1F, 0x25, 0x05, 0xDA, 0x80, 0xE8, 0x2B, 0x03, 0x01, 0x00, 0x3A, 0x02, 0x00, 0x03, 0x1B, + 0x03, 0x02, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, + 0x04, 0x11, 0x00, 0x2B, 0x05, 0x03, 0x00, 0x32, 0x00, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, + 0x05, 0x06, 0x00, 0x2D, 0x06, 0x00, 0x04, 0x32, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, + 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x2B, 0x07, 0x02, 0x00, 0x3A, 0x06, 0x00, 0x07, 0x2C, + 0x07, 0x03, 0x00, 0x33, 0x07, 0x03, 0x06, 0x34, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x36, + 0x07, 0x00, 0x00, 0x2B, 0x05, 0x02, 0x00, 0x32, 0x00, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, + 0x05, 0x06, 0x00, 0x2D, 0x06, 0x00, 0x04, 0x32, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, + 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x32, 0x06, 0x03, 0x00, 0x34, + 0x05, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x36, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0x88, 0x2D, 0x0D, + 0x00, 0x0D, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x02, 0x1E, 0x00, 0x1E, + 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x09, 0x01, 0x17, + 0x00, 0x17, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x02, 0x1E, 0x00, 0x1E, + 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x09, 0x01, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xCD, 0x00, 0xFC, 0x00, 0x00, 0x07, 0x01, 0x01, + 0x01, 0x01, 0x0B, 0x01, 0x01, 0x0C, 0xCE, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x71, 0x71, + 0xDA, 0x18, 0xDA, 0x80, 0xE7, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x80, 0xCF, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, 0xBF, 0xFF, + 0x00, 0x0A, 0xDA, 0x80, 0xD1, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x80, 0xD2, 0xBF, 0xFF, 0x00, 0x0E, + 0xDA, 0x80, 0xD3, 0x00, 0x0B, 0x00, 0xDA, 0x80, 0xDB, 0x00, 0x0B, 0x01, 0xDA, 0x80, 0xD4, 0x01, + 0x0B, 0x03, 0xCF, 0x02, 0x71, 0x71, 0x30, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2B, 0x05, + 0x00, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x2B, 0x06, 0x01, 0x00, 0x3A, 0x05, 0x00, 0x06, 0x31, 0x05, + 0x00, 0x00, 0x35, 0x06, 0x03, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x36, 0x05, + 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x01, 0x01, 0x0E, 0x47, 0x01, + 0x0D, 0xCE, 0x02, 0x71, 0x71, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xDA, 0x80, 0xA4, 0xDA, + 0x80, 0xA5, 0xDA, 0x80, 0xA6, 0xCF, 0x07, 0x75, 0x6E, 0x71, 0x75, 0x6F, 0x74, 0x65, 0xDA, 0x80, + 0xE7, 0xDA, 0x80, 0xE0, 0xDA, 0x66, 0xDA, 0x80, 0xCB, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x09, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x00, 0x06, 0xCE, 0x03, 0x6B, 0x76, 0x73, 0xDA, 0x18, 0xDA, + 0x80, 0xA8, 0x00, 0x0E, 0x00, 0xCF, 0x04, 0x64, 0x69, 0x63, 0x74, 0x00, 0x0E, 0x01, 0xCF, 0x03, + 0x6B, 0x76, 0x73, 0x01, 0x0E, 0x03, 0xDA, 0x23, 0x01, 0x0D, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x31, 0x04, 0x0D, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x06, 0x0D, 0x04, 0xDA, 0x22, 0x40, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x28, 0x05, 0x00, + 0x00, 0x49, 0x04, 0x00, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x1F, 0x05, 0x08, 0x00, 0x1B, 0x04, 0x05, + 0x00, 0x3A, 0x06, 0x00, 0x04, 0x33, 0x03, 0x04, 0x06, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x07, 0x08, + 0x00, 0x49, 0x05, 0x00, 0x05, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x86, 0xB1, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x2A, 0x00, 0x18, + 0x00, 0x18, 0x00, 0x18, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xD8, 0x05, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0xDA, 0x80, 0xC9, 0xD8, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x80, + 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x80, 0xCF, 0xBF, + 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x80, 0xD1, 0xBF, 0xFF, 0x00, + 0x0C, 0xDA, 0x80, 0xD2, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x80, 0xD3, 0x00, 0x47, 0x00, 0xDA, 0x1E, + 0x00, 0x47, 0x01, 0xDA, 0x80, 0xEC, 0x04, 0x47, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x49, 0x16, 0x28, 0x06, 0xCF, 0x02, 0x78, 0x30, 0x2E, 0x01, 0x00, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x21, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x02, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x07, + 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x35, 0x04, 0x06, 0x00, 0x34, 0x04, 0x00, + 0x00, 0x46, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3B, 0x04, 0x00, + 0x06, 0x1B, 0x06, 0x04, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x25, 0x04, 0x07, 0x06, 0x1E, 0x04, 0x09, + 0x00, 0x2B, 0x08, 0x01, 0x00, 0x3B, 0x07, 0x00, 0x08, 0x31, 0x07, 0x00, 0x00, 0x2D, 0x09, 0x00, + 0x04, 0x35, 0x08, 0x09, 0x00, 0x32, 0x06, 0x08, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x36, 0x07, 0x00, + 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x35, 0x07, 0x08, 0x00, 0x31, 0x07, 0x00, + 0x00, 0x2C, 0x08, 0x07, 0x00, 0x36, 0x08, 0x00, 0x00, 0x2C, 0x05, 0x08, 0x00, 0x25, 0x04, 0x03, + 0x05, 0x1E, 0x04, 0x04, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x36, 0x05, 0x00, + 0x00, 0x2C, 0x06, 0x09, 0x00, 0x25, 0x05, 0x03, 0x06, 0x1E, 0x05, 0x0A, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x07, 0x0A, 0x00, 0x35, 0x06, 0x07, 0x00, 0x32, 0x01, 0x06, 0x00, 0x2C, 0x08, 0x04, + 0x00, 0x35, 0x07, 0x08, 0x00, 0x34, 0x07, 0x00, 0x00, 0x2C, 0x06, 0x0B, 0x00, 0x36, 0x06, 0x00, + 0x00, 0x2C, 0x07, 0x0C, 0x00, 0x25, 0x06, 0x03, 0x07, 0x1E, 0x06, 0x0A, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x35, 0x07, 0x08, 0x00, 0x32, 0x01, 0x07, 0x00, 0x2C, 0x09, 0x04, + 0x00, 0x35, 0x08, 0x09, 0x00, 0x34, 0x08, 0x00, 0x00, 0x2C, 0x07, 0x0D, 0x00, 0x36, 0x07, 0x00, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x88, 0x37, 0x05, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x14, 0x00, + 0x14, 0x00, 0x10, 0x01, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x02, + 0x1C, 0x00, 0x1C, 0x00, 0x14, 0x01, 0x18, 0x00, 0x18, 0x00, 0x14, 0x01, 0x27, 0x00, 0x27, 0x00, + 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x01, 0x23, 0x00, 0x23, 0x00, + 0x23, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0xBF, 0xF9, 0x07, 0x00, 0x07, 0x00, 0x07, 0x08, 0x10, + 0x00, 0x10, 0x00, 0x10, 0xBF, 0xF8, 0x07, 0x00, 0x07, 0x00, 0x07, 0x09, 0x20, 0x00, 0x20, 0x00, + 0x20, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0xBF, 0xF7, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x0A, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, 0xF6, 0x07, 0x88, 0x37, 0x05, 0x00, 0x05, 0x0D, 0x0C, + 0x00, 0x0C, 0x00, 0x19, 0x00, 0x19, 0x00, 0x15, 0x00, 0x15, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x01, 0x01, 0x01, 0x0C, 0x3D, 0x01, 0x14, 0xCE, 0x05, 0x64, + 0x6F, 0x74, 0x75, 0x70, 0xDA, 0x18, 0xD2, 0x00, 0x00, 0xD8, 0x03, 0x64, 0x79, 0x6E, 0xD5, 0x00, + 0xDA, 0x61, 0xDA, 0x06, 0xDA, 0x37, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x02, 0x02, + 0x02, 0x08, 0x28, 0x00, 0x05, 0xCE, 0x0B, 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, + 0x61, 0x78, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xDA, 0x80, 0xA4, 0xD0, 0x06, 0x70, 0x61, + 0x72, 0x65, 0x6E, 0x73, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xC8, 0xD8, 0x0F, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x2F, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, 0xD8, 0x0C, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x70, 0x00, 0x28, 0x00, 0xCF, 0x06, 0x62, 0x65, + 0x66, 0x6F, 0x72, 0x65, 0x00, 0x28, 0x01, 0xCF, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, 0x28, + 0x02, 0xCF, 0x0B, 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x05, 0x0F, + 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x50, 0x1F, 0x27, 0x05, 0xDA, 0x80, 0xAD, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, + 0x25, 0x05, 0x06, 0x04, 0x1B, 0x04, 0x05, 0x00, 0x1E, 0x05, 0x08, 0x00, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x25, 0x07, 0x08, 0x06, + 0x1B, 0x03, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x18, 0x00, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2C, 0x07, 0x03, 0x00, + 0x25, 0x06, 0x07, 0x05, 0x1E, 0x06, 0x06, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, + 0x35, 0x05, 0x07, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x2C, 0x07, 0x05, 0x00, 0x35, 0x05, 0x07, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x35, 0x04, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, + 0x34, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x07, 0x00, 0x36, 0x06, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, + 0x85, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x03, 0x03, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, 0x01, 0x12, + 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, + 0xFE, 0x10, 0x00, 0x07, 0x03, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0xBF, 0xFA, 0x03, 0xD0, 0x0A, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0x66, 0x6F, 0x72, + 0x6D, 0xD8, 0x06, 0x73, 0x65, 0x74, 0x64, 0x79, 0x6E, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xA6, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x02, 0x02, 0x02, 0x04, 0x0F, 0x00, 0x03, 0xCE, 0x0C, + 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x21, 0xDA, 0x18, 0xDA, 0x65, + 0xDA, 0x66, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xFD, 0x00, 0x0F, 0x00, 0xDA, 0x81, 0x02, 0x00, 0x0F, + 0x01, 0xDA, 0x81, 0x03, 0x00, 0x0F, 0x02, 0xCF, 0x0C, 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, + 0x6E, 0x74, 0x61, 0x78, 0x21, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x2C, 0x06, 0x01, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x06, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x04, 0x06, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x03, 0x01, 0x00, 0x32, 0x00, 0x03, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x36, 0x04, 0x00, + 0x00, 0x85, 0x0D, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x17, 0x01, 0x19, + 0x00, 0x19, 0x00, 0x19, 0xBF, 0xFF, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xCC, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x80, 0xCD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x80, 0xCE, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x80, 0xCF, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x80, 0xD0, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x80, + 0xD1, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x80, 0xD2, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x80, 0xD3, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x80, 0xD4, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x80, 0xD5, 0x00, 0x3D, 0x00, + 0xDA, 0x80, 0xDB, 0x00, 0x3D, 0x01, 0xDA, 0x80, 0xD6, 0x09, 0x3D, 0x03, 0xCF, 0x01, 0x68, 0x0C, + 0x3D, 0x05, 0xDA, 0x49, 0x10, 0x15, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x4A, + 0x15, 0x3D, 0x07, 0xDA, 0x6B, 0x18, 0x21, 0x09, 0xDA, 0x6C, 0x21, 0x3D, 0x09, 0xCF, 0x01, 0x6D, + 0x24, 0x3D, 0x0B, 0xCF, 0x02, 0x6D, 0x3F, 0x28, 0x03, 0x00, 0x00, 0x49, 0x02, 0x00, 0x03, 0x28, + 0x04, 0x00, 0x00, 0x25, 0x03, 0x04, 0x02, 0x1E, 0x03, 0x03, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x03, + 0x02, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3A, 0x02, 0x00, 0x03, 0x1B, 0x03, 0x02, 0x00, 0x2D, + 0x05, 0x00, 0x12, 0x3A, 0x04, 0x05, 0x03, 0x1B, 0x05, 0x04, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, + 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x1B, + 0x06, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x2C, + 0x09, 0x03, 0x00, 0x3B, 0x08, 0x07, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x1E, 0x09, 0x05, 0x00, 0x2B, + 0x0B, 0x00, 0x00, 0x3A, 0x0A, 0x09, 0x0B, 0x1B, 0x08, 0x0A, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, + 0x0B, 0x04, 0x00, 0x3B, 0x0A, 0x07, 0x0B, 0x1B, 0x08, 0x0A, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x2C, + 0x0B, 0x05, 0x00, 0x3A, 0x0A, 0x07, 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1E, 0x05, 0x06, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x35, 0x0C, 0x05, 0x00, 0x32, 0x00, 0x0C, 0x00, 0x2C, 0x0D, 0x06, 0x00, 0x36, + 0x0D, 0x00, 0x00, 0x1E, 0x0B, 0x0B, 0x00, 0x2C, 0x0C, 0x07, 0x00, 0x32, 0x0C, 0x00, 0x00, 0x2C, + 0x0D, 0x08, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x2B, 0x0C, 0x01, 0x00, 0x32, 0x00, 0x0C, 0x00, 0x2C, + 0x0D, 0x09, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x34, 0x0C, 0x00, 0x00, 0x36, 0x09, 0x00, 0x00, 0x2D, + 0x0C, 0x00, 0x04, 0x32, 0x0C, 0x00, 0x00, 0x2C, 0x0D, 0x0A, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x32, + 0x00, 0x0C, 0x00, 0x2C, 0x0D, 0x0B, 0x00, 0x36, 0x0D, 0x00, 0x00, 0xBF, 0xFF, 0x88, 0x54, 0x10, + 0x00, 0x10, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x1A, 0x00, 0x1A, 0x01, 0x0C, 0x00, 0x0C, + 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, + 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x10, + 0x00, 0x29, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x29, 0x00, 0x29, 0x00, 0x38, 0x00, 0x38, 0x00, 0x29, + 0x00, 0x05, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x01, 0x05, 0x01, 0x18, 0x00, 0x18, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x05, 0x02, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, + 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x26, 0x00, 0x26, 0x01, 0x17, 0x00, 0x17, 0x00, + 0x17, 0x00, 0x17, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x88, 0x04, 0x01, 0x05, 0x03, 0x01, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x02, 0x03, 0x00, 0x03, 0x02, 0x03, + 0x00, 0x03, 0x08, 0x03, 0x00, 0x03, 0x08, 0x03, 0x00, 0x03, 0x09, 0x03, 0x00, 0x03, 0x04, 0x03, + 0x00, 0x03, 0x0A, 0x03, 0x00, 0x03, 0x10, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x0D, 0x03, 0x00, 0x03, 0x0D, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0E, + 0x01, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x0E, 0x00, + 0x0E, 0x02, 0x12, 0x00, 0x12, 0xBF, 0xFE, 0x0E, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x04, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFC, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x05, 0x20, 0x00, 0x20, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFB, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, 0x0E, 0x00, 0x0E, 0xBF, 0xFA, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0xBF, 0xA5, 0x01, + 0x56, 0x01, 0x04, 0x00, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x10, 0x02, 0x02, 0x02, 0x09, + 0x65, 0x00, 0x12, 0xCE, 0x09, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, 0x74, 0x3D, 0xDA, 0x18, + 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xDA, 0x66, 0xDA, 0x80, 0xC9, 0xDA, 0x80, 0xEF, 0xDA, 0x80, 0xCB, + 0xDA, 0x80, 0xCA, 0xD0, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xD8, 0x06, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x00, 0x65, 0x00, 0xDA, 0x1E, 0x00, 0x65, 0x01, 0xDA, 0x80, 0xD9, 0x00, 0x65, + 0x02, 0xCF, 0x09, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, 0x74, 0x3D, 0x04, 0x65, 0x04, 0xCF, + 0x02, 0x74, 0x78, 0x09, 0x65, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x0B, + 0x65, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x61, 0x12, 0x27, 0x07, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x15, 0x27, 0x08, 0xDA, 0x23, 0x16, 0x26, 0x09, 0xDA, + 0x80, 0xC3, 0x18, 0x26, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x1C, 0x26, + 0x0D, 0xCF, 0x02, 0x78, 0x78, 0x1E, 0x26, 0x0E, 0xCF, 0x02, 0x79, 0x79, 0x2D, 0x42, 0x08, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x42, 0x09, 0xDA, 0x23, 0x31, 0x41, 0x0A, + 0xDA, 0x80, 0xC3, 0x33, 0x41, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x37, + 0x41, 0x0E, 0xDA, 0x81, 0x19, 0x39, 0x41, 0x0F, 0xDA, 0x81, 0x1A, 0x2E, 0x02, 0x00, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x4A, 0x06, 0x04, 0x05, 0x1B, + 0x05, 0x06, 0x00, 0x1E, 0x05, 0x02, 0x00, 0x03, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x25, + 0x06, 0x04, 0x07, 0x1E, 0x06, 0x19, 0x00, 0x3F, 0x07, 0x00, 0x00, 0x3F, 0x08, 0x01, 0x00, 0x4A, + 0x09, 0x07, 0x08, 0x1B, 0x07, 0x09, 0x00, 0x1E, 0x07, 0x02, 0x00, 0x03, 0x07, 0x00, 0x00, 0x2A, + 0x08, 0x00, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x3F, 0x0A, 0x00, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x23, + 0x0A, 0x09, 0x0B, 0x1E, 0x0A, 0x0C, 0x00, 0x3A, 0x0C, 0x00, 0x09, 0x1B, 0x0D, 0x0C, 0x00, 0x3A, + 0x0C, 0x01, 0x09, 0x1B, 0x0E, 0x0C, 0x00, 0x32, 0x0D, 0x0E, 0x00, 0x35, 0x0C, 0x02, 0x00, 0x1E, + 0x0C, 0x03, 0x00, 0x29, 0x08, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x09, 0x09, 0x01, 0x1C, + 0xF4, 0xFF, 0xFF, 0x03, 0x08, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x25, 0x07, 0x04, 0x08, 0x1E, + 0x07, 0x19, 0x00, 0x3F, 0x08, 0x00, 0x00, 0x3F, 0x09, 0x01, 0x00, 0x4A, 0x0A, 0x08, 0x09, 0x1B, + 0x08, 0x0A, 0x00, 0x1E, 0x08, 0x02, 0x00, 0x03, 0x08, 0x00, 0x00, 0x2A, 0x09, 0x00, 0x00, 0x2B, + 0x0A, 0x00, 0x00, 0x3F, 0x0B, 0x00, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x23, 0x0B, 0x0A, 0x0C, 0x1E, + 0x0B, 0x0C, 0x00, 0x3A, 0x0D, 0x00, 0x0A, 0x1B, 0x0E, 0x0D, 0x00, 0x3A, 0x0D, 0x01, 0x0A, 0x1B, + 0x0F, 0x0D, 0x00, 0x32, 0x0E, 0x0F, 0x00, 0x35, 0x0D, 0x02, 0x00, 0x1E, 0x0D, 0x03, 0x00, 0x29, + 0x09, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x0A, 0x0A, 0x01, 0x1C, 0xF4, 0xFF, 0xFF, 0x03, + 0x09, 0x00, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x25, 0x08, 0x04, 0x09, 0x1E, 0x08, 0x09, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, + 0x0B, 0x04, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x32, 0x09, 0x0A, 0x00, 0x36, 0x02, 0x00, 0x00, 0x2C, + 0x0A, 0x05, 0x00, 0x25, 0x09, 0x04, 0x0A, 0x1E, 0x09, 0x09, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x0B, 0x06, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x35, + 0x0B, 0x0C, 0x00, 0x32, 0x0A, 0x0B, 0x00, 0x36, 0x02, 0x00, 0x00, 0x2C, 0x0B, 0x07, 0x00, 0x25, + 0x0A, 0x04, 0x0B, 0x1E, 0x0A, 0x09, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x0C, 0x08, 0x00, 0x35, + 0x0B, 0x0C, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x4A, + 0x0D, 0x0B, 0x0C, 0x03, 0x0D, 0x00, 0x00, 0x4A, 0x0B, 0x00, 0x01, 0x03, 0x0B, 0x00, 0x00, 0x88, + 0x7B, 0x01, 0x04, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x02, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, + 0x18, 0x00, 0x23, 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x02, 0x14, 0x01, 0x14, 0x00, + 0x1E, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x1E, 0x00, 0x16, 0x01, 0x1E, 0x00, 0x16, 0x01, + 0x1A, 0x00, 0x1A, 0x00, 0x16, 0x01, 0x1F, 0x00, 0x18, 0xBF, 0xFC, 0x14, 0x00, 0x14, 0xBF, 0xFE, + 0x12, 0xBF, 0xFE, 0x05, 0x00, 0x05, 0x00, 0x05, 0x0A, 0x18, 0x00, 0x23, 0x00, 0x12, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x02, 0x14, 0x01, 0x14, 0x00, 0x1E, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, + 0x01, 0x1E, 0x00, 0x16, 0x01, 0x1E, 0x00, 0x16, 0x01, 0x1A, 0x00, 0x1A, 0x00, 0x16, 0x01, 0x1F, + 0x00, 0x18, 0xBF, 0xFC, 0x14, 0x00, 0x14, 0xBF, 0xFE, 0x12, 0xBF, 0xF5, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x13, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x0F, 0x00, + 0x0F, 0xBF, 0xED, 0x05, 0x00, 0x05, 0x00, 0x05, 0x14, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x2D, + 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xEC, 0x05, 0x00, 0x05, 0x00, 0x05, 0x15, + 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x0F, 0x00, 0x0F, 0x01, + 0x07, 0x00, 0x07, 0xCE, 0x1A, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6E, + 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x6F, 0x20, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x00, + 0x16, 0x00, 0xDA, 0x1E, 0x00, 0x16, 0x01, 0xDA, 0x80, 0xCC, 0x00, 0x16, 0x02, 0xCF, 0x05, 0x6D, + 0x61, 0x63, 0x65, 0x78, 0x00, 0x16, 0x03, 0xCF, 0x08, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, + 0x73, 0x04, 0x16, 0x05, 0xCF, 0x07, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x05, 0x16, 0x06, + 0xCF, 0x07, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, 0x1B, 0x03, 0x00, 0x00, 0x32, 0x00, 0x01, + 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x06, 0x00, + 0x00, 0x32, 0x05, 0x03, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1E, 0x07, 0x0C, + 0x00, 0x05, 0x06, 0x06, 0x01, 0x2B, 0x09, 0xC8, 0x00, 0x21, 0x08, 0x06, 0x09, 0x1E, 0x08, 0x03, + 0x00, 0x2C, 0x09, 0x02, 0x00, 0x01, 0x09, 0x00, 0x00, 0x1B, 0x03, 0x05, 0x00, 0x32, 0x05, 0x01, + 0x00, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x05, 0x08, 0x00, 0x1C, 0xF2, 0xFF, 0xFF, 0x03, 0x05, 0x00, + 0x00, 0x88, 0xC3, 0x03, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x03, 0x01, 0x03, 0x01, 0x0A, + 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, + 0x00, 0x07, 0x01, 0x05, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFC, 0x03, 0xBF, 0xF6, 0x01, + 0x00, 0x1D, 0x00, 0xCF, 0x08, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x00, 0x1D, 0x01, + 0xCF, 0x03, 0x74, 0x72, 0x75, 0x00, 0x1D, 0x02, 0xCF, 0x03, 0x66, 0x61, 0x6C, 0x00, 0x1D, 0x03, + 0xDA, 0x80, 0x86, 0x01, 0x1D, 0x05, 0xCF, 0x03, 0x6C, 0x65, 0x6E, 0x17, 0x1D, 0x07, 0xCF, 0x04, + 0x66, 0x61, 0x6C, 0x32, 0x19, 0x1D, 0x09, 0xCF, 0x03, 0x61, 0x75, 0x78, 0x3F, 0x04, 0x00, 0x00, + 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x25, 0x06, 0x07, 0x05, 0x1E, 0x06, 0x03, 0x00, + 0x2C, 0x07, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, + 0x35, 0x06, 0x07, 0x00, 0x1E, 0x06, 0x03, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x01, 0x07, 0x00, 0x00, + 0x2C, 0x07, 0x03, 0x00, 0x3D, 0x07, 0x07, 0x00, 0x1E, 0x07, 0x07, 0x00, 0x31, 0x02, 0x00, 0x00, + 0x2C, 0x08, 0x03, 0x00, 0x3D, 0x08, 0x08, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x06, 0x07, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x30, 0x08, 0x00, 0x00, + 0x1B, 0x09, 0x08, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x36, 0x09, 0x00, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x05, 0x35, 0x01, 0x0B, 0xCE, 0x03, 0x61, + 0x75, 0x78, 0xDA, 0x18, 0xDA, 0x80, 0x95, 0xDA, 0x52, 0xDA, 0x57, 0xDA, 0x51, 0xDA, 0x58, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x81, 0x22, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, 0x23, 0xBF, 0xFF, 0x00, + 0x02, 0xDA, 0x81, 0x24, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x80, 0x86, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x81, 0x25, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x81, 0x26, 0x00, 0x35, 0x00, 0xDA, 0x80, 0xC3, 0x00, + 0x35, 0x01, 0xDA, 0x81, 0x27, 0x08, 0x35, 0x04, 0xCF, 0x02, 0x62, 0x6C, 0x0D, 0x35, 0x03, 0xCF, + 0x02, 0x62, 0x72, 0x21, 0x35, 0x07, 0xDA, 0x69, 0x2E, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x05, + 0x47, 0x02, 0x00, 0x03, 0x1E, 0x02, 0x03, 0x00, 0x2D, 0x03, 0x00, 0x01, 0x03, 0x03, 0x00, 0x00, + 0x2D, 0x04, 0x00, 0x00, 0x3A, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x05, 0x01, 0x00, + 0x06, 0x03, 0x05, 0x00, 0x2D, 0x06, 0x00, 0x00, 0x3A, 0x05, 0x06, 0x03, 0x1B, 0x03, 0x05, 0x00, + 0x31, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x0E, 0x00, + 0x2C, 0x07, 0x01, 0x00, 0x33, 0x07, 0x04, 0x03, 0x45, 0x06, 0x00, 0x00, 0x2B, 0x08, 0x02, 0x00, + 0x06, 0x07, 0x08, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x08, 0x01, 0x00, 0x2C, 0x09, 0x02, 0x00, + 0x33, 0x09, 0x06, 0x08, 0x2D, 0x09, 0x00, 0x07, 0x31, 0x09, 0x00, 0x00, 0x45, 0x07, 0x00, 0x00, + 0x03, 0x07, 0x00, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, + 0x2C, 0x09, 0x01, 0x00, 0x33, 0x09, 0x06, 0x03, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, + 0x33, 0x09, 0x04, 0x07, 0x45, 0x06, 0x00, 0x00, 0x2B, 0x0A, 0x02, 0x00, 0x06, 0x09, 0x0A, 0x00, + 0x31, 0x09, 0x00, 0x00, 0x35, 0x0A, 0x01, 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x33, 0x0B, 0x06, 0x0A, + 0x45, 0x09, 0x00, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x33, 0x0A, 0x08, 0x09, 0x2D, 0x0A, 0x00, 0x07, + 0x31, 0x0A, 0x00, 0x00, 0x45, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0x82, 0xA8, + 0x03, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x11, 0x00, 0x11, 0x00, + 0x09, 0x01, 0x1E, 0x00, 0x1E, 0x00, 0x11, 0x00, 0x11, 0x00, 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x24, 0x00, 0x24, 0x00, 0x1F, 0x00, + 0x1F, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x1F, 0x00, + 0x1F, 0x00, 0x16, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, + 0x27, 0x00, 0x27, 0x00, 0x22, 0x00, 0x22, 0xBF, 0xFF, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x82, 0xA4, 0x0C, 0x00, 0x03, 0x01, + 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, 0x11, 0x00, 0x11, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x03, 0x00, 0x12, 0x00, 0x12, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x1A, 0x00, 0x1A, 0x00, + 0x1A, 0x00, 0x1A, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x0B, + 0x04, 0x00, 0x04, 0x00, 0x04, 0xA3, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, 0xCB, 0x28, 0x69, + 0x66, 0x2D, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x66, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x4D, 0x61, + 0x6B, 0x65, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x0A, 0x65, 0x76, 0x61, + 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x74, 0x72, 0x75, 0x60, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x65, + 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x60, 0x66, 0x61, 0x6C, + 0x60, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0x20, 0x42, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x73, + 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x6C, 0x65, + 0x74, 0x60, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x06, 0x63, 0x61, + 0x6E, 0x63, 0x65, 0x6C, 0xD3, 0x02, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x20, 0x02, + 0x02, 0x02, 0x02, 0x00, 0x02, 0xCE, 0x06, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x4C, 0x00, 0x00, + 0x01, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, 0x9C, 0x28, 0x63, 0x61, 0x6E, 0x63, 0x65, + 0x6C, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x73, 0x75, 0x6D, 0x65, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x62, 0x75, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, + 0x74, 0x65, 0x6C, 0x79, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6C, 0x65, 0x74, 0x73, 0x20, 0x61, + 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x77, 0x69, + 0x6E, 0x64, 0x20, 0x61, 0x20, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6D, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x61, 0x73, 0x20, 0x72, + 0x65, 0x73, 0x75, 0x6D, 0x65, 0x2E, 0xCF, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x12, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, + 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2E, 0x63, 0x84, 0x3C, 0x01, 0xDA, 0x06, 0xD8, + 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x08, 0xCE, 0x81, 0xB9, 0x28, 0x63, 0x6F, + 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x73, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, + 0x6E, 0x76, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x73, 0x29, + 0x0A, 0x0A, 0x43, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x41, 0x62, + 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x53, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x54, 0x72, + 0x65, 0x65, 0x20, 0x28, 0x61, 0x73, 0x74, 0x29, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x50, 0x61, 0x69, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x69, 0x74, 0x79, 0x20, 0x74, + 0x6F, 0x20, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x76, 0x61, 0x6C, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x6F, 0x65, + 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x20, 0x61, 0x73, 0x74, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, + 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6B, + 0x65, 0x79, 0x73, 0x20, 0x3A, 0x6C, 0x69, 0x6E, 0x65, 0x2C, 0x20, 0x3A, 0x63, 0x6F, 0x6C, 0x75, + 0x6D, 0x6E, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, + 0x66, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x61, + 0x69, 0x6C, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x60, 0x6C, 0x69, 0x6E, 0x74, 0x73, + 0x60, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, + 0x2C, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, + 0x64, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x60, 0x28, 0x6C, 0x65, 0x76, + 0x65, 0x6C, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x20, 0x6D, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x29, 0x60, 0x2E, 0xCF, 0x12, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x2D, 0x75, 0x6E, 0x70, 0x61, 0x63, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x12, 0x83, 0x2A, 0x01, 0xDA, 0x06, 0xD8, 0x12, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x2D, 0x75, 0x6E, 0x70, 0x61, 0x63, 0x6B, 0xDA, 0x08, 0xCE, 0x80, + 0xA4, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2D, 0x75, 0x6E, + 0x70, 0x61, 0x63, 0x6B, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x29, 0x0A, 0x0A, 0x47, + 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x6E, 0x65, 0x74, 0x2F, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x61, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x2C, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x70, 0x61, 0x69, + 0x72, 0x2E, 0x20, 0x55, 0x6E, 0x69, 0x78, 0x20, 0x64, 0x6F, 0x6D, 0x61, 0x69, 0x6E, 0x20, 0x73, + 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xCF, 0x06, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x66, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x9C, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, + 0x00, 0x00, 0x05, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x06, 0x00, 0x03, 0xCE, 0x06, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x66, 0xDA, 0x18, 0xDA, 0x54, 0x00, 0x06, 0x00, 0xCF, 0x03, 0x66, + 0x6D, 0x74, 0x00, 0x06, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x06, 0x02, 0xDA, 0x81, 0x3C, 0x31, 0x00, + 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x01, 0x03, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x9F, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x75, 0x28, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x66, 0x20, 0x66, + 0x6D, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x41, 0x20, 0x63, 0x6F, + 0x6D, 0x62, 0x69, 0x6E, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x60, 0x2E, 0x20, 0x45, 0x71, 0x75, 0x69, 0x76, 0x61, + 0x6C, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x66, + 0x6D, 0x74, 0x20, 0x3B, 0x61, 0x72, 0x67, 0x73, 0x29, 0x29, 0x60, 0x2E, 0xCF, 0x02, 0x69, 0x6E, + 0xD3, 0x02, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x06, 0x04, 0x03, 0x02, 0x03, 0x00, + 0x06, 0xCE, 0x02, 0x69, 0x6E, 0x3A, 0x00, 0x00, 0x01, 0x28, 0x03, 0x00, 0x00, 0x25, 0x03, 0x00, + 0x03, 0x1D, 0x03, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xDA, 0x08, 0xCE, + 0x81, 0x8A, 0x28, 0x69, 0x6E, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x64, 0x73, 0x20, 0x61, 0x74, 0x20, 0x6B, 0x65, 0x79, 0x2C, + 0x20, 0x77, 0x6F, 0x72, 0x6B, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x73, 0x2E, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2C, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x2C, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x2C, + 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x61, 0x73, + 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2E, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x73, 0x2C, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x73, 0x2C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, + 0x73, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x64, 0x2E, 0x20, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6E, + 0x69, 0x6C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x6F, 0x72, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x20, 0x69, + 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xCF, 0x08, 0x6F, 0x73, + 0x2F, 0x6C, 0x73, 0x74, 0x61, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, + 0x07, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x6C, 0x73, 0x74, 0x61, 0x74, 0xDA, 0x08, + 0xCE, 0x47, 0x28, 0x6F, 0x73, 0x2F, 0x6C, 0x73, 0x74, 0x61, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x61, 0x62, 0x7C, 0x6B, 0x65, 0x79, 0x29, 0x0A, 0x0A, + 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x2C, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x64, 0x6F, 0x6E, 0x27, 0x74, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x73, + 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x73, 0x2E, 0x0A, 0xCF, 0x02, 0x2D, 0x2D, 0xD3, 0x04, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x8B, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x08, 0x00, 0x02, 0xCE, 0x02, 0x2D, 0x2D, 0xDA, 0x18, + 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x0A, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x13, 0xCE, 0x01, 0x2D, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, + 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, + 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x08, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, + 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x08, 0x03, 0x03, 0x04, + 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, + 0xDA, 0x34, 0x00, 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x81, 0x4D, 0x2C, 0x03, 0x00, + 0x00, 0x2B, 0x04, 0x01, 0x00, 0x33, 0x03, 0x00, 0x04, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x33, 0x04, 0x00, 0x02, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x80, 0x8B, 0x2F, + 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0xDA, 0x08, + 0xCE, 0x22, 0x28, 0x2D, 0x2D, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x63, 0x72, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x20, 0x78, 0x20, 0x62, + 0x79, 0x20, 0x31, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, + 0x67, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0F, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x6D, 0x61, 0x74, 0x68, 0x2E, 0x63, 0x81, 0x19, 0x01, 0xDA, 0x06, 0xD8, 0x08, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0xDA, 0x08, 0xCE, 0x31, 0x28, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6C, 0x20, 0x6C, 0x6F, + 0x67, 0x61, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x0A, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x74, 0x79, 0x70, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xCE, 0x10, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x74, 0x75, 0x70, 0x6C, 0x65, + 0x2E, 0x63, 0x56, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xA4, 0xDA, 0x08, 0xCE, 0x81, 0x1D, 0x28, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x75, 0x70, 0x29, 0x0A, 0x0A, + 0x43, 0x68, 0x65, 0x63, 0x6B, 0x73, 0x20, 0x68, 0x6F, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x65, 0x64, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x3A, 0x62, + 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x3A, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x73, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, + 0x77, 0x69, 0x73, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, + 0x6D, 0x65, 0x20, 0x6D, 0x6F, 0x73, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x69, 0x6D, 0x65, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x70, 0x72, + 0x69, 0x6E, 0x74, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x72, 0x2E, 0xCF, 0x09, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, 0x73, + 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x63, 0x81, + 0x3D, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0xDA, + 0x08, 0xCE, 0x80, 0xF3, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x63, + 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x72, 0x65, 0x2D, 0x61, 0x6C, 0x6C, + 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x60, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x60, 0x20, 0x65, 0x6E, 0x74, + 0x72, 0x69, 0x65, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6D, 0x65, 0x61, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x66, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6B, 0x6E, 0x6F, + 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, + 0x20, 0x65, 0x6E, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, 0x67, 0x6F, 0x69, 0x6E, 0x67, 0x20, 0x69, + 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x6D, + 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, + 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x61, 0x76, 0x6F, 0x69, 0x64, 0x65, 0x64, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xCF, 0x07, 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, 0x74, + 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xFD, 0x01, 0xDA, 0x06, 0xD7, 0x00, + 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x09, 0x22, 0x00, + 0x04, 0xCE, 0x07, 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, 0x74, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, + 0x9B, 0xD8, 0x09, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xD0, 0x02, 0x69, 0x65, + 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x05, 0x02, 0x02, 0x01, 0x02, 0x00, 0x02, 0xCE, 0x06, 0x72, + 0x65, 0x73, 0x75, 0x6D, 0x65, 0x37, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xD8, 0x0C, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD7, 0x00, 0xCD, 0x00, 0x09, + 0x00, 0x19, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0xCE, 0x04, 0x6E, 0x6F, + 0x74, 0x3D, 0x3F, 0x01, 0x00, 0x00, 0x24, 0x02, 0x01, 0x02, 0x1D, 0x02, 0x0A, 0x00, 0x3D, 0x03, + 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, + 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, 0x03, 0x04, 0x00, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, + 0xFA, 0xFF, 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x03, 0x03, + 0x00, 0x00, 0xD0, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xCF, 0x03, 0x6C, 0x65, 0x74, 0x00, 0x22, + 0x00, 0xCF, 0x04, 0x62, 0x6F, 0x64, 0x79, 0x00, 0x22, 0x01, 0xDA, 0x81, 0x66, 0x02, 0x22, 0x03, + 0xDA, 0x80, 0xAA, 0x05, 0x22, 0x04, 0xDA, 0x6C, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x02, 0x04, 0x00, 0x1B, 0x04, 0x02, 0x00, + 0x46, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x32, 0x06, 0x02, 0x00, 0x34, 0x00, 0x00, 0x00, + 0x45, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x33, 0x06, 0x05, 0x07, + 0x45, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x32, 0x06, 0x03, 0x00, 0x45, 0x05, 0x00, 0x00, + 0x33, 0x03, 0x02, 0x04, 0x31, 0x05, 0x00, 0x00, 0x46, 0x06, 0x00, 0x00, 0x2C, 0x05, 0x05, 0x00, + 0x32, 0x05, 0x03, 0x00, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x2C, 0x08, 0x07, 0x00, + 0x33, 0x07, 0x08, 0x02, 0x45, 0x05, 0x00, 0x00, 0x32, 0x05, 0x04, 0x00, 0x46, 0x02, 0x00, 0x00, + 0x2C, 0x07, 0x08, 0x00, 0x33, 0x07, 0x06, 0x02, 0x45, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, + 0x81, 0x02, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x16, 0x00, 0x16, 0x00, 0x03, 0x01, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x08, 0xCE, 0x80, 0xD2, 0x28, 0x70, 0x72, 0x6F, 0x74, 0x65, + 0x63, 0x74, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x73, + 0x2C, 0x20, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x2E, 0x20, 0x45, 0x76, + 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x0A, 0x6F, 0x66, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, + 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6C, 0x2C, 0x20, 0x66, 0x61, 0x6C, + 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x0A, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, + 0x07, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x3A, 0x84, 0x6C, 0x01, 0xDA, 0x06, 0xD8, 0x07, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0xDA, + 0x08, 0xCE, 0x80, 0xA7, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, + 0x6C, 0x2E, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x71, 0x75, 0x65, 0x75, 0x65, 0x20, 0x62, 0x65, 0x66, + 0x6F, 0x72, 0x65, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, + 0x6F, 0x20, 0x30, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, + 0x65, 0x77, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x2E, 0xCF, 0x02, 0x2D, 0x3D, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x8D, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, + 0xCE, 0x02, 0x2D, 0x3D, 0xDA, 0x18, 0xDA, 0x81, 0x52, 0xDA, 0x34, 0x00, 0x08, 0x00, 0xDA, 0x1E, + 0x00, 0x08, 0x01, 0xDA, 0x35, 0x00, 0x08, 0x02, 0xDA, 0x81, 0x7B, 0x2C, 0x04, 0x00, 0x00, 0x32, + 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, + 0x05, 0x00, 0x03, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0x8D, 0x34, 0x00, 0x34, + 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0xDA, 0x08, 0xCE, 0x27, + 0x28, 0x2D, 0x3D, 0x20, 0x78, 0x20, 0x26, 0x20, 0x6E, 0x73, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x63, + 0x72, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x20, + 0x78, 0x20, 0x62, 0x79, 0x20, 0x6E, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x06, 0x65, 0x64, 0x65, 0x66, + 0x65, 0x72, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x43, 0x01, 0xDA, 0x06, + 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0B, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0C, + 0x2E, 0x00, 0x05, 0xCE, 0x06, 0x65, 0x64, 0x65, 0x66, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x51, 0xDA, + 0x80, 0x9B, 0xDA, 0x81, 0x6B, 0xD0, 0x02, 0x74, 0x69, 0xDA, 0x52, 0xDA, 0x81, 0x6D, 0xDA, 0x81, + 0x6F, 0xCF, 0x01, 0x3D, 0xD0, 0x04, 0x64, 0x65, 0x61, 0x64, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, + 0x1A, 0x02, 0x02, 0x02, 0x02, 0x00, 0x02, 0xCE, 0x09, 0x70, 0x72, 0x6F, 0x70, 0x61, 0x67, 0x61, + 0x74, 0x65, 0x39, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x58, 0xDA, 0x57, 0x00, 0x2E, + 0x00, 0xCF, 0x04, 0x66, 0x6F, 0x72, 0x6D, 0x00, 0x2E, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x2E, 0x02, + 0xDA, 0x81, 0x81, 0x02, 0x2E, 0x04, 0xDA, 0x80, 0xAA, 0x05, 0x2E, 0x05, 0xDA, 0x6C, 0x2C, 0x04, + 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x03, + 0x05, 0x00, 0x1B, 0x05, 0x03, 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x32, 0x07, + 0x03, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x2C, 0x08, + 0x03, 0x00, 0x33, 0x07, 0x06, 0x08, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x33, 0x07, + 0x04, 0x03, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x32, 0x07, 0x04, 0x00, 0x45, 0x03, + 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x33, 0x08, 0x05, 0x03, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, + 0x06, 0x00, 0x32, 0x08, 0x04, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x09, 0x07, 0x00, 0x2C, 0x0A, + 0x08, 0x00, 0x33, 0x09, 0x03, 0x0A, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x09, 0x00, 0x33, 0x09, + 0x05, 0x04, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x0A, 0x0A, 0x00, 0x33, 0x0A, 0x00, 0x03, 0x45, 0x09, + 0x00, 0x00, 0x2C, 0x0A, 0x0B, 0x00, 0x33, 0x0A, 0x08, 0x05, 0x31, 0x09, 0x00, 0x00, 0x45, 0x03, + 0x00, 0x00, 0x2C, 0x09, 0x0A, 0x00, 0x33, 0x09, 0x06, 0x07, 0x31, 0x03, 0x00, 0x00, 0x45, 0x08, + 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x81, 0x47, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0xDA, 0x08, 0xCE, 0x80, 0x9F, 0x28, 0x65, 0x64, 0x65, 0x66, 0x65, 0x72, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, + 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x60, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x60, + 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x74, 0x65, 0x72, 0x6D, + 0x69, 0x6E, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x62, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x6C, + 0x79, 0x20, 0x28, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x75, + 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x30, 0x2D, 0x34, 0x29, 0x2E, + 0x0A, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x02, 0x2D, 0x3E, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x11, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, + 0xFD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x05, 0x00, 0x01, 0x04, + 0xCE, 0x02, 0x2D, 0x3E, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x03, 0x03, + 0x03, 0x00, 0x0C, 0x00, 0x08, 0xCE, 0x06, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0xDA, 0x18, 0x00, + 0x0C, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x0C, 0x01, 0xCF, 0x04, 0x69, 0x6E, 0x69, 0x74, 0x00, 0x0C, + 0x02, 0xDA, 0x1F, 0x00, 0x0C, 0x03, 0xCF, 0x06, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x00, 0x0C, + 0x04, 0xCF, 0x05, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x00, 0x0B, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x6F, 0x03, 0x0B, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x6E, + 0x06, 0x0B, 0x07, 0xCF, 0x02, 0x65, 0x6C, 0x1B, 0x04, 0x01, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, + 0x05, 0x02, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x07, 0x00, 0x3A, 0x05, 0x02, 0x06, 0x1B, + 0x07, 0x05, 0x00, 0x32, 0x04, 0x07, 0x00, 0x35, 0x04, 0x00, 0x00, 0x49, 0x06, 0x02, 0x06, 0x1C, + 0xFA, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x83, 0x8A, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xF7, + 0x01, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, 0xCF, 0x05, 0x66, 0x6F, 0x72, 0x6D, 0x73, + 0x00, 0x05, 0x02, 0xDA, 0x81, 0x8D, 0x01, 0x05, 0x04, 0xCF, 0x03, 0x66, 0x6F, 0x70, 0x30, 0x03, + 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x33, 0x04, 0x00, 0x01, 0x2C, 0x05, 0x00, 0x00, 0x36, 0x05, + 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x02, 0x02, 0x02, 0x06, 0x23, 0x00, 0x06, 0xCE, + 0x03, 0x66, 0x6F, 0x70, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xD8, 0x0B, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x80, 0xE7, 0xDA, 0x80, 0xE3, 0xDA, 0x81, + 0x08, 0x00, 0x23, 0x00, 0xDA, 0x80, 0xE4, 0x00, 0x23, 0x01, 0xCF, 0x01, 0x6E, 0x00, 0x23, 0x02, + 0xDA, 0x81, 0x9B, 0x17, 0x23, 0x05, 0xDA, 0x81, 0x0B, 0x19, 0x23, 0x06, 0xDA, 0x80, 0xDB, 0x1F, + 0x23, 0x04, 0xCF, 0x05, 0x70, 0x61, 0x72, 0x74, 0x73, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x00, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x0C, + 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3A, 0x04, 0x01, 0x06, 0x2B, 0x06, 0x01, 0x00, 0x32, 0x01, 0x06, + 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, 0x03, + 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x03, 0x07, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x40, 0x04, 0x00, + 0x00, 0x32, 0x01, 0x04, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x03, 0x06, + 0x00, 0x3D, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3D, 0x04, 0x03, 0x01, 0x1B, 0x06, 0x04, + 0x00, 0x32, 0x05, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, 0x04, + 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x04, 0x07, 0x00, 0x32, 0x01, 0x04, 0x00, 0x2C, 0x08, 0x05, + 0x00, 0x36, 0x08, 0x00, 0x00, 0x85, 0x17, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x14, 0x00, 0x14, + 0x00, 0x10, 0x01, 0x19, 0x00, 0x19, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, + 0x12, 0xBF, 0xFE, 0x10, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x10, 0x00, 0x10, + 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x85, 0x16, + 0x03, 0x00, 0x03, 0x06, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xDD, 0x28, 0x2D, + 0x3E, 0x20, 0x78, 0x20, 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x49, + 0x6E, 0x73, 0x65, 0x72, 0x74, 0x73, 0x20, 0x78, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x69, + 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, + 0x6E, 0x73, 0x65, 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, + 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, + 0x6D, 0x61, 0x6E, 0x6E, 0x65, 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x6F, 0x20, 0x6F, + 0x6E, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x78, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x69, 0x70, 0x65, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x0C, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xCE, 0x11, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x2E, 0x63, 0x81, 0xBD, 0x01, 0xDA, 0x06, 0xD8, 0x0C, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0xDA, 0x08, 0xCE, 0x81, 0x77, 0x28, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0x20, 0x64, 0x65, 0x6C, 0x69, + 0x6D, 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x20, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x29, 0x0A, 0x0A, 0x53, 0x70, 0x6C, 0x69, 0x74, 0x73, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0x20, 0x60, 0x64, + 0x65, 0x6C, 0x69, 0x6D, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x75, + 0x62, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x75, + 0x62, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, + 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0x20, 0x60, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x60, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x60, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, + 0x65, 0x61, 0x72, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x64, 0x65, + 0x6C, 0x69, 0x6D, 0x60, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, 0x74, 0x60, 0x20, 0x28, 0x69, 0x66, 0x20, 0x70, 0x72, + 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x29, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x78, 0x69, + 0x6D, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x60, 0x20, 0x72, + 0x65, 0x73, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x28, 0x69, 0x66, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x29, 0x2E, 0xCF, 0x04, 0x63, 0x6F, 0x72, 0x6F, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x82, 0x7A, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, + 0x05, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x0B, 0x00, 0x02, 0xCE, 0x04, 0x63, 0x6F, + 0x72, 0x6F, 0xDA, 0x18, 0xDA, 0x80, 0x9B, 0xD2, 0x00, 0x01, 0xDA, 0x80, 0xE7, 0xDA, 0x81, 0x6B, + 0xD0, 0x02, 0x79, 0x69, 0x00, 0x0B, 0x00, 0xDA, 0x81, 0x74, 0x00, 0x0B, 0x01, 0xDA, 0x81, 0xA7, + 0x2C, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, 0x02, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00, + 0x2C, 0x03, 0x02, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x03, 0x00, 0x2C, 0x04, 0x04, 0x00, + 0x33, 0x03, 0x02, 0x04, 0x2C, 0x03, 0x02, 0x00, 0x36, 0x03, 0x00, 0x00, 0x82, 0x7D, 0x14, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x7F, 0x28, 0x63, 0x6F, 0x72, 0x6F, 0x20, 0x26, 0x20, 0x62, + 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x41, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x6D, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6D, 0x61, 0x79, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, + 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x20, 0x28, 0x63, 0x6F, 0x72, 0x6F, 0x75, 0x74, 0x69, 0x6E, 0x65, 0x29, 0x2E, 0x20, 0x53, 0x61, + 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, + 0x77, 0x20, 0x28, 0x66, 0x6E, 0x20, 0x5B, 0x5D, 0x20, 0x3B, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x20, + 0x3A, 0x79, 0x69, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x33, 0x32, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0x87, 0x01, 0xDA, 0x06, 0xD8, 0x12, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x33, 0x32, + 0xDA, 0x08, 0xCE, 0x80, 0x84, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, + 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x33, 0x32, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, + 0x68, 0x20, 0x61, 0x20, 0x33, 0x32, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, + 0x6E, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x6F, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x67, 0x61, 0x6D, 0x6D, 0x61, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x27, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x67, 0x61, 0x6D, 0x6D, 0x61, + 0xDA, 0x08, 0xCE, 0x21, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x67, 0x61, 0x6D, 0x6D, 0x61, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x67, 0x61, 0x6D, 0x6D, + 0x61, 0x28, 0x78, 0x29, 0x2E, 0xCF, 0x04, 0x64, 0x65, 0x66, 0x2D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x45, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, + 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x06, 0x00, 0x03, 0xCE, 0x04, 0x64, 0x65, 0x66, + 0x2D, 0xDA, 0x18, 0xDA, 0x52, 0xDA, 0x62, 0x00, 0x06, 0x00, 0xCF, 0x04, 0x6E, 0x61, 0x6D, 0x65, + 0x00, 0x06, 0x01, 0xCF, 0x04, 0x6D, 0x6F, 0x72, 0x65, 0x00, 0x06, 0x02, 0xDA, 0x81, 0xB9, 0x2C, + 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x34, 0x01, 0x00, 0x00, 0x45, + 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x48, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x45, 0x28, 0x64, 0x65, 0x66, 0x2D, 0x20, 0x6E, 0x61, 0x6D, + 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, + 0x05, 0x65, 0x70, 0x72, 0x69, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0D, 0x73, + 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x69, 0x6F, 0x2E, 0x63, 0x82, 0x23, 0x01, 0xDA, + 0x06, 0xD8, 0x05, 0x65, 0x70, 0x72, 0x69, 0x6E, 0xDA, 0x08, 0xCE, 0x5A, 0x28, 0x65, 0x70, 0x72, + 0x69, 0x6E, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x73, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x20, 0x73, 0x74, + 0x64, 0x65, 0x72, 0x72, 0x29, 0x60, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, + 0x66, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x6F, 0x75, 0x74, 0x20, 0x73, 0x74, 0x64, + 0x6F, 0x75, 0x74, 0x29, 0x60, 0x2E, 0xCF, 0x06, 0x2A, 0x61, 0x72, 0x67, 0x73, 0x2A, 0xD3, 0x04, + 0xD0, 0x03, 0x64, 0x79, 0x6E, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8F, 0x8B, 0x01, + 0xDA, 0x06, 0xD0, 0x04, 0x61, 0x72, 0x67, 0x73, 0xDA, 0x08, 0xCE, 0x4B, 0x44, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x63, + 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, + 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2E, 0xCF, 0x05, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0x01, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, + 0xDD, 0x00, 0x00, 0x16, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0xA3, 0x00, 0x2A, + 0xCE, 0x05, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xDA, 0x18, 0xDA, 0x80, 0xA9, 0x00, 0x80, 0xA3, 0x00, + 0xCF, 0x04, 0x70, 0x72, 0x65, 0x64, 0x00, 0x80, 0xA3, 0x01, 0xDA, 0x1F, 0x00, 0x80, 0xA3, 0x02, + 0xDA, 0x80, 0xAB, 0x00, 0x80, 0xA3, 0x03, 0xDA, 0x81, 0xCD, 0x00, 0x80, 0xA3, 0x04, 0xDA, 0x80, + 0xAD, 0x02, 0x80, 0xA2, 0x06, 0xDA, 0x80, 0xAE, 0x02, 0x80, 0xA2, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x04, 0x11, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x07, 0x11, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x0A, 0x11, 0x09, + 0xDA, 0x1E, 0x15, 0x29, 0x09, 0xDA, 0x80, 0xB2, 0x16, 0x29, 0x08, 0xDA, 0x80, 0xB3, 0x16, 0x29, + 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x19, 0x29, 0x0B, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x1C, 0x29, 0x0C, 0xDA, 0x1E, 0x2D, 0x4A, 0x0A, 0xDA, 0x80, + 0xB2, 0x2F, 0x4A, 0x0B, 0xDA, 0x80, 0xB6, 0x30, 0x4A, 0x09, 0xDA, 0x80, 0xB3, 0x31, 0x4A, 0x0C, + 0xDA, 0x80, 0xB7, 0x31, 0x4A, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x34, + 0x4A, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x37, 0x4A, 0x0F, 0xDA, 0x1E, + 0x4E, 0x75, 0x0B, 0xDA, 0x80, 0xB2, 0x50, 0x75, 0x0C, 0xDA, 0x80, 0xB6, 0x52, 0x75, 0x0D, 0xDA, + 0x80, 0xBA, 0x53, 0x75, 0x0A, 0xDA, 0x80, 0xB3, 0x54, 0x75, 0x0E, 0xDA, 0x80, 0xB7, 0x55, 0x75, + 0x0F, 0xDA, 0x80, 0xBB, 0x55, 0x75, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, + 0x58, 0x75, 0x11, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x5B, 0x75, 0x12, 0xDA, + 0x1E, 0x79, 0x80, 0xA2, 0x0B, 0xDA, 0x80, 0xBE, 0x7D, 0x80, 0xA2, 0x0C, 0xDA, 0x80, 0xBF, 0x7E, + 0x80, 0xA2, 0x0A, 0xDA, 0x80, 0xC0, 0x7E, 0x80, 0xA2, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x65, 0x80, 0x81, 0x80, 0xA2, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x64, 0x80, 0x84, 0x80, 0xA2, 0x0F, 0xDA, 0x1E, 0x80, 0x85, 0x80, 0x99, 0x0D, 0xDA, 0x80, 0xC3, + 0x80, 0x85, 0x80, 0x99, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x80, 0x89, + 0x80, 0x97, 0x12, 0xDA, 0x80, 0xC5, 0x80, 0x8B, 0x80, 0x97, 0x13, 0xDA, 0x80, 0xC6, 0x80, 0x8D, + 0x80, 0x97, 0x14, 0xDA, 0x80, 0xC7, 0x2B, 0x04, 0x00, 0x00, 0x3F, 0x05, 0x02, 0x00, 0x1B, 0x06, + 0x05, 0x00, 0x26, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x0E, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x07, + 0x01, 0x08, 0x1B, 0x08, 0x07, 0x00, 0x1F, 0x08, 0x09, 0x00, 0x3A, 0x07, 0x01, 0x08, 0x1B, 0x09, + 0x07, 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x07, 0x00, 0x00, 0x1E, 0x07, 0x02, 0x00, 0x05, 0x04, + 0x04, 0x01, 0x49, 0x08, 0x01, 0x08, 0x1C, 0xF8, 0xFF, 0xFF, 0x1C, 0x91, 0x00, 0x00, 0x26, 0x07, + 0x06, 0x01, 0x1E, 0x07, 0x17, 0x00, 0x3D, 0x08, 0x02, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x28, 0x08, + 0x00, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x49, 0x0A, 0x01, 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1F, 0x0B, + 0x0F, 0x00, 0x3A, 0x0A, 0x01, 0x0B, 0x1B, 0x0C, 0x0A, 0x00, 0x49, 0x08, 0x09, 0x08, 0x28, 0x0D, + 0x00, 0x00, 0x25, 0x0A, 0x0D, 0x08, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x08, 0x00, 0x00, 0x3A, 0x0A, + 0x09, 0x08, 0x32, 0x0C, 0x0A, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x1E, 0x0D, 0x02, 0x00, 0x05, 0x04, + 0x04, 0x01, 0x49, 0x0B, 0x01, 0x0B, 0x1C, 0xF2, 0xFF, 0xFF, 0x1C, 0x79, 0x00, 0x00, 0x26, 0x08, + 0x06, 0x02, 0x1E, 0x08, 0x20, 0x00, 0x3D, 0x09, 0x02, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x3D, 0x09, + 0x02, 0x01, 0x1B, 0x0B, 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x28, 0x0E, + 0x00, 0x00, 0x49, 0x0D, 0x01, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1F, 0x0E, 0x15, 0x00, 0x3A, 0x0D, + 0x01, 0x0E, 0x1B, 0x0F, 0x0D, 0x00, 0x49, 0x09, 0x0A, 0x09, 0x28, 0x10, 0x00, 0x00, 0x25, 0x0D, + 0x10, 0x09, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x0E, 0x00, 0x00, 0x49, 0x0C, 0x0B, 0x0C, 0x28, 0x10, + 0x00, 0x00, 0x25, 0x0D, 0x10, 0x0C, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x3A, 0x0D, + 0x0A, 0x09, 0x3A, 0x10, 0x0B, 0x0C, 0x33, 0x0F, 0x0D, 0x10, 0x35, 0x11, 0x00, 0x00, 0x1E, 0x11, + 0x02, 0x00, 0x05, 0x04, 0x04, 0x01, 0x49, 0x0E, 0x01, 0x0E, 0x1C, 0xEC, 0xFF, 0xFF, 0x1C, 0x58, + 0x00, 0x00, 0x26, 0x09, 0x06, 0x03, 0x1E, 0x09, 0x2A, 0x00, 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, + 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, 0x0C, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x02, 0x1B, 0x0D, + 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0E, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x28, 0x11, + 0x00, 0x00, 0x49, 0x10, 0x01, 0x11, 0x1B, 0x11, 0x10, 0x00, 0x1F, 0x11, 0x1C, 0x00, 0x3A, 0x10, + 0x01, 0x11, 0x1B, 0x12, 0x10, 0x00, 0x49, 0x0A, 0x0B, 0x0A, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, + 0x13, 0x0A, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x15, 0x00, 0x00, 0x49, 0x0E, 0x0C, 0x0E, 0x28, 0x13, + 0x00, 0x00, 0x25, 0x10, 0x13, 0x0E, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x10, 0x00, 0x00, 0x49, 0x0F, + 0x0D, 0x0F, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, 0x0F, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x0B, + 0x00, 0x00, 0x3A, 0x10, 0x0B, 0x0A, 0x3A, 0x13, 0x0C, 0x0E, 0x3A, 0x14, 0x0D, 0x0F, 0x33, 0x12, + 0x10, 0x13, 0x31, 0x14, 0x00, 0x00, 0x35, 0x15, 0x00, 0x00, 0x1E, 0x15, 0x02, 0x00, 0x05, 0x04, + 0x04, 0x01, 0x49, 0x11, 0x01, 0x11, 0x1C, 0xE5, 0xFF, 0xFF, 0x1C, 0x2D, 0x00, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x0A, 0x0C, 0x00, 0x1B, 0x0C, 0x0A, 0x00, 0x2A, 0x0A, + 0x00, 0x00, 0x28, 0x0E, 0x00, 0x00, 0x49, 0x0D, 0x01, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1F, 0x0E, + 0x20, 0x00, 0x3A, 0x0D, 0x01, 0x0E, 0x1B, 0x0F, 0x0D, 0x00, 0x2B, 0x0D, 0x00, 0x00, 0x23, 0x10, + 0x0D, 0x06, 0x1E, 0x10, 0x12, 0x00, 0x3A, 0x11, 0x0B, 0x0D, 0x1B, 0x12, 0x11, 0x00, 0x3A, 0x11, + 0x02, 0x0D, 0x1B, 0x13, 0x11, 0x00, 0x49, 0x11, 0x13, 0x12, 0x1B, 0x14, 0x11, 0x00, 0x28, 0x15, + 0x00, 0x00, 0x25, 0x11, 0x15, 0x14, 0x1E, 0x11, 0x04, 0x00, 0x29, 0x0A, 0x00, 0x00, 0x1C, 0x07, + 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0B, 0x0D, 0x14, 0x3A, 0x15, 0x13, 0x14, 0x3C, 0x0C, + 0x0D, 0x15, 0x05, 0x0D, 0x0D, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x08, + 0x00, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x34, 0x0C, 0x00, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x1E, 0x0D, + 0x02, 0x00, 0x05, 0x04, 0x04, 0x01, 0x49, 0x0E, 0x01, 0x0E, 0x1C, 0xE1, 0xFF, 0xFF, 0x03, 0x04, + 0x00, 0x00, 0x84, 0x05, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xDA, 0x08, 0xCE, 0x5C, 0x28, 0x63, + 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x20, + 0x69, 0x6E, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x60, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x29, + 0x60, 0x0A, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0xCF, 0x10, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x62, 0x79, 0x74, 0x65, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0x13, 0x01, 0xDA, 0x06, 0xD8, 0x10, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x62, 0x79, 0x74, 0x65, 0xDA, 0x08, 0xCE, + 0x80, 0xA8, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x62, + 0x79, 0x74, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, + 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, + 0x20, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x6E, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x69, + 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x6F, 0x76, 0x65, 0x72, 0x66, 0x6C, 0x6F, 0x77, 0x73, 0x2E, 0xCF, 0x0A, 0x64, 0x6F, 0x63, 0x2D, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8C, + 0x49, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x49, 0x04, 0x01, 0x04, 0x0A, + 0x80, 0x8A, 0x00, 0x18, 0x2D, 0xCE, 0x0A, 0x64, 0x6F, 0x63, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0xDA, 0x18, 0xD0, 0x09, 0x64, 0x6F, 0x63, 0x2D, 0x77, 0x69, 0x64, 0x74, 0x68, 0xDA, 0x80, + 0xFB, 0xD0, 0x09, 0x64, 0x6F, 0x63, 0x2D, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0xD5, 0x04, 0xD0, 0x04, + 0x63, 0x6F, 0x64, 0x65, 0xD2, 0x02, 0x00, 0xCE, 0x05, 0x1B, 0x5B, 0x39, 0x37, 0x6D, 0xCE, 0x05, + 0x1B, 0x5B, 0x33, 0x39, 0x6D, 0xD0, 0x04, 0x62, 0x6F, 0x6C, 0x64, 0xD2, 0x02, 0x00, 0xCE, 0x04, + 0x1B, 0x5B, 0x31, 0x6D, 0xCE, 0x05, 0x1B, 0x5B, 0x32, 0x32, 0x6D, 0xD0, 0x09, 0x75, 0x6E, 0x64, + 0x65, 0x72, 0x6C, 0x69, 0x6E, 0x65, 0xD2, 0x02, 0x00, 0xCE, 0x04, 0x1B, 0x5B, 0x34, 0x6D, 0xCE, + 0x05, 0x1B, 0x5B, 0x32, 0x34, 0x6D, 0xD0, 0x07, 0x69, 0x74, 0x61, 0x6C, 0x69, 0x63, 0x73, 0xDA, + 0x81, 0xF7, 0xD5, 0x04, 0xDA, 0x81, 0xEC, 0xD2, 0x02, 0x00, 0xCE, 0x01, 0x60, 0xDA, 0x81, 0xFA, + 0xDA, 0x81, 0xF0, 0xD2, 0x02, 0x00, 0xCE, 0x02, 0x2A, 0x2A, 0xDA, 0x81, 0xFC, 0xDA, 0x81, 0xF4, + 0xD2, 0x02, 0x00, 0xCE, 0x01, 0x5F, 0xDA, 0x81, 0xFE, 0xDA, 0x81, 0xF8, 0xD2, 0x02, 0x00, 0xCE, + 0x01, 0x2A, 0xDA, 0x82, 0x00, 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, + 0x69, 0x63, 0x65, 0xDA, 0x81, 0xED, 0xCE, 0x00, 0xDA, 0x81, 0xEE, 0xDA, 0x81, 0x12, 0x00, 0x80, + 0x8A, 0x00, 0xCF, 0x03, 0x73, 0x74, 0x72, 0x00, 0x80, 0x8A, 0x01, 0xCF, 0x05, 0x77, 0x69, 0x64, + 0x74, 0x68, 0x00, 0x80, 0x8A, 0x02, 0xCF, 0x06, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x00, 0x80, + 0x8A, 0x03, 0xCF, 0x08, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x69, 0x7A, 0x65, 0x00, 0x80, 0x8A, 0x04, + 0xDA, 0x81, 0xE5, 0x04, 0x80, 0x8A, 0x06, 0xDA, 0x82, 0x07, 0x04, 0x0E, 0x01, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x64, 0x0F, 0x80, 0x8A, 0x07, 0xCF, 0x09, 0x6D, 0x61, 0x78, 0x2D, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x1A, 0x80, 0x8A, 0x0A, 0xCF, 0x09, 0x68, 0x61, 0x73, 0x2D, 0x63, + 0x6F, 0x6C, 0x6F, 0x72, 0x1F, 0x80, 0x8A, 0x0C, 0xCF, 0x0A, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x69, + 0x74, 0x65, 0x72, 0x73, 0x21, 0x80, 0x8A, 0x0E, 0xCF, 0x05, 0x6D, 0x6F, 0x64, 0x65, 0x73, 0x23, + 0x80, 0x8A, 0x10, 0xCF, 0x0B, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0x2D, 0x6D, 0x6F, 0x64, 0x65, + 0x24, 0x80, 0x8A, 0x11, 0xCF, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6F, 0x72, 0x26, 0x80, 0x8A, 0x13, + 0xCF, 0x05, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x28, 0x80, 0x8A, 0x15, 0xCF, 0x01, 0x63, 0x2A, 0x80, + 0x8A, 0x17, 0xCF, 0x02, 0x63, 0x6E, 0x2C, 0x80, 0x8A, 0x19, 0xCF, 0x03, 0x63, 0x2B, 0x2B, 0x2E, + 0x80, 0x8A, 0x1B, 0xCF, 0x04, 0x63, 0x2B, 0x3D, 0x6E, 0x30, 0x80, 0x8A, 0x1D, 0xCF, 0x09, 0x73, + 0x6B, 0x69, 0x70, 0x77, 0x68, 0x69, 0x74, 0x65, 0x32, 0x80, 0x8A, 0x1F, 0xCF, 0x08, 0x73, 0x6B, + 0x69, 0x70, 0x6C, 0x69, 0x6E, 0x65, 0x34, 0x80, 0x8A, 0x21, 0xCF, 0x03, 0x75, 0x6C, 0x3F, 0x36, + 0x80, 0x8A, 0x23, 0xCF, 0x03, 0x6F, 0x6C, 0x3F, 0x38, 0x80, 0x8A, 0x25, 0xCF, 0x04, 0x66, 0x63, + 0x62, 0x3F, 0x3A, 0x80, 0x8A, 0x27, 0xCF, 0x03, 0x6E, 0x6C, 0x3F, 0x3B, 0x80, 0x8A, 0x28, 0xCF, + 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0x3D, 0x80, 0x8A, + 0x2A, 0xCF, 0x08, 0x67, 0x65, 0x74, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x3F, 0x80, 0x8A, 0x2C, 0xCF, + 0x04, 0x70, 0x75, 0x73, 0x68, 0x41, 0x80, 0x8A, 0x2E, 0xCF, 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x2D, 0x6C, 0x69, 0x73, 0x74, 0x43, 0x80, 0x8A, 0x30, 0xCF, 0x0D, 0x61, 0x64, 0x64, 0x2D, 0x63, + 0x6F, 0x64, 0x65, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x45, 0x80, 0x8A, 0x32, 0xCF, 0x09, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x2D, 0x66, 0x63, 0x62, 0x47, 0x80, 0x8A, 0x34, 0xCF, 0x09, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x2D, 0x69, 0x63, 0x62, 0x49, 0x80, 0x8A, 0x36, 0xCF, 0x0D, 0x74, 0x6F, 0x6B, 0x65, + 0x6E, 0x69, 0x7A, 0x65, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0x56, 0x6B, 0x37, 0xCF, 0x0A, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0x5B, 0x6B, 0x3A, 0xCF, 0x07, 0x66, 0x6C, 0x2D, + 0x6F, 0x70, 0x65, 0x6E, 0x60, 0x6B, 0x3B, 0xCF, 0x08, 0x66, 0x6C, 0x2D, 0x63, 0x6C, 0x6F, 0x73, + 0x65, 0x71, 0x80, 0x8A, 0x39, 0xCF, 0x03, 0x62, 0x75, 0x66, 0x72, 0x80, 0x8A, 0x3A, 0xCF, 0x0E, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x2D, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x74, 0x80, + 0x8A, 0x3C, 0xCF, 0x0B, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x76, + 0x80, 0x8A, 0x3E, 0xCF, 0x07, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x6E, 0x6C, 0x78, 0x80, 0x8A, 0x40, + 0xCF, 0x09, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x77, 0x6F, 0x72, 0x64, 0x7A, 0x80, 0x8A, 0x42, 0xCF, + 0x09, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x63, 0x6F, 0x64, 0x65, 0x7C, 0x80, 0x8A, 0x44, 0xCF, 0x09, + 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x6E, 0x6F, 0x64, 0x65, 0x7D, 0x80, 0x89, 0x45, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x80, 0x80, 0x80, 0x89, 0x47, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x44, 0x80, 0x83, 0x80, 0x89, 0x48, 0xDA, 0x81, 0x99, 0x20, 0x02, 0x03, 0x00, + 0x2B, 0x05, 0x04, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x05, 0x02, 0x00, 0x1B, 0x06, 0x05, 0x00, + 0x1E, 0x01, 0x03, 0x00, 0x1B, 0x07, 0x01, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x00, 0x00, + 0x2B, 0x09, 0x50, 0x00, 0x32, 0x08, 0x09, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x35, 0x08, 0x09, 0x00, + 0x1B, 0x07, 0x08, 0x00, 0x07, 0x08, 0x07, 0x08, 0x1B, 0x07, 0x08, 0x00, 0x28, 0x0B, 0x00, 0x00, + 0x4A, 0x0A, 0x0B, 0x03, 0x1E, 0x0A, 0x03, 0x00, 0x1B, 0x09, 0x03, 0x00, 0x1C, 0x06, 0x00, 0x00, + 0x2C, 0x0B, 0x02, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, + 0x1B, 0x09, 0x0B, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x1E, 0x0A, 0x03, 0x00, 0x2C, 0x0B, 0x03, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x44, 0x0D, 0x00, 0x00, + 0x1B, 0x0E, 0x0D, 0x00, 0x30, 0x0F, 0x00, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x2B, 0x11, 0x00, 0x00, + 0x40, 0x12, 0x00, 0x00, 0x1B, 0x13, 0x12, 0x00, 0x30, 0x14, 0x01, 0x00, 0x1B, 0x15, 0x14, 0x00, + 0x30, 0x16, 0x02, 0x00, 0x1B, 0x17, 0x16, 0x00, 0x30, 0x18, 0x03, 0x00, 0x1B, 0x19, 0x18, 0x00, + 0x30, 0x1A, 0x04, 0x00, 0x1B, 0x1B, 0x1A, 0x00, 0x30, 0x1C, 0x05, 0x00, 0x1B, 0x1D, 0x1C, 0x00, + 0x30, 0x1E, 0x06, 0x00, 0x1B, 0x1F, 0x1E, 0x00, 0x30, 0x20, 0x07, 0x00, 0x1B, 0x21, 0x20, 0x00, + 0x30, 0x22, 0x08, 0x00, 0x1B, 0x23, 0x22, 0x00, 0x30, 0x24, 0x09, 0x00, 0x1B, 0x25, 0x24, 0x00, + 0x30, 0x26, 0x0A, 0x00, 0x1B, 0x27, 0x26, 0x00, 0x28, 0x28, 0x00, 0x00, 0x30, 0x29, 0x0B, 0x00, + 0x1B, 0x2A, 0x29, 0x00, 0x30, 0x2B, 0x0C, 0x00, 0x1B, 0x2C, 0x2B, 0x00, 0x30, 0x2D, 0x0D, 0x00, + 0x1B, 0x2E, 0x2D, 0x00, 0x30, 0x2F, 0x0E, 0x00, 0x1B, 0x30, 0x2F, 0x00, 0x30, 0x31, 0x0F, 0x00, + 0x1B, 0x32, 0x31, 0x00, 0x30, 0x33, 0x10, 0x00, 0x1B, 0x34, 0x33, 0x00, 0x30, 0x35, 0x11, 0x00, + 0x1B, 0x36, 0x35, 0x00, 0x30, 0x28, 0x12, 0x00, 0x2B, 0x38, 0x00, 0x00, 0x3A, 0x37, 0x00, 0x38, + 0x2B, 0x39, 0x28, 0x00, 0x25, 0x38, 0x39, 0x37, 0x1E, 0x38, 0x1C, 0x00, 0x35, 0x37, 0x1F, 0x00, + 0x07, 0x37, 0x11, 0x01, 0x2B, 0x39, 0x00, 0x00, 0x33, 0x00, 0x39, 0x37, 0x2C, 0x3A, 0x05, 0x00, + 0x35, 0x39, 0x3A, 0x00, 0x1B, 0x37, 0x39, 0x00, 0x1E, 0x0A, 0x03, 0x00, 0x2C, 0x39, 0x06, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x39, 0x07, 0x00, 0x1B, 0x3A, 0x39, 0x00, 0x1E, 0x0A, 0x03, 0x00, + 0x2C, 0x39, 0x08, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x39, 0x07, 0x00, 0x1B, 0x3B, 0x39, 0x00, + 0x33, 0x3A, 0x37, 0x3B, 0x2C, 0x3C, 0x09, 0x00, 0x35, 0x39, 0x3C, 0x00, 0x3F, 0x3C, 0x37, 0x00, + 0x32, 0x39, 0x3C, 0x00, 0x45, 0x39, 0x00, 0x00, 0x31, 0x39, 0x00, 0x00, 0x45, 0x39, 0x00, 0x00, + 0x31, 0x39, 0x00, 0x00, 0x35, 0x3C, 0x2C, 0x00, 0x2B, 0x37, 0x00, 0x00, 0x31, 0x37, 0x00, 0x00, + 0x35, 0x37, 0x28, 0x00, 0x2C, 0x38, 0x07, 0x00, 0x31, 0x38, 0x00, 0x00, 0x41, 0x38, 0x00, 0x00, + 0x1B, 0x39, 0x38, 0x00, 0x2B, 0x3A, 0x00, 0x00, 0x30, 0x3B, 0x13, 0x00, 0x1B, 0x3C, 0x3B, 0x00, + 0x30, 0x3D, 0x14, 0x00, 0x1B, 0x3E, 0x3D, 0x00, 0x30, 0x3F, 0x15, 0x00, 0x1B, 0x40, 0x3F, 0x00, + 0x30, 0x41, 0x16, 0x00, 0x1B, 0x42, 0x41, 0x00, 0x30, 0x43, 0x17, 0x00, 0x1B, 0x44, 0x43, 0x00, + 0x1B, 0x45, 0x13, 0x00, 0x28, 0x47, 0x00, 0x00, 0x49, 0x46, 0x45, 0x47, 0x1B, 0x47, 0x46, 0x00, + 0x1F, 0x47, 0x08, 0x00, 0x3A, 0x46, 0x45, 0x47, 0x1B, 0x48, 0x46, 0x00, 0x35, 0x46, 0x3E, 0x00, + 0x32, 0x48, 0x06, 0x00, 0x35, 0x46, 0x44, 0x00, 0x49, 0x47, 0x45, 0x47, 0x1C, 0xF9, 0xFF, 0xFF, + 0x03, 0x39, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x01, 0x11, 0x01, + 0x0F, 0xCE, 0x0B, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0x2D, 0x6D, 0x6F, 0x64, 0x65, 0xDA, 0x18, + 0xD8, 0x03, 0x6E, 0x6F, 0x74, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, + 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, + 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, + 0x82, 0x0D, 0x00, 0x11, 0x00, 0xCF, 0x04, 0x6D, 0x6F, 0x64, 0x65, 0x00, 0x11, 0x01, 0xDA, 0x82, + 0x0E, 0x02, 0x11, 0x03, 0xCF, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x05, 0x11, 0x05, 0xCF, + 0x06, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x73, 0x2D, 0x03, 0x00, 0x0E, 0x3B, 0x02, 0x03, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x2D, 0x05, 0x00, 0x0C, 0x3B, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2D, 0x07, 0x00, 0x0E, 0x3C, + 0x07, 0x00, 0x06, 0x1E, 0x03, 0x03, 0x00, 0x2B, 0x06, 0x01, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, + 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x62, 0x11, + 0x00, 0x11, 0x00, 0x05, 0x01, 0x11, 0x00, 0x11, 0x00, 0x05, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x00, 0x05, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x0F, 0xCE, 0x01, 0x63, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, + 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x82, 0x10, 0x00, 0x04, 0x00, 0xDA, 0x82, 0x11, 0x2D, 0x02, 0x00, 0x00, 0x2D, 0x03, + 0x00, 0x11, 0x3B, 0x01, 0x02, 0x03, 0x03, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x6C, 0x0E, 0x00, + 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x00, 0x05, + 0x01, 0x11, 0xCE, 0x02, 0x63, 0x6E, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, + 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, + 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, + 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, + 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, + 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, + 0x11, 0x00, 0x05, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x05, 0x01, 0xDA, 0x82, 0x12, 0x2D, 0x03, 0x00, + 0x11, 0x06, 0x02, 0x00, 0x03, 0x2D, 0x04, 0x00, 0x00, 0x3B, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, + 0x00, 0xBF, 0xFF, 0x8C, 0x6D, 0x19, 0x00, 0x19, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x12, 0xCE, 0x03, 0x63, 0x2B, 0x2B, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, + 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, + 0x82, 0x12, 0x00, 0x08, 0x00, 0xDA, 0x82, 0x13, 0x03, 0x08, 0x02, 0xDA, 0x23, 0x2D, 0x02, 0x00, + 0x00, 0x2D, 0x03, 0x00, 0x11, 0x3B, 0x01, 0x02, 0x03, 0x1B, 0x02, 0x01, 0x00, 0x2D, 0x03, 0x00, + 0x11, 0x05, 0x01, 0x03, 0x01, 0x2F, 0x01, 0x00, 0x11, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8C, + 0x6E, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x10, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x10, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x00, 0x08, 0x01, 0x14, 0xCE, 0x04, 0x63, + 0x2B, 0x3D, 0x6E, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, + 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, + 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, + 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, + 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, + 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0x00, 0x08, 0x00, 0xDA, + 0x81, 0x9E, 0x00, 0x08, 0x01, 0xDA, 0x82, 0x14, 0x03, 0x08, 0x03, 0xDA, 0x23, 0x2D, 0x03, 0x00, + 0x00, 0x2D, 0x04, 0x00, 0x11, 0x3B, 0x02, 0x03, 0x04, 0x1B, 0x03, 0x02, 0x00, 0x2D, 0x04, 0x00, + 0x11, 0x06, 0x02, 0x04, 0x00, 0x2F, 0x02, 0x00, 0x11, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8C, + 0x6F, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x12, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x12, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x01, 0x14, 0xCE, 0x09, 0x73, + 0x6B, 0x69, 0x70, 0x77, 0x68, 0x69, 0x74, 0x65, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, + 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, + 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, + 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, + 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, + 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, + 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0x00, 0x0C, 0x00, 0xDA, 0x82, 0x15, 0x00, 0x0C, + 0x01, 0xDA, 0x1E, 0x2D, 0x01, 0x00, 0x11, 0x2D, 0x03, 0x00, 0x15, 0x35, 0x02, 0x03, 0x00, 0x26, + 0x03, 0x02, 0x20, 0x1E, 0x03, 0x05, 0x00, 0x2D, 0x04, 0x00, 0x11, 0x05, 0x02, 0x04, 0x01, 0x2F, + 0x02, 0x00, 0x11, 0x1C, 0xF9, 0xFF, 0xFF, 0x2D, 0x03, 0x00, 0x11, 0x08, 0x02, 0x03, 0x01, 0x03, + 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x72, 0x05, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0C, 0x00, 0x05, + 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x13, 0x01, 0x17, 0xCE, 0x08, 0x73, 0x6B, 0x69, + 0x70, 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, + 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, + 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, + 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, + 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, + 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, + 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, + 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, + 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0x00, 0x13, 0x00, 0xDA, + 0x82, 0x16, 0x00, 0x13, 0x01, 0xDA, 0x1E, 0x03, 0x09, 0x03, 0xDA, 0x80, 0xD9, 0x03, 0x09, 0x03, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x2D, 0x01, 0x00, 0x11, 0x2D, 0x03, 0x00, + 0x15, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x1E, 0x03, 0x04, 0x00, 0x4B, 0x04, 0x03, + 0x0A, 0x1B, 0x02, 0x04, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x05, + 0x00, 0x2D, 0x04, 0x00, 0x11, 0x05, 0x03, 0x04, 0x01, 0x2F, 0x03, 0x00, 0x11, 0x1C, 0xF4, 0xFF, + 0xFF, 0x2D, 0x03, 0x00, 0x19, 0x35, 0x02, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x11, 0x08, 0x03, 0x04, + 0x01, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x76, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x0C, + 0x00, 0x19, 0x00, 0x20, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x05, 0x00, 0x36, 0x00, 0x36, + 0x00, 0x36, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x18, 0x01, 0x1A, 0xCE, 0x03, 0x75, 0x6C, 0x3F, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, + 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, + 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, + 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0x00, 0x18, + 0x00, 0xDA, 0x82, 0x17, 0x02, 0x18, 0x02, 0xDA, 0x1E, 0x07, 0x18, 0x03, 0xCF, 0x02, 0x78, 0x31, + 0x09, 0x18, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x67, 0x0C, 0x12, 0x06, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x68, 0x12, 0x17, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x66, 0x2D, 0x02, 0x00, 0x15, 0x35, 0x01, 0x02, 0x00, 0x1B, 0x02, 0x01, 0x00, + 0x2B, 0x01, 0x01, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x17, 0x35, 0x01, 0x03, 0x00, + 0x1B, 0x03, 0x01, 0x00, 0x26, 0x01, 0x03, 0x20, 0x1B, 0x04, 0x01, 0x00, 0x1E, 0x01, 0x0D, 0x00, + 0x26, 0x05, 0x02, 0x2A, 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x06, 0x03, 0x00, 0x1B, 0x05, 0x06, 0x00, + 0x1C, 0x03, 0x00, 0x00, 0x26, 0x07, 0x02, 0x2D, 0x1B, 0x05, 0x07, 0x00, 0x1B, 0x06, 0x05, 0x00, + 0x1E, 0x05, 0x03, 0x00, 0x2B, 0x07, 0x02, 0x00, 0x03, 0x07, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, + 0x03, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x7D, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x00, 0x14, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0x02, 0x09, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x02, 0x0D, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x1D, 0x00, 0x09, 0xBF, 0xFE, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x00, + 0x00, 0x00, 0x00, 0x29, 0x01, 0x1C, 0xCE, 0x03, 0x6F, 0x6C, 0x3F, 0xDA, 0x18, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, + 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, + 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, + 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, + 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, + 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, + 0x00, 0x29, 0x00, 0xDA, 0x82, 0x18, 0x00, 0x29, 0x01, 0xCF, 0x03, 0x6F, 0x6C, 0x64, 0x05, 0x0E, + 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x69, 0x14, 0x29, 0x03, 0xCF, 0x02, 0x63, + 0x31, 0x19, 0x29, 0x04, 0xCF, 0x02, 0x63, 0x32, 0x1A, 0x29, 0x02, 0xCF, 0x02, 0x63, 0x2A, 0x1D, + 0x23, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x6A, 0x2D, 0x01, 0x00, 0x11, 0x2D, + 0x04, 0x00, 0x15, 0x35, 0x03, 0x04, 0x00, 0x2B, 0x05, 0x30, 0x00, 0x47, 0x04, 0x03, 0x05, 0x1B, + 0x03, 0x04, 0x00, 0x1E, 0x04, 0x07, 0x00, 0x2D, 0x06, 0x00, 0x15, 0x35, 0x05, 0x06, 0x00, 0x2B, + 0x07, 0x39, 0x00, 0x48, 0x06, 0x05, 0x07, 0x1B, 0x02, 0x06, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, + 0x02, 0x03, 0x00, 0x1E, 0x02, 0x04, 0x00, 0x2D, 0x04, 0x00, 0x19, 0x35, 0x03, 0x04, 0x00, 0x1C, + 0xF0, 0xFF, 0xFF, 0x2D, 0x03, 0x00, 0x15, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2B, + 0x02, 0x01, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x17, 0x35, 0x02, 0x04, 0x00, 0x1B, + 0x04, 0x02, 0x00, 0x2D, 0x02, 0x00, 0x11, 0x2F, 0x01, 0x00, 0x11, 0x26, 0x06, 0x03, 0x2E, 0x1B, + 0x07, 0x06, 0x00, 0x1E, 0x06, 0x04, 0x00, 0x26, 0x08, 0x04, 0x20, 0x1B, 0x05, 0x08, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x05, 0x07, 0x00, 0x1E, 0x05, 0x05, 0x00, 0x2D, 0x07, 0x00, 0x11, 0x08, + 0x06, 0x02, 0x07, 0x07, 0x06, 0x06, 0xFE, 0x03, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, + 0xFF, 0x8C, 0x83, 0x05, 0x01, 0x15, 0x00, 0x15, 0x00, 0x11, 0x00, 0x11, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x28, 0x00, 0x28, 0x00, 0x24, 0x00, 0x24, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x00, 0x15, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x01, 0x10, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x21, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0xBF, 0xFF, 0x07, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x14, + 0x01, 0x17, 0xCE, 0x04, 0x66, 0x63, 0x62, 0x3F, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, + 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, + 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, + 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, + 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, + 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, + 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, + 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, + 0x23, 0xDA, 0x82, 0x18, 0x00, 0x14, 0x00, 0xDA, 0x82, 0x19, 0x2D, 0x02, 0x00, 0x15, 0x35, 0x01, + 0x02, 0x00, 0x2B, 0x02, 0x01, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x17, 0x35, 0x02, + 0x03, 0x00, 0x2B, 0x03, 0x02, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x17, 0x35, 0x03, + 0x04, 0x00, 0x2B, 0x05, 0x60, 0x00, 0x25, 0x04, 0x05, 0x01, 0x1E, 0x04, 0x04, 0x00, 0x25, 0x04, + 0x01, 0x02, 0x1E, 0x04, 0x02, 0x00, 0x25, 0x04, 0x02, 0x03, 0x1E, 0x04, 0x03, 0x00, 0x2B, 0x01, + 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x89, 0x22, 0x00, + 0x22, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, + 0x2D, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x11, 0x00, + 0x11, 0x00, 0x11, 0x00, 0x11, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, + 0x01, 0x18, 0xCE, 0x03, 0x6E, 0x6C, 0x3F, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, + 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, + 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, + 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, + 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, + 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, + 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, + 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0x00, 0x05, 0x00, 0xDA, 0x82, 0x1A, + 0x2D, 0x02, 0x00, 0x15, 0x35, 0x01, 0x02, 0x00, 0x2B, 0x03, 0x0A, 0x00, 0x25, 0x02, 0x03, 0x01, + 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x8A, 0x1E, 0x00, 0x1E, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x0A, 0x01, 0x1D, 0xCE, 0x08, + 0x67, 0x65, 0x74, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x0E, 0x00, 0x06, 0xCE, 0x03, 0x6D, + 0x69, 0x6E, 0xDA, 0x18, 0x00, 0x0E, 0x00, 0xDA, 0x80, 0xE8, 0x00, 0x0E, 0x01, 0xCF, 0x03, 0x6D, + 0x69, 0x6E, 0x00, 0x0E, 0x00, 0xDA, 0x24, 0x02, 0x0E, 0x03, 0xDA, 0x22, 0x04, 0x0E, 0x04, 0xDA, + 0x23, 0x08, 0x0D, 0x05, 0xDA, 0x1E, 0x28, 0x03, 0x00, 0x00, 0x49, 0x02, 0x00, 0x03, 0x1B, 0x03, + 0x02, 0x00, 0x3B, 0x02, 0x00, 0x03, 0x1B, 0x04, 0x02, 0x00, 0x49, 0x03, 0x00, 0x03, 0x1F, 0x03, + 0x07, 0x00, 0x3A, 0x02, 0x00, 0x03, 0x1B, 0x05, 0x02, 0x00, 0x23, 0x02, 0x05, 0x04, 0x1E, 0x02, + 0x02, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x82, 0xE9, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xDA, 0x82, 0x03, 0xBF, 0xFF, + 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, + 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, + 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, + 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, + 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, + 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, + 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, + 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, + 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0x00, 0x0A, 0x00, + 0xCF, 0x04, 0x66, 0x72, 0x6F, 0x6D, 0x00, 0x0A, 0x01, 0xCF, 0x02, 0x74, 0x6F, 0x00, 0x0A, 0x02, + 0xDA, 0x82, 0x1C, 0x05, 0x0A, 0x03, 0xDA, 0x82, 0x4E, 0x2D, 0x04, 0x00, 0x00, 0x3F, 0x03, 0x04, + 0x00, 0x32, 0x01, 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x03, 0x04, + 0x00, 0x2D, 0x05, 0x00, 0x00, 0x33, 0x05, 0x00, 0x03, 0x2C, 0x05, 0x01, 0x00, 0x36, 0x05, 0x00, + 0x00, 0xBF, 0xFF, 0x8C, 0x92, 0x15, 0x00, 0x15, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x05, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, + 0x01, 0x01, 0x04, 0x01, 0x1C, 0xCE, 0x04, 0x70, 0x75, 0x73, 0x68, 0xDA, 0x18, 0xDA, 0x80, 0xA8, + 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, + 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, + 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, + 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, + 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, + 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, + 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, + 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, + 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, + 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0x00, 0x04, 0x00, 0xDA, 0x1E, 0x00, 0x04, 0x01, 0xDA, 0x82, + 0x1D, 0x2D, 0x02, 0x00, 0x13, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x36, 0x02, 0x00, + 0x00, 0xBF, 0xFF, 0x8C, 0x94, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x0E, 0x03, 0x03, 0x03, 0x00, 0x32, 0x01, 0x26, 0xCE, 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x2D, 0x6C, 0x69, 0x73, 0x74, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, + 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, + 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, + 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, + 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, + 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, + 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, + 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, + 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, + 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, + 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, + 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, + 0x2C, 0xDA, 0x82, 0x1D, 0x00, 0x32, 0x00, 0xCF, 0x0C, 0x62, 0x75, 0x6C, 0x6C, 0x65, 0x74, 0x2D, + 0x63, 0x68, 0x65, 0x63, 0x6B, 0x00, 0x32, 0x01, 0xCF, 0x07, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, + 0x6C, 0x00, 0x32, 0x02, 0xDA, 0x82, 0x07, 0x00, 0x32, 0x03, 0xDA, 0x82, 0x1E, 0x02, 0x32, 0x05, + 0xCF, 0x0A, 0x74, 0x65, 0x6D, 0x70, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x03, 0x32, 0x06, 0xCF, + 0x09, 0x6F, 0x6C, 0x64, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x05, 0x32, 0x07, 0xCF, 0x0E, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x08, 0x0E, 0x0A, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x6B, 0x10, 0x1C, 0x0B, 0xDA, 0x1E, 0x1C, 0x2D, + 0x0A, 0xCF, 0x0B, 0x69, 0x74, 0x65, 0x6D, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x23, 0x2D, + 0x0B, 0xCF, 0x0A, 0x69, 0x74, 0x65, 0x6D, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x31, 0x01, 0x00, + 0x00, 0x40, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2D, 0x06, 0x00, 0x13, 0x2F, 0x05, 0x00, + 0x13, 0x1B, 0x07, 0x02, 0x00, 0x2D, 0x0A, 0x00, 0x15, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x0A, 0x09, + 0x00, 0x1E, 0x09, 0x04, 0x00, 0x47, 0x0B, 0x07, 0x02, 0x1B, 0x08, 0x0B, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x08, 0x0A, 0x00, 0x1E, 0x08, 0x1F, 0x00, 0x35, 0x0A, 0x00, 0x00, 0x1B, 0x0B, 0x0A, + 0x00, 0x1E, 0x0A, 0x0A, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2D, 0x0D, 0x00, 0x1B, 0x35, 0x0C, 0x0D, + 0x00, 0x2D, 0x0D, 0x00, 0x1D, 0x35, 0x0C, 0x0D, 0x00, 0x06, 0x0D, 0x02, 0x0C, 0x06, 0x0D, 0x0D, + 0x0B, 0x1B, 0x09, 0x0D, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x09, 0x00, 0x00, 0x1B, 0x0A, 0x09, + 0x00, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x1D, 0x35, 0x07, 0x09, + 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x40, 0x09, 0x00, 0x00, 0x1B, 0x0B, 0x09, 0x00, 0x2F, 0x0B, 0x00, + 0x13, 0x31, 0x0A, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x28, 0x35, 0x07, 0x09, 0x00, 0x2F, 0x05, 0x00, + 0x13, 0x31, 0x0B, 0x00, 0x00, 0x2D, 0x0C, 0x00, 0x2C, 0x35, 0x09, 0x0C, 0x00, 0x1C, 0xDA, 0xFF, + 0xFF, 0x2F, 0x06, 0x00, 0x13, 0x31, 0x05, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x2C, 0x35, 0x08, 0x09, + 0x00, 0x03, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0x97, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, + 0x01, 0x05, 0x01, 0x05, 0x01, 0x11, 0x00, 0x11, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x15, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x02, 0x16, 0x00, 0x09, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x01, 0x15, 0x00, 0x15, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x09, 0x00, 0x09, 0x00, + 0x09, 0xBF, 0xFF, 0x07, 0x04, 0x07, 0x00, 0x07, 0x01, 0x1D, 0x00, 0x1D, 0x01, 0x09, 0x01, 0x07, + 0x00, 0x07, 0x01, 0x07, 0x01, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, + 0x00, 0x07, 0xBF, 0xF4, 0x05, 0x0D, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xED, 0x03, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x03, 0x03, 0x03, 0x06, 0x1A, 0x01, 0x21, 0xCE, 0x0D, 0x61, + 0x64, 0x64, 0x2D, 0x63, 0x6F, 0x64, 0x65, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x18, 0xCE, 0x01, + 0x20, 0xD8, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, + 0xCE, 0x01, 0x0A, 0xDA, 0x81, 0x12, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, + 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xD0, 0x02, 0x63, 0x62, 0xBF, 0xFF, + 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, + 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, + 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, + 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, + 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, + 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, + 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, + 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, + 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, + 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, + 0x82, 0x1E, 0x00, 0x1A, 0x00, 0xDA, 0x82, 0x07, 0x00, 0x1A, 0x01, 0xCF, 0x05, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x00, 0x1A, 0x02, 0xCF, 0x03, 0x65, 0x6E, 0x64, 0x00, 0x1A, 0x03, 0xDA, 0x82, 0x1F, + 0x08, 0x1A, 0x04, 0xCF, 0x0D, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x63, 0x68, 0x75, + 0x6E, 0x6B, 0x2C, 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, + 0x05, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x32, 0x05, 0x04, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x35, 0x05, + 0x06, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2D, 0x07, 0x00, 0x2A, 0x35, 0x06, + 0x07, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x33, 0x04, 0x07, 0x06, 0x2C, 0x08, 0x04, 0x00, 0x35, 0x07, + 0x08, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x32, 0x06, 0x07, 0x00, 0x40, 0x06, 0x00, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x2D, 0x08, 0x00, 0x2C, 0x35, 0x07, 0x08, 0x00, 0x2D, 0x08, 0x00, 0x1F, 0x35, 0x06, + 0x08, 0x00, 0x2D, 0x08, 0x00, 0x1D, 0x36, 0x08, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0xAD, 0x25, 0x00, + 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x05, 0x01, + 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, + 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x01, 0x01, 0x00, 0x1B, 0x01, 0x21, 0xCE, 0x09, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x66, 0x63, 0x62, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, + 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, + 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, + 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, + 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, + 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, + 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, + 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, + 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, + 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, + 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, + 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, + 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0x00, 0x1B, 0x00, 0xDA, 0x82, 0x07, 0x00, 0x1B, 0x01, 0xDA, + 0x82, 0x20, 0x09, 0x1B, 0x05, 0xDA, 0x82, 0x5F, 0x0A, 0x1B, 0x06, 0xDA, 0x82, 0x60, 0x2B, 0x02, + 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x1B, 0x35, 0x02, 0x03, 0x00, 0x2D, 0x04, + 0x00, 0x1F, 0x35, 0x03, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x1B, 0x35, 0x04, + 0x05, 0x00, 0x2D, 0x05, 0x00, 0x11, 0x2D, 0x06, 0x00, 0x11, 0x2D, 0x08, 0x00, 0x15, 0x35, 0x07, + 0x08, 0x00, 0x1E, 0x07, 0x0B, 0x00, 0x2D, 0x09, 0x00, 0x25, 0x35, 0x08, 0x09, 0x00, 0x1E, 0x08, + 0x02, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x1F, 0x35, 0x08, 0x09, 0x00, 0x2D, 0x06, + 0x00, 0x11, 0x2D, 0x09, 0x00, 0x1D, 0x35, 0x08, 0x09, 0x00, 0x1C, 0xF4, 0xFF, 0xFF, 0x33, 0x00, + 0x05, 0x06, 0x2D, 0x07, 0x00, 0x30, 0x36, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0xB3, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, + 0x05, 0x01, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x00, + 0x12, 0x01, 0x07, 0x00, 0x07, 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, 0xBF, 0xFC, 0x05, 0x05, 0x05, + 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x00, 0x12, 0x01, + 0x23, 0xCE, 0x09, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x69, 0x63, 0x62, 0xDA, 0x18, 0xBF, 0xFF, + 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, + 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, + 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, + 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, + 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, + 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, + 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, + 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, + 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, + 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, + 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, 0x32, 0xDA, 0x82, 0x20, + 0x00, 0x12, 0x00, 0xDA, 0x82, 0x07, 0x00, 0x12, 0x01, 0xDA, 0x82, 0x21, 0x00, 0x12, 0x02, 0xDA, + 0x82, 0x55, 0x01, 0x12, 0x03, 0xDA, 0x82, 0x5F, 0x02, 0x12, 0x04, 0xDA, 0x82, 0x60, 0x1B, 0x02, + 0x00, 0x00, 0x2D, 0x03, 0x00, 0x11, 0x2D, 0x04, 0x00, 0x11, 0x2D, 0x06, 0x00, 0x15, 0x35, 0x05, + 0x06, 0x00, 0x1E, 0x05, 0x0A, 0x00, 0x2D, 0x07, 0x00, 0x1F, 0x35, 0x06, 0x07, 0x00, 0x2D, 0x04, + 0x00, 0x11, 0x2D, 0x06, 0x00, 0x1D, 0x35, 0x02, 0x06, 0x00, 0x23, 0x06, 0x02, 0x00, 0x1E, 0x06, + 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xF5, 0xFF, 0xFF, 0x33, 0x00, 0x03, 0x04, 0x2D, 0x05, + 0x00, 0x30, 0x36, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0xC0, 0x05, 0x01, 0x05, 0x01, 0x05, 0x01, + 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x01, 0x07, 0x01, 0x1B, 0x00, 0x1B, 0x01, + 0x0B, 0x00, 0x07, 0x00, 0x25, 0xBF, 0xFC, 0x05, 0x05, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x02, + 0xFE, 0x00, 0x00, 0x18, 0x01, 0x01, 0x01, 0x08, 0x58, 0x01, 0x02, 0x2A, 0xCE, 0x0D, 0x74, 0x6F, + 0x6B, 0x65, 0x6E, 0x69, 0x7A, 0x65, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x18, 0xDA, 0x82, 0x04, + 0xDA, 0x81, 0xEC, 0xDA, 0x82, 0x30, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, + 0x75, 0x73, 0x68, 0xDA, 0x81, 0xF4, 0xDA, 0x81, 0xF0, 0xDA, 0x81, 0xF8, 0xDA, 0x80, 0xE0, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, + 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, + 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, + 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, + 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, + 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, + 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, + 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, + 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, + 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, + 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, + 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, 0x32, 0xDA, 0x82, + 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0x00, 0x58, 0x00, 0xCF, 0x04, 0x6C, 0x69, 0x6E, + 0x65, 0x00, 0x58, 0x01, 0xDA, 0x82, 0x22, 0x01, 0x58, 0x03, 0xCF, 0x06, 0x74, 0x6F, 0x6B, 0x65, + 0x6E, 0x73, 0x05, 0x58, 0x05, 0xCF, 0x05, 0x74, 0x6F, 0x6B, 0x65, 0x6E, 0x06, 0x58, 0x06, 0xCF, + 0x0C, 0x74, 0x6F, 0x6B, 0x65, 0x6E, 0x2D, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x08, 0x58, 0x08, + 0xCF, 0x05, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x0A, 0x58, 0x0A, 0xCF, 0x08, 0x65, 0x6E, 0x64, 0x74, + 0x6F, 0x6B, 0x65, 0x6E, 0x0B, 0x54, 0x0B, 0xDA, 0x80, 0xC3, 0x0D, 0x54, 0x0D, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x6C, 0x11, 0x54, 0x0F, 0xCF, 0x01, 0x62, 0x13, 0x19, 0x10, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x6D, 0x40, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, + 0x2C, 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x41, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, + 0x2B, 0x06, 0x00, 0x00, 0x30, 0x07, 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x30, 0x09, 0x01, 0x00, + 0x1B, 0x0A, 0x09, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x3F, 0x0C, 0x00, 0x00, 0x1B, 0x0D, 0x0C, 0x00, + 0x23, 0x0C, 0x0B, 0x0D, 0x1E, 0x0C, 0x45, 0x00, 0x3B, 0x0E, 0x00, 0x0B, 0x1B, 0x0F, 0x0E, 0x00, + 0x26, 0x0E, 0x0F, 0x0A, 0x1B, 0x10, 0x0E, 0x00, 0x1E, 0x10, 0x03, 0x00, 0x1B, 0x0E, 0x10, 0x00, + 0x1C, 0x03, 0x00, 0x00, 0x26, 0x11, 0x0F, 0x20, 0x1B, 0x0E, 0x11, 0x00, 0x1E, 0x0E, 0x03, 0x00, + 0x35, 0x10, 0x0A, 0x00, 0x1C, 0x37, 0x00, 0x00, 0x26, 0x10, 0x0F, 0x60, 0x1E, 0x10, 0x05, 0x00, + 0x2C, 0x11, 0x01, 0x00, 0x31, 0x11, 0x00, 0x00, 0x35, 0x11, 0x08, 0x00, 0x1C, 0x31, 0x00, 0x00, + 0x2C, 0x11, 0x01, 0x00, 0x31, 0x11, 0x00, 0x00, 0x2D, 0x12, 0x00, 0x0E, 0x35, 0x11, 0x12, 0x00, + 0x31, 0x11, 0x00, 0x00, 0x2C, 0x13, 0x02, 0x00, 0x35, 0x12, 0x13, 0x00, 0x1E, 0x12, 0x25, 0x00, + 0x26, 0x11, 0x0F, 0x5C, 0x1E, 0x11, 0x08, 0x00, 0x05, 0x06, 0x06, 0x01, 0x05, 0x0B, 0x0B, 0x01, + 0x3B, 0x13, 0x00, 0x0B, 0x32, 0x05, 0x13, 0x00, 0x2C, 0x15, 0x03, 0x00, 0x35, 0x14, 0x15, 0x00, + 0x1C, 0x1B, 0x00, 0x00, 0x26, 0x13, 0x0F, 0x5F, 0x1E, 0x13, 0x05, 0x00, 0x2C, 0x14, 0x04, 0x00, + 0x31, 0x14, 0x00, 0x00, 0x35, 0x14, 0x08, 0x00, 0x1C, 0x15, 0x00, 0x00, 0x26, 0x14, 0x0F, 0x2A, + 0x1E, 0x14, 0x0F, 0x00, 0x05, 0x15, 0x0B, 0x01, 0x3B, 0x16, 0x00, 0x15, 0x2B, 0x17, 0x2A, 0x00, + 0x25, 0x15, 0x17, 0x16, 0x1E, 0x15, 0x06, 0x00, 0x05, 0x0B, 0x0B, 0x01, 0x2C, 0x16, 0x05, 0x00, + 0x31, 0x16, 0x00, 0x00, 0x35, 0x16, 0x08, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x16, 0x06, 0x00, + 0x31, 0x16, 0x00, 0x00, 0x35, 0x16, 0x08, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x05, 0x06, 0x06, 0x01, + 0x32, 0x05, 0x0F, 0x00, 0x2C, 0x16, 0x03, 0x00, 0x35, 0x15, 0x16, 0x00, 0x1C, 0x05, 0x00, 0x00, + 0x05, 0x06, 0x06, 0x01, 0x32, 0x05, 0x0F, 0x00, 0x2C, 0x13, 0x03, 0x00, 0x35, 0x11, 0x13, 0x00, + 0x05, 0x0B, 0x0B, 0x01, 0x1C, 0xBB, 0xFF, 0xFF, 0x35, 0x0B, 0x0A, 0x00, 0x31, 0x03, 0x00, 0x00, + 0x2C, 0x0C, 0x07, 0x00, 0x36, 0x0C, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, + 0x01, 0x01, 0x01, 0x01, 0x0F, 0x02, 0x27, 0xCE, 0x05, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0xDA, 0x18, + 0xDA, 0x82, 0x65, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, + 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, + 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, + 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, + 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, + 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, + 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, + 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, + 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, + 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, + 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, + 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, + 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, + 0x00, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x01, 0x00, + 0xDA, 0x82, 0x66, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x01, 0x03, 0xDA, 0x82, + 0x67, 0xBF, 0xFF, 0x01, 0x05, 0xDA, 0x82, 0x68, 0xBF, 0xFF, 0x01, 0x06, 0xDA, 0x82, 0x69, 0x00, + 0x0F, 0x00, 0xDA, 0x82, 0x31, 0x00, 0x0F, 0x01, 0xDA, 0x82, 0x6A, 0x03, 0x0F, 0x03, 0xCF, 0x01, + 0x64, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x10, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, + 0x00, 0x2D, 0x04, 0x00, 0x0A, 0x1E, 0x04, 0x02, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x3F, 0x04, 0x03, + 0x00, 0x2D, 0x06, 0x01, 0x06, 0x06, 0x05, 0x06, 0x04, 0x2F, 0x05, 0x01, 0x06, 0x2D, 0x04, 0x01, + 0x05, 0x32, 0x04, 0x03, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, + 0x8C, 0xCF, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x2A, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x18, 0x01, 0x07, 0xCE, 0x08, 0x65, 0x6E, + 0x64, 0x74, 0x6F, 0x6B, 0x65, 0x6E, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, + 0x01, 0x01, 0x01, 0x00, 0x03, 0x00, 0x02, 0xCE, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, 0xDA, 0x18, + 0x00, 0x03, 0x00, 0xCF, 0x02, 0x78, 0x73, 0x00, 0x03, 0x01, 0xCF, 0x05, 0x66, 0x69, 0x72, 0x73, + 0x74, 0x2B, 0x03, 0x00, 0x00, 0x3B, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x82, 0xF6, 0x03, + 0x00, 0x03, 0x00, 0x03, 0xDA, 0x81, 0x12, 0xDA, 0x80, 0xA8, 0xD8, 0x0C, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x66, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x67, 0xBF, 0xFF, 0x00, + 0x05, 0xDA, 0x82, 0x68, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x69, 0xBF, 0xFF, 0x00, 0x08, 0xDA, + 0x82, 0x6A, 0x00, 0x18, 0x00, 0xDA, 0x82, 0x6B, 0x2D, 0x01, 0x00, 0x05, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x02, 0x00, 0x00, 0x35, 0x01, 0x02, 0x00, 0x1E, 0x01, 0x0C, 0x00, 0x2D, 0x02, 0x00, 0x05, + 0x31, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2D, 0x03, 0x00, 0x06, + 0x32, 0x02, 0x03, 0x00, 0x45, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x03, 0x32, 0x03, 0x02, 0x00, + 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2D, 0x01, 0x00, 0x05, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x02, 0x03, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x2F, 0x02, 0x00, 0x06, + 0x2D, 0x02, 0x00, 0x06, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8C, 0xD3, 0x0B, 0x00, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2C, 0x00, + 0x2C, 0x00, 0x2C, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x01, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x8C, 0xCB, 0x05, 0x00, 0x05, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x01, 0x05, 0x00, 0x05, 0x04, 0x05, + 0x00, 0x05, 0x04, 0x05, 0x00, 0x0F, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x07, + 0x02, 0x0D, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x1E, 0x00, 0x09, 0xBF, 0xFF, + 0x07, 0x01, 0x2F, 0xBF, 0xFF, 0x07, 0x02, 0x09, 0xBF, 0xFE, 0x07, 0x02, 0x19, 0x00, 0x19, 0x00, + 0x19, 0xBF, 0xFE, 0x07, 0x03, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0xBF, 0xFD, 0x07, 0x05, 0x0B, 0xBF, 0xFF, 0x09, 0x02, 0x1D, 0x01, 0x3A, 0x00, 0x30, + 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0xBF, 0xFD, 0x09, 0x04, 0x0B, 0xBF, 0xFC, 0x09, 0x04, 0x1B, + 0x00, 0x1B, 0x00, 0x1B, 0xBF, 0xFC, 0x09, 0x05, 0x0B, 0xBF, 0xFB, 0x09, 0x06, 0x26, 0x00, 0x1C, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0B, 0x01, 0x11, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFE, + 0x0B, 0x03, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xF7, 0x09, 0x0A, 0x0F, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x21, 0xBF, 0xF2, 0x07, 0x0F, 0x0D, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0xBF, 0xEF, 0x05, + 0x00, 0x05, 0x12, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x68, 0x00, 0x00, 0x00, 0xCD, 0x02, + 0xFE, 0x00, 0x00, 0x10, 0x01, 0x01, 0x01, 0x02, 0x42, 0x01, 0x02, 0x28, 0xCE, 0x0C, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x2D, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0xDA, 0x18, 0xD0, 0x02, 0x75, 0x6C, + 0xD0, 0x02, 0x6F, 0x6C, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, + 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, + 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, + 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, + 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, + 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, + 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, + 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, + 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, + 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, + 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, + 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, + 0xFF, 0x00, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x00, + 0x36, 0xDA, 0x82, 0x22, 0x00, 0x42, 0x00, 0xDA, 0x82, 0x07, 0x00, 0x42, 0x01, 0xDA, 0x82, 0x1B, + 0x00, 0x42, 0x02, 0xCF, 0x0A, 0x6E, 0x65, 0x77, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x01, + 0x42, 0x03, 0xCF, 0x07, 0x70, 0x2D, 0x73, 0x74, 0x61, 0x72, 0x74, 0x02, 0x42, 0x04, 0xCF, 0x05, + 0x70, 0x2D, 0x65, 0x6E, 0x64, 0x04, 0x42, 0x06, 0xCF, 0x06, 0x70, 0x2D, 0x6C, 0x69, 0x6E, 0x65, + 0x06, 0x42, 0x08, 0xCF, 0x08, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x2D, 0x70, 0x09, 0x0F, 0x0B, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x6F, 0x1B, 0x02, 0x00, 0x00, 0x28, 0x03, 0x00, + 0x00, 0x28, 0x04, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x30, 0x07, 0x01, + 0x00, 0x1B, 0x08, 0x07, 0x00, 0x2D, 0x0B, 0x00, 0x15, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x0B, 0x0A, + 0x00, 0x1E, 0x0A, 0x04, 0x00, 0x47, 0x0C, 0x02, 0x00, 0x1B, 0x09, 0x0C, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x09, 0x0B, 0x00, 0x1E, 0x09, 0x31, 0x00, 0x2D, 0x0B, 0x00, 0x27, 0x35, 0x0A, 0x0B, + 0x00, 0x1E, 0x0A, 0x07, 0x00, 0x35, 0x0B, 0x08, 0x00, 0x2D, 0x0C, 0x00, 0x19, 0x35, 0x0B, 0x0C, + 0x00, 0x2D, 0x0B, 0x00, 0x1D, 0x35, 0x02, 0x0B, 0x00, 0x1C, 0x27, 0x00, 0x00, 0x2D, 0x0C, 0x00, + 0x21, 0x35, 0x0B, 0x0C, 0x00, 0x1E, 0x0B, 0x08, 0x00, 0x35, 0x0C, 0x08, 0x00, 0x2D, 0x0C, 0x00, + 0x21, 0x2C, 0x0D, 0x00, 0x00, 0x33, 0x0C, 0x0D, 0x02, 0x2D, 0x0C, 0x00, 0x2E, 0x35, 0x02, 0x0C, + 0x00, 0x1C, 0x1D, 0x00, 0x00, 0x2D, 0x0D, 0x00, 0x23, 0x35, 0x0C, 0x0D, 0x00, 0x1E, 0x0C, 0x08, + 0x00, 0x35, 0x0D, 0x08, 0x00, 0x2D, 0x0D, 0x00, 0x23, 0x2C, 0x0E, 0x01, 0x00, 0x33, 0x0D, 0x0E, + 0x02, 0x2D, 0x0D, 0x00, 0x2E, 0x35, 0x02, 0x0D, 0x00, 0x1C, 0x13, 0x00, 0x00, 0x2D, 0x0E, 0x00, + 0x25, 0x35, 0x0D, 0x0E, 0x00, 0x1E, 0x0D, 0x06, 0x00, 0x35, 0x0E, 0x08, 0x00, 0x31, 0x02, 0x00, + 0x00, 0x2D, 0x0E, 0x00, 0x32, 0x35, 0x02, 0x0E, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x2B, 0x0F, 0x04, + 0x00, 0x06, 0x0E, 0x0F, 0x00, 0x47, 0x0F, 0x02, 0x0E, 0x1E, 0x0F, 0x06, 0x00, 0x35, 0x0E, 0x08, + 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x0E, 0x00, 0x34, 0x35, 0x02, 0x0E, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x35, 0x0E, 0x06, 0x00, 0x1C, 0xC8, 0xFF, 0xFF, 0x35, 0x09, 0x08, 0x00, 0x03, 0x02, 0x00, + 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x02, 0x26, + 0xCE, 0x06, 0x70, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x18, 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x82, + 0x05, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x01, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x01, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x01, + 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x01, 0x07, 0xDA, + 0x82, 0x0A, 0xBF, 0xFF, 0x01, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x01, 0x0C, 0xDA, 0x82, 0x0C, + 0xBF, 0xFF, 0x01, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x01, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, + 0x01, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x01, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x01, 0x15, + 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x01, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x01, 0x19, 0xDA, 0x82, + 0x13, 0xBF, 0xFF, 0x01, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x01, 0x1D, 0xDA, 0x82, 0x15, 0xBF, + 0xFF, 0x01, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x01, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x01, + 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x01, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x01, 0x27, 0xDA, + 0x82, 0x1A, 0xBF, 0xFF, 0x01, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x01, 0x2A, 0xDA, 0x82, 0x1C, + 0xBF, 0xFF, 0x01, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x01, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, + 0x01, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x01, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x01, 0x34, + 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x01, 0x36, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, + 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x7A, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x7B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x82, 0x7C, 0x00, 0x0E, 0x00, + 0xDA, 0x82, 0x7D, 0x2D, 0x01, 0x00, 0x03, 0x1E, 0x01, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x2D, + 0x01, 0x01, 0x11, 0x2F, 0x01, 0x00, 0x03, 0x2D, 0x02, 0x01, 0x1F, 0x35, 0x01, 0x02, 0x00, 0x2D, + 0x02, 0x01, 0x11, 0x2F, 0x02, 0x00, 0x04, 0x2D, 0x03, 0x01, 0x1D, 0x35, 0x02, 0x03, 0x00, 0x2F, + 0x02, 0x00, 0x02, 0x2D, 0x03, 0x00, 0x02, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8C, 0xF2, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x01, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, + 0x09, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x09, 0x00, 0x09, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x02, 0x28, 0xCE, 0x08, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, + 0x2D, 0x70, 0xDA, 0x18, 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x01, 0x01, 0xDA, + 0x82, 0x06, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x01, 0x03, 0xDA, 0x82, 0x08, + 0xBF, 0xFF, 0x01, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x01, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, + 0x01, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x01, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x01, 0x0A, + 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x01, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x01, 0x0E, 0xDA, 0x82, + 0x0D, 0xBF, 0xFF, 0x01, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x01, 0x11, 0xDA, 0x82, 0x0F, 0xBF, + 0xFF, 0x01, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x01, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x01, + 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x01, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x01, 0x1B, 0xDA, + 0x82, 0x14, 0xBF, 0xFF, 0x01, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x01, 0x1F, 0xDA, 0x82, 0x16, + 0xBF, 0xFF, 0x01, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x01, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, + 0x01, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x01, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x01, 0x28, + 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x01, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x01, 0x2C, 0xDA, 0x82, + 0x1D, 0xBF, 0xFF, 0x01, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x01, 0x30, 0xDA, 0x82, 0x1F, 0xBF, + 0xFF, 0x01, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x01, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x01, + 0x36, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x7A, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x7B, + 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x82, 0x7C, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x7D, 0x00, 0x1A, + 0x00, 0xDA, 0x82, 0x7E, 0x00, 0x09, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x6E, + 0x2D, 0x02, 0x00, 0x03, 0x2D, 0x03, 0x00, 0x03, 0x1E, 0x03, 0x06, 0x00, 0x2D, 0x04, 0x00, 0x04, + 0x2D, 0x05, 0x00, 0x03, 0x21, 0x03, 0x04, 0x05, 0x1B, 0x01, 0x03, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x1B, 0x01, 0x02, 0x00, 0x1E, 0x01, 0x10, 0x00, 0x2D, 0x02, 0x00, 0x03, 0x2D, 0x03, 0x00, 0x04, + 0x32, 0x02, 0x03, 0x00, 0x2D, 0x03, 0x01, 0x2A, 0x35, 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, + 0x2D, 0x04, 0x01, 0x36, 0x35, 0x03, 0x04, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2D, 0x04, 0x01, 0x2C, + 0x35, 0x02, 0x04, 0x00, 0x28, 0x02, 0x00, 0x00, 0x2F, 0x02, 0x00, 0x03, 0x2D, 0x02, 0x00, 0x03, + 0x03, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8C, 0xF8, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x09, + 0x01, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, + 0x09, 0x8C, 0xEE, 0x07, 0x01, 0x07, 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, 0x06, 0x07, 0x00, 0x07, + 0x04, 0x13, 0x00, 0x13, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x17, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x07, 0x02, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x09, 0x01, 0x15, 0x00, 0x20, 0x00, 0x20, 0x00, + 0x36, 0x00, 0x36, 0xBF, 0xFF, 0x09, 0x02, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x09, 0x02, 0x15, 0x00, + 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0xBF, 0xFE, 0x09, 0x03, 0x0B, 0x00, 0x0B, + 0xBF, 0xFD, 0x09, 0x03, 0x15, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0xBF, + 0xFD, 0x09, 0x04, 0x0B, 0x00, 0x0B, 0xBF, 0xFC, 0x09, 0x04, 0x16, 0x00, 0x31, 0x00, 0x31, 0x00, + 0x31, 0xBF, 0xFC, 0x09, 0x05, 0x1A, 0x00, 0x1A, 0x00, 0x0B, 0xBF, 0xFB, 0x09, 0x05, 0x2C, 0x00, + 0x47, 0x00, 0x47, 0x00, 0x47, 0xBF, 0xFB, 0x09, 0x06, 0x0B, 0xBF, 0xF9, 0x07, 0x08, 0x07, 0xBF, + 0xEA, 0x05, 0x1C, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x03, + 0x12, 0x01, 0x28, 0xCE, 0x0B, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, + 0xDA, 0x18, 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0x5B, 0xDA, 0x82, 0x65, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, + 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, + 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, + 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, + 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, + 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, + 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, + 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, + 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, + 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, + 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, + 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, + 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x00, + 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x00, 0x36, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x37, 0xDA, + 0x82, 0x23, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x24, 0xBF, 0xFF, 0x00, 0x3B, 0xDA, 0x82, 0x25, + 0xBF, 0xFF, 0x00, 0x39, 0xDA, 0x82, 0x26, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x27, 0x00, 0x12, + 0x00, 0xDA, 0x82, 0x07, 0x00, 0x12, 0x01, 0xDA, 0x82, 0x28, 0x02, 0x12, 0x03, 0xCF, 0x05, 0x64, + 0x65, 0x6C, 0x74, 0x61, 0x2D, 0x03, 0x00, 0x3A, 0x08, 0x02, 0x00, 0x03, 0x1B, 0x03, 0x02, 0x00, + 0x2B, 0x05, 0x00, 0x00, 0x23, 0x04, 0x05, 0x03, 0x1E, 0x04, 0x0C, 0x00, 0x2C, 0x05, 0x00, 0x00, + 0x32, 0x05, 0x03, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2D, 0x06, 0x00, 0x39, + 0x32, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2F, 0x00, 0x00, 0x3A, + 0x2D, 0x05, 0x00, 0x3A, 0x03, 0x05, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8D, 0x16, + 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x18, 0x00, 0x18, 0x00, + 0x18, 0x00, 0x18, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, + 0x07, 0xBF, 0xFE, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x00, 0x01, 0x02, 0x09, 0x01, + 0x28, 0xCE, 0x07, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x6E, 0x6C, 0xDA, 0x18, 0xDA, 0x82, 0x5C, 0xDA, + 0x82, 0x65, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, + 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, + 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, + 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, + 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, + 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, + 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, + 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, + 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x00, 0x36, 0xDA, + 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x37, 0xDA, 0x82, 0x23, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x24, + 0xBF, 0xFF, 0x00, 0x3B, 0xDA, 0x82, 0x25, 0xBF, 0xFF, 0x00, 0x39, 0xDA, 0x82, 0x26, 0xBF, 0xFF, + 0x00, 0x3A, 0xDA, 0x82, 0x27, 0xBF, 0xFF, 0x00, 0x3C, 0xDA, 0x82, 0x28, 0x00, 0x09, 0x00, 0xDA, + 0x82, 0x07, 0x00, 0x09, 0x01, 0xDA, 0x82, 0x29, 0x2D, 0x02, 0x00, 0x39, 0x2C, 0x03, 0x00, 0x00, + 0x32, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, + 0x2F, 0x03, 0x00, 0x3A, 0x2D, 0x03, 0x00, 0x3A, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8D, 0x1C, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0C, 0x03, 0x02, 0x03, 0x03, 0x38, 0x01, 0x30, 0xCE, 0x09, + 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x77, 0x6F, 0x72, 0x64, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x00, 0x04, 0x00, 0x02, 0xCE, 0x04, 0x6C, 0x61, 0x73, 0x74, + 0xDA, 0x18, 0x00, 0x04, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x04, 0x01, 0xDA, 0x80, 0xE4, 0x3F, 0x02, + 0x00, 0x00, 0x07, 0x03, 0x02, 0x01, 0x3B, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x82, 0xFB, + 0x0E, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0x65, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, + 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, + 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, + 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, + 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, + 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, + 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, + 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, + 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, + 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, 0x32, 0xDA, 0x82, 0x20, 0xBF, + 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x00, 0x36, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, + 0x37, 0xDA, 0x82, 0x23, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x24, 0xBF, 0xFF, 0x00, 0x3B, 0xDA, + 0x82, 0x25, 0xBF, 0xFF, 0x00, 0x39, 0xDA, 0x82, 0x26, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x27, + 0xBF, 0xFF, 0x00, 0x3C, 0xDA, 0x82, 0x28, 0xBF, 0xFF, 0x00, 0x3E, 0xDA, 0x82, 0x29, 0x00, 0x38, + 0x00, 0xCF, 0x04, 0x77, 0x6F, 0x72, 0x64, 0x00, 0x38, 0x01, 0xDA, 0x82, 0x07, 0x00, 0x38, 0x02, + 0xDA, 0x81, 0x25, 0x00, 0x38, 0x03, 0xDA, 0x82, 0x2A, 0x04, 0x38, 0x05, 0xCF, 0x09, 0x6C, 0x61, + 0x73, 0x74, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x04, 0x10, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x71, 0x07, 0x0D, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x70, 0x1E, + 0x38, 0x07, 0xDA, 0x81, 0x25, 0x1E, 0x29, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x72, 0x2D, 0x04, 0x00, 0x39, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x1B, 0x05, 0x04, 0x00, 0x1E, 0x05, 0x0A, 0x00, 0x4B, 0x08, 0x05, 0x0A, 0x1B, 0x09, 0x08, + 0x00, 0x1E, 0x08, 0x04, 0x00, 0x4B, 0x0A, 0x05, 0x20, 0x1B, 0x07, 0x0A, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x07, 0x09, 0x00, 0x1B, 0x06, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x05, + 0x00, 0x1E, 0x06, 0x09, 0x00, 0x2D, 0x07, 0x00, 0x39, 0x2C, 0x08, 0x01, 0x00, 0x32, 0x07, 0x08, + 0x00, 0x2C, 0x08, 0x02, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2D, 0x08, 0x00, 0x3A, 0x05, 0x07, 0x08, + 0x01, 0x2F, 0x07, 0x00, 0x3A, 0x20, 0x02, 0x04, 0x00, 0x3F, 0x07, 0x00, 0x00, 0x1B, 0x06, 0x07, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x01, 0x09, + 0x00, 0x2B, 0x0A, 0x01, 0x00, 0x2D, 0x0B, 0x00, 0x3A, 0x06, 0x09, 0x0A, 0x0B, 0x06, 0x09, 0x09, + 0x07, 0x2D, 0x0B, 0x00, 0x07, 0x21, 0x0A, 0x09, 0x0B, 0x1B, 0x08, 0x0A, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x08, 0x01, 0x00, 0x1E, 0x08, 0x06, 0x00, 0x2D, 0x0A, 0x00, 0x3E, 0x35, 0x09, 0x0A, + 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x0A, 0x00, 0x3C, 0x35, 0x09, 0x0A, 0x00, 0x2D, 0x08, 0x00, + 0x39, 0x32, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x02, 0x00, 0x35, 0x08, 0x09, 0x00, 0x2D, 0x0A, 0x00, + 0x3A, 0x06, 0x09, 0x0A, 0x07, 0x2F, 0x09, 0x00, 0x3A, 0x2D, 0x0A, 0x00, 0x3A, 0x03, 0x0A, 0x00, + 0x00, 0xBF, 0xFF, 0x8D, 0x20, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0x01, 0x0B, + 0x02, 0x0D, 0xBF, 0xFE, 0x0B, 0x00, 0x0B, 0x03, 0x0D, 0xBF, 0xFD, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x04, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x05, 0x00, 0x12, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x17, + 0x00, 0x17, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x01, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x02, 0x02, 0x02, 0x07, + 0x24, 0x01, 0x2C, 0xCE, 0x09, 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x63, 0x6F, 0x64, 0x65, 0xDA, 0x18, + 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0x5B, 0xDA, 0x82, 0x5C, 0xDA, 0x81, 0x12, 0xDA, 0x82, 0x5D, 0xDA, + 0x82, 0x65, 0xDA, 0x82, 0x87, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x82, 0x06, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, + 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, + 0x0A, 0xDA, 0x82, 0x0B, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, + 0x82, 0x0D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, + 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, + 0x00, 0x17, 0xDA, 0x82, 0x12, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, + 0xDA, 0x82, 0x14, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, + 0x16, 0xBF, 0xFF, 0x00, 0x21, 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, + 0xFF, 0x00, 0x25, 0xDA, 0x82, 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, + 0x28, 0xDA, 0x82, 0x1B, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, + 0x82, 0x1D, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, + 0xBF, 0xFF, 0x00, 0x32, 0xDA, 0x82, 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, + 0x00, 0x36, 0xDA, 0x82, 0x22, 0xBF, 0xFF, 0x00, 0x37, 0xDA, 0x82, 0x23, 0xBF, 0xFF, 0x00, 0x3A, + 0xDA, 0x82, 0x24, 0xBF, 0xFF, 0x00, 0x3B, 0xDA, 0x82, 0x25, 0xBF, 0xFF, 0x00, 0x39, 0xDA, 0x82, + 0x26, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x27, 0xBF, 0xFF, 0x00, 0x3C, 0xDA, 0x82, 0x28, 0xBF, + 0xFF, 0x00, 0x3E, 0xDA, 0x82, 0x29, 0xBF, 0xFF, 0x00, 0x40, 0xDA, 0x82, 0x2A, 0x00, 0x24, 0x00, + 0xCF, 0x04, 0x63, 0x6F, 0x64, 0x65, 0x00, 0x24, 0x01, 0xDA, 0x82, 0x07, 0x00, 0x24, 0x02, 0xDA, + 0x82, 0x2B, 0x0A, 0x24, 0x04, 0xCF, 0x0B, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x2B, 0x04, 0x04, 0x00, 0x06, 0x03, 0x04, 0x01, 0x2C, 0x04, 0x00, 0x00, 0x32, 0x04, + 0x03, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x32, 0x03, + 0x04, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x35, 0x03, 0x05, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x06, + 0x04, 0x00, 0x06, 0x05, 0x06, 0x01, 0x31, 0x05, 0x00, 0x00, 0x2D, 0x07, 0x00, 0x3C, 0x35, 0x06, + 0x07, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x33, 0x05, 0x04, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x05, + 0x07, 0x00, 0x2D, 0x07, 0x00, 0x39, 0x32, 0x07, 0x05, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x35, 0x07, + 0x08, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x35, 0x05, 0x08, 0x00, 0x2B, 0x09, + 0x0A, 0x00, 0x25, 0x08, 0x09, 0x05, 0x1E, 0x08, 0x05, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x2F, 0x05, + 0x00, 0x3A, 0x2D, 0x05, 0x00, 0x3A, 0x03, 0x05, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x3E, 0x36, 0x05, + 0x00, 0x00, 0xBF, 0xFF, 0x8D, 0x30, 0x36, 0x00, 0x36, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, + 0x23, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x05, 0x01, 0x12, 0x00, 0x12, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x12, 0x02, 0x02, 0x02, 0x0D, 0x7E, 0x01, 0x3F, 0xCE, 0x09, 0x65, 0x6D, 0x69, 0x74, + 0x2D, 0x6E, 0x6F, 0x64, 0x65, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, + 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x06, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x3F, 0xDA, 0x18, + 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x06, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, + 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x6F, 0x2E, 0x00, + 0x2E, 0x00, 0x2E, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0x5B, 0xDA, + 0x82, 0x5C, 0xDA, 0x81, 0x12, 0xDA, 0x82, 0x5D, 0xDA, 0x82, 0x72, 0xDA, 0x82, 0x78, 0xCE, 0x02, + 0x2A, 0x20, 0xDA, 0x82, 0x79, 0xCE, 0x04, 0x25, 0x64, 0x2E, 0x20, 0xDA, 0x54, 0xDA, 0x82, 0x5E, + 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x82, 0x05, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, 0x06, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x81, 0xE5, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x82, 0x07, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x82, + 0x09, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x0A, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x82, 0x0B, 0xBF, + 0xFF, 0x00, 0x0C, 0xDA, 0x82, 0x0C, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x82, 0x0D, 0xBF, 0xFF, 0x00, + 0x10, 0xDA, 0x82, 0x0E, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x82, 0x0F, 0xBF, 0xFF, 0x00, 0x13, 0xDA, + 0x82, 0x10, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x82, 0x11, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x82, 0x12, + 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x82, 0x13, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x82, 0x14, 0xBF, 0xFF, + 0x00, 0x1D, 0xDA, 0x82, 0x15, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x82, 0x16, 0xBF, 0xFF, 0x00, 0x21, + 0xDA, 0x82, 0x17, 0xBF, 0xFF, 0x00, 0x23, 0xDA, 0x82, 0x18, 0xBF, 0xFF, 0x00, 0x25, 0xDA, 0x82, + 0x19, 0xBF, 0xFF, 0x00, 0x27, 0xDA, 0x82, 0x1A, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x82, 0x1B, 0xBF, + 0xFF, 0x00, 0x2A, 0xDA, 0x82, 0x1C, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x82, 0x1D, 0xBF, 0xFF, 0x00, + 0x2E, 0xDA, 0x82, 0x1E, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x82, 0x1F, 0xBF, 0xFF, 0x00, 0x32, 0xDA, + 0x82, 0x20, 0xBF, 0xFF, 0x00, 0x34, 0xDA, 0x82, 0x21, 0xBF, 0xFF, 0x00, 0x36, 0xDA, 0x82, 0x22, + 0xBF, 0xFF, 0x00, 0x37, 0xDA, 0x82, 0x23, 0xBF, 0xFF, 0x00, 0x3A, 0xDA, 0x82, 0x24, 0xBF, 0xFF, + 0x00, 0x3B, 0xDA, 0x82, 0x25, 0xBF, 0xFF, 0x00, 0x39, 0xDA, 0x82, 0x26, 0xBF, 0xFF, 0x00, 0x3A, + 0xDA, 0x82, 0x27, 0xBF, 0xFF, 0x00, 0x3C, 0xDA, 0x82, 0x28, 0xBF, 0xFF, 0x00, 0x3E, 0xDA, 0x82, + 0x29, 0xBF, 0xFF, 0x00, 0x40, 0xDA, 0x82, 0x2A, 0xBF, 0xFF, 0x00, 0x42, 0xDA, 0x82, 0x2B, 0x00, + 0x7E, 0x00, 0xDA, 0x81, 0x99, 0x00, 0x7E, 0x01, 0xDA, 0x82, 0x07, 0x00, 0x7E, 0x02, 0xDA, 0x82, + 0x2C, 0x10, 0x25, 0x05, 0xCF, 0x03, 0x72, 0x65, 0x70, 0x10, 0x23, 0x00, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x74, 0x13, 0x23, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x73, 0x17, 0x23, 0x09, 0xDA, 0x82, 0x89, 0x19, 0x23, 0x0A, 0xDA, 0x81, 0x25, 0x28, 0x7E, 0x06, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x75, 0x2C, 0x4D, 0x07, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x76, 0x2E, 0x4D, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x77, 0x31, 0x4C, 0x0A, 0xDA, 0x80, 0xC3, 0x3D, 0x4A, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x79, 0x40, 0x4A, 0x0D, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x78, 0x43, + 0x4A, 0x0E, 0xCF, 0x05, 0x73, 0x75, 0x62, 0x65, 0x6C, 0x50, 0x75, 0x08, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x7A, 0x52, 0x75, 0x0A, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x41, 0x55, 0x74, 0x0B, 0xDA, 0x80, 0xC3, 0x5F, 0x74, 0x0D, 0xCF, 0x03, 0x6C, 0x61, 0x62, 0x65, + 0x72, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x68, 0x72, 0x0F, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x42, 0x6B, 0x72, 0x10, 0xDA, 0x82, 0x9F, 0x2E, 0x02, 0x00, + 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x3C, 0x35, 0x03, 0x04, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x1E, 0x00, 0x2C, 0x05, 0x01, + 0x00, 0x32, 0x05, 0x01, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2C, 0x06, 0x03, + 0x00, 0x32, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, + 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, 0x06, 0x00, 0x07, 0x1B, 0x07, 0x06, 0x00, 0x1F, 0x07, 0x0F, + 0x00, 0x3A, 0x06, 0x00, 0x07, 0x3D, 0x08, 0x06, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x3D, 0x08, 0x06, + 0x01, 0x1B, 0x0A, 0x08, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x33, 0x06, 0x05, 0x09, 0x2C, 0x08, 0x05, + 0x00, 0x35, 0x06, 0x08, 0x00, 0x33, 0x06, 0x01, 0x0A, 0x2D, 0x0B, 0x00, 0x40, 0x35, 0x08, 0x0B, + 0x00, 0x49, 0x07, 0x00, 0x07, 0x1C, 0xF2, 0xFF, 0xFF, 0x2D, 0x06, 0x00, 0x3E, 0x36, 0x06, 0x00, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, + 0x00, 0x2C, 0x07, 0x07, 0x00, 0x25, 0x05, 0x06, 0x07, 0x1E, 0x05, 0x22, 0x00, 0x2B, 0x07, 0x01, + 0x00, 0x3F, 0x08, 0x00, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x23, 0x08, 0x07, 0x09, 0x1E, 0x08, 0x1C, + 0x00, 0x1B, 0x0A, 0x07, 0x00, 0x22, 0x0B, 0x0A, 0x01, 0x1E, 0x0B, 0x04, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2D, 0x0D, 0x00, 0x3C, 0x35, 0x0C, 0x0D, 0x00, 0x2C, 0x0B, 0x08, 0x00, 0x28, 0x0C, 0x00, + 0x00, 0x32, 0x0B, 0x0C, 0x00, 0x2D, 0x0C, 0x00, 0x40, 0x35, 0x0B, 0x0C, 0x00, 0x3B, 0x0B, 0x00, + 0x0A, 0x1B, 0x0C, 0x0B, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x49, 0x0B, 0x0C, 0x0D, 0x1B, 0x0D, 0x0B, + 0x00, 0x1F, 0x0D, 0x09, 0x00, 0x3A, 0x0B, 0x0C, 0x0D, 0x1B, 0x0E, 0x0B, 0x00, 0x2B, 0x0F, 0x02, + 0x00, 0x06, 0x0B, 0x0F, 0x01, 0x32, 0x0E, 0x0B, 0x00, 0x35, 0x0F, 0x02, 0x00, 0x49, 0x0D, 0x0C, + 0x0D, 0x1C, 0xF8, 0xFF, 0xFF, 0x05, 0x07, 0x07, 0x01, 0x1C, 0xE4, 0xFF, 0xFF, 0x04, 0x00, 0x00, + 0x00, 0x2C, 0x08, 0x09, 0x00, 0x25, 0x07, 0x06, 0x08, 0x1E, 0x07, 0x26, 0x00, 0x2B, 0x08, 0x01, + 0x00, 0x3F, 0x09, 0x00, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x23, 0x09, 0x08, 0x0A, 0x1E, 0x09, 0x20, + 0x00, 0x1B, 0x0B, 0x08, 0x00, 0x22, 0x0C, 0x0B, 0x01, 0x1E, 0x0C, 0x04, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2D, 0x0E, 0x00, 0x3C, 0x35, 0x0D, 0x0E, 0x00, 0x2C, 0x0C, 0x0A, 0x00, 0x32, 0x0C, 0x0B, + 0x00, 0x2C, 0x0D, 0x0B, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x28, 0x0C, 0x00, + 0x00, 0x32, 0x0D, 0x0C, 0x00, 0x2D, 0x0E, 0x00, 0x40, 0x35, 0x0C, 0x0E, 0x00, 0x3B, 0x0C, 0x00, + 0x0B, 0x1B, 0x0E, 0x0C, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0C, 0x0E, 0x0F, 0x1B, 0x0F, 0x0C, + 0x00, 0x1F, 0x0F, 0x09, 0x00, 0x3A, 0x0C, 0x0E, 0x0F, 0x1B, 0x10, 0x0C, 0x00, 0x3F, 0x0C, 0x0D, + 0x00, 0x06, 0x11, 0x0C, 0x01, 0x32, 0x10, 0x11, 0x00, 0x35, 0x0C, 0x02, 0x00, 0x49, 0x0F, 0x0E, + 0x0F, 0x1C, 0xF8, 0xFF, 0xFF, 0x05, 0x08, 0x08, 0x01, 0x1C, 0xE0, 0xFF, 0xFF, 0x04, 0x00, 0x00, + 0x00, 0x2C, 0x09, 0x0C, 0x00, 0x25, 0x08, 0x06, 0x09, 0x1E, 0x08, 0x06, 0x00, 0x2B, 0x0A, 0x01, + 0x00, 0x3B, 0x09, 0x00, 0x0A, 0x32, 0x09, 0x01, 0x00, 0x2D, 0x0A, 0x00, 0x42, 0x36, 0x0A, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8D, 0x37, 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x02, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFF, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x09, 0x00, 0x09, + 0x05, 0x09, 0x00, 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x01, 0x0D, 0x00, 0x16, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x13, + 0x00, 0x0F, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x01, 0x1B, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x37, 0x00, 0x37, 0x00, 0x26, 0x00, 0x26, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFD, + 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, 0x05, 0x0D, 0x00, 0x16, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x13, 0x00, 0x0F, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x1B, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x0F, 0x01, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x1B, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x3A, 0x00, 0x37, 0x00, 0x26, 0x00, 0x26, 0x00, 0x0F, 0x00, 0x0F, + 0xBF, 0xFC, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFB, 0x07, 0x00, 0x07, 0x00, 0x07, 0x0A, 0x18, + 0x00, 0x18, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xF6, 0x07, 0x8C, 0x4F, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x15, 0x00, 0x12, 0x00, 0x03, 0x01, 0x16, 0x00, 0x16, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x02, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0xBF, 0xFE, + 0x12, 0x00, 0x03, 0x06, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x0A, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x07, 0x03, 0x01, 0x03, 0x00, 0x03, 0x03, 0x03, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x02, 0x03, 0x00, 0x03, + 0x04, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, 0x06, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x06, 0x03, 0x01, 0x03, 0x00, 0x03, 0x03, 0x03, 0x00, 0x03, 0x02, 0x03, + 0x00, 0x03, 0x16, 0x03, 0x00, 0x03, 0x06, 0x03, 0x00, 0x03, 0x0D, 0x03, 0x00, 0x03, 0x0B, 0x03, + 0x00, 0x03, 0x23, 0x05, 0x1A, 0x16, 0x00, 0x16, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x01, 0x05, + 0x01, 0x29, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x05, 0x01, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x05, + 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x32, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x05, 0x00, 0x05, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03, 0x03, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x03, 0x03, 0x00, 0x03, 0x06, 0x03, 0x00, 0x03, 0x04, 0x03, 0x00, 0x03, + 0x0F, 0x03, 0x00, 0x03, 0x09, 0x03, 0x00, 0x03, 0x17, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x01, 0x05, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x00, + 0x03, 0xBE, 0xFB, 0x01, 0x81, 0x54, 0xAB, 0xAA, 0xAA, 0x55, 0x55, 0x56, 0x05, 0x00, 0x00, 0x00, + 0xDA, 0x08, 0xCE, 0x81, 0x1F, 0x28, 0x64, 0x6F, 0x63, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, + 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, + 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x69, 0x7A, 0x65, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x61, 0x20, 0x64, 0x6F, 0x63, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x72, 0x61, 0x70, 0x20, 0x61, + 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x2E, 0x20, + 0x44, 0x6F, 0x63, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x65, + 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x62, 0x65, 0x20, 0x70, 0x6C, 0x61, 0x69, 0x6E, 0x74, 0x65, + 0x78, 0x74, 0x0A, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, 0x6F, + 0x66, 0x20, 0x6D, 0x61, 0x72, 0x6B, 0x64, 0x6F, 0x77, 0x6E, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x73, 0x20, 0x61, 0x20, 0x6C, 0x6F, 0x6E, 0x67, 0x20, 0x73, + 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x72, + 0x6F, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x0A, 0x61, 0x20, 0x77, 0x65, + 0x6C, 0x6C, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x65, 0x64, 0x20, 0x64, 0x6F, 0x63, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x65, 0x78, 0x74, 0x2E, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x32, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x1B, 0x01, 0xDA, 0x06, 0xD8, 0x09, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x32, 0xDA, 0x08, 0xCE, 0x2B, 0x28, 0x6D, 0x61, + 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x32, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, + 0x20, 0x32, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x0C, 0x6F, 0x73, 0x2F, 0x73, 0x69, 0x67, + 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x83, + 0x65, 0x01, 0xDA, 0x06, 0xD8, 0x0C, 0x6F, 0x73, 0x2F, 0x73, 0x69, 0x67, 0x61, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0xDA, 0x08, 0xCE, 0x80, 0xE1, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x69, 0x67, 0x61, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, + 0x74, 0x2D, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x72, 0x29, 0x0A, 0x0A, + 0x41, 0x64, 0x64, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x68, 0x61, 0x6E, + 0x64, 0x6C, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x20, 0x6E, 0x69, 0x6C, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, + 0x72, 0x60, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x72, + 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x68, + 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, + 0x63, 0x2D, 0x6B, 0x69, 0x6C, 0x6C, 0x60, 0x2E, 0xCF, 0x04, 0x77, 0x68, 0x65, 0x6E, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xB0, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, + 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, 0xCE, + 0x04, 0x77, 0x68, 0x65, 0x6E, 0xDA, 0x18, 0xDA, 0x58, 0xDA, 0x57, 0x00, 0x08, 0x00, 0xCF, 0x09, + 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x08, 0x01, 0xDA, 0x81, 0x74, 0x00, + 0x08, 0x02, 0xDA, 0x82, 0xB0, 0x2C, 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, + 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, 0x03, 0x45, 0x04, 0x00, + 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0xB3, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x5E, 0x28, 0x77, 0x68, 0x65, 0x6E, 0x20, + 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, + 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, + 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x07, 0x70, 0x72, 0x65, + 0x77, 0x61, 0x6C, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x69, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x01, 0x07, 0x00, + 0x01, 0x03, 0xCE, 0x07, 0x70, 0x72, 0x65, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x18, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x02, 0x02, 0x02, 0x09, 0x23, 0x00, 0x04, 0xCE, 0x04, 0x77, 0x61, + 0x6C, 0x6B, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xCB, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0A, 0x02, 0x02, 0x02, 0x00, 0x10, 0x00, 0x07, 0xCE, 0x09, 0x77, 0x61, 0x6C, 0x6B, 0x2D, 0x64, + 0x69, 0x63, 0x74, 0xDA, 0x18, 0x00, 0x10, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x10, 0x01, 0xDA, 0x81, + 0x8B, 0x00, 0x10, 0x02, 0xCF, 0x09, 0x77, 0x61, 0x6C, 0x6B, 0x2D, 0x64, 0x69, 0x63, 0x74, 0x01, + 0x10, 0x04, 0xDA, 0x23, 0x01, 0x0F, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x54, + 0x04, 0x0F, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x53, 0x06, 0x0F, 0x05, 0xDA, + 0x22, 0x44, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x01, + 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x0A, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, + 0x00, 0x35, 0x07, 0x00, 0x00, 0x3A, 0x08, 0x01, 0x05, 0x31, 0x08, 0x00, 0x00, 0x35, 0x09, 0x00, + 0x00, 0x3C, 0x04, 0x07, 0x09, 0x49, 0x06, 0x01, 0x06, 0x1C, 0xF7, 0xFF, 0xFF, 0x03, 0x04, 0x00, + 0x00, 0x85, 0x51, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x17, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, + 0x03, 0xBF, 0xFE, 0x01, 0xDA, 0x80, 0xC9, 0xDA, 0x80, 0xCA, 0xDA, 0x66, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x0A, 0x02, 0x02, 0x02, 0x01, 0x10, 0x00, 0x07, 0xCE, 0x08, 0x77, 0x61, 0x6C, + 0x6B, 0x2D, 0x69, 0x6E, 0x64, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0x00, 0x10, 0x00, 0xDA, 0x80, 0xAA, + 0x00, 0x10, 0x01, 0xDA, 0x81, 0x8B, 0x00, 0x10, 0x02, 0xCF, 0x08, 0x77, 0x61, 0x6C, 0x6B, 0x2D, + 0x69, 0x6E, 0x64, 0x01, 0x10, 0x04, 0xDA, 0x23, 0x01, 0x0F, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x52, 0x04, 0x0F, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x51, + 0x07, 0x0F, 0x07, 0xDA, 0x1E, 0x40, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x06, 0x00, + 0x00, 0x49, 0x05, 0x01, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x0A, 0x00, 0x3A, 0x05, 0x01, + 0x06, 0x1B, 0x07, 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x05, 0x00, 0x00, 0x32, 0x04, 0x05, + 0x00, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x08, 0x09, 0x00, 0x49, 0x06, 0x01, 0x06, 0x1C, 0xF7, 0xFF, + 0xFF, 0x03, 0x04, 0x00, 0x00, 0x85, 0x4C, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x20, 0x00, 0x20, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFE, 0x01, 0xDA, 0x80, 0xA3, 0xDA, 0x81, 0x08, 0x00, 0x23, 0x00, + 0xDA, 0x80, 0xAA, 0x00, 0x23, 0x01, 0xDA, 0x81, 0x8B, 0x00, 0x23, 0x02, 0xCF, 0x04, 0x77, 0x61, + 0x6C, 0x6B, 0x03, 0x23, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x55, 0x31, 0x01, + 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, + 0x01, 0x00, 0x25, 0x03, 0x04, 0x05, 0x1E, 0x03, 0x04, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x05, + 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x25, 0x05, 0x04, 0x06, 0x1E, 0x05, + 0x07, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x36, 0x07, 0x00, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x25, 0x06, + 0x04, 0x07, 0x1E, 0x06, 0x04, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x36, 0x07, + 0x00, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x25, 0x07, 0x04, 0x08, 0x1E, 0x07, 0x07, 0x00, 0x32, 0x00, + 0x01, 0x00, 0x2C, 0x09, 0x06, 0x00, 0x35, 0x08, 0x09, 0x00, 0x32, 0x01, 0x08, 0x00, 0x2C, 0x09, + 0x08, 0x00, 0x36, 0x09, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x85, 0x5C, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, + 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, + 0xFD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x04, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0xBF, 0xFC, 0x03, 0x00, 0x07, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x07, 0x01, 0xDA, 0x81, + 0x8B, 0x00, 0x07, 0x02, 0xDA, 0x82, 0xB7, 0x2E, 0x02, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x36, + 0x05, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x01, 0x01, 0x01, 0x00, 0x04, 0x01, 0x04, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, 0x8B, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0xB7, 0x00, 0x04, 0x00, 0xDA, 0x1E, 0x2D, 0x01, 0x00, 0x00, + 0x32, 0x01, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x02, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x85, 0x6C, + 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x85, 0x69, 0x01, 0x03, 0x09, 0x00, 0x20, 0x00, 0x20, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x05, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x70, + 0x72, 0x65, 0x77, 0x61, 0x6C, 0x6B, 0x20, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x29, 0x0A, 0x0A, + 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x70, 0x6F, 0x73, 0x74, + 0x77, 0x61, 0x6C, 0x6B, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x70, 0x72, + 0x65, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x72, 0x61, 0x76, 0x65, 0x72, 0x73, 0x61, + 0x6C, 0x2E, 0xCF, 0x07, 0x2A, 0x72, 0x65, 0x64, 0x65, 0x66, 0x2A, 0xD3, 0x04, 0xDA, 0x81, 0xC9, + 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD5, 0x01, 0xDA, 0x06, 0xD0, 0x05, 0x72, + 0x65, 0x64, 0x65, 0x66, 0xDA, 0x08, 0xCE, 0x7A, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x73, 0x65, 0x74, + 0x2C, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x61, + 0x6C, 0x6C, 0x79, 0x20, 0x72, 0x65, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, + 0x70, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x64, 0x65, 0x66, 0x73, 0x2E, 0x20, 0x57, 0x69, + 0x6C, 0x6C, 0x20, 0x73, 0x6C, 0x6F, 0x77, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, + 0x74, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6C, 0x6F, 0x70, 0x6D, 0x65, 0x6E, + 0x74, 0x2E, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x13, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x74, 0x61, 0x6E, 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, + 0x61, 0x6E, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x6E, 0x67, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, + 0xDA, 0x82, 0x4C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xE7, 0x01, 0xDA, + 0x06, 0xDA, 0x82, 0x4A, 0xDA, 0x08, 0xCE, 0x3B, 0x28, 0x6D, 0x69, 0x6E, 0x20, 0x26, 0x20, 0x61, + 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x20, 0x6D, 0x69, 0x6E, 0x69, 0x6D, 0x75, + 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x2E, 0xCF, 0x02, 0x2F, 0x3D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x80, 0x8F, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, 0xCE, 0x02, 0x2F, 0x3D, 0xDA, 0x18, 0xD7, 0x00, + 0xCD, 0x00, 0x09, 0x00, 0x0C, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, + 0x01, 0x2F, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, + 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, + 0x01, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x0C, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, + 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x0C, 0x03, 0x03, 0x04, 0x05, 0x05, + 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x34, + 0x00, 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x35, 0x00, 0x08, 0x02, 0xDA, 0x82, 0xD8, + 0x2C, 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, + 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, 0x03, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, + 0x80, 0x8F, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, + 0x38, 0xDA, 0x08, 0xCE, 0x2B, 0x28, 0x2F, 0x3D, 0x20, 0x78, 0x20, 0x26, 0x20, 0x6E, 0x73, 0x29, + 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x28, 0x73, 0x65, 0x74, 0x20, 0x78, 0x20, 0x28, 0x2F, 0x20, 0x78, 0x20, 0x6E, 0x29, 0x29, 0x2E, + 0xDA, 0x37, 0xCB, 0xCF, 0x04, 0x6E, 0x6F, 0x74, 0x3D, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x81, 0x70, + 0xDA, 0x08, 0xCE, 0x48, 0x28, 0x6E, 0x6F, 0x74, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, + 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x09, 0x66, 0x66, + 0x69, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, + 0x85, 0x68, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, + 0xDA, 0x08, 0xCE, 0x81, 0x26, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, + 0x66, 0x66, 0x69, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, + 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x77, 0x6F, + 0x75, 0x6C, 0x64, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x65, + 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x70, + 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x66, 0x69, 0x2C, 0x20, 0x6F, + 0x72, 0x20, 0x73, 0x65, 0x6E, 0x64, 0x20, 0x43, 0x2F, 0x43, 0x2B, 0x2B, 0x2F, 0x6E, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x6F, 0x72, 0x20, + 0x74, 0x6F, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6C, 0x69, 0x65, 0x64, 0x2E, 0xCF, 0x08, 0x6F, 0x73, 0x2F, + 0x73, 0x70, 0x61, 0x77, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0x80, + 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0xDA, 0x08, 0xCE, + 0x84, 0x9D, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x73, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x65, 0x6E, 0x76, 0x29, + 0x0A, 0x0A, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6F, 0x67, + 0x72, 0x61, 0x6D, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6D, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x20, 0x68, + 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, + 0x20, 0x74, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x73, 0x20, 0x60, 0x6F, 0x73, + 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x60, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x77, 0x61, 0x69, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x69, 0x6E, 0x2C, 0x20, 0x3A, + 0x6F, 0x75, 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x20, 0x6B, 0x65, + 0x79, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x65, 0x6E, 0x76, 0x60, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x60, 0x3A, 0x70, 0x69, 0x70, + 0x65, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x67, 0x65, 0x74, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, + 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x61, 0x6E, 0x64, 0x61, 0x72, 0x64, 0x20, 0x49, + 0x4F, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, 0x63, + 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, + 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x72, + 0x69, 0x74, 0x74, 0x65, 0x6E, 0x20, 0x74, 0x6F, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x60, 0x70, 0x72, + 0x6F, 0x63, 0x60, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6C, + 0x64, 0x73, 0x20, 0x3A, 0x69, 0x6E, 0x2C, 0x20, 0x3A, 0x6F, 0x75, 0x74, 0x2C, 0x20, 0x3A, 0x65, + 0x72, 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x64, 0x64, 0x69, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x3A, 0x70, 0x69, + 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x75, 0x6E, 0x69, 0x78, 0x2D, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x70, + 0x6C, 0x61, 0x74, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x2E, 0x20, 0x60, 0x28, 0x6F, 0x73, 0x2F, 0x70, + 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x29, 0x60, 0x20, + 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x72, 0x65, 0x6A, 0x6F, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, + 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, 0x60, + 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x70, 0x72, + 0x6F, 0x63, 0x29, 0x60, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, 0x73, 0x2C, 0x20, 0x70, + 0x72, 0x6F, 0x63, 0x20, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, + 0x66, 0x69, 0x65, 0x6C, 0x64, 0x2C, 0x20, 0x3A, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x2D, 0x63, + 0x6F, 0x64, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x3A, 0x78, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x20, + 0x69, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6F, 0x73, 0x2F, + 0x73, 0x70, 0x61, 0x77, 0x6E, 0x2C, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x7A, 0x65, 0x72, 0x6F, 0x20, + 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, + 0x61, 0x75, 0x73, 0x65, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, + 0x74, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6D, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x3A, 0x70, 0x69, 0x70, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2C, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, + 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6F, 0x72, 0x73, 0x2E, 0x20, 0x54, + 0x68, 0x65, 0x79, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x2C, 0x20, + 0x6F, 0x72, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x63, 0x6C, 0x6F, 0x73, + 0x65, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x61, 0x6C, 0x6C, + 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x73, 0x20, 0x6F, 0x6E, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x73, 0x20, 0x61, 0x72, 0x65, 0x6E, 0x27, 0x74, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, 0x72, + 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x60, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, + 0x73, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x73, 0x20, 0x62, 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x20, 0x66, 0x75, 0x6C, 0x6C, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, + 0x73, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x20, + 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, + 0x65, 0x73, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x2E, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x63, 0x61, 0x6E, + 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x2C, 0x20, 0x6F, 0x73, 0x2F, 0x70, + 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, + 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x2C, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x2E, 0xCF, + 0x09, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x77, 0x69, 0x74, 0x68, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x81, 0x7A, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, + 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x17, 0x00, 0x06, 0xCE, 0x09, 0x77, 0x68, 0x65, + 0x6E, 0x2D, 0x77, 0x69, 0x74, 0x68, 0xDA, 0x18, 0xD0, 0x05, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xD7, + 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0B, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0C, 0x2B, + 0x00, 0x05, 0xCE, 0x05, 0x64, 0x65, 0x66, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x9B, + 0xDA, 0x81, 0x6B, 0xDA, 0x81, 0x86, 0xDA, 0x52, 0xDA, 0x81, 0x6D, 0xDA, 0x81, 0x6F, 0xDA, 0x81, + 0x87, 0xDA, 0x81, 0x88, 0xDA, 0x81, 0x89, 0xDA, 0x57, 0xDA, 0x58, 0x00, 0x2B, 0x00, 0xDA, 0x81, + 0x8B, 0x00, 0x2B, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x2B, 0x02, 0xCF, 0x05, 0x64, 0x65, 0x66, 0x65, + 0x72, 0x02, 0x2B, 0x04, 0xDA, 0x80, 0xAA, 0x05, 0x2B, 0x05, 0xDA, 0x6C, 0x2C, 0x04, 0x00, 0x00, + 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x03, 0x05, 0x00, + 0x1B, 0x05, 0x03, 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x32, 0x07, 0x03, 0x00, + 0x34, 0x01, 0x00, 0x00, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x2C, 0x08, 0x03, 0x00, + 0x33, 0x07, 0x06, 0x08, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x33, 0x07, 0x04, 0x03, + 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x32, 0x07, 0x04, 0x00, 0x45, 0x03, 0x00, 0x00, + 0x2C, 0x08, 0x04, 0x00, 0x33, 0x08, 0x05, 0x03, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x06, 0x00, + 0x32, 0x08, 0x04, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x09, 0x07, 0x00, 0x2C, 0x0A, 0x08, 0x00, + 0x33, 0x09, 0x03, 0x0A, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x09, 0x00, 0x33, 0x09, 0x05, 0x04, + 0x45, 0x03, 0x00, 0x00, 0x2C, 0x0A, 0x0A, 0x00, 0x33, 0x0A, 0x08, 0x05, 0x31, 0x03, 0x00, 0x00, + 0x45, 0x09, 0x00, 0x00, 0x2C, 0x08, 0x0B, 0x00, 0x33, 0x08, 0x06, 0x07, 0x32, 0x00, 0x09, 0x00, + 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x81, 0x3A, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, + 0x80, 0x86, 0x00, 0x17, 0x01, 0xDA, 0x81, 0x74, 0x01, 0x17, 0x03, 0xCF, 0x07, 0x62, 0x69, 0x6E, + 0x64, 0x69, 0x6E, 0x67, 0x03, 0x17, 0x04, 0xCF, 0x04, 0x63, 0x74, 0x6F, 0x72, 0x05, 0x17, 0x05, + 0xCF, 0x04, 0x64, 0x74, 0x6F, 0x72, 0x06, 0x17, 0x00, 0xDA, 0x82, 0xED, 0x08, 0x0D, 0x05, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x3D, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, + 0x3D, 0x02, 0x00, 0x01, 0x1B, 0x04, 0x02, 0x00, 0x3D, 0x02, 0x00, 0x02, 0x1B, 0x05, 0x02, 0x00, + 0x2E, 0x00, 0x00, 0x00, 0x32, 0x03, 0x04, 0x00, 0x46, 0x02, 0x00, 0x00, 0x1E, 0x05, 0x03, 0x00, + 0x1B, 0x06, 0x05, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x32, 0x06, 0x03, 0x00, + 0x45, 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, + 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x33, 0x08, 0x02, 0x07, 0x45, 0x06, 0x00, 0x00, + 0x03, 0x06, 0x00, 0x00, 0x81, 0x7A, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x04, 0x03, 0x00, 0x03, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xA0, 0x28, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x5B, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x74, 0x6F, + 0x72, 0x20, 0x64, 0x74, 0x6F, 0x72, 0x5D, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, + 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x66, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, + 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x6E, 0x69, 0x6C, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, + 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x60, 0x77, 0x69, 0x74, 0x68, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x04, 0x64, 0x65, + 0x66, 0x6E, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x0A, 0x01, 0xDA, 0x06, 0xD7, + 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x17, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0D, 0x36, + 0x00, 0x01, 0x0C, 0xCE, 0x04, 0x64, 0x65, 0x66, 0x6E, 0xDA, 0x18, 0xDA, 0x82, 0x04, 0xCE, 0x01, + 0x28, 0xD8, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xDA, 0x82, 0x5A, 0xD8, 0x12, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0xCE, 0x02, 0x25, 0x6A, 0xD8, 0x0D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x6F, 0x72, + 0x6D, 0x61, 0x74, 0xCE, 0x03, 0x29, 0x0A, 0x0A, 0xDA, 0x81, 0x12, 0xDA, 0x80, 0xA8, 0xDA, 0x80, + 0xE0, 0xDA, 0x80, 0x9B, 0xDA, 0x52, 0x00, 0x36, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x36, 0x01, 0xDA, + 0x81, 0xBF, 0x00, 0x36, 0x02, 0xDA, 0x82, 0xFB, 0x01, 0x36, 0x04, 0xDA, 0x81, 0x25, 0x03, 0x36, + 0x06, 0xCF, 0x09, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x04, 0x36, 0x07, 0xCF, + 0x06, 0x64, 0x6F, 0x63, 0x73, 0x74, 0x72, 0x06, 0x36, 0x09, 0xCF, 0x06, 0x66, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x0A, 0x36, 0x0B, 0xDA, 0x82, 0x5F, 0x0C, 0x36, 0x0D, 0xDA, 0x80, 0xE8, 0x0D, 0x36, + 0x0E, 0xCF, 0x05, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x0F, 0x36, 0x10, 0xCF, 0x06, 0x61, 0x72, 0x67, + 0x6C, 0x65, 0x6E, 0x14, 0x36, 0x12, 0xDA, 0x82, 0x26, 0x3F, 0x03, 0x01, 0x00, 0x1B, 0x04, 0x03, + 0x00, 0x40, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x30, 0x08, 0x00, + 0x00, 0x1B, 0x09, 0x08, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0A, 0x09, + 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3A, 0x0C, 0x01, 0x0B, 0x1B, 0x0D, 0x0C, 0x00, 0x2B, 0x0E, 0x00, + 0x00, 0x3F, 0x0F, 0x0D, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x2C, 0x11, 0x01, 0x00, 0x32, 0x11, 0x00, + 0x00, 0x2C, 0x12, 0x02, 0x00, 0x35, 0x11, 0x12, 0x00, 0x1B, 0x12, 0x11, 0x00, 0x23, 0x13, 0x0E, + 0x10, 0x1E, 0x13, 0x0C, 0x00, 0x2C, 0x14, 0x03, 0x00, 0x32, 0x12, 0x14, 0x00, 0x2C, 0x15, 0x04, + 0x00, 0x35, 0x14, 0x15, 0x00, 0x3A, 0x14, 0x0D, 0x0E, 0x2C, 0x15, 0x05, 0x00, 0x33, 0x12, 0x15, + 0x14, 0x2C, 0x16, 0x06, 0x00, 0x35, 0x15, 0x16, 0x00, 0x05, 0x0E, 0x0E, 0x01, 0x1C, 0xF4, 0xFF, + 0xFF, 0x2C, 0x13, 0x07, 0x00, 0x33, 0x12, 0x13, 0x07, 0x2C, 0x14, 0x08, 0x00, 0x35, 0x13, 0x14, + 0x00, 0x32, 0x06, 0x13, 0x00, 0x2C, 0x15, 0x09, 0x00, 0x35, 0x14, 0x15, 0x00, 0x32, 0x01, 0x0B, + 0x00, 0x2C, 0x15, 0x0A, 0x00, 0x35, 0x13, 0x15, 0x00, 0x2C, 0x16, 0x0B, 0x00, 0x32, 0x16, 0x00, + 0x00, 0x34, 0x13, 0x00, 0x00, 0x45, 0x15, 0x00, 0x00, 0x2C, 0x16, 0x0C, 0x00, 0x32, 0x16, 0x00, + 0x00, 0x34, 0x06, 0x00, 0x00, 0x31, 0x15, 0x00, 0x00, 0x45, 0x13, 0x00, 0x00, 0x03, 0x13, 0x00, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x01, 0x01, 0x04, 0x1C, 0x01, 0x0A, 0xDA, 0x80, + 0xD8, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xD0, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0xDA, 0x80, 0xA8, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x81, 0xBE, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, + 0xBF, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x82, 0xFB, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x81, 0x25, 0xBF, + 0xFF, 0x00, 0x06, 0xDA, 0x83, 0x06, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x83, 0x07, 0x00, 0x1C, 0x00, + 0xDA, 0x80, 0xC3, 0x00, 0x1C, 0x01, 0xDA, 0x80, 0xCE, 0x03, 0x1C, 0x03, 0xCF, 0x03, 0x69, 0x74, + 0x68, 0x07, 0x1C, 0x04, 0xDA, 0x80, 0xDB, 0x2E, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x01, 0x3A, + 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, + 0x02, 0x04, 0x00, 0x1B, 0x04, 0x02, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x25, 0x05, 0x04, 0x06, 0x1E, + 0x05, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x25, 0x06, 0x04, 0x07, 0x1E, + 0x06, 0x03, 0x00, 0x2F, 0x03, 0x00, 0x07, 0x1C, 0x05, 0x00, 0x00, 0x2D, 0x07, 0x00, 0x06, 0x32, + 0x07, 0x03, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2D, 0x07, 0x00, 0x04, 0x23, + 0x06, 0x00, 0x07, 0x1E, 0x06, 0x04, 0x00, 0x05, 0x07, 0x00, 0x01, 0x31, 0x07, 0x00, 0x00, 0x36, + 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x15, 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x00, + 0x09, 0x03, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x01, 0x0F, 0xBF, 0xFF, 0x0D, 0x02, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x00, 0x22, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x0D, 0x11, 0x0E, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, 0x02, 0x07, 0xBF, 0xFF, + 0x05, 0x0B, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x05, 0x02, 0x05, 0x01, + 0x11, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x0C, 0x00, + 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x1F, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x01, 0x12, 0xBF, 0xFD, 0x05, 0x04, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xD2, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x57, 0x28, 0x64, 0x65, 0x66, 0x6E, 0x20, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x69, + 0x6E, 0x65, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x45, + 0x71, 0x75, 0x69, 0x76, 0x61, 0x6C, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x64, + 0x65, 0x66, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x28, 0x66, 0x6E, 0x20, 0x6E, 0x61, 0x6D, 0x65, + 0x20, 0x5B, 0x61, 0x72, 0x67, 0x73, 0x5D, 0x20, 0x2E, 0x2E, 0x2E, 0x29, 0x29, 0x60, 0x2E, 0xDA, + 0x37, 0xCB, 0xCF, 0x08, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x69, 0x7A, 0x65, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x81, 0xCD, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x66, 0x66, 0x69, 0x2F, + 0x73, 0x69, 0x7A, 0x65, 0xDA, 0x08, 0xCE, 0x36, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x69, 0x7A, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x66, 0x66, 0x69, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2E, 0xCF, 0x0E, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x1E, 0x01, 0xDA, 0x06, 0xD8, 0x0E, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xDA, 0x08, 0xCE, + 0x4D, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x20, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x2E, 0xCF, 0x06, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, + 0x25, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, 0x03, 0x03, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x08, 0x00, 0x06, 0xCE, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0xDA, + 0x18, 0x00, 0x08, 0x00, 0xDA, 0x24, 0x00, 0x08, 0x01, 0xDA, 0x80, 0xDE, 0x00, 0x08, 0x02, 0xCF, + 0x04, 0x66, 0x75, 0x6E, 0x63, 0x00, 0x08, 0x03, 0xDA, 0x80, 0xE8, 0x00, 0x08, 0x04, 0xDA, 0x83, + 0x18, 0x01, 0x08, 0x06, 0xDA, 0x82, 0x41, 0x3B, 0x05, 0x00, 0x01, 0x1B, 0x06, 0x05, 0x00, 0x31, + 0x06, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x35, 0x07, 0x02, 0x00, 0x1B, 0x08, 0x00, 0x00, 0x3C, + 0x08, 0x01, 0x07, 0x03, 0x08, 0x00, 0x00, 0x86, 0x2A, 0x0C, 0x00, 0x03, 0x01, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xF1, 0x28, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x46, 0x6F, 0x72, 0x20, 0x61, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x6E, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, + 0x2C, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x69, 0x74, 0x73, 0x20, 0x63, 0x6F, + 0x72, 0x72, 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x72, 0x65, 0x73, 0x75, 0x6C, + 0x74, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x66, 0x75, + 0x6E, 0x63, 0x60, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x61, 0x72, 0x67, 0x73, 0x60, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x0A, 0x61, + 0x6C, 0x6F, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x66, 0x75, 0x6E, 0x63, 0x60, 0x20, 0x61, + 0x73, 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x60, 0x64, 0x73, 0x60, 0x2C, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2E, 0xCF, 0x0A, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0x6D, 0x31, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x57, 0x81, 0x18, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x65, 0x78, 0x70, 0x6D, 0x31, 0xDA, 0x08, 0xCE, 0x34, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, + 0x78, 0x70, 0x6D, 0x31, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6F, 0x77, 0x65, 0x72, 0x20, + 0x6F, 0x66, 0x20, 0x78, 0x20, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0x20, 0x31, 0x2E, 0xCF, 0x12, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x75, 0x70, 0x70, 0x65, + 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x0D, 0x01, 0xDA, 0x06, + 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x75, + 0x70, 0x70, 0x65, 0x72, 0xDA, 0x08, 0xCE, 0x80, 0xBE, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x75, 0x70, 0x70, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, + 0x61, 0x63, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, + 0x70, 0x65, 0x72, 0x63, 0x61, 0x73, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6D, 0x73, 0x65, 0x6C, 0x76, 0x65, 0x73, 0x20, 0x69, 0x6E, + 0x20, 0x41, 0x53, 0x43, 0x49, 0x49, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, 0x6F, 0x6E, 0x6C, + 0x79, 0x20, 0x61, 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x20, + 0x63, 0x61, 0x73, 0x65, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2C, 0x20, 0x6D, 0x65, 0x61, 0x6E, + 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x6F, 0x20, 0x75, 0x6E, 0x69, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6F, 0x72, 0x74, 0x2E, 0xCF, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x74, + 0x6F, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0x62, 0x81, 0x80, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xCA, 0xDA, 0x08, 0xCE, 0x80, 0x84, 0x28, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x74, 0x6F, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, + 0x74, 0x61, 0x62, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x61, 0x20, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x74, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x75, 0x6E, + 0x74, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x73, 0x2E, 0xCF, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x62, 0x79, 0x74, 0x65, + 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xDE, 0x01, 0xDA, 0x06, + 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x62, 0x79, 0x74, 0x65, 0x73, 0xDA, 0x08, + 0xCE, 0x57, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, + 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2E, 0xCF, 0x07, 0x65, 0x76, 0x2F, 0x67, 0x69, + 0x76, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x83, 0xD1, 0x01, 0xDA, 0x06, + 0xD8, 0x07, 0x65, 0x76, 0x2F, 0x67, 0x69, 0x76, 0x65, 0xDA, 0x08, 0xCE, 0x80, 0xA4, 0x28, 0x65, + 0x76, 0x2F, 0x67, 0x69, 0x76, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x57, 0x72, 0x69, 0x74, 0x65, 0x20, 0x61, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, + 0x6C, 0x2C, 0x20, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, + 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x69, + 0x73, 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, + 0x65, 0x64, 0x2C, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, + 0x65, 0x2E, 0xCF, 0x0C, 0x2A, 0x65, 0x78, 0x69, 0x74, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2A, + 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD8, 0x01, + 0xDA, 0x06, 0xD0, 0x0A, 0x65, 0x78, 0x69, 0x74, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xDA, 0x08, + 0xCE, 0x60, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x60, 0x72, 0x75, 0x6E, + 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x60, 0x20, 0x75, 0x70, 0x6F, 0x6E, 0x20, 0x61, + 0x6E, 0x20, 0x65, 0x78, 0x69, 0x74, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6C, 0x74, 0x2C, 0x20, 0x60, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, + 0x60, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, + 0x6C, 0x2E, 0xCF, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, + 0x75, 0x69, 0x6E, 0x74, 0x36, 0x34, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, + 0x81, 0x99, 0x01, 0xDA, 0x06, 0xD8, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, + 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x36, 0x34, 0xDA, 0x08, 0xCE, 0x80, 0x84, 0x28, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x75, 0x69, 0x6E, 0x74, 0x36, + 0x34, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x61, 0x20, 0x36, 0x34, 0x20, + 0x62, 0x69, 0x74, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6F, 0x6E, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2E, 0xCF, 0x0C, 0x2A, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x2A, + 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xDB, 0x01, + 0xDA, 0x06, 0xDA, 0x81, 0x06, 0xDA, 0x08, 0xCE, 0x42, 0x49, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, + 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2C, 0x20, 0x69, 0x73, 0x20, 0x62, 0x6F, 0x75, 0x6E, + 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x6E, 0x76, 0x6F, 0x6B, 0x65, + 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xCF, 0x04, 0x2D, 0x3F, 0x3E, + 0x3E, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x3B, 0x01, 0xDA, 0x06, 0xD7, + 0x00, 0xCD, 0x00, 0xFD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x05, + 0x00, 0x01, 0x04, 0xCE, 0x04, 0x2D, 0x3F, 0x3E, 0x3E, 0xDA, 0x18, 0xDA, 0x81, 0x92, 0x00, 0x05, + 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, 0xDA, 0x81, 0x9A, 0x00, 0x05, 0x02, 0xDA, 0x83, 0x45, 0x01, + 0x05, 0x04, 0xDA, 0x81, 0x9B, 0x30, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x33, 0x04, 0x00, + 0x01, 0x2C, 0x05, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x02, + 0x02, 0x02, 0x09, 0x31, 0x00, 0x07, 0xDA, 0x81, 0x9C, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, + 0xDA, 0x81, 0x9D, 0xDA, 0x80, 0xE7, 0xDA, 0x51, 0xDA, 0x80, 0xE3, 0xDA, 0x81, 0x08, 0xDA, 0x57, + 0xDA, 0x81, 0x73, 0x00, 0x31, 0x00, 0xDA, 0x80, 0xE4, 0x00, 0x31, 0x01, 0xDA, 0x81, 0x9E, 0x00, + 0x31, 0x02, 0xDA, 0x81, 0x9B, 0x17, 0x31, 0x05, 0xDA, 0x81, 0x0B, 0x19, 0x31, 0x06, 0xDA, 0x80, + 0xDB, 0x1C, 0x31, 0x07, 0xDA, 0x69, 0x24, 0x31, 0x08, 0xDA, 0x81, 0x9F, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x25, 0x05, 0x06, 0x04, + 0x1E, 0x05, 0x0C, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3A, 0x04, 0x01, 0x06, 0x2B, 0x06, 0x01, 0x00, + 0x32, 0x01, 0x06, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x32, 0x04, 0x06, 0x00, + 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x03, 0x07, 0x00, 0x1C, 0x06, 0x00, 0x00, + 0x40, 0x04, 0x00, 0x00, 0x32, 0x01, 0x04, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1B, 0x03, 0x06, 0x00, 0x3D, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3D, 0x04, 0x03, 0x01, + 0x1B, 0x06, 0x04, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x04, 0x07, 0x00, 0x1B, 0x07, 0x04, 0x00, + 0x31, 0x05, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x40, 0x09, 0x00, 0x00, + 0x33, 0x08, 0x06, 0x09, 0x2C, 0x0B, 0x05, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x08, 0x0A, 0x00, + 0x32, 0x07, 0x00, 0x00, 0x46, 0x09, 0x00, 0x00, 0x32, 0x01, 0x08, 0x00, 0x2C, 0x0C, 0x06, 0x00, + 0x35, 0x0B, 0x0C, 0x00, 0x2C, 0x0D, 0x07, 0x00, 0x33, 0x0D, 0x07, 0x0B, 0x45, 0x0C, 0x00, 0x00, + 0x2C, 0x0D, 0x08, 0x00, 0x33, 0x0D, 0x09, 0x0C, 0x45, 0x0B, 0x00, 0x00, 0x03, 0x0B, 0x00, 0x00, + 0x85, 0x43, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, 0x01, 0x19, 0x00, + 0x19, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, + 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFE, 0x10, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x00, + 0x05, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x85, 0x42, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, 0x00, 0x03, + 0xDA, 0x08, 0xCE, 0x81, 0x29, 0x28, 0x2D, 0x3F, 0x3E, 0x3E, 0x20, 0x78, 0x20, 0x26, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x20, 0x63, 0x69, 0x72, + 0x63, 0x75, 0x69, 0x74, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6D, + 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x73, 0x20, 0x78, 0x20, + 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x60, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x6F, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6D, 0x65, 0x20, 0x6D, 0x61, 0x6E, 0x6E, 0x65, 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x73, 0x6F, 0x20, 0x6F, 0x6E, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x69, 0x70, 0x65, + 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x6E, 0x69, 0x6C, 0x0A, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x6D, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x0A, 0x55, 0x73, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x66, 0x6F, 0x72, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x69, 0x70, 0x65, + 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2E, 0xDA, 0x37, + 0xCB, 0xCF, 0x0A, 0x66, 0x66, 0x69, 0x2F, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0xAE, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x66, 0x66, 0x69, + 0x2F, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xDA, 0x08, 0xCE, 0x81, 0x1C, 0x28, 0x66, 0x66, 0x69, + 0x2F, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x70, 0x61, 0x74, + 0x68, 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x61, 0x64, 0x20, 0x61, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, + 0x64, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x64, 0x6C, 0x6C, 0x20, + 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x61, + 0x6E, 0x79, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x69, 0x74, 0x2E, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x60, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x60, + 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x75, 0x6E, + 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x63, 0x6F, 0x64, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x67, 0x65, 0x74, 0x20, 0x61, 0x20, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, + 0x70, 0x61, 0x74, 0x68, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x6F, 0x70, + 0x65, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x60, 0x63, 0x6F, 0x72, 0x65, 0x2F, + 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x60, 0x2E, 0xCF, 0x07, 0x62, 0x6C, 0x73, 0x68, 0x69, 0x66, + 0x74, 0xD3, 0x02, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x10, 0x06, 0x00, 0x00, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x07, 0x62, 0x6C, 0x73, 0x68, 0x69, 0x66, 0x74, 0x3F, + 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x03, + 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3D, + 0x04, 0x00, 0x00, 0x14, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, + 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x14, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, + 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, 0x91, + 0x28, 0x62, 0x6C, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x78, 0x20, 0x26, 0x20, 0x73, 0x68, 0x69, + 0x66, 0x74, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x20, 0x62, 0x69, 0x74, + 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x73, + 0x2E, 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x6D, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x2E, 0xCF, 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, + 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2E, 0x63, 0x83, 0x96, 0x01, 0xDA, 0x06, 0xD8, + 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, 0x65, 0xDA, + 0x08, 0xCE, 0x80, 0xD3, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, + 0x75, 0x6D, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, 0x0A, 0x0A, 0x49, 0x6E, + 0x70, 0x75, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6D, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, + 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, + 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x20, 0x60, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, 0x2E, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x66, 0x6C, + 0x6F, 0x6F, 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x1F, 0x01, + 0xDA, 0x06, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0xDA, 0x08, + 0xCE, 0x54, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, + 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x61, 0x6E, 0x20, 0x78, 0x2E, 0xCF, 0x0D, 0x2A, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0x6C, + 0x69, 0x6E, 0x74, 0x73, 0x2A, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x87, 0xF2, 0x01, 0xDA, 0x06, 0xD0, 0x0B, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0x6C, + 0x69, 0x6E, 0x74, 0x73, 0xDA, 0x08, 0xCE, 0x80, 0x9F, 0x42, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x6C, 0x69, + 0x6E, 0x74, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6F, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, + 0x72, 0x20, 0x69, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, + 0x2E, 0x0A, 0x54, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, + 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, + 0x67, 0x2C, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6F, + 0x72, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x75, 0x73, 0x65, 0x20, 0x60, 0x6D, 0x61, + 0x63, 0x6C, 0x69, 0x6E, 0x74, 0x66, 0x60, 0x2E, 0xCF, 0x07, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, + 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x2E, 0x63, 0x86, 0x66, 0x01, 0xDA, 0x06, 0xD8, + 0x07, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xDA, 0x08, 0xCE, 0x81, 0x7A, 0x28, 0x6D, 0x61, + 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x78, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x72, 0x65, 0x76, + 0x65, 0x72, 0x73, 0x65, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x6E, 0x6F, 0x2D, 0x63, 0x79, 0x63, 0x6C, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x4D, + 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, + 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x63, + 0x61, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x20, 0x62, 0x65, + 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x72, 0x65, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, + 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x2C, 0x20, 0x6F, 0x6E, 0x65, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, + 0x6C, 0x20, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, + 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x77, 0x61, 0x72, 0x64, 0x20, 0x6C, 0x6F, 0x6F, + 0x6B, 0x75, 0x70, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x63, 0x6F, 0x76, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, + 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x2E, 0xCF, 0x08, 0x70, 0x65, 0x67, 0x2F, 0x66, 0x69, 0x6E, + 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x70, 0x65, 0x67, 0x2E, 0x63, 0x87, 0x0E, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x70, + 0x65, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x08, 0xCE, 0x7F, 0x28, 0x70, 0x65, 0x67, 0x2F, + 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x65, 0x67, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, + 0x0A, 0x0A, 0x46, 0x69, 0x6E, 0x64, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x67, + 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x65, 0x78, 0x74, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xCF, 0x0A, 0x64, 0x72, 0x6F, 0x70, + 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, + 0x97, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x02, 0x02, 0x02, 0x0B, + 0x24, 0x00, 0x03, 0xCE, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xDA, + 0x18, 0xD8, 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x3F, 0xDA, 0x80, 0xE0, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x03, 0x03, 0x03, 0x02, 0x10, 0x00, 0x07, 0xCE, 0x10, 0x64, + 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, + 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x03, 0x02, 0x03, 0x00, 0x10, 0x00, 0x07, + 0xCE, 0x0A, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0xDA, 0x18, 0x00, 0x10, + 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x10, 0x01, 0xDA, 0x1F, 0x00, 0x10, 0x02, 0xDA, 0x20, 0x00, 0x10, + 0x03, 0xCF, 0x0A, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0x10, 0x04, + 0xDA, 0x22, 0x01, 0x10, 0x05, 0xDA, 0x23, 0x08, 0x0F, 0x07, 0xCF, 0x04, 0x69, 0x74, 0x65, 0x6D, + 0x28, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x02, 0x00, 0x49, 0x04, 0x01, 0x04, 0x28, 0x07, 0x00, 0x00, + 0x25, 0x06, 0x04, 0x07, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x3A, 0x06, 0x01, 0x04, + 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x06, 0x00, 0x00, 0x1E, 0x06, 0x03, 0x00, + 0x1B, 0x05, 0x04, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xF4, 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, + 0x84, 0x16, 0x03, 0x01, 0x03, 0x02, 0x0C, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x13, 0x01, + 0x0F, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x07, 0x01, 0x07, 0xBF, 0xFA, 0x03, + 0xBF, 0xFB, 0x01, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x00, 0x03, + 0x00, 0x02, 0xCE, 0x04, 0x6E, 0x69, 0x6C, 0x3F, 0xDA, 0x18, 0x00, 0x03, 0x00, 0xDA, 0x1E, 0x00, + 0x03, 0x01, 0xCF, 0x04, 0x6E, 0x69, 0x6C, 0x3F, 0x28, 0x03, 0x00, 0x00, 0x25, 0x02, 0x00, 0x03, + 0x03, 0x02, 0x00, 0x00, 0x74, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x10, 0x00, 0xDA, 0x80, 0xAA, + 0x00, 0x10, 0x01, 0xDA, 0x81, 0xD2, 0x00, 0x10, 0x02, 0xDA, 0x1F, 0x00, 0x10, 0x03, 0xCF, 0x10, + 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, + 0x01, 0x10, 0x05, 0xDA, 0x81, 0x25, 0x05, 0x10, 0x07, 0xDA, 0x80, 0xC3, 0x0D, 0x10, 0x09, 0xDA, + 0x82, 0x5F, 0x3F, 0x04, 0x02, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2C, 0x07, + 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0A, + 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x08, 0x05, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x32, 0x02, 0x09, 0x00, 0x36, 0x00, + 0x00, 0x00, 0x84, 0x8C, 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, + 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0xDA, 0x2B, 0xDA, 0x82, 0x03, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, + 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3F, + 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xC9, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, + 0x07, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, + 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, + 0x6D, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0xD8, 0x0F, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x2F, 0x74, 0x6F, 0x2D, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x03, 0x03, 0x03, 0x00, 0x13, 0x00, 0x09, 0xCE, 0x0F, 0x64, 0x72, + 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x2D, 0x64, 0x69, 0x63, 0x74, 0xDA, 0x18, 0x00, + 0x13, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x13, 0x01, 0xDA, 0x81, 0xD2, 0x00, 0x13, 0x02, 0xDA, 0x1F, + 0x00, 0x13, 0x03, 0xCF, 0x0F, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x2D, + 0x64, 0x69, 0x63, 0x74, 0x02, 0x13, 0x05, 0xDA, 0x80, 0xAD, 0x02, 0x12, 0x02, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x47, 0x05, 0x12, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x46, 0x08, 0x12, 0x08, 0xDA, 0x80, 0xC3, 0x09, 0x12, 0x09, 0xDA, 0x1E, 0x31, 0x02, 0x00, + 0x00, 0x35, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, 0x06, 0x02, + 0x07, 0x1B, 0x07, 0x06, 0x00, 0x1F, 0x07, 0x0C, 0x00, 0x3A, 0x06, 0x02, 0x07, 0x1B, 0x08, 0x07, + 0x00, 0x1B, 0x09, 0x06, 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x06, 0x01, 0x00, 0x1E, 0x06, 0x02, + 0x00, 0x1C, 0x05, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x3C, 0x05, 0x08, 0x06, 0x49, 0x07, 0x02, + 0x07, 0x1C, 0xF5, 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, 0x84, 0x93, 0x0C, 0x00, 0x0C, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x22, + 0x00, 0x22, 0x00, 0x03, 0x00, 0x03, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFD, + 0x01, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, + 0xCE, 0x06, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xCB, 0x00, + 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x06, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, + 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x6C, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x28, 0x00, + 0x28, 0x00, 0x28, 0xD8, 0x0B, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x03, 0x02, 0x03, 0x00, 0x10, 0x00, 0x07, 0xCE, + 0x04, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x18, 0x00, 0x10, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x10, 0x01, + 0xDA, 0x1F, 0x00, 0x10, 0x02, 0xDA, 0x20, 0x00, 0x10, 0x03, 0xCF, 0x04, 0x66, 0x69, 0x6E, 0x64, + 0x00, 0x10, 0x04, 0xDA, 0x22, 0x01, 0x10, 0x05, 0xDA, 0x23, 0x08, 0x0F, 0x07, 0xDA, 0x83, 0x7C, + 0x28, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x02, 0x00, 0x49, 0x04, 0x01, 0x04, 0x28, 0x07, 0x00, 0x00, + 0x25, 0x06, 0x04, 0x07, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x3A, 0x06, 0x01, 0x04, + 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x06, 0x00, 0x00, 0x1E, 0x06, 0x03, 0x00, + 0x1B, 0x05, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xF4, 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, + 0x84, 0x25, 0x03, 0x01, 0x03, 0x02, 0x0C, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x13, 0x01, + 0x0F, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x07, 0x01, 0x07, 0xBF, 0xFA, 0x03, + 0xBF, 0xFA, 0x01, 0x00, 0x24, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x24, 0x01, 0xDA, 0x1F, 0x00, 0x24, + 0x02, 0xDA, 0x83, 0x71, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, + 0x1E, 0x03, 0x05, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, 0x04, 0x00, 0x01, 0x2C, 0x04, 0x02, 0x00, + 0x36, 0x04, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x35, 0x04, 0x05, 0x00, + 0x1E, 0x04, 0x05, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x33, 0x05, 0x00, 0x01, 0x2C, 0x05, 0x02, 0x00, + 0x36, 0x05, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x35, 0x05, 0x06, 0x00, + 0x1E, 0x05, 0x05, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x33, 0x06, 0x00, 0x01, 0x2C, 0x06, 0x07, 0x00, + 0x36, 0x06, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x07, 0x08, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1E, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x33, 0x07, 0x00, 0x01, 0x2C, 0x07, 0x07, 0x00, + 0x36, 0x07, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x35, 0x07, 0x08, 0x00, + 0x03, 0x01, 0x00, 0x00, 0x84, 0x9B, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x01, 0x14, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x02, + 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFD, 0x03, + 0x03, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFC, + 0x03, 0x04, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x05, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, + 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, + 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, + 0x20, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, + 0x64, 0x29, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x60, 0x2E, 0xCF, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, + 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x63, + 0x82, 0x54, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x6F, 0xDA, 0x08, 0xCE, 0x82, 0x06, 0x28, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x66, 0x69, 0x62, 0x29, 0x0A, + 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x6F, + 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, 0x65, 0x61, 0x64, 0x20, + 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, + 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, 0x64, 0x0A, 0x2A, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x68, 0x61, + 0x73, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x65, 0x64, 0x20, 0x6F, 0x75, 0x74, 0x0A, 0x2A, 0x20, + 0x3A, 0x64, 0x65, 0x62, 0x75, 0x67, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, + 0x69, 0x6E, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x0A, 0x2A, 0x20, + 0x3A, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6E, 0x20, 0x79, 0x69, + 0x65, 0x6C, 0x64, 0x65, 0x64, 0x0A, 0x2A, 0x20, 0x3A, 0x75, 0x73, 0x65, 0x72, 0x28, 0x30, 0x2D, + 0x37, 0x29, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, + 0x73, 0x20, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x0A, 0x2A, 0x20, 0x3A, + 0x69, 0x6E, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x72, 0x72, 0x75, 0x70, 0x74, 0x65, 0x64, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x75, 0x73, 0x70, 0x65, + 0x6E, 0x64, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x20, 0x69, 0x73, 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x62, + 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, 0x72, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x6C, + 0x69, 0x76, 0x65, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, + 0x69, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, 0x72, 0x75, 0x6E, + 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x64, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x65, + 0x77, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x68, 0x61, + 0x73, 0x20, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x65, 0x6E, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, + 0x72, 0x75, 0x6E, 0xCF, 0x0A, 0x66, 0x66, 0x69, 0x2F, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0xD9, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x66, + 0x66, 0x69, 0x2F, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0xDA, 0x08, 0xCE, 0x80, 0xAE, 0x28, 0x66, + 0x66, 0x69, 0x2F, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x29, 0x0A, + 0x0A, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, + 0x79, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, + 0x79, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x6F, 0x72, 0x2E, 0x20, 0x4D, 0x65, 0x6D, + 0x6F, 0x72, 0x79, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x77, 0x61, 0x79, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x66, 0x72, 0x65, 0x65, 0x64, 0x20, 0x6D, 0x61, 0x6E, 0x75, 0x61, 0x6C, 0x6C, 0x79, + 0x21, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x77, 0x20, + 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, + 0x69, 0x66, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x3D, 0x20, 0x30, 0x2E, 0xCF, 0x05, 0x70, 0x72, + 0x69, 0x6E, 0x66, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x81, 0x01, + 0xDA, 0x06, 0xD8, 0x05, 0x70, 0x72, 0x69, 0x6E, 0x66, 0xDA, 0x08, 0xCE, 0x3D, 0x28, 0x70, 0x72, + 0x69, 0x6E, 0x66, 0x20, 0x66, 0x6D, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x4C, + 0x69, 0x6B, 0x65, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x60, 0x20, 0x62, 0x75, 0x74, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x6F, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, + 0x67, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x2E, 0xDA, 0x80, 0xCD, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0x04, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0x93, 0xDA, 0x08, + 0xCE, 0x80, 0x85, 0x28, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, 0x20, 0x78, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x6F, 0x6E, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x29, 0x0A, 0x0A, 0x45, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x20, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x2E, 0x0A, 0x53, 0x65, + 0x65, 0x20, 0x60, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x60, 0x20, 0x64, 0x6F, 0x63, 0x73, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x20, 0x6F, 0x6E, 0x20, 0x60, 0x6F, 0x6E, 0x2D, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x60, 0x2E, 0xCF, 0x02, 0x6F, 0x72, 0xD3, 0x04, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x19, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x0F, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x06, 0x27, 0x00, 0x07, 0xCE, 0x02, 0x6F, + 0x72, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x03, 0x08, + 0x00, 0x02, 0xCE, 0x0B, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, 0x65, 0x6E, 0x74, 0x3F, 0xDA, + 0x18, 0xDA, 0x65, 0xD5, 0x06, 0xDA, 0x81, 0x11, 0xCB, 0xDA, 0x66, 0xCB, 0xDA, 0x80, 0xC9, 0xCB, + 0xDA, 0x80, 0x97, 0xCB, 0xDA, 0x80, 0xCB, 0xCB, 0xDA, 0x80, 0xA3, 0xCB, 0xDA, 0x82, 0x30, 0x00, + 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xCF, 0x0B, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, + 0x65, 0x6E, 0x74, 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x2C, 0x04, 0x01, 0x00, 0x3A, 0x03, 0x04, 0x02, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x02, 0x02, 0x00, + 0x36, 0x02, 0x00, 0x00, 0x80, 0x85, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x08, 0x00, 0x08, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x57, 0xDA, 0x80, 0xE7, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x58, + 0x00, 0x27, 0x00, 0xDA, 0x81, 0x9A, 0x00, 0x27, 0x01, 0xDA, 0x83, 0xA4, 0x01, 0x27, 0x03, 0xDA, + 0x81, 0x25, 0x03, 0x27, 0x05, 0xDA, 0x80, 0xC3, 0x05, 0x27, 0x07, 0xDA, 0x23, 0x0A, 0x26, 0x0A, + 0xCF, 0x02, 0x66, 0x69, 0x17, 0x25, 0x0C, 0xCF, 0x03, 0x24, 0x66, 0x69, 0x3F, 0x02, 0x00, 0x00, + 0x1B, 0x03, 0x02, 0x00, 0x07, 0x04, 0x03, 0x01, 0x1B, 0x05, 0x04, 0x00, 0x3B, 0x06, 0x00, 0x05, + 0x1B, 0x07, 0x06, 0x00, 0x22, 0x08, 0x05, 0x00, 0x1E, 0x08, 0x1F, 0x00, 0x07, 0x05, 0x05, 0x01, + 0x3A, 0x09, 0x00, 0x05, 0x1B, 0x0A, 0x09, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, + 0x35, 0x09, 0x0B, 0x00, 0x1E, 0x09, 0x07, 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x33, 0x0B, 0x0A, 0x0A, + 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x35, 0x07, 0x0B, 0x00, 0x1C, 0x11, 0x00, 0x00, + 0x2C, 0x0C, 0x03, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x2C, 0x0B, 0x04, 0x00, + 0x33, 0x0B, 0x0C, 0x0A, 0x2C, 0x0D, 0x02, 0x00, 0x35, 0x0B, 0x0D, 0x00, 0x2C, 0x0D, 0x01, 0x00, + 0x33, 0x0D, 0x0C, 0x0C, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0E, 0x02, 0x00, 0x35, 0x0D, 0x0E, 0x00, + 0x2C, 0x0E, 0x05, 0x00, 0x33, 0x0E, 0x0B, 0x0D, 0x2C, 0x0E, 0x02, 0x00, 0x35, 0x07, 0x0E, 0x00, + 0x1C, 0xE1, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x81, 0x1D, 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x00, + 0x03, 0x01, 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, 0x05, 0x01, 0x0D, 0x00, 0x05, 0x01, + 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0E, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0xBF, 0xFF, 0x0E, 0x03, 0x1B, 0x00, 0x1B, 0x00, 0x12, 0x01, 0x1D, 0x00, 0x1D, 0x00, 0x1D, + 0x00, 0x1D, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0xBF, 0xFF, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xF9, 0x03, 0xBF, 0xF9, 0x01, 0xDA, 0x08, 0xCE, 0x80, 0x83, + 0x28, 0x6F, 0x72, 0x20, 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x76, + 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x73, 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x66, 0x20, + 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, + 0x79, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x0A, 0x65, 0x76, 0x61, + 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, + 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x14, 0x01, 0xDA, 0x06, + 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0x68, 0xDA, 0x08, 0xCE, 0x33, 0x28, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x79, 0x70, 0x65, 0x72, 0x62, + 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x74, 0x61, 0x6E, 0x67, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x2E, 0xCF, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x3A, 0x01, 0xDA, 0x06, 0xD8, 0x0B, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x08, 0xCE, 0x80, 0xBF, + 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x74, + 0x74, 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, + 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6E, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, + 0x63, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x69, + 0x66, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, + 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, + 0x05, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, + 0x82, 0x11, 0x01, 0xDA, 0x06, 0xD8, 0x05, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xDA, 0x08, 0xCE, 0x81, + 0x49, 0x28, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, + 0x72, 0x69, 0x6E, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x6F, 0x6C, 0x65, 0x20, 0x28, 0x73, 0x74, 0x61, 0x6E, + 0x64, 0x61, 0x72, 0x64, 0x20, 0x6F, 0x75, 0x74, 0x29, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, + 0x79, 0x2E, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2C, 0x20, 0x61, 0x20, + 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, + 0x72, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x65, 0x64, 0x2E, 0x20, 0x55, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x60, + 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x6F, 0x75, 0x74, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, + 0x29, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x65, 0x20, + 0x77, 0x68, 0x61, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x63, 0x68, 0x61, + 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6F, 0x2E, 0x20, 0x45, 0x78, 0x70, 0x65, + 0x63, 0x74, 0x73, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x6F, 0x75, 0x74, 0x20, 0x73, + 0x74, 0x64, 0x6F, 0x75, 0x74, 0x29, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x65, 0x69, + 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x66, 0x69, 0x6C, 0x65, + 0x20, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x13, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x33, 0x32, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0xAB, 0x01, 0xDA, 0x06, 0xD8, 0x13, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, + 0x74, 0x33, 0x32, 0xDA, 0x08, 0xCE, 0x80, 0x92, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x70, 0x75, 0x73, 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x33, 0x32, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x29, 0x0A, + 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6E, 0x64, 0x65, 0x72, 0x6C, + 0x79, 0x69, 0x6E, 0x67, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, + 0x33, 0x32, 0x20, 0x62, 0x69, 0x74, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x6F, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x04, 0x64, 0x72, 0x6F, 0x70, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0x7B, 0x01, 0xDA, 0x06, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0C, 0x02, 0x02, 0x02, 0x0A, 0x2C, 0x00, 0x05, 0xCE, 0x04, 0x64, + 0x72, 0x6F, 0x70, 0xDA, 0x18, 0xDA, 0x83, 0x76, 0xDA, 0x80, 0xE0, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x0A, 0x03, 0x03, 0x03, 0x00, 0x14, 0x00, 0x05, 0xCE, 0x0C, 0x64, 0x72, 0x6F, 0x70, + 0x2D, 0x6E, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x18, 0x00, 0x14, 0x00, 0xDA, 0x80, 0xAA, + 0x00, 0x14, 0x01, 0xDA, 0x81, 0x9E, 0x00, 0x14, 0x02, 0xDA, 0x1F, 0x00, 0x14, 0x03, 0xCF, 0x0C, + 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x6E, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x01, 0x14, 0x05, 0xDA, + 0x81, 0x25, 0x3F, 0x04, 0x02, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x48, 0x06, + 0x07, 0x01, 0x1E, 0x06, 0x02, 0x00, 0x48, 0x06, 0x01, 0x05, 0x1E, 0x06, 0x03, 0x00, 0x32, 0x02, + 0x01, 0x00, 0x36, 0x00, 0x00, 0x00, 0x09, 0x07, 0x05, 0xFF, 0x23, 0x08, 0x07, 0x01, 0x1E, 0x08, + 0x02, 0x00, 0x24, 0x08, 0x01, 0x00, 0x1E, 0x08, 0x05, 0x00, 0x06, 0x07, 0x05, 0x01, 0x2B, 0x09, + 0x00, 0x00, 0x33, 0x02, 0x09, 0x07, 0x36, 0x00, 0x00, 0x00, 0x32, 0x02, 0x05, 0x00, 0x36, 0x00, + 0x00, 0x00, 0x84, 0x6E, 0x0C, 0x00, 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, + 0xFF, 0x03, 0x01, 0x12, 0x00, 0x12, 0x01, 0x08, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, + 0x03, 0x02, 0x1E, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x01, 0x05, 0x00, 0x05, 0xDA, 0x2B, 0xDA, + 0x82, 0x03, 0xDA, 0x83, 0x81, 0xDA, 0x83, 0x84, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, + 0x03, 0x03, 0x03, 0x00, 0x13, 0x00, 0x0A, 0xCE, 0x0B, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x6E, 0x2D, + 0x64, 0x69, 0x63, 0x74, 0xDA, 0x18, 0x00, 0x13, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x13, 0x01, 0xDA, + 0x81, 0x9E, 0x00, 0x13, 0x02, 0xDA, 0x1F, 0x00, 0x13, 0x03, 0xCF, 0x0B, 0x64, 0x72, 0x6F, 0x70, + 0x2D, 0x6E, 0x2D, 0x64, 0x69, 0x63, 0x74, 0x02, 0x13, 0x05, 0xDA, 0x80, 0xAD, 0x03, 0x13, 0x06, + 0xCF, 0x04, 0x6C, 0x65, 0x66, 0x74, 0x03, 0x12, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x44, 0x06, 0x12, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x09, 0x12, + 0x09, 0xDA, 0x80, 0xC3, 0x0A, 0x12, 0x0A, 0xDA, 0x1E, 0x31, 0x02, 0x00, 0x00, 0x35, 0x04, 0x00, + 0x00, 0x1B, 0x05, 0x04, 0x00, 0x1B, 0x06, 0x01, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x07, 0x02, + 0x08, 0x1B, 0x08, 0x07, 0x00, 0x1F, 0x08, 0x0B, 0x00, 0x3A, 0x07, 0x02, 0x08, 0x1B, 0x09, 0x08, + 0x00, 0x07, 0x06, 0x06, 0x01, 0x24, 0x07, 0x06, 0x00, 0x1E, 0x07, 0x02, 0x00, 0x1C, 0x05, 0x00, + 0x00, 0x28, 0x07, 0x00, 0x00, 0x3C, 0x05, 0x09, 0x07, 0x49, 0x08, 0x02, 0x08, 0x1C, 0xF6, 0xFF, + 0xFF, 0x03, 0x05, 0x00, 0x00, 0x84, 0x76, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, 0x03, 0x01, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x25, 0x00, 0x22, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x33, 0x00, 0x33, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xDA, 0x83, 0x8A, + 0xDA, 0x83, 0x8D, 0x00, 0x2C, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x2C, 0x01, 0xDA, 0x1F, 0x00, 0x2C, + 0x02, 0xDA, 0x83, 0xC4, 0x20, 0x2C, 0x07, 0xDA, 0x80, 0xDE, 0x21, 0x2B, 0x08, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, + 0x04, 0x00, 0x1E, 0x03, 0x05, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, 0x04, 0x00, 0x01, 0x2C, 0x04, + 0x02, 0x00, 0x36, 0x04, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x35, 0x04, + 0x05, 0x00, 0x1E, 0x04, 0x05, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x33, 0x05, 0x00, 0x01, 0x2C, 0x05, + 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x35, 0x05, + 0x06, 0x00, 0x1E, 0x05, 0x05, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x33, 0x06, 0x00, 0x01, 0x2C, 0x06, + 0x07, 0x00, 0x36, 0x06, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x07, 0x08, 0x00, 0x35, 0x06, + 0x07, 0x00, 0x1E, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x33, 0x07, 0x00, 0x01, 0x2C, 0x07, + 0x07, 0x00, 0x36, 0x07, 0x00, 0x00, 0x28, 0x07, 0x00, 0x00, 0x1B, 0x08, 0x00, 0x00, 0x22, 0x09, + 0x08, 0x00, 0x1E, 0x09, 0x08, 0x00, 0x49, 0x07, 0x01, 0x07, 0x28, 0x0B, 0x00, 0x00, 0x25, 0x0A, + 0x0B, 0x07, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x07, 0x08, 0x08, 0x01, 0x1C, 0xF8, + 0xFF, 0xFF, 0x03, 0x01, 0x00, 0x00, 0x84, 0x80, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, + 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, + 0x03, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, + 0xFD, 0x03, 0x03, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xBF, 0xFC, 0x03, 0x04, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x02, 0x07, 0x01, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x01, 0x1D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x00, 0x2E, 0xBF, 0xFF, 0x07, + 0x00, 0x07, 0xBF, 0xFE, 0x05, 0xDA, 0x08, 0xCE, 0x80, 0xB5, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x20, + 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x44, 0x72, 0x6F, 0x70, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, + 0x64, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, + 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x20, 0x64, 0x72, 0x6F, 0x70, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2E, 0xCF, + 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x6F, 0x66, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0x57, 0x83, 0xB1, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x65, 0x6F, 0x66, 0xDA, 0x08, 0xCE, 0x76, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x72, 0x2F, 0x65, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x49, + 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x72, + 0x65, 0x61, 0x63, 0x68, 0x65, 0x64, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x75, 0x74, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x3A, 0x64, 0x65, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2E, + 0xCF, 0x06, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x66, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0xC3, 0x82, 0x9A, 0x01, 0xDA, 0x06, 0xD8, 0x06, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x66, 0xDA, + 0x08, 0xCE, 0x5D, 0x28, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x66, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x6D, + 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x70, + 0x72, 0x69, 0x6E, 0x66, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x73, + 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x60, 0x74, + 0x6F, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6E, 0x65, 0x78, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x34, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x6E, 0x65, 0x78, 0x74, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6E, + 0x65, 0x78, 0x74, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, + 0x73, 0x65, 0x6E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x20, 0x78, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x79, 0x2E, 0xCF, 0x0C, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0x57, 0x84, 0x40, 0x01, 0xDA, 0x06, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0xDA, 0x08, 0xCE, 0x81, 0x2B, 0x28, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x27, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x72, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6C, + 0x69, 0x6E, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x69, 0x6E, + 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x73, 0x65, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, + 0x6E, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xCF, 0x0D, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x94, + 0x82, 0x5D, 0x01, 0xDA, 0x06, 0xD8, 0x0D, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6E, 0x74, 0xDA, 0x08, 0xCE, 0x35, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, 0x72, + 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0xCF, 0x05, 0x64, + 0x65, 0x65, 0x70, 0x3D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0x9A, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x02, 0x06, 0x00, + 0x03, 0xCE, 0x05, 0x64, 0x65, 0x65, 0x70, 0x3D, 0xDA, 0x18, 0xDA, 0x81, 0x0F, 0xDA, 0x82, 0x30, + 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x80, 0xD9, 0x00, 0x06, 0x02, 0xDA, 0x83, + 0xED, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x31, 0x03, 0x00, + 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x88, 0x9E, 0x08, 0x00, 0x08, 0x00, 0x08, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0x8F, 0x28, 0x64, 0x65, 0x65, 0x70, + 0x3D, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x3D, 0x60, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2C, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x29, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x0A, 0x65, 0x71, 0x75, + 0x61, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x2E, 0x20, 0x4D, 0x75, 0x63, 0x68, 0x20, 0x73, 0x6C, 0x6F, 0x77, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x60, 0x3D, 0x60, 0x2E, 0xCF, 0x0E, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x69, 0x6E, 0x74, 0x33, 0x32, 0x2D, 0x6D, 0x61, 0x78, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x57, 0x81, 0x9E, 0x01, 0xDA, 0x06, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0xDA, 0x08, + 0xCE, 0x47, 0x54, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x63, 0x6F, + 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x62, + 0x79, 0x20, 0x61, 0x20, 0x33, 0x32, 0x20, 0x62, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0xCF, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2F, 0x70, 0x6F, 0x70, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, 0x73, 0x72, 0x63, + 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x63, 0x80, 0xB9, 0x01, + 0xDA, 0x06, 0xD8, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x6F, 0x70, 0xDA, 0x08, 0xCE, + 0x80, 0x86, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x6F, 0x70, 0x20, 0x61, 0x72, 0x72, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, + 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x69, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, + 0x72, 0x61, 0x79, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x4D, + 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x70, 0x75, + 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x09, 0x65, 0x76, 0x2F, 0x72, 0x77, 0x6C, + 0x6F, 0x63, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8C, 0x25, 0x01, 0xDA, + 0x06, 0xD8, 0x09, 0x65, 0x76, 0x2F, 0x72, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x08, 0xCE, 0x40, + 0x28, 0x65, 0x76, 0x2F, 0x72, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x77, + 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6F, + 0x72, 0x64, 0x69, 0x6E, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x2E, + 0xCF, 0x0A, 0x66, 0x66, 0x69, 0x2F, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0xBE, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x66, 0x66, 0x69, 0x2F, + 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xDA, 0x08, 0xCE, 0x80, 0x95, 0x28, 0x66, 0x66, 0x69, 0x2F, + 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x79, + 0x6D, 0x62, 0x6F, 0x6C, 0x2D, 0x6E, 0x61, 0x6D, 0x65, 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x6F, 0x6B, + 0x75, 0x70, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x66, 0x72, 0x6F, 0x6D, + 0x20, 0x61, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, + 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x6C, 0x6F, 0x6F, + 0x6B, 0x75, 0x70, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x61, 0x20, 0x72, 0x61, 0x77, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x69, 0x73, 0x20, + 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x65, 0x6C, 0x73, 0x65, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0xCF, 0x02, 0x70, 0x70, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x87, 0x07, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x05, 0x0A, 0x00, + 0x02, 0xCE, 0x02, 0x70, 0x70, 0xDA, 0x18, 0xD0, 0x0D, 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, 0x2D, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xCE, 0x02, 0x25, 0x71, 0xDA, 0x80, 0xFB, 0xD8, 0x06, 0x70, + 0x72, 0x69, 0x6E, 0x74, 0x66, 0xD8, 0x05, 0x66, 0x6C, 0x75, 0x73, 0x68, 0x00, 0x0A, 0x00, 0xDA, + 0x1E, 0x00, 0x0A, 0x01, 0xDA, 0x84, 0x07, 0x2C, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, + 0x02, 0x03, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x35, 0x02, 0x03, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, + 0x04, 0x03, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2C, 0x02, 0x04, 0x00, 0x36, 0x02, 0x00, 0x00, 0x87, + 0x0A, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x68, 0x28, 0x70, 0x70, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x50, 0x72, 0x65, 0x74, 0x74, 0x79, 0x2D, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, + 0x2A, 0x6F, 0x75, 0x74, 0x2A, 0x29, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, + 0x6D, 0x61, 0x74, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x69, 0x73, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x2A, 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, + 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x2A, 0x20, 0x22, 0x25, 0x71, 0x22, 0x29, 0x60, 0x2E, + 0xCF, 0x0D, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x6E, 0x61, 0x6D, 0x65, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x09, 0x01, 0xDA, 0x06, 0xD8, 0x0D, 0x6E, + 0x65, 0x74, 0x2F, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x6E, 0x61, 0x6D, 0x65, 0xDA, 0x08, 0xCE, 0x51, + 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, + 0x2E, 0xCF, 0x06, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x81, 0xC3, 0x82, 0x2B, 0x01, 0xDA, 0x06, 0xD8, 0x06, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0xDA, 0x08, 0xCE, 0x80, 0xD4, 0x28, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74, 0x6C, 0x79, + 0x20, 0x28, 0x6E, 0x6F, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, + 0x64, 0x69, 0x6E, 0x67, 0x73, 0x29, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x74, 0x72, + 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, + 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61, 0x72, 0x67, + 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, + 0x20, 0x61, 0x73, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, + 0x64, 0x79, 0x6E, 0x73, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x87, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0C, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x06, 0x23, 0x00, 0x08, 0xCE, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x64, 0x79, 0x6E, 0x73, + 0xDA, 0x18, 0xCF, 0x06, 0x73, 0x65, 0x74, 0x64, 0x79, 0x6E, 0xDA, 0x80, 0xA8, 0xDA, 0x80, 0x9B, + 0xDA, 0x81, 0x6B, 0xD0, 0x01, 0x70, 0xDA, 0x81, 0x6D, 0x00, 0x23, 0x00, 0xDA, 0x81, 0x22, 0x00, + 0x23, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x23, 0x02, 0xDA, 0x84, 0x1B, 0x01, 0x15, 0x04, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x5A, 0x02, 0x15, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x04, 0x15, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x07, + 0x15, 0x07, 0xDA, 0x80, 0xC3, 0x14, 0x23, 0x04, 0xCF, 0x09, 0x64, 0x79, 0x6E, 0x2D, 0x66, 0x6F, + 0x72, 0x6D, 0x73, 0x40, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3F, + 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x23, 0x05, 0x03, 0x06, 0x1E, 0x05, 0x0F, 0x00, 0x1B, + 0x07, 0x03, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x08, 0x00, 0x00, 0x05, 0x09, 0x07, 0x01, 0x31, + 0x09, 0x00, 0x00, 0x35, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x33, 0x0B, 0x08, 0x0A, 0x45, + 0x09, 0x00, 0x00, 0x32, 0x04, 0x09, 0x00, 0x2C, 0x0A, 0x01, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x05, + 0x03, 0x03, 0x02, 0x1C, 0xF1, 0xFF, 0xFF, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x32, + 0x06, 0x03, 0x00, 0x34, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, + 0x06, 0x03, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x33, 0x06, 0x05, 0x07, 0x45, 0x03, 0x00, 0x00, 0x2C, + 0x06, 0x05, 0x00, 0x32, 0x06, 0x03, 0x00, 0x45, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x85, + 0x8E, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x17, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x11, 0x00, 0x11, 0x00, 0x29, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xE4, 0x28, 0x77, 0x69, 0x74, + 0x68, 0x2D, 0x64, 0x79, 0x6E, 0x73, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, + 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x61, 0x20, 0x62, + 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x68, 0x61, 0x73, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x0A, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, + 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x73, 0x65, 0x74, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x0A, 0x6F, + 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x70, + 0x65, 0x72, 0x6C, 0x79, 0x0A, 0x75, 0x6E, 0x73, 0x65, 0x74, 0x2C, 0x20, 0x61, 0x73, 0x20, 0x64, + 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2D, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x2E, + 0xDA, 0x37, 0xCB, 0xCF, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x63, 0x6C, 0x6F, + 0x73, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x83, 0x10, 0x01, 0xDA, 0x06, + 0xD8, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xDA, + 0x08, 0xCE, 0x80, 0xF8, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x63, 0x6C, 0x6F, + 0x73, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x20, + 0x70, 0x69, 0x70, 0x65, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x60, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x65, + 0x6E, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x6E, 0x2C, 0x20, + 0x69, 0x66, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x2C, 0x20, + 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x69, 0x74, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x69, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, + 0x61, 0x69, 0x74, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x0B, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x81, 0x5D, 0x4A, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xE0, 0xDA, 0x08, 0xCE, 0x81, 0xE9, 0x28, + 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x61, 0x72, 0x72, 0x74, + 0x75, 0x70, 0x20, 0x5B, 0x2C, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x20, 0x5B, 0x2C, 0x65, + 0x6E, 0x64, 0x3D, 0x28, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x61, 0x72, 0x72, 0x74, 0x75, + 0x70, 0x29, 0x5D, 0x5D, 0x29, 0x0A, 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x73, 0x75, + 0x62, 0x2D, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, + 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x60, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x20, 0x65, 0x78, 0x63, 0x6C, + 0x75, 0x73, 0x69, 0x76, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x60, 0x20, 0x6F, 0x72, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, + 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x30, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x6F, 0x66, + 0x20, 0x60, 0x61, 0x72, 0x72, 0x74, 0x75, 0x70, 0x60, 0x2C, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, 0x74, 0x60, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, + 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, + 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, + 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x70, 0x75, 0x74, 0x2E, 0x20, + 0x4E, 0x6F, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x66, 0x20, 0x60, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x66, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x20, 0x69, + 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2C, 0x20, 0x74, 0x6F, 0x20, 0x61, + 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x20, 0x6E, 0x65, 0x67, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xCF, 0x0B, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0x9D, + 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x02, 0x11, + 0x00, 0x06, 0xCE, 0x0B, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xDA, + 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x09, 0x2C, 0x00, 0x04, + 0xCE, 0x09, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xDA, 0x18, 0xD8, 0x0A, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x83, 0x59, 0xD8, 0x0D, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xDA, 0x81, 0x72, 0xD8, 0x0C, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xDA, 0x83, 0xD7, 0xD8, + 0x0F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, + 0xD8, 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, + 0xDA, 0x80, 0xA8, 0x00, 0x2C, 0x00, 0xDA, 0x82, 0x05, 0x00, 0x2C, 0x01, 0xCF, 0x09, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0x02, 0x2C, 0x03, 0xDA, 0x6D, 0x04, 0x2C, 0x04, 0xDA, + 0x23, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x40, 0x02, 0x00, + 0x00, 0x1B, 0x04, 0x02, 0x00, 0x32, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x02, 0x05, + 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x35, 0x02, 0x05, 0x00, 0x2C, 0x06, 0x03, + 0x00, 0x25, 0x05, 0x06, 0x02, 0x1E, 0x05, 0x05, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x04, + 0x00, 0x35, 0x02, 0x06, 0x00, 0x01, 0x02, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x05, + 0x00, 0x35, 0x02, 0x05, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x06, 0x00, 0x35, 0x02, 0x05, + 0x00, 0x1E, 0x02, 0x08, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x07, 0x00, 0x35, 0x05, 0x06, + 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x07, 0x08, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1C, 0xF6, 0xFF, + 0xFF, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x35, 0x02, 0x05, 0x00, 0x2C, 0x06, 0x03, + 0x00, 0x25, 0x05, 0x06, 0x02, 0x1E, 0x05, 0x06, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x04, + 0x00, 0x35, 0x02, 0x06, 0x00, 0x01, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, + 0x00, 0x8A, 0x91, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0xBF, 0xFF, 0x05, 0x02, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, + 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x05, 0x11, 0x00, 0x03, 0xCE, 0x04, 0x65, 0x76, 0x61, + 0x6C, 0xDA, 0x18, 0xD0, 0x04, 0x65, 0x76, 0x61, 0x6C, 0xDA, 0x81, 0x35, 0xDA, 0x65, 0xD0, 0x08, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xDA, 0x81, 0x72, 0x00, 0x11, 0x00, 0xDA, 0x81, + 0x8B, 0x00, 0x11, 0x01, 0xCF, 0x04, 0x65, 0x76, 0x61, 0x6C, 0x05, 0x11, 0x03, 0xDA, 0x80, 0xAD, + 0x28, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x33, 0x00, 0x02, 0x03, 0x2C, 0x03, 0x01, 0x00, + 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, + 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x25, 0x05, 0x04, 0x06, 0x1E, 0x05, 0x02, 0x00, + 0x36, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x3B, 0x04, 0x03, 0x06, 0x01, 0x04, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x8A, 0x79, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x03, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x01, 0x05, 0x01, + 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x00, 0x05, 0x00, 0x11, 0x00, 0xDA, 0x82, 0x05, 0x00, 0x11, 0x01, + 0xDA, 0x84, 0x30, 0x00, 0x11, 0x02, 0xDA, 0x23, 0x04, 0x10, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x4D, 0x07, 0x10, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x4C, + 0x0A, 0x10, 0x06, 0xDA, 0x1E, 0x28, 0x02, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, + 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x03, 0x04, + 0x05, 0x1B, 0x05, 0x03, 0x00, 0x1F, 0x05, 0x08, 0x00, 0x3A, 0x03, 0x04, 0x05, 0x1B, 0x06, 0x03, + 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x49, 0x05, 0x04, + 0x05, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x8A, 0xA1, 0x03, 0x01, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xDA, 0x08, 0xCE, + 0x80, 0x84, 0x28, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, + 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x72, 0x6F, 0x6C, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x65, 0x6E, 0x76, + 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x65, 0x64, + 0x65, 0x64, 0x2C, 0x20, 0x75, 0x73, 0x65, 0x20, 0x60, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, + 0x74, 0x65, 0x78, 0x74, 0x60, 0x2E, 0xCF, 0x0B, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x62, 0x75, + 0x69, 0x6C, 0x64, 0xD3, 0x02, 0xDA, 0x06, 0xCE, 0x07, 0x66, 0x39, 0x32, 0x66, 0x33, 0x65, 0x62, + 0xDA, 0x08, 0xCE, 0x32, 0x54, 0x68, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x20, 0x69, 0x64, + 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x70, 0x72, + 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0xCF, 0x07, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x69, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x94, 0x01, 0xDA, 0x06, 0xC8, 0x18, + 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, 0xDA, 0x08, 0xCE, 0x0D, 0x54, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x69, 0x2E, 0xCF, 0x08, 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, + 0x61, 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x4F, 0x01, 0xDA, 0x06, + 0xD8, 0x08, 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x08, 0xCE, 0x81, 0xD0, 0x28, + 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, + 0x6E, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x20, + 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x75, + 0x70, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2C, 0x20, 0x73, 0x75, 0x73, 0x70, + 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x76, 0x61, + 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x77, + 0x6F, 0x72, 0x64, 0x20, 0x60, 0x3A, 0x61, 0x6C, 0x6C, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6C, 0x65, 0x73, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x28, 0x61, 0x6E, 0x64, 0x20, + 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x30, 0x29, 0x2C, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x74, 0x68, 0x6F, 0x73, 0x65, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x65, + 0x61, 0x72, 0x6C, 0x79, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, + 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, + 0x69, 0x6E, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x75, + 0x70, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x74, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x61, 0x69, 0x73, + 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0xCF, + 0x04, 0x70, 0x6F, 0x73, 0x3F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x35, + 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x01, 0x06, + 0x00, 0x02, 0xCE, 0x04, 0x70, 0x6F, 0x73, 0x3F, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x09, 0x02, 0x02, 0x02, 0x01, 0x10, 0x00, 0x05, 0xCE, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61, + 0x72, 0x65, 0xDA, 0x18, 0xD0, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x00, 0x10, 0x00, + 0xDA, 0x1E, 0x00, 0x10, 0x01, 0xDA, 0x80, 0xD9, 0x00, 0x10, 0x02, 0xCF, 0x07, 0x63, 0x6F, 0x6D, + 0x70, 0x61, 0x72, 0x65, 0x02, 0x10, 0x04, 0xDA, 0x80, 0xAA, 0x08, 0x10, 0x06, 0xDA, 0x80, 0xAA, + 0x2C, 0x04, 0x00, 0x00, 0x3B, 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1E, 0x03, 0x03, 0x00, + 0x32, 0x00, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x3B, 0x05, 0x01, 0x06, + 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x05, 0x05, 0x00, 0x32, 0x01, 0x00, 0x00, 0x35, 0x07, 0x06, 0x00, + 0x09, 0x08, 0x07, 0xFF, 0x03, 0x08, 0x00, 0x00, 0x27, 0x07, 0x00, 0x01, 0x03, 0x07, 0x00, 0x00, + 0x83, 0x0E, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x84, 0x53, 0x2B, 0x02, 0x00, 0x00, + 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x26, 0x03, 0x02, 0x01, + 0x03, 0x03, 0x00, 0x00, 0x83, 0x35, 0x33, 0x00, 0x33, 0x00, 0x33, 0x00, 0x33, 0x00, 0x30, 0x00, + 0x30, 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x70, 0x6F, 0x73, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, + 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x67, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x30, 0x2E, 0xCF, 0x0C, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xB4, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x03, 0xDA, 0x08, 0xCE, 0x81, + 0x89, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, + 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, + 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, + 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x60, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, + 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x2C, 0x20, 0x65, 0x78, + 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x30, 0x2E, + 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, 0x74, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x65, 0x6E, + 0x64, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6E, + 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x4E, 0x6F, 0x74, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x66, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, 0x74, 0x60, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x65, 0x78, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, + 0x66, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, + 0x69, 0x76, 0x65, 0x2C, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, 0x20, + 0x66, 0x75, 0x6C, 0x6C, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x6C, + 0x69, 0x63, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2E, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x65, 0x78, 0x70, 0x32, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x17, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0x32, 0xDA, + 0x08, 0xCE, 0x2B, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0x32, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x32, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x6F, 0x77, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x0A, + 0x6F, 0x73, 0x2F, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x04, 0x87, 0x7E, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x6F, 0x73, 0x2F, 0x73, 0x79, 0x6D, + 0x6C, 0x69, 0x6E, 0x6B, 0xDA, 0x08, 0xCE, 0x80, 0x80, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x79, 0x6D, + 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x6F, 0x6C, 0x64, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6E, 0x65, 0x77, + 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, + 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x6F, 0x6C, 0x64, + 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x65, 0x77, 0x70, 0x61, 0x74, 0x68, 0x2C, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, + 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x6F, 0x73, 0x2F, 0x6C, 0x69, 0x6E, + 0x6B, 0x20, 0x6F, 0x6C, 0x64, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6E, 0x65, 0x77, 0x70, 0x61, 0x74, + 0x68, 0x20, 0x74, 0x72, 0x75, 0x65, 0x29, 0x60, 0x2E, 0xCF, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, + 0x77, 0x68, 0x69, 0x6C, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xA1, + 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x02, 0x06, + 0x00, 0x03, 0xCE, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x18, + 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x02, 0x00, 0x01, 0x02, + 0xCE, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xDA, 0x18, 0x00, 0x02, + 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x02, 0x01, 0xCF, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x30, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x03, 0x01, 0x01, 0x01, 0x01, 0x06, 0x01, 0x03, 0xDA, 0x18, 0xDA, 0x82, 0x30, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x84, 0x72, 0x00, 0x06, 0x00, 0xDA, 0x1E, + 0x31, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x00, 0x35, 0x01, 0x02, 0x00, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x02, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x82, 0xD0, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x82, 0xD0, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, + 0xDA, 0x83, 0x74, 0x00, 0x06, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x06, 0x01, 0xDA, 0x1F, 0x00, 0x06, + 0x02, 0xDA, 0x84, 0x6B, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, + 0x32, 0x03, 0x01, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x84, 0xA5, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xBC, 0x28, 0x64, + 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, + 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x47, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x20, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x61, 0x74, 0x69, 0x73, + 0x66, 0x79, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x62, 0x6F, 0x72, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x72, 0x65, 0x73, + 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0xCF, 0x03, 0x6D, 0x6F, 0x64, 0xD3, + 0x02, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x1D, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, + 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x03, 0x6D, 0x6F, 0x64, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, + 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, + 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x0E, 0x03, 0x03, + 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, + 0x05, 0x0E, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, + 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, 0x94, 0x28, 0x6D, 0x6F, 0x64, 0x20, 0x26, + 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6C, + 0x79, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x6F, 0x20, + 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, + 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x72, 0x65, 0x6D, 0x61, + 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x60, 0x28, 0x6D, + 0x6F, 0x64, 0x20, 0x78, 0x20, 0x30, 0x29, 0x60, 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6E, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x60, 0x78, 0x60, 0x2E, 0xCF, 0x06, + 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, + 0x4F, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0E, 0x01, 0x01, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x0A, 0x37, 0x00, 0x07, 0xCE, 0x06, 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0xDA, + 0x18, 0xDA, 0x51, 0xDA, 0x58, 0xDA, 0x80, 0x9B, 0xDA, 0x81, 0x6B, 0xD0, 0x02, 0x69, 0x30, 0xDA, + 0x52, 0xDA, 0x81, 0x6D, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x18, 0x06, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0xCE, 0x01, 0x3D, 0x3F, 0x01, 0x00, 0x00, 0x24, 0x02, 0x01, 0x02, + 0x1D, 0x02, 0x0A, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, + 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, 0x03, 0x04, 0x00, + 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFA, 0xFF, 0x29, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, + 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x81, 0x89, 0xDA, 0x57, 0x00, 0x37, 0x00, + 0xCF, 0x03, 0x74, 0x61, 0x67, 0x00, 0x37, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x37, 0x02, 0xDA, 0x84, + 0x79, 0x02, 0x37, 0x04, 0xDA, 0x80, 0xAD, 0x05, 0x37, 0x05, 0xCF, 0x06, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x08, 0x37, 0x06, 0xCF, 0x07, 0x70, 0x61, 0x79, 0x6C, 0x6F, 0x61, 0x64, 0x0B, 0x37, + 0x07, 0xCF, 0x03, 0x66, 0x69, 0x62, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, + 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x03, 0x05, 0x00, 0x1B, 0x05, 0x03, 0x00, 0x2C, 0x06, + 0x00, 0x00, 0x35, 0x03, 0x06, 0x00, 0x1B, 0x06, 0x03, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x03, + 0x07, 0x00, 0x1B, 0x07, 0x03, 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x31, 0x09, + 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x08, 0x00, 0x00, 0x32, 0x00, 0x08, 0x00, 0x46, 0x09, + 0x00, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x33, 0x0A, 0x03, 0x09, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, + 0x03, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x33, 0x09, 0x08, 0x0A, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x09, + 0x05, 0x00, 0x33, 0x09, 0x07, 0x03, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x06, 0x00, 0x32, 0x09, + 0x07, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x33, 0x0A, 0x04, 0x03, 0x45, 0x09, + 0x00, 0x00, 0x32, 0x05, 0x06, 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x0B, 0x05, 0x00, 0x33, 0x0B, + 0x03, 0x04, 0x45, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x07, 0x00, 0x33, 0x0B, 0x00, 0x05, 0x45, 0x03, + 0x00, 0x00, 0x2C, 0x0C, 0x08, 0x00, 0x33, 0x0C, 0x04, 0x07, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0D, + 0x09, 0x00, 0x33, 0x0D, 0x03, 0x06, 0x31, 0x0B, 0x00, 0x00, 0x45, 0x0C, 0x00, 0x00, 0x2C, 0x0B, + 0x01, 0x00, 0x33, 0x0B, 0x08, 0x09, 0x32, 0x0A, 0x0C, 0x00, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, + 0x00, 0x00, 0x81, 0x53, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0xDA, 0x08, 0xCE, 0x80, 0x8F, 0x28, 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0x20, 0x74, 0x61, + 0x67, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x75, + 0x70, 0x20, 0x61, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x2E, 0x20, 0x60, 0x74, 0x61, 0x67, 0x60, 0x20, 0x73, 0x68, + 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x0A, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x20, 0x60, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x60, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, + 0x77, 0x6F, 0x72, 0x64, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, + 0x71, 0x72, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x1C, 0x01, + 0xDA, 0x06, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x71, 0x72, 0x74, 0xDA, 0x08, 0xCE, + 0x2C, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x71, 0x72, 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x71, 0x75, 0x61, + 0x72, 0x65, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x0C, 0x6E, + 0x65, 0x74, 0x2F, 0x70, 0x65, 0x65, 0x72, 0x6E, 0x61, 0x6D, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x12, 0x83, 0x19, 0x01, 0xDA, 0x06, 0xD8, 0x0C, 0x6E, 0x65, 0x74, 0x2F, 0x70, + 0x65, 0x65, 0x72, 0x6E, 0x61, 0x6D, 0x65, 0xDA, 0x08, 0xCE, 0x58, 0x28, 0x6E, 0x65, 0x74, 0x2F, + 0x70, 0x65, 0x65, 0x72, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6D, 0x6F, 0x74, + 0x65, 0x20, 0x70, 0x65, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6F, 0x72, 0x64, + 0x65, 0x72, 0x2E, 0xCF, 0x08, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0x52, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, + 0x00, 0x00, 0x10, 0x02, 0x01, 0x02, 0x14, 0x3C, 0x00, 0x01, 0x06, 0xCE, 0x08, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x67, 0x65, 0x72, 0xDA, 0x18, 0xD8, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x67, + 0x65, 0x74, 0x65, 0x6E, 0x76, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x00, 0x01, + 0x02, 0x0B, 0x00, 0x04, 0xCE, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0xDA, 0x18, + 0xDA, 0x00, 0xD8, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6F, + 0x74, 0x6F, 0x00, 0x0B, 0x00, 0xCF, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x00, 0x0B, 0x01, + 0xCF, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0x04, 0x0B, 0x03, 0xDA, 0x84, 0x99, + 0x09, 0x0B, 0x04, 0xCF, 0x06, 0x6E, 0x65, 0x77, 0x65, 0x6E, 0x76, 0x1E, 0x00, 0x03, 0x00, 0x1B, + 0x02, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x44, + 0x04, 0x00, 0x00, 0x32, 0x04, 0x03, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, + 0x04, 0x05, 0x00, 0x03, 0x04, 0x00, 0x00, 0x89, 0x5D, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x03, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0xBF, 0xFA, 0x01, 0xD0, + 0x05, 0x66, 0x69, 0x62, 0x65, 0x72, 0xD0, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2D, 0x6C, 0x65, + 0x76, 0x65, 0x6C, 0xD8, 0x10, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6C, 0x61, 0x73, 0x74, 0x2D, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0xD0, 0x06, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0xD3, 0x13, 0xCF, + 0x09, 0x2E, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8D, 0xEA, 0x03, 0xDA, 0x06, 0xD7, 0x01, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, + 0x01, 0x00, 0x01, 0x01, 0x06, 0x01, 0x03, 0xCE, 0x09, 0x2E, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, + 0x64, 0x65, 0xDA, 0x18, 0xD0, 0x08, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0xBF, 0xFF, + 0x00, 0x01, 0xCF, 0x07, 0x2E, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0x00, 0x06, 0x00, 0xDA, 0x81, + 0x9E, 0x00, 0x06, 0x01, 0xDA, 0x84, 0xA1, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x01, 0x35, + 0x02, 0x03, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, + 0xFF, 0x8D, 0xED, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x07, + 0xC9, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x00, 0x01, 0x03, 0x0B, 0x00, 0x04, + 0xCE, 0x07, 0x2E, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x06, 0x01, 0x00, 0x01, 0x02, 0x0C, 0x00, 0x04, 0xCE, 0x06, 0x2E, 0x66, 0x72, 0x61, + 0x6D, 0x65, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x00, 0x01, 0xCE, 0x06, 0x2E, 0x66, 0x69, 0x62, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x84, 0x9C, + 0xDA, 0x80, 0xFB, 0x00, 0x04, 0x00, 0xCF, 0x06, 0x2E, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, 0x01, + 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x36, 0x01, 0x00, 0x00, 0x8D, 0xB8, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xD8, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, + 0x74, 0x61, 0x63, 0x6B, 0x00, 0x0C, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x0C, 0x01, 0xCF, 0x06, 0x2E, + 0x66, 0x72, 0x61, 0x6D, 0x65, 0x05, 0x0C, 0x02, 0xDA, 0x82, 0x10, 0x05, 0x0A, 0x00, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x4F, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x31, + 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x1E, + 0x00, 0x03, 0x00, 0x1B, 0x04, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3A, + 0x05, 0x02, 0x04, 0x03, 0x05, 0x00, 0x00, 0x8D, 0xC9, 0x1B, 0x00, 0x1B, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x03, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, 0x00, 0x03, + 0xDA, 0x84, 0x40, 0xD8, 0x06, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0x00, 0x0B, 0x00, 0xDA, 0x81, + 0x9E, 0x00, 0x0B, 0x01, 0xDA, 0x84, 0xA7, 0x03, 0x0B, 0x03, 0xCF, 0x05, 0x66, 0x72, 0x61, 0x6D, + 0x65, 0x07, 0x0B, 0x05, 0xDA, 0x83, 0x1D, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x31, 0x04, 0x00, 0x00, 0x35, + 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x36, + 0x06, 0x00, 0x00, 0x8D, 0xE6, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x84, 0xA4, 0xC9, 0xC9, 0xC9, + 0xC9, 0xDA, 0x08, 0xCE, 0x3E, 0x28, 0x2E, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x2E, 0xCF, 0x07, 0x2E, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x32, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x0A, 0x01, 0x00, 0x01, 0x05, 0x11, 0x00, 0x05, 0xCE, 0x07, 0x2E, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0xDA, 0x18, 0xDA, 0x84, 0xAA, 0xD0, 0x06, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x07, 0x15, 0x00, 0x04, 0xCE, 0x05, + 0x73, 0x6C, 0x75, 0x72, 0x70, 0xDA, 0x18, 0xD0, 0x02, 0x72, 0x62, 0xD8, 0x09, 0x66, 0x69, 0x6C, + 0x65, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0xCE, 0x14, 0x63, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0xDA, 0x81, 0x12, 0xD0, + 0x03, 0x61, 0x6C, 0x6C, 0xD8, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xD8, + 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x00, 0x15, 0x00, 0xCF, 0x04, + 0x70, 0x61, 0x74, 0x68, 0x00, 0x15, 0x01, 0xCF, 0x05, 0x73, 0x6C, 0x75, 0x72, 0x70, 0x04, 0x15, + 0x03, 0xDA, 0x80, 0xAA, 0x10, 0x15, 0x05, 0xCF, 0x08, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, + 0x73, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, + 0x00, 0x1B, 0x03, 0x02, 0x00, 0x1E, 0x03, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x04, 0x02, + 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x35, 0x04, 0x05, 0x00, 0x01, 0x04, 0x00, + 0x00, 0x2C, 0x04, 0x04, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x05, 0x05, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x1B, 0x05, 0x04, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x35, 0x06, 0x07, + 0x00, 0x03, 0x05, 0x00, 0x00, 0x86, 0xF4, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0D, 0x01, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFA, + 0x01, 0xDA, 0x82, 0x5C, 0xD8, 0x06, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x00, 0x11, 0x00, 0xDA, + 0x81, 0x9E, 0x00, 0x11, 0x01, 0xDA, 0x84, 0xB5, 0x03, 0x11, 0x03, 0xDA, 0x84, 0xB3, 0x07, 0x11, + 0x05, 0xDA, 0x49, 0x0B, 0x11, 0x07, 0xCF, 0x0A, 0x61, 0x6C, 0x6C, 0x2D, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, + 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x31, 0x04, 0x00, 0x00, 0x35, 0x04, 0x03, 0x00, 0x1B, 0x05, + 0x04, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, + 0x06, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x33, 0x08, 0x07, 0x09, 0x2C, 0x08, + 0x04, 0x00, 0x36, 0x08, 0x00, 0x00, 0x8E, 0x35, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x47, 0x28, 0x2E, 0x73, + 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x53, + 0x68, 0x6F, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, + 0x6F, 0x64, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x67, 0x65, 0x64, 0x2E, 0xCF, 0x05, 0x2E, 0x73, 0x74, 0x65, 0x70, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x5A, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x08, 0x01, 0x00, 0x01, 0x02, 0x11, 0x00, 0x06, 0xCE, 0x05, 0x2E, 0x73, 0x74, 0x65, 0x70, 0xDA, + 0x18, 0xDA, 0x84, 0xAC, 0xD8, 0x0A, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x65, 0x70, + 0x00, 0x11, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x11, 0x01, 0xDA, 0x84, 0xC9, 0x00, 0x11, 0x02, 0xDA, + 0x80, 0xAD, 0x01, 0x10, 0x03, 0xDA, 0x80, 0xC3, 0x01, 0x06, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x06, 0x10, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x5A, + 0x28, 0x02, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x1B, 0x04, 0x00, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x01, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x23, 0x04, 0x03, 0x05, + 0x1E, 0x04, 0x08, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x31, 0x06, 0x00, 0x00, + 0x2C, 0x07, 0x01, 0x00, 0x35, 0x02, 0x07, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, 0xF8, 0xFF, 0xFF, + 0x03, 0x02, 0x00, 0x00, 0x8E, 0x5D, 0x03, 0x01, 0x03, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x1A, 0x00, 0x1A, 0x00, 0x0E, 0x00, 0x0E, 0x00, + 0x0E, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xDA, 0x08, 0xCE, 0x30, 0x28, 0x2E, 0x73, + 0x74, 0x65, 0x70, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x6E, 0x20, + 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0xCF, 0x09, 0x2E, + 0x62, 0x72, 0x65, 0x61, 0x6B, 0x61, 0x6C, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8E, 0x20, 0x03, 0xDA, 0x06, 0xD7, 0x01, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x00, + 0x01, 0x05, 0x19, 0x01, 0x09, 0xCE, 0x09, 0x2E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x61, 0x6C, 0x6C, + 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x00, 0x01, 0x02, 0x06, 0x00, + 0x02, 0xCE, 0x03, 0x2E, 0x66, 0x6E, 0xDA, 0x18, 0xDA, 0x84, 0xAA, 0xDA, 0x84, 0x40, 0x00, 0x06, + 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x06, 0x01, 0xCF, 0x03, 0x2E, 0x66, 0x6E, 0x31, 0x00, 0x00, 0x00, + 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x3A, 0x03, 0x02, 0x04, + 0x03, 0x03, 0x00, 0x00, 0x8D, 0xD4, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0xD8, 0x0C, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xCE, + 0x04, 0x73, 0x65, 0x74, 0x20, 0xCE, 0x10, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, + 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0xDA, 0x84, 0xC6, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x84, + 0xA7, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x84, 0xA1, 0xBF, 0xFF, 0x00, 0x03, 0xCF, 0x06, 0x2E, 0x70, + 0x70, 0x61, 0x73, 0x6D, 0x00, 0x19, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x19, 0x01, 0xDA, 0x84, 0xD2, + 0x03, 0x19, 0x03, 0xCF, 0x03, 0x66, 0x75, 0x6E, 0x07, 0x19, 0x05, 0xCF, 0x08, 0x62, 0x79, 0x74, + 0x65, 0x63, 0x6F, 0x64, 0x65, 0x08, 0x12, 0x06, 0xDA, 0x80, 0xC3, 0x0A, 0x12, 0x08, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x56, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x02, 0x35, + 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3F, 0x07, 0x05, 0x00, 0x1B, + 0x08, 0x07, 0x00, 0x23, 0x07, 0x06, 0x08, 0x1E, 0x07, 0x06, 0x00, 0x32, 0x03, 0x06, 0x00, 0x2C, + 0x0A, 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x05, 0x06, 0x06, 0x01, 0x1C, 0xFA, 0xFF, 0xFF, 0x3F, + 0x06, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, 0x07, 0x06, 0x08, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x36, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x8E, 0x23, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x05, 0x01, 0x05, + 0x00, 0x0F, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, + 0x05, 0x00, 0x05, 0x02, 0x14, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0xDB, 0x00, 0xDA, 0x08, 0xCE, 0x50, 0x28, 0x2E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x61, 0x6C, + 0x6C, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x62, + 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xCF, 0x05, 0x2E, 0x6E, 0x65, 0x78, 0x74, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x4C, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x08, 0x01, 0x00, 0x01, 0x01, 0x10, 0x00, 0x06, 0xCE, 0x05, 0x2E, 0x6E, 0x65, + 0x78, 0x74, 0xDA, 0x18, 0xDA, 0x84, 0xAC, 0x00, 0x10, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x10, 0x01, + 0xDA, 0x84, 0xE2, 0x00, 0x10, 0x02, 0xDA, 0x80, 0xAD, 0x01, 0x0F, 0x03, 0xDA, 0x80, 0xC3, 0x01, + 0x06, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x59, 0x06, 0x0F, 0x05, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x58, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x1E, + 0x00, 0x03, 0x00, 0x1B, 0x04, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x01, 0x00, 0x1B, + 0x05, 0x04, 0x00, 0x23, 0x04, 0x03, 0x05, 0x1E, 0x04, 0x07, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, + 0x06, 0x07, 0x00, 0x28, 0x07, 0x00, 0x00, 0x37, 0x02, 0x06, 0x07, 0x05, 0x03, 0x03, 0x01, 0x1C, + 0xF9, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x8E, 0x4F, 0x03, 0x01, 0x03, 0x00, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x16, 0x00, 0x16, 0x00, 0x0E, + 0x00, 0x0E, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xDA, 0x08, 0xCE, 0x2A, 0x28, 0x2E, + 0x6E, 0x65, 0x78, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x6F, + 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x62, 0x72, 0x65, + 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x2E, 0xCF, 0x09, 0x2E, 0x63, 0x6C, 0x65, 0x61, 0x72, + 0x61, 0x6C, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x29, 0x03, 0xDA, + 0x06, 0xD7, 0x01, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x00, 0x01, 0x05, 0x19, 0x01, 0x0A, + 0xCE, 0x09, 0x2E, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0xDA, 0x18, 0xDA, 0x84, 0xD7, + 0xD8, 0x0E, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, + 0xCE, 0x08, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x65, 0x64, 0x20, 0xDA, 0x84, 0xDC, 0xDA, 0x84, 0xC6, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x84, 0xA7, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x84, 0xA1, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x84, 0xDD, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x84, 0xD2, 0x00, 0x19, 0x00, 0xDA, + 0x81, 0x9E, 0x00, 0x19, 0x01, 0xDA, 0x84, 0xEA, 0x03, 0x19, 0x03, 0xDA, 0x84, 0xDE, 0x07, 0x19, + 0x05, 0xDA, 0x84, 0xDF, 0x08, 0x12, 0x06, 0xDA, 0x80, 0xC3, 0x0A, 0x12, 0x08, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x57, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, + 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x02, 0x35, 0x04, + 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3F, 0x07, 0x05, 0x00, 0x1B, 0x08, + 0x07, 0x00, 0x23, 0x07, 0x06, 0x08, 0x1E, 0x07, 0x06, 0x00, 0x32, 0x03, 0x06, 0x00, 0x2C, 0x0A, + 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x05, 0x06, 0x06, 0x01, 0x1C, 0xFA, 0xFF, 0xFF, 0x3F, 0x06, + 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, 0x07, 0x06, 0x08, 0x31, 0x03, + 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x36, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x8E, 0x2C, 0x0E, 0x00, + 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x05, 0x01, 0x05, 0x00, + 0x0F, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, + 0x00, 0x05, 0x02, 0x18, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xDB, 0x00, 0xDA, 0x08, 0xCE, 0x42, 0x28, 0x2E, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x61, 0x6C, 0x6C, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x65, 0x61, 0x72, 0x20, + 0x61, 0x6C, 0x6C, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x73, 0x20, + 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x84, 0xA7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xE3, 0x03, 0xDA, 0x06, 0xDA, 0x84, 0xA8, 0xDA, 0x08, 0xCE, 0x3D, + 0x28, 0x2E, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, + 0x62, 0x6C, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6E, 0x74, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xCF, 0x05, 0x2E, + 0x73, 0x6C, 0x6F, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xDB, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x02, 0x00, 0x02, 0x01, 0x09, 0x00, + 0x04, 0xCE, 0x05, 0x2E, 0x73, 0x6C, 0x6F, 0x74, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x05, 0x01, 0x00, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x06, 0x2E, 0x73, 0x6C, 0x6F, 0x74, + 0x73, 0xDA, 0x18, 0xDA, 0x84, 0xAA, 0xD0, 0x05, 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x00, 0x06, 0x00, + 0xDA, 0x81, 0x9E, 0x00, 0x06, 0x01, 0xCF, 0x06, 0x2E, 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x31, 0x00, + 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x3A, 0x03, + 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8D, 0xD9, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x09, 0x00, 0xCF, 0x03, 0x6E, 0x74, 0x68, 0x00, 0x09, 0x01, 0xCF, 0x09, + 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2D, 0x69, 0x64, 0x78, 0x00, 0x09, 0x02, 0xDA, 0x84, 0xF6, 0x02, + 0x07, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x50, 0x31, 0x01, 0x00, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x1B, 0x04, 0x00, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3A, 0x05, 0x03, 0x04, 0x03, 0x05, 0x00, 0x00, 0x8D, + 0xDE, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x03, + 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x3A, 0x28, 0x2E, 0x73, 0x6C, 0x6F, 0x74, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x6E, 0x74, 0x68, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2D, 0x69, 0x64, 0x78, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x74, 0x68, 0x20, 0x73, 0x6C, 0x6F, 0x74, 0x2E, + 0xCF, 0x06, 0x2E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8E, 0x3A, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x00, 0x00, + 0x00, 0x07, 0x14, 0x00, 0x04, 0xCE, 0x06, 0x2E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x18, 0xDA, + 0x84, 0xAA, 0xDA, 0x84, 0x40, 0xD0, 0x02, 0x70, 0x63, 0xDA, 0x84, 0xDA, 0xCE, 0x12, 0x73, 0x65, + 0x74, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, + 0xCE, 0x07, 0x20, 0x61, 0x74, 0x20, 0x70, 0x63, 0x3D, 0xDA, 0x84, 0xC6, 0x00, 0x14, 0x00, 0xDA, + 0x85, 0x03, 0x02, 0x14, 0x02, 0xDA, 0x84, 0xB3, 0x06, 0x14, 0x04, 0xDA, 0x84, 0xDE, 0x0A, 0x14, + 0x06, 0xCF, 0x02, 0x70, 0x63, 0x2C, 0x02, 0x00, 0x00, 0x35, 0x01, 0x02, 0x00, 0x1B, 0x02, 0x01, + 0x00, 0x2C, 0x03, 0x01, 0x00, 0x31, 0x03, 0x00, 0x00, 0x35, 0x03, 0x02, 0x00, 0x1B, 0x04, 0x03, + 0x00, 0x2C, 0x05, 0x02, 0x00, 0x31, 0x05, 0x00, 0x00, 0x35, 0x05, 0x02, 0x00, 0x1B, 0x06, 0x05, + 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x04, + 0x00, 0x2C, 0x09, 0x05, 0x00, 0x33, 0x08, 0x04, 0x09, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x06, + 0x00, 0x36, 0x08, 0x00, 0x00, 0x8E, 0x3D, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, + 0xCE, 0x2B, 0x28, 0x2E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, + 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x63, 0x2E, 0xCF, 0x06, 0x2E, + 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x43, + 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x07, 0x14, + 0x00, 0x04, 0xCE, 0x06, 0x2E, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xDA, 0x18, 0xDA, 0x84, 0xAA, 0xDA, + 0x84, 0x40, 0xDA, 0x85, 0x08, 0xDA, 0x84, 0xEF, 0xCE, 0x16, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x65, + 0x64, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, + 0xDA, 0x85, 0x0A, 0xDA, 0x84, 0xC6, 0x00, 0x14, 0x00, 0xDA, 0x85, 0x0D, 0x02, 0x14, 0x02, 0xDA, + 0x84, 0xB3, 0x06, 0x14, 0x04, 0xDA, 0x84, 0xDE, 0x0A, 0x14, 0x06, 0xDA, 0x85, 0x0B, 0x2C, 0x02, + 0x00, 0x00, 0x35, 0x01, 0x02, 0x00, 0x1B, 0x02, 0x01, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x35, 0x03, 0x02, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x31, 0x05, + 0x00, 0x00, 0x35, 0x05, 0x02, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, + 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x2C, 0x09, 0x05, 0x00, 0x33, 0x08, + 0x04, 0x09, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x36, 0x08, 0x00, 0x00, 0x8E, 0x46, + 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x2E, 0x63, 0x6C, 0x65, + 0x61, 0x72, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x65, 0x61, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, + 0x74, 0x2E, 0xDA, 0x84, 0xB0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xC6, + 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xAA, 0xDA, 0x08, 0xCE, 0x23, 0x28, 0x2E, 0x66, 0x72, 0x61, 0x6D, + 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x77, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0xDA, 0x84, 0xD9, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xD1, 0x01, 0xDA, 0x06, 0xDA, 0x84, + 0xD7, 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x2E, 0x66, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, + 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x84, 0xFE, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xD6, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xFB, + 0xDA, 0x08, 0xCE, 0x38, 0x28, 0x2E, 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, + 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x2E, 0xCF, 0x06, 0x2E, 0x73, + 0x74, 0x61, 0x63, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xBF, 0x01, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xFC, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x0B, 0x00, + 0x01, 0x01, 0xCE, 0x06, 0x2E, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xDA, 0x18, 0xDA, 0x83, 0xBD, 0xDA, + 0x84, 0x21, 0xDA, 0x81, 0x6B, 0x00, 0x0B, 0x00, 0xDA, 0x85, 0x1D, 0x2C, 0x02, 0x00, 0x00, 0x35, + 0x01, 0x02, 0x00, 0x30, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, 0x02, 0x03, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x28, 0x04, 0x00, 0x00, 0x37, 0x02, 0x03, 0x04, 0x2C, + 0x03, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xD0, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x06, 0x0D, 0x00, 0xDA, 0x18, 0xD0, 0x09, 0x65, 0x72, 0x72, 0x2D, 0x63, 0x6F, 0x6C, 0x6F, 0x72, + 0xDA, 0x81, 0x07, 0xDA, 0x84, 0xAC, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x00, 0x02, 0x04, 0x00, 0x01, 0xCE, 0x07, 0x2E, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0xDA, 0x18, + 0xDA, 0x84, 0x9F, 0xDA, 0x80, 0xFB, 0x00, 0x04, 0x00, 0xCF, 0x07, 0x2E, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x2C, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x36, 0x01, + 0x00, 0x00, 0x8D, 0xBD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x82, 0x04, 0xD8, 0x10, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, + 0x2C, 0x00, 0x00, 0x00, 0x2A, 0x01, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, + 0x35, 0x00, 0x01, 0x00, 0x2C, 0x02, 0x02, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2C, 0x03, 0x03, 0x00, + 0x35, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x33, 0x01, 0x02, 0x03, 0x2C, 0x03, 0x05, 0x00, + 0x36, 0x03, 0x00, 0x00, 0x8D, 0xC3, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x34, 0x00, 0x34, 0x00, 0x3D, 0x00, 0x3D, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x8D, + 0xC2, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x28, 0x28, 0x2E, 0x73, 0x74, 0x61, 0x63, + 0x6B, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x63, + 0x6B, 0x2E, 0xCF, 0x07, 0x2E, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xCC, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x05, 0x01, 0x00, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x2E, 0x6C, 0x6F, 0x63, 0x61, 0x6C, + 0x73, 0xDA, 0x18, 0xDA, 0x84, 0xAA, 0xD0, 0x06, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x73, 0x00, 0x06, + 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x06, 0x01, 0xDA, 0x85, 0x28, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, + 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x3B, 0x03, 0x02, 0x04, 0x03, 0x03, + 0x00, 0x00, 0x8D, 0xCF, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, + 0x08, 0xCE, 0x25, 0x28, 0x2E, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x77, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x20, + 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x85, 0x25, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xBA, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x23, 0xDA, 0x08, 0xCE, 0x31, + 0x28, 0x2E, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, + 0x6C, 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x64, + 0x2E, 0xDA, 0x84, 0xDD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0xEF, 0x03, + 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xFC, 0x00, 0x00, 0x20, 0x01, 0x00, 0x01, 0x2B, 0x80, 0xAD, + 0x00, 0x01, 0x17, 0xCE, 0x06, 0x2E, 0x70, 0x70, 0x61, 0x73, 0x6D, 0xDA, 0x18, 0xDA, 0x84, 0xAA, + 0xDA, 0x84, 0x40, 0xDA, 0x84, 0xB2, 0xDA, 0x84, 0xA6, 0xDA, 0x85, 0x08, 0xD0, 0x09, 0x73, 0x6F, + 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, 0xD2, 0x02, 0x00, 0xBF, 0xFE, 0xBF, 0xFE, 0xDA, 0x85, + 0x23, 0xCE, 0x0F, 0x0A, 0x20, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x3A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0xDA, 0x84, 0xC6, 0xDA, 0x84, 0xAC, 0xDA, 0x81, 0x6F, 0xCE, 0x0E, 0x20, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x3A, 0x20, 0x20, 0x20, 0x20, 0x20, 0xD0, 0x04, 0x6E, 0x61, 0x6D, + 0x65, 0xCE, 0x0B, 0x3C, 0x61, 0x6E, 0x6F, 0x6E, 0x79, 0x6D, 0x6F, 0x75, 0x73, 0x3E, 0xDA, 0x84, + 0xBA, 0xDA, 0x82, 0x04, 0xDA, 0x81, 0x45, 0xCE, 0x0E, 0x20, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3A, 0x20, 0x20, 0x20, 0xCE, 0x02, 0x20, 0x5B, 0xCE, 0x01, 0x5D, 0xD0, 0x09, + 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0xCE, 0x12, 0x20, 0x20, 0x63, 0x6F, 0x6E, + 0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x3A, 0x20, 0x20, 0x25, 0x2E, 0x34, 0x71, 0xD8, 0x07, 0x65, + 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0xDA, 0x84, 0xFD, 0xCE, 0x13, 0x20, 0x20, 0x73, 0x6C, 0x6F, + 0x74, 0x73, 0x3A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x25, 0x2E, 0x34, 0x71, 0x0A, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x03, 0x07, 0x00, 0x02, 0xCE, 0x07, 0x66, + 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0xDA, 0x18, 0xD0, 0x04, 0x6D, 0x6F, 0x64, 0x65, 0xD8, 0x07, + 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x61, 0x74, 0xD0, 0x04, 0x66, 0x69, 0x6C, 0x65, 0x00, 0x07, 0x00, + 0xDA, 0x84, 0xC3, 0x00, 0x07, 0x01, 0xCF, 0x07, 0x66, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x2C, + 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x25, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, 0x00, 0x8B, 0x0B, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x84, 0xBB, 0xDA, 0x82, 0x5A, + 0xDA, 0x82, 0x5B, 0xDA, 0x80, 0xA4, 0xDA, 0x80, 0xA5, 0xDA, 0x82, 0x00, 0xDA, 0x81, 0xC5, 0xCE, + 0x02, 0x3E, 0x20, 0xCE, 0x02, 0x20, 0x20, 0xDA, 0x81, 0x12, 0xDA, 0x80, 0xA6, 0xD8, 0x0B, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0xCE, 0x05, 0x25, 0x2E, 0x32, 0x30, + 0x73, 0xD8, 0x06, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x66, 0xCE, 0x08, 0x20, 0x23, 0x20, 0x6C, 0x69, + 0x6E, 0x65, 0x20, 0xCE, 0x09, 0x2C, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x00, 0x80, + 0xAD, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x80, 0xAD, 0x01, 0xDA, 0x84, 0xDD, 0x03, 0x80, 0xAD, 0x03, + 0xDA, 0x84, 0xB3, 0x07, 0x80, 0xAD, 0x05, 0xDA, 0x83, 0x1D, 0x0B, 0x80, 0xAD, 0x07, 0xCF, 0x04, + 0x64, 0x61, 0x73, 0x6D, 0x0E, 0x80, 0xAD, 0x09, 0xDA, 0x84, 0xDF, 0x12, 0x80, 0xAD, 0x0B, 0xDA, + 0x85, 0x0B, 0x15, 0x80, 0xAD, 0x0D, 0xCF, 0x09, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, + 0x70, 0x16, 0x80, 0xAD, 0x0E, 0xCF, 0x08, 0x6C, 0x61, 0x73, 0x74, 0x2D, 0x6C, 0x6F, 0x63, 0x39, + 0x3F, 0x12, 0xCF, 0x09, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x48, 0x62, 0x14, + 0xCF, 0x08, 0x73, 0x72, 0x63, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x4D, 0x52, 0x17, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x51, 0x54, 0x62, 0x17, 0xCF, 0x04, 0x64, 0x75, 0x6D, 0x70, 0x58, + 0x62, 0x19, 0xCF, 0x02, 0x73, 0x6C, 0x5A, 0x62, 0x1A, 0xCF, 0x01, 0x5F, 0x67, 0x80, 0xAD, 0x14, + 0xCF, 0x07, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6E, 0x67, 0x68, 0x80, 0xAB, 0x15, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x54, 0x6A, 0x80, 0xAB, 0x17, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x55, 0x6D, 0x80, 0xAB, 0x18, 0xDA, 0x80, 0xC3, 0x70, 0x80, 0xA9, 0x1A, 0xCF, 0x05, + 0x69, 0x6E, 0x73, 0x74, 0x72, 0x80, 0x98, 0x80, 0xA7, 0x1C, 0xDA, 0x85, 0x57, 0x80, 0x9A, 0x80, + 0xA7, 0x1D, 0xCF, 0x02, 0x73, 0x63, 0x80, 0x9D, 0x80, 0xA7, 0x1B, 0xCF, 0x03, 0x6C, 0x6F, 0x63, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, + 0x2C, 0x04, 0x01, 0x00, 0x31, 0x04, 0x00, 0x00, 0x35, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, + 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, + 0x2C, 0x09, 0x03, 0x00, 0x3A, 0x08, 0x07, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x2C, 0x0A, 0x04, 0x00, + 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0A, 0x03, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x2C, 0x0D, 0x05, 0x00, + 0x3A, 0x0C, 0x07, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x2C, 0x0E, 0x06, 0x00, 0x2C, 0x10, 0x07, 0x00, + 0x35, 0x0F, 0x10, 0x00, 0x2C, 0x10, 0x08, 0x00, 0x32, 0x10, 0x0F, 0x00, 0x2C, 0x11, 0x09, 0x00, + 0x35, 0x10, 0x11, 0x00, 0x2C, 0x11, 0x0A, 0x00, 0x35, 0x0F, 0x11, 0x00, 0x31, 0x0F, 0x00, 0x00, + 0x2C, 0x12, 0x0B, 0x00, 0x35, 0x11, 0x12, 0x00, 0x2C, 0x0F, 0x0C, 0x00, 0x32, 0x0F, 0x11, 0x00, + 0x2C, 0x12, 0x09, 0x00, 0x35, 0x0F, 0x12, 0x00, 0x2C, 0x12, 0x0D, 0x00, 0x3B, 0x11, 0x07, 0x12, + 0x20, 0x11, 0x02, 0x00, 0x2C, 0x11, 0x0E, 0x00, 0x2C, 0x12, 0x0F, 0x00, 0x2C, 0x13, 0x10, 0x00, + 0x33, 0x07, 0x12, 0x13, 0x2C, 0x13, 0x11, 0x00, 0x35, 0x12, 0x13, 0x00, 0x2C, 0x13, 0x12, 0x00, + 0x2C, 0x14, 0x13, 0x00, 0x33, 0x13, 0x11, 0x14, 0x2C, 0x13, 0x14, 0x00, 0x32, 0x12, 0x13, 0x00, + 0x2C, 0x14, 0x09, 0x00, 0x35, 0x13, 0x14, 0x00, 0x2C, 0x11, 0x15, 0x00, 0x31, 0x11, 0x00, 0x00, + 0x35, 0x11, 0x07, 0x00, 0x1B, 0x12, 0x11, 0x00, 0x1E, 0x11, 0x05, 0x00, 0x2C, 0x14, 0x16, 0x00, + 0x32, 0x14, 0x12, 0x00, 0x2C, 0x15, 0x17, 0x00, 0x35, 0x14, 0x15, 0x00, 0x2C, 0x11, 0x18, 0x00, + 0x31, 0x11, 0x00, 0x00, 0x35, 0x11, 0x03, 0x00, 0x2C, 0x12, 0x19, 0x00, 0x32, 0x12, 0x11, 0x00, + 0x2C, 0x14, 0x17, 0x00, 0x35, 0x12, 0x14, 0x00, 0x2C, 0x14, 0x0F, 0x00, 0x3A, 0x11, 0x07, 0x14, + 0x1B, 0x14, 0x11, 0x00, 0x1E, 0x11, 0x19, 0x00, 0x31, 0x14, 0x00, 0x00, 0x2C, 0x17, 0x1A, 0x00, + 0x35, 0x16, 0x17, 0x00, 0x1B, 0x17, 0x16, 0x00, 0x1E, 0x16, 0x03, 0x00, 0x1B, 0x15, 0x0D, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x15, 0x17, 0x00, 0x1E, 0x15, 0x10, 0x00, 0x30, 0x16, 0x00, 0x00, + 0x1B, 0x17, 0x16, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x35, 0x16, 0x0D, 0x00, 0x3D, 0x18, 0x16, 0x00, + 0x1B, 0x19, 0x18, 0x00, 0x3D, 0x18, 0x16, 0x01, 0x1B, 0x1A, 0x18, 0x00, 0x31, 0x14, 0x00, 0x00, + 0x2C, 0x18, 0x1B, 0x00, 0x35, 0x16, 0x18, 0x00, 0x32, 0x16, 0x19, 0x00, 0x35, 0x18, 0x17, 0x00, + 0x2C, 0x18, 0x09, 0x00, 0x35, 0x16, 0x18, 0x00, 0x2C, 0x11, 0x1C, 0x00, 0x2B, 0x14, 0x14, 0x00, + 0x32, 0x11, 0x14, 0x00, 0x2C, 0x14, 0x1D, 0x00, 0x35, 0x11, 0x14, 0x00, 0x1B, 0x14, 0x11, 0x00, + 0x2B, 0x15, 0x00, 0x00, 0x3F, 0x16, 0x09, 0x00, 0x1B, 0x17, 0x16, 0x00, 0x23, 0x16, 0x15, 0x17, + 0x1E, 0x16, 0x3F, 0x00, 0x1B, 0x18, 0x15, 0x00, 0x31, 0x18, 0x00, 0x00, 0x35, 0x19, 0x09, 0x00, + 0x1B, 0x1A, 0x19, 0x00, 0x31, 0x1A, 0x00, 0x00, 0x2C, 0x1C, 0x1E, 0x00, 0x35, 0x1B, 0x1C, 0x00, + 0x2C, 0x1D, 0x1F, 0x00, 0x25, 0x1C, 0x1B, 0x1D, 0x1E, 0x1C, 0x03, 0x00, 0x2C, 0x19, 0x20, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x19, 0x1C, 0x00, 0x31, 0x19, 0x00, 0x00, 0x2C, 0x1C, 0x21, 0x00, + 0x35, 0x1B, 0x1C, 0x00, 0x25, 0x1B, 0x18, 0x0B, 0x1E, 0x1B, 0x03, 0x00, 0x2C, 0x19, 0x22, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x19, 0x23, 0x00, 0x31, 0x19, 0x00, 0x00, 0x2C, 0x1C, 0x21, 0x00, + 0x35, 0x1B, 0x1C, 0x00, 0x2C, 0x19, 0x24, 0x00, 0x32, 0x19, 0x1A, 0x00, 0x2C, 0x1B, 0x25, 0x00, + 0x35, 0x19, 0x1B, 0x00, 0x2C, 0x1B, 0x1C, 0x00, 0x32, 0x19, 0x1B, 0x00, 0x2C, 0x1C, 0x26, 0x00, + 0x35, 0x1B, 0x1C, 0x00, 0x32, 0x1B, 0x14, 0x00, 0x2C, 0x1C, 0x24, 0x00, 0x35, 0x19, 0x1C, 0x00, + 0x2C, 0x1B, 0x27, 0x00, 0x32, 0x1B, 0x19, 0x00, 0x2C, 0x1C, 0x28, 0x00, 0x35, 0x1B, 0x1C, 0x00, + 0x1E, 0x0D, 0x13, 0x00, 0x31, 0x18, 0x00, 0x00, 0x35, 0x19, 0x0D, 0x00, 0x3D, 0x1B, 0x19, 0x00, + 0x1B, 0x1C, 0x1B, 0x00, 0x3D, 0x1B, 0x19, 0x01, 0x1B, 0x1D, 0x1B, 0x00, 0x32, 0x1C, 0x1D, 0x00, + 0x45, 0x19, 0x00, 0x00, 0x1B, 0x1B, 0x19, 0x00, 0x4A, 0x19, 0x1B, 0x0E, 0x1E, 0x19, 0x08, 0x00, + 0x1B, 0x0E, 0x1B, 0x00, 0x2C, 0x1E, 0x29, 0x00, 0x2C, 0x1F, 0x2A, 0x00, 0x33, 0x1E, 0x1C, 0x1F, + 0x31, 0x1D, 0x00, 0x00, 0x2C, 0x1F, 0x21, 0x00, 0x35, 0x1E, 0x1F, 0x00, 0x2C, 0x1B, 0x09, 0x00, + 0x35, 0x19, 0x1B, 0x00, 0x05, 0x15, 0x15, 0x01, 0x1C, 0xC1, 0xFF, 0xFF, 0x2C, 0x15, 0x09, 0x00, + 0x36, 0x15, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x14, 0x02, 0x02, 0x02, 0x11, 0x3F, 0x00, + 0x0C, 0xCE, 0x04, 0x64, 0x75, 0x6D, 0x70, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, + 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x0E, 0x00, 0x06, 0xCE, 0x03, 0x6D, 0x61, + 0x78, 0xDA, 0x18, 0x00, 0x0E, 0x00, 0xDA, 0x80, 0xE8, 0x00, 0x0E, 0x01, 0xCF, 0x03, 0x6D, 0x61, + 0x78, 0x00, 0x0E, 0x00, 0xDA, 0x24, 0x02, 0x0E, 0x03, 0xDA, 0x22, 0x04, 0x0E, 0x04, 0xDA, 0x23, + 0x08, 0x0D, 0x05, 0xDA, 0x1E, 0x28, 0x03, 0x00, 0x00, 0x49, 0x02, 0x00, 0x03, 0x1B, 0x03, 0x02, + 0x00, 0x3B, 0x02, 0x00, 0x03, 0x1B, 0x04, 0x02, 0x00, 0x49, 0x03, 0x00, 0x03, 0x1F, 0x03, 0x07, + 0x00, 0x3A, 0x02, 0x00, 0x03, 0x1B, 0x05, 0x02, 0x00, 0x21, 0x02, 0x05, 0x04, 0x1E, 0x02, 0x02, + 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x82, 0xE5, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xDA, 0x82, 0x04, 0xDA, 0x82, 0x5C, + 0xDA, 0x81, 0xA5, 0xDA, 0x80, 0xE3, 0xDA, 0x82, 0x4A, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x6C, 0x6F, 0x67, 0x31, 0x30, 0xDA, 0x83, 0x5E, 0xDA, 0x7D, 0xCE, 0x01, 0x25, 0xCE, 0x05, 0x64, + 0x3A, 0x20, 0x25, 0x73, 0xDA, 0x81, 0x12, 0xDA, 0x82, 0x5A, 0xDA, 0x81, 0xC5, 0xDA, 0x85, 0x49, + 0xDA, 0x85, 0x4A, 0xDA, 0x85, 0x41, 0x00, 0x3F, 0x00, 0xCF, 0x03, 0x73, 0x72, 0x63, 0x00, 0x3F, + 0x01, 0xCF, 0x03, 0x63, 0x75, 0x72, 0x00, 0x3F, 0x02, 0xDA, 0x85, 0x56, 0x00, 0x3F, 0x03, 0xCF, + 0x06, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x06, 0x3F, 0x04, 0xCF, 0x03, 0x62, 0x65, 0x67, 0x11, + 0x3F, 0x06, 0xCF, 0x05, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x17, 0x3F, 0x07, 0xDA, 0x82, 0x60, 0x21, + 0x3F, 0x0B, 0xCF, 0x06, 0x64, 0x69, 0x67, 0x69, 0x74, 0x73, 0x27, 0x3F, 0x0D, 0xCF, 0x07, 0x66, + 0x6D, 0x74, 0x2D, 0x73, 0x74, 0x72, 0x28, 0x3F, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x52, 0x28, 0x3F, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x53, 0x2B, 0x3E, + 0x10, 0xDA, 0x80, 0xC3, 0x2B, 0x03, 0x05, 0x00, 0x08, 0x04, 0x01, 0x03, 0x2B, 0x05, 0x01, 0x00, + 0x32, 0x05, 0x04, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x04, 0x05, 0x00, + 0x2C, 0x06, 0x01, 0x00, 0x31, 0x06, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, + 0x32, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x32, 0x06, 0x07, 0x00, + 0x2C, 0x09, 0x04, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, 0x06, 0x08, 0x00, 0x06, 0x07, 0x01, 0x03, + 0x3F, 0x09, 0x06, 0x00, 0x32, 0x07, 0x09, 0x00, 0x2C, 0x0B, 0x05, 0x00, 0x35, 0x0A, 0x0B, 0x00, + 0x1B, 0x07, 0x0A, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0B, 0x06, 0x00, 0x35, 0x09, 0x0B, 0x00, + 0x31, 0x09, 0x00, 0x00, 0x2C, 0x0C, 0x07, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x31, 0x0B, 0x00, 0x00, + 0x2C, 0x0C, 0x08, 0x00, 0x35, 0x09, 0x0C, 0x00, 0x1B, 0x0B, 0x09, 0x00, 0x2C, 0x0C, 0x09, 0x00, + 0x2C, 0x0D, 0x0A, 0x00, 0x33, 0x0C, 0x0B, 0x0D, 0x2C, 0x0D, 0x0B, 0x00, 0x35, 0x0C, 0x0D, 0x00, + 0x1B, 0x0D, 0x0C, 0x00, 0x1B, 0x0E, 0x04, 0x00, 0x23, 0x0F, 0x0E, 0x07, 0x1E, 0x0F, 0x14, 0x00, + 0x1B, 0x10, 0x0E, 0x00, 0x2C, 0x11, 0x0C, 0x00, 0x31, 0x11, 0x00, 0x00, 0x2C, 0x12, 0x0D, 0x00, + 0x35, 0x11, 0x12, 0x00, 0x25, 0x12, 0x10, 0x01, 0x1E, 0x12, 0x03, 0x00, 0x2C, 0x11, 0x0E, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x11, 0x0F, 0x00, 0x31, 0x11, 0x00, 0x00, 0x2C, 0x13, 0x0D, 0x00, + 0x35, 0x12, 0x13, 0x00, 0x3B, 0x11, 0x06, 0x10, 0x33, 0x0D, 0x10, 0x11, 0x2C, 0x13, 0x10, 0x00, + 0x35, 0x12, 0x13, 0x00, 0x05, 0x0E, 0x0E, 0x01, 0x1C, 0xEC, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, + 0x8E, 0x04, 0x0B, 0x01, 0x1B, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0B, 0x01, + 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x16, 0x00, + 0x16, 0x00, 0x16, 0x00, 0x0B, 0x01, 0x19, 0x00, 0x28, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, + 0x0B, 0x01, 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x17, 0x00, + 0x17, 0x00, 0x17, 0x00, 0x0B, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, + 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x01, 0x18, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x01, 0x20, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFD, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x8D, 0xF2, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x05, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x05, 0x01, + 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x05, 0x01, 0x05, 0x01, + 0x20, 0x00, 0x20, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x2C, 0x00, 0x2C, 0x00, + 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x1E, 0x00, + 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x42, 0x00, 0x42, 0x00, 0x42, 0x00, 0x42, 0x00, 0x42, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x1A, 0x00, + 0x1A, 0x00, 0x1A, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x19, 0x00, + 0x19, 0x00, 0x05, 0x00, 0x05, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x07, 0x02, 0x09, 0x00, 0x09, 0x0C, 0x16, 0x00, 0x16, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x0B, 0x00, + 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, + 0x05, 0x01, 0x05, 0x00, 0x18, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x18, 0x00, + 0x18, 0xBF, 0xFF, 0x05, 0x02, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x12, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x2C, 0x00, 0x2C, + 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x17, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, 0x01, 0x17, 0x00, 0x17, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x13, 0x00, 0x13, 0xBF, 0xFF, 0x09, 0x02, + 0x11, 0x00, 0x0B, 0x01, 0x0D, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x01, 0x07, 0x00, 0x07, 0xBF, 0xF5, 0x05, 0x00, 0x05, 0x0C, 0x05, 0x00, 0x05, 0xDA, 0x08, + 0xCE, 0x45, 0x28, 0x2E, 0x70, 0x70, 0x61, 0x73, 0x6D, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, + 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x65, 0x74, 0x74, 0x79, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xCF, 0x06, 0x2E, 0x6E, 0x65, 0x78, 0x74, 0x63, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x54, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x00, 0x01, 0x02, 0x05, 0x00, 0x02, 0xCE, 0x06, 0x2E, 0x6E, + 0x65, 0x78, 0x74, 0x63, 0xDA, 0x18, 0xDA, 0x85, 0x10, 0xDA, 0x84, 0xE5, 0x00, 0x05, 0x00, 0xDA, + 0x81, 0x9E, 0x00, 0x05, 0x01, 0xDA, 0x85, 0x70, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8E, 0x57, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x4C, 0x28, 0x2E, 0x6E, 0x65, 0x78, + 0x74, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x6F, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, + 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x2C, 0x20, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x69, 0x6E, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x62, 0x72, 0x65, 0x61, + 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x2E, 0xDA, 0x84, 0xAE, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8D, 0xB5, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xAC, 0xDA, 0x08, 0xCE, 0x2F, 0x28, + 0x2E, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x62, + 0x65, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x64, 0x2E, 0xD7, 0x00, + 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x08, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x12, 0x00, + 0x09, 0xCE, 0x0A, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xDA, 0x18, 0x00, + 0x12, 0x00, 0xCF, 0x03, 0x74, 0x61, 0x62, 0x00, 0x12, 0x01, 0xCF, 0x05, 0x63, 0x6F, 0x6C, 0x6C, + 0x73, 0x00, 0x12, 0x02, 0xCF, 0x0A, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x69, 0x6E, 0x74, 0x6F, + 0x00, 0x11, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x77, 0x02, 0x11, 0x04, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x76, 0x05, 0x11, 0x05, 0xDA, 0x82, 0x11, 0x05, 0x0F, + 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x75, 0x08, 0x0F, 0x06, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x74, 0x0A, 0x0F, 0x03, 0xDA, 0x80, 0xDE, 0x28, 0x04, 0x00, 0x00, + 0x49, 0x03, 0x01, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x0E, 0x00, 0x3A, 0x03, 0x01, 0x04, + 0x1B, 0x05, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x03, 0x05, 0x06, 0x1B, 0x06, 0x03, 0x00, + 0x1F, 0x06, 0x06, 0x00, 0x1B, 0x03, 0x06, 0x00, 0x3A, 0x07, 0x05, 0x03, 0x3C, 0x00, 0x03, 0x07, + 0x49, 0x06, 0x05, 0x06, 0x1C, 0xFB, 0xFF, 0xFF, 0x49, 0x04, 0x01, 0x04, 0x1C, 0xF3, 0xFF, 0xFF, + 0x03, 0x00, 0x00, 0x00, 0x86, 0x31, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x12, 0x00, 0x05, 0xBF, + 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCE, 0x0F, 0x65, 0x6E, 0x74, + 0x65, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5B, 0xCE, 0x12, 0x5D, 0x20, + 0x2D, 0x20, 0x28, 0x71, 0x75, 0x69, 0x74, 0x29, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x78, 0x69, 0x74, + 0xDA, 0x84, 0xC6, 0xDA, 0x84, 0x0F, 0xD1, 0x01, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x07, + 0x03, 0x01, 0x03, 0x00, 0x07, 0x00, 0x01, 0x05, 0xCE, 0x12, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, + 0x65, 0x72, 0x2D, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xDA, 0x18, 0x00, 0x07, + 0x00, 0xCF, 0x03, 0x65, 0x6E, 0x76, 0x00, 0x07, 0x01, 0xCF, 0x05, 0x6C, 0x65, 0x76, 0x65, 0x6C, + 0x00, 0x07, 0x02, 0xCF, 0x07, 0x69, 0x73, 0x2D, 0x72, 0x65, 0x70, 0x6C, 0x00, 0x07, 0x03, 0xCF, + 0x12, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x2D, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x04, 0x07, 0x05, 0xDA, 0x85, 0x88, 0x20, 0x01, 0x03, 0x00, 0x2B, 0x04, 0x01, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x04, 0x01, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x30, 0x06, 0x00, + 0x00, 0x03, 0x06, 0x00, 0x00, 0xCD, 0x02, 0xF6, 0x00, 0x00, 0x0B, 0x02, 0x02, 0x02, 0x11, 0x3D, + 0x01, 0x01, 0x0B, 0xDA, 0x18, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, 0xDA, 0x06, 0xDA, 0x85, 0x58, + 0xDA, 0x84, 0x0C, 0xDA, 0x84, 0x0D, 0xDA, 0x81, 0x6C, 0xDA, 0x81, 0x6B, 0xDA, 0x81, 0x72, 0xCE, + 0x18, 0x62, 0x61, 0x64, 0x20, 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x61, 0x74, 0x20, 0x25, 0x76, 0x3A, 0x20, 0x25, 0x76, 0xDA, 0x85, 0x41, 0xD8, 0x06, 0x65, 0x66, + 0x6C, 0x75, 0x73, 0x68, 0xDA, 0x84, 0x0F, 0xDA, 0x82, 0x04, 0xDA, 0x85, 0x26, 0xD0, 0x05, 0x64, + 0x65, 0x62, 0x75, 0x67, 0xDA, 0x84, 0x93, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, 0x87, 0xBF, 0xFF, + 0x00, 0x01, 0xDA, 0x85, 0x88, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x85, 0x89, 0xBF, 0xFF, 0x00, 0x03, + 0xDA, 0x85, 0x8A, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0x88, 0x00, 0x3D, 0x00, 0xDA, 0x80, 0xAA, + 0x00, 0x3D, 0x01, 0xDA, 0x1E, 0x03, 0x3D, 0x03, 0xCF, 0x02, 0x66, 0x73, 0x1A, 0x2B, 0x05, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x57, 0x1D, 0x2B, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x58, 0x23, 0x2A, 0x08, 0xCF, 0x01, 0x65, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, + 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x25, 0x04, + 0x05, 0x03, 0x1E, 0x04, 0x28, 0x00, 0x2D, 0x05, 0x00, 0x02, 0x1E, 0x05, 0x25, 0x00, 0x2C, 0x05, + 0x02, 0x00, 0x32, 0x05, 0x01, 0x00, 0x44, 0x05, 0x00, 0x00, 0x2D, 0x06, 0x00, 0x00, 0x2C, 0x07, + 0x03, 0x00, 0x3C, 0x06, 0x07, 0x05, 0x2D, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x3B, 0x05, + 0x06, 0x07, 0x20, 0x05, 0x02, 0x00, 0x2C, 0x05, 0x05, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x30, 0x05, + 0x00, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x32, 0x05, 0x07, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x35, 0x07, + 0x08, 0x00, 0x1B, 0x05, 0x07, 0x00, 0x28, 0x08, 0x00, 0x00, 0x37, 0x07, 0x05, 0x08, 0x1B, 0x08, + 0x07, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x07, 0x09, 0x00, 0x2C, 0x0A, + 0x08, 0x00, 0x25, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x08, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x33, 0x07, + 0x06, 0x08, 0x2C, 0x0A, 0x0A, 0x00, 0x35, 0x07, 0x0A, 0x00, 0x2C, 0x0A, 0x0B, 0x00, 0x35, 0x07, + 0x0A, 0x00, 0x1C, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x0C, 0x00, 0x36, 0x05, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x2C, 0x05, 0x0D, 0x00, 0x33, 0x00, 0x01, 0x05, 0x2C, 0x07, 0x0E, 0x00, 0x35, 0x05, + 0x07, 0x00, 0x2C, 0x07, 0x0B, 0x00, 0x35, 0x05, 0x07, 0x00, 0x2D, 0x07, 0x00, 0x00, 0x2C, 0x08, + 0x0F, 0x00, 0x3B, 0x05, 0x07, 0x08, 0x1E, 0x05, 0x05, 0x00, 0x2D, 0x07, 0x00, 0x05, 0x32, 0x00, + 0x07, 0x00, 0x2C, 0x07, 0x10, 0x00, 0x36, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, + 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0xDA, 0x18, 0xDA, + 0x84, 0x0E, 0xBF, 0xFF, 0x00, 0x06, 0xCF, 0x02, 0x70, 0x66, 0x2D, 0x00, 0x00, 0x06, 0x2D, 0x01, + 0x00, 0x01, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0xBF, 0xFF, + 0x8B, 0x7A, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x8B, 0x74, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x01, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x03, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, + 0xBF, 0xFC, 0x09, 0x05, 0x09, 0x00, 0x09, 0xBF, 0xF8, 0x07, 0x0A, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x00, 0x1E, + 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x09, 0x42, 0x00, 0x00, 0x00, 0x8B, 0x72, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x25, 0x00, 0x00, 0x00, 0xD0, + 0x06, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0xD0, 0x09, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0xD0, 0x03, 0x65, 0x6E, 0x76, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x43, 0x01, + 0x01, 0x01, 0x25, 0x81, 0x1A, 0x00, 0x05, 0x2F, 0xCE, 0x0B, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, + 0x6E, 0x74, 0x65, 0x78, 0x74, 0xDA, 0x18, 0xD0, 0x04, 0x72, 0x65, 0x61, 0x64, 0xD0, 0x0E, 0x6F, + 0x6E, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xD0, 0x0B, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2D, 0x66, 0x6C, 0x61, 0x67, 0x73, 0xDA, 0x85, 0x95, 0xD0, 0x10, 0x6F, + 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xDA, + 0x85, 0x93, 0xD0, 0x06, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0xDA, 0x85, 0x94, 0xDA, 0x84, 0xBA, + 0xD0, 0x09, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, 0xD0, 0x12, 0x6F, 0x6E, 0x2D, + 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0xD0, + 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x65, 0x72, 0xDA, 0x83, 0xEB, 0xDA, 0x84, 0x95, 0xDA, + 0x85, 0x26, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x05, 0x03, 0x05, 0x0C, 0x24, 0x00, + 0x07, 0xCE, 0x0B, 0x62, 0x61, 0x64, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x18, + 0xDA, 0x85, 0x22, 0xDA, 0x80, 0xFB, 0xCE, 0x05, 0x1B, 0x5B, 0x33, 0x31, 0x6D, 0xDA, 0x82, 0x04, + 0xCE, 0x01, 0x3A, 0xCE, 0x11, 0x3A, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x3A, 0x20, 0xDA, 0x81, 0xC5, 0xDA, 0x85, 0x26, 0xDA, 0x84, 0xC6, 0xD7, + 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x0B, 0x03, 0x03, 0x03, 0x08, 0x25, 0x00, 0x01, 0x06, 0xCE, + 0x0E, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0x2D, 0x63, 0x6F, 0x6C, 0xDA, + 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, + 0xCE, 0x07, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x83, 0x0B, + 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x07, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x66, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, + 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0xD0, 0x01, 0x72, 0xDA, 0x84, 0xBE, 0xDA, 0x81, 0x86, 0xDA, 0x81, + 0x6B, 0xDA, 0x82, 0xF2, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, 0x00, 0x25, 0x00, 0xCF, 0x05, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x00, 0x25, 0x01, 0xDA, 0x82, 0x66, 0x00, 0x25, 0x02, 0xCF, 0x03, 0x63, + 0x6F, 0x6C, 0x00, 0x25, 0x03, 0xCF, 0x0E, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, 0x6C, 0x69, 0x6E, + 0x65, 0x2D, 0x63, 0x6F, 0x6C, 0x14, 0x24, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x70, 0x17, 0x24, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x71, 0x1E, 0x01, 0x02, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x00, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x2C, 0x04, 0x01, 0x00, 0x32, 0x00, 0x04, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x1B, 0x05, 0x04, 0x00, 0x1E, 0x04, 0x16, 0x00, 0x30, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x03, + 0x00, 0x32, 0x06, 0x07, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x06, 0x07, + 0x00, 0x28, 0x08, 0x00, 0x00, 0x37, 0x07, 0x06, 0x08, 0x1B, 0x08, 0x07, 0x00, 0x31, 0x05, 0x00, + 0x00, 0x2C, 0x09, 0x05, 0x00, 0x35, 0x07, 0x09, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x09, 0x06, + 0x00, 0x35, 0x07, 0x09, 0x00, 0x2C, 0x0A, 0x07, 0x00, 0x25, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x02, + 0x00, 0x03, 0x08, 0x00, 0x00, 0x39, 0x07, 0x08, 0x06, 0x03, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0C, 0x38, 0x01, 0x05, 0xDA, 0x18, + 0xDA, 0x84, 0xC0, 0xDA, 0x84, 0xC1, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, + 0x01, 0x00, 0x02, 0x00, 0x02, 0xCE, 0x03, 0x64, 0x65, 0x63, 0xDA, 0x18, 0x00, 0x02, 0x00, 0xDA, + 0x1E, 0x00, 0x02, 0x01, 0xCF, 0x03, 0x64, 0x65, 0x63, 0x07, 0x02, 0x00, 0x01, 0x03, 0x02, 0x00, + 0x00, 0x80, 0x89, 0x20, 0x00, 0x20, 0xDA, 0x82, 0x5C, 0xDA, 0x83, 0xB8, 0xDA, 0x82, 0x03, 0xDA, + 0x85, 0x4A, 0xDA, 0x84, 0xC6, 0xDA, 0x7D, 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0x5B, 0xCE, 0x01, 0x5E, + 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x80, 0xAA, 0x05, 0x38, 0x01, 0xCF, 0x0B, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x2D, 0x63, 0x6F, 0x64, 0x65, 0x06, 0x38, 0x02, 0xDA, 0x83, 0x09, 0x0B, 0x19, 0x04, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x72, 0x1E, 0x37, 0x04, 0xCF, 0x08, 0x6C, 0x69, + 0x6E, 0x65, 0x2D, 0x65, 0x6E, 0x64, 0x2D, 0x00, 0x00, 0x05, 0x2C, 0x01, 0x00, 0x00, 0x32, 0x00, + 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x35, 0x00, 0x01, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x2B, 0x02, + 0x00, 0x00, 0x2D, 0x03, 0x00, 0x01, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, + 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x22, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x0C, 0x00, 0x1E, 0x02, + 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x33, 0x05, + 0x01, 0x02, 0x2C, 0x05, 0x04, 0x00, 0x35, 0x02, 0x05, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x05, 0x02, + 0x02, 0x01, 0x07, 0x04, 0x04, 0x01, 0x1C, 0xF4, 0xFF, 0xFF, 0x1E, 0x02, 0x1E, 0x00, 0x2C, 0x03, + 0x03, 0x00, 0x33, 0x03, 0x01, 0x02, 0x2C, 0x04, 0x04, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, + 0x03, 0x00, 0x33, 0x01, 0x02, 0x04, 0x2C, 0x05, 0x05, 0x00, 0x35, 0x03, 0x05, 0x00, 0x2C, 0x05, + 0x06, 0x00, 0x32, 0x05, 0x03, 0x00, 0x2C, 0x06, 0x07, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2D, 0x03, + 0x00, 0x02, 0x1E, 0x03, 0x0F, 0x00, 0x2D, 0x03, 0x00, 0x02, 0x06, 0x02, 0x02, 0x03, 0x2D, 0x03, + 0x00, 0x02, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x08, 0x00, 0x35, 0x03, 0x05, 0x00, 0x2C, 0x05, + 0x09, 0x00, 0x32, 0x05, 0x03, 0x00, 0x2C, 0x06, 0x0A, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2C, 0x03, + 0x0B, 0x00, 0x32, 0x05, 0x03, 0x00, 0x2C, 0x03, 0x07, 0x00, 0x36, 0x03, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x89, 0x7C, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, + 0x16, 0x00, 0x16, 0x00, 0x05, 0x01, 0x05, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x15, 0x01, 0x12, 0x00, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x01, 0x07, 0x00, 0x11, 0xBF, 0xFD, 0x05, 0x00, 0x05, 0x04, 0x05, 0x01, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x07, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x01, 0x09, 0x00, 0x09, 0x01, 0x24, + 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x07, 0xBF, 0xFD, 0x05, 0x89, 0x79, 0x03, 0x00, + 0x03, 0x00, 0x10, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x1B, 0x01, + 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x26, 0x00, 0x00, 0x00, 0xCE, 0x04, 0x1B, 0x5B, 0x30, + 0x6D, 0xDA, 0x85, 0x8C, 0x00, 0x24, 0x00, 0xCF, 0x03, 0x6D, 0x73, 0x67, 0x00, 0x24, 0x01, 0xCF, + 0x06, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x66, 0x00, 0x24, 0x02, 0xDA, 0x85, 0xAB, 0x00, 0x24, 0x03, + 0xDA, 0x82, 0x66, 0x00, 0x24, 0x04, 0xDA, 0x85, 0xAC, 0x00, 0x24, 0x05, 0xCF, 0x0B, 0x62, 0x61, + 0x64, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x04, 0x24, 0x07, 0xCF, 0x02, 0x65, 0x63, + 0x2C, 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x2C, 0x08, 0x03, 0x00, 0x2C, 0x09, 0x04, 0x00, 0x33, 0x08, 0x02, 0x09, 0x2C, 0x09, 0x04, 0x00, + 0x33, 0x03, 0x09, 0x04, 0x2C, 0x09, 0x05, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x0A, 0x06, 0x00, + 0x35, 0x09, 0x0A, 0x00, 0x1E, 0x01, 0x06, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, 0x01, 0x00, 0x08, + 0x2C, 0x0A, 0x07, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, + 0x2C, 0x0A, 0x08, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x1E, 0x07, 0x08, 0x00, 0x33, 0x02, 0x03, 0x04, + 0x2C, 0x0A, 0x09, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x31, 0x08, 0x00, 0x00, + 0x2C, 0x0A, 0x06, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x2C, 0x08, 0x0B, 0x00, 0x36, 0x08, 0x00, 0x00, + 0x89, 0x9E, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x08, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, + 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x03, 0x00, 0x03, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x0C, 0x05, 0x03, 0x05, 0x0C, 0x1F, 0x00, 0x07, 0xCE, 0x0C, 0x77, 0x61, 0x72, 0x6E, + 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x85, 0x22, 0xDA, 0x80, 0xFB, + 0xCE, 0x05, 0x1B, 0x5B, 0x33, 0x33, 0x6D, 0xDA, 0x82, 0x04, 0xDA, 0x85, 0xA3, 0xCE, 0x13, 0x3A, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, + 0x20, 0x28, 0xCE, 0x03, 0x29, 0x3A, 0x20, 0xDA, 0x81, 0xC5, 0xDA, 0x84, 0xC6, 0xDA, 0x85, 0xA5, + 0xDA, 0x85, 0xB7, 0xDA, 0x85, 0x8C, 0x00, 0x1F, 0x00, 0xDA, 0x85, 0xB8, 0x00, 0x1F, 0x01, 0xDA, + 0x85, 0x88, 0x00, 0x1F, 0x02, 0xDA, 0x85, 0xAB, 0x00, 0x1F, 0x03, 0xDA, 0x82, 0x66, 0x00, 0x1F, + 0x04, 0xDA, 0x85, 0xAC, 0x00, 0x1F, 0x05, 0xCF, 0x0C, 0x77, 0x61, 0x72, 0x6E, 0x2D, 0x63, 0x6F, + 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x04, 0x1F, 0x07, 0xDA, 0x85, 0xBB, 0x2C, 0x06, 0x00, 0x00, 0x31, + 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, + 0x07, 0x03, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x2C, + 0x09, 0x04, 0x00, 0x33, 0x08, 0x02, 0x09, 0x2C, 0x09, 0x04, 0x00, 0x33, 0x03, 0x09, 0x04, 0x2C, + 0x09, 0x05, 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x33, 0x09, 0x01, 0x0A, 0x2C, 0x0A, 0x07, 0x00, 0x35, + 0x09, 0x0A, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x0A, 0x08, 0x00, 0x35, 0x08, 0x0A, 0x00, 0x1E, + 0x07, 0x08, 0x00, 0x33, 0x02, 0x03, 0x04, 0x2C, 0x0B, 0x09, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x2C, + 0x0A, 0x0A, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x07, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x2C, + 0x0A, 0x0B, 0x00, 0x36, 0x0A, 0x00, 0x00, 0x89, 0x8C, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x03, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x08, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x01, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x01, 0x03, 0x00, 0x03, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0D, 0x02, + 0x02, 0x02, 0x0B, 0x21, 0x00, 0x06, 0xCE, 0x09, 0x62, 0x61, 0x64, 0x2D, 0x70, 0x61, 0x72, 0x73, + 0x65, 0xDA, 0x18, 0xDA, 0x85, 0x22, 0xDA, 0x80, 0xFB, 0xD0, 0x05, 0x77, 0x68, 0x65, 0x72, 0x65, + 0xDA, 0x85, 0xA2, 0xDA, 0x82, 0x04, 0xDA, 0x81, 0x72, 0xDA, 0x85, 0xB7, 0xDA, 0x85, 0xA3, 0xCE, + 0x0F, 0x3A, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x3A, 0x20, + 0xDA, 0x84, 0xC6, 0xDA, 0x85, 0x8C, 0x00, 0x21, 0x00, 0xDA, 0x6D, 0x00, 0x21, 0x01, 0xDA, 0x85, + 0xAB, 0x00, 0x21, 0x02, 0xCF, 0x09, 0x62, 0x61, 0x64, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x04, + 0x21, 0x04, 0xDA, 0x85, 0xBB, 0x09, 0x21, 0x07, 0xDA, 0x82, 0x66, 0x0B, 0x21, 0x08, 0xDA, 0x85, + 0xAC, 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, + 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, + 0x00, 0x3D, 0x06, 0x05, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x3D, 0x06, 0x05, 0x01, 0x1B, 0x08, 0x06, + 0x00, 0x1E, 0x04, 0x03, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x04, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1E, 0x04, 0x03, + 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x2C, 0x0B, 0x07, + 0x00, 0x33, 0x06, 0x01, 0x0B, 0x2C, 0x0B, 0x07, 0x00, 0x33, 0x07, 0x0B, 0x08, 0x2C, 0x0B, 0x08, + 0x00, 0x33, 0x0B, 0x09, 0x0A, 0x2C, 0x0C, 0x09, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x2C, 0x06, 0x0A, + 0x00, 0x36, 0x06, 0x00, 0x00, 0x89, 0x67, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, + 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x07, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0xBF, 0xF7, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x0A, 0x03, 0x00, 0x03, 0xD0, 0x0B, 0x3C, 0x61, 0x6E, 0x6F, 0x6E, + 0x79, 0x6D, 0x6F, 0x75, 0x73, 0x3E, 0xD0, 0x03, 0x79, 0x64, 0x74, 0xDA, 0x85, 0xA7, 0xD0, 0x0C, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x2D, 0x66, 0x69, 0x6C, 0x65, 0xD0, 0x04, 0x65, 0x78, + 0x69, 0x74, 0xDA, 0x83, 0x3A, 0xDA, 0x81, 0x45, 0xDA, 0x84, 0x37, 0xD0, 0x07, 0x63, 0x6F, 0x6E, + 0x73, 0x75, 0x6D, 0x65, 0xD0, 0x07, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0xD0, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0xD0, 0x08, 0x68, 0x61, 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, 0xDA, + 0x82, 0x04, 0xDA, 0x82, 0x76, 0xD0, 0x06, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0xD0, 0x05, 0x66, + 0x6C, 0x75, 0x73, 0x68, 0xDA, 0x83, 0x76, 0xD0, 0x03, 0x65, 0x6F, 0x66, 0xDA, 0x81, 0x72, 0x00, + 0x81, 0x1A, 0x00, 0xCF, 0x04, 0x6F, 0x70, 0x74, 0x73, 0x00, 0x81, 0x1A, 0x01, 0xCF, 0x0B, 0x72, + 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x02, 0x81, 0x1A, 0x03, 0xCF, 0x04, + 0x72, 0x65, 0x61, 0x64, 0x05, 0x81, 0x1A, 0x04, 0xCF, 0x0E, 0x6F, 0x6E, 0x2D, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x08, 0x81, 0x1A, 0x05, 0xCF, 0x05, 0x67, 0x75, + 0x61, 0x72, 0x64, 0x0B, 0x81, 0x1A, 0x06, 0xDA, 0x85, 0x87, 0x0E, 0x81, 0x1A, 0x07, 0xCF, 0x10, + 0x6F, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, + 0x11, 0x81, 0x1A, 0x08, 0xCF, 0x06, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x14, 0x81, 0x1A, 0x09, + 0xCF, 0x06, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x17, 0x81, 0x1A, 0x0A, 0xCF, 0x08, 0x6F, 0x6E, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1A, 0x81, 0x1A, 0x0B, 0xCF, 0x0D, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6C, 0x74, 0x2D, 0x77, 0x68, 0x65, 0x72, 0x65, 0x1D, 0x81, 0x1A, 0x0C, 0xCF, 0x09, 0x65, + 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x81, 0x1A, 0x0D, 0xCF, 0x12, 0x6F, 0x6E, + 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, + 0x23, 0x81, 0x1A, 0x0E, 0xCF, 0x06, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2A, 0x30, 0x0F, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x74, 0x33, 0x81, 0x1A, 0x0F, 0xDA, 0x85, 0x87, 0x39, + 0x81, 0x1A, 0x11, 0xDA, 0x85, 0xD8, 0x3E, 0x81, 0x1A, 0x13, 0xDA, 0x85, 0xDA, 0x43, 0x81, 0x1A, + 0x15, 0xDA, 0x85, 0xD7, 0x48, 0x81, 0x1A, 0x17, 0xDA, 0x85, 0xDD, 0x4D, 0x81, 0x1A, 0x19, 0xDA, + 0x85, 0xD5, 0x53, 0x81, 0x1A, 0x1B, 0xDA, 0x85, 0xDC, 0x58, 0x81, 0x1A, 0x1D, 0xDA, 0x85, 0xDB, + 0x5D, 0x81, 0x1A, 0x1F, 0xDA, 0x85, 0xD6, 0x5E, 0x81, 0x1A, 0x20, 0xDA, 0x85, 0xAB, 0x66, 0x81, + 0x1A, 0x22, 0xCF, 0x05, 0x6C, 0x69, 0x6E, 0x74, 0x73, 0x68, 0x81, 0x1A, 0x24, 0xCF, 0x05, 0x65, + 0x76, 0x61, 0x6C, 0x31, 0x76, 0x7D, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, + 0x7D, 0x81, 0x1A, 0x26, 0xDA, 0x6D, 0x80, 0x81, 0x81, 0x1A, 0x28, 0xCF, 0x09, 0x70, 0x2D, 0x63, + 0x6F, 0x6E, 0x73, 0x75, 0x6D, 0x65, 0x80, 0x85, 0x81, 0x1A, 0x2A, 0xCF, 0x09, 0x70, 0x2D, 0x70, + 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0x80, 0x89, 0x81, 0x1A, 0x2C, 0xCF, 0x08, 0x70, 0x2D, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x80, 0x8D, 0x81, 0x1A, 0x2E, 0xCF, 0x0A, 0x70, 0x2D, 0x68, 0x61, + 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, 0x80, 0x8F, 0x81, 0x1A, 0x30, 0xCF, 0x09, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x80, 0x91, 0x81, 0x1A, 0x32, 0xCF, 0x07, 0x70, 0x72, 0x6F, + 0x64, 0x75, 0x63, 0x65, 0x80, 0x95, 0x81, 0x1A, 0x34, 0xDA, 0x82, 0x26, 0x80, 0x96, 0x81, 0x1A, + 0x35, 0xCF, 0x0F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2D, 0x6E, 0x6F, 0x74, 0x2D, 0x64, 0x6F, + 0x6E, 0x65, 0x80, 0xA2, 0x80, 0xFA, 0x37, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x46, + 0x80, 0xB5, 0x80, 0xFA, 0x39, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x47, 0x80, 0xB8, + 0x80, 0xFA, 0x3A, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x48, 0x80, 0xBB, 0x80, 0xFA, + 0x3B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x49, 0x80, 0xBB, 0x80, 0xC9, 0x39, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x4B, 0x80, 0xBF, 0x80, 0xC6, 0x3E, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x4A, 0x80, 0xC9, 0x80, 0xD1, 0x3B, 0xCF, 0x09, 0x6E, 0x65, 0x77, + 0x2D, 0x77, 0x68, 0x65, 0x72, 0x65, 0x80, 0xD2, 0x80, 0xFA, 0x3C, 0xCF, 0x06, 0x70, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x80, 0xD3, 0x80, 0xFA, 0x3D, 0xCF, 0x07, 0x70, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x80, 0xD5, 0x80, 0xFA, 0x3F, 0xDA, 0x81, 0x25, 0x2C, 0x03, 0x00, 0x00, 0x3A, 0x02, 0x00, + 0x03, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x3A, 0x02, 0x00, 0x04, 0x1B, 0x04, 0x02, + 0x00, 0x2C, 0x05, 0x02, 0x00, 0x3A, 0x02, 0x00, 0x05, 0x1B, 0x05, 0x02, 0x00, 0x2C, 0x06, 0x03, + 0x00, 0x3A, 0x02, 0x00, 0x06, 0x1B, 0x06, 0x02, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x3A, 0x02, 0x00, + 0x07, 0x1B, 0x07, 0x02, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x3A, 0x02, 0x00, 0x08, 0x1B, 0x08, 0x02, + 0x00, 0x2C, 0x09, 0x06, 0x00, 0x3A, 0x02, 0x00, 0x09, 0x1B, 0x09, 0x02, 0x00, 0x2C, 0x0A, 0x07, + 0x00, 0x3A, 0x02, 0x00, 0x0A, 0x1B, 0x0A, 0x02, 0x00, 0x2C, 0x0B, 0x08, 0x00, 0x3A, 0x02, 0x00, + 0x0B, 0x1B, 0x0B, 0x02, 0x00, 0x2C, 0x0C, 0x09, 0x00, 0x3A, 0x02, 0x00, 0x0C, 0x1B, 0x0C, 0x02, + 0x00, 0x2C, 0x0D, 0x0A, 0x00, 0x3A, 0x02, 0x00, 0x0D, 0x1B, 0x0D, 0x02, 0x00, 0x2C, 0x0E, 0x0B, + 0x00, 0x3A, 0x02, 0x00, 0x0E, 0x1B, 0x0E, 0x02, 0x00, 0x20, 0x06, 0x0E, 0x00, 0x2C, 0x10, 0x0C, + 0x00, 0x35, 0x0F, 0x10, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x11, 0x0D, 0x00, 0x35, 0x10, 0x11, + 0x00, 0x1B, 0x0F, 0x10, 0x00, 0x1E, 0x0F, 0x03, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x1C, 0x03, 0x00, + 0x00, 0x44, 0x11, 0x00, 0x00, 0x1B, 0x10, 0x11, 0x00, 0x1B, 0x02, 0x10, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x02, 0x06, 0x00, 0x1B, 0x0F, 0x02, 0x00, 0x20, 0x08, 0x04, 0x00, 0x30, 0x11, 0x00, + 0x00, 0x1B, 0x10, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x10, 0x08, 0x00, 0x1B, 0x11, 0x10, + 0x00, 0x20, 0x0A, 0x03, 0x00, 0x2C, 0x12, 0x0E, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x12, 0x0A, + 0x00, 0x1B, 0x13, 0x12, 0x00, 0x20, 0x07, 0x03, 0x00, 0x2C, 0x14, 0x0F, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x14, 0x07, 0x00, 0x1B, 0x15, 0x14, 0x00, 0x20, 0x0D, 0x03, 0x00, 0x2C, 0x16, 0x10, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x16, 0x0D, 0x00, 0x1B, 0x17, 0x16, 0x00, 0x20, 0x04, 0x03, + 0x00, 0x2C, 0x18, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x18, 0x04, 0x00, 0x1B, 0x19, 0x18, + 0x00, 0x20, 0x0C, 0x04, 0x00, 0x30, 0x1B, 0x01, 0x00, 0x1B, 0x1A, 0x1B, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x1A, 0x0C, 0x00, 0x1B, 0x1B, 0x1A, 0x00, 0x20, 0x0B, 0x03, 0x00, 0x2C, 0x1C, 0x12, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x1C, 0x0B, 0x00, 0x1B, 0x1D, 0x1C, 0x00, 0x20, 0x05, 0x03, + 0x00, 0x2C, 0x1E, 0x13, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x1E, 0x05, 0x00, 0x1B, 0x1F, 0x1E, + 0x00, 0x1B, 0x20, 0x1D, 0x00, 0x31, 0x20, 0x00, 0x00, 0x2C, 0x22, 0x14, 0x00, 0x35, 0x21, 0x22, + 0x00, 0x1E, 0x21, 0x03, 0x00, 0x2C, 0x22, 0x15, 0x00, 0x3C, 0x0F, 0x22, 0x20, 0x40, 0x21, 0x00, + 0x00, 0x1B, 0x22, 0x21, 0x00, 0x30, 0x23, 0x02, 0x00, 0x1B, 0x24, 0x23, 0x00, 0x1E, 0x03, 0x0E, + 0x00, 0x2C, 0x26, 0x16, 0x00, 0x3A, 0x25, 0x0F, 0x26, 0x1E, 0x25, 0x02, 0x00, 0x1C, 0x06, 0x00, + 0x00, 0x32, 0x0F, 0x20, 0x00, 0x35, 0x25, 0x03, 0x00, 0x31, 0x25, 0x00, 0x00, 0x35, 0x26, 0x24, + 0x00, 0x1C, 0xF8, 0xFF, 0xFF, 0x2C, 0x25, 0x17, 0x00, 0x33, 0x0F, 0x25, 0x0F, 0x2C, 0x25, 0x18, + 0x00, 0x36, 0x25, 0x00, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x25, 0x09, 0x00, 0x1C, 0x04, 0x00, + 0x00, 0x2C, 0x27, 0x19, 0x00, 0x35, 0x26, 0x27, 0x00, 0x1B, 0x25, 0x26, 0x00, 0x1B, 0x26, 0x25, + 0x00, 0x2C, 0x27, 0x1A, 0x00, 0x31, 0x27, 0x00, 0x00, 0x35, 0x27, 0x26, 0x00, 0x1B, 0x28, 0x27, + 0x00, 0x2C, 0x29, 0x1B, 0x00, 0x31, 0x29, 0x00, 0x00, 0x35, 0x29, 0x26, 0x00, 0x1B, 0x2A, 0x29, + 0x00, 0x2C, 0x2B, 0x1C, 0x00, 0x31, 0x2B, 0x00, 0x00, 0x35, 0x2B, 0x26, 0x00, 0x1B, 0x2C, 0x2B, + 0x00, 0x2C, 0x2D, 0x1D, 0x00, 0x31, 0x2D, 0x00, 0x00, 0x35, 0x2D, 0x26, 0x00, 0x1B, 0x2E, 0x2D, + 0x00, 0x30, 0x2F, 0x03, 0x00, 0x1B, 0x30, 0x2F, 0x00, 0x30, 0x31, 0x04, 0x00, 0x1B, 0x32, 0x31, + 0x00, 0x2C, 0x33, 0x1E, 0x00, 0x31, 0x33, 0x00, 0x00, 0x41, 0x33, 0x00, 0x00, 0x1B, 0x34, 0x33, + 0x00, 0x29, 0x35, 0x00, 0x00, 0x1E, 0x35, 0x64, 0x00, 0x2C, 0x36, 0x16, 0x00, 0x31, 0x36, 0x00, + 0x00, 0x35, 0x36, 0x0F, 0x00, 0x1E, 0x36, 0x02, 0x00, 0x1C, 0x5F, 0x00, 0x00, 0x31, 0x34, 0x00, + 0x00, 0x2C, 0x37, 0x1F, 0x00, 0x35, 0x36, 0x37, 0x00, 0x32, 0x34, 0x26, 0x00, 0x35, 0x36, 0x11, + 0x00, 0x1B, 0x37, 0x36, 0x00, 0x2C, 0x38, 0x20, 0x00, 0x25, 0x36, 0x37, 0x38, 0x1E, 0x36, 0x08, + 0x00, 0x31, 0x26, 0x00, 0x00, 0x2C, 0x39, 0x21, 0x00, 0x35, 0x38, 0x39, 0x00, 0x31, 0x34, 0x00, + 0x00, 0x2C, 0x39, 0x1F, 0x00, 0x35, 0x38, 0x39, 0x00, 0x1C, 0x4E, 0x00, 0x00, 0x31, 0x37, 0x00, + 0x00, 0x2C, 0x3A, 0x22, 0x00, 0x35, 0x39, 0x3A, 0x00, 0x1E, 0x39, 0x04, 0x00, 0x3F, 0x3A, 0x37, + 0x00, 0x1B, 0x38, 0x3A, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x38, 0x00, 0x00, 0x1B, 0x39, 0x38, + 0x00, 0x2B, 0x3A, 0x00, 0x00, 0x3B, 0x38, 0x37, 0x3A, 0x1B, 0x3A, 0x38, 0x00, 0x2B, 0x3B, 0x01, + 0x00, 0x3B, 0x38, 0x37, 0x3B, 0x1B, 0x3B, 0x38, 0x00, 0x1E, 0x39, 0x0C, 0x00, 0x2B, 0x3E, 0x02, + 0x00, 0x48, 0x3D, 0x3E, 0x39, 0x1B, 0x3E, 0x3D, 0x00, 0x1E, 0x3D, 0x05, 0x00, 0x2C, 0x40, 0x08, + 0x00, 0x25, 0x3F, 0x3A, 0x40, 0x1B, 0x3C, 0x3F, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x3C, 0x3E, + 0x00, 0x1B, 0x38, 0x3C, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x38, 0x39, 0x00, 0x1E, 0x38, 0x09, + 0x00, 0x1B, 0x20, 0x3B, 0x00, 0x31, 0x3B, 0x00, 0x00, 0x2C, 0x3D, 0x14, 0x00, 0x35, 0x3C, 0x3D, + 0x00, 0x1E, 0x3C, 0x03, 0x00, 0x2C, 0x3D, 0x15, 0x00, 0x3C, 0x0F, 0x3D, 0x3B, 0x1C, 0x29, 0x00, + 0x00, 0x2B, 0x3C, 0x00, 0x00, 0x28, 0x3D, 0x00, 0x00, 0x3F, 0x3E, 0x34, 0x00, 0x1B, 0x3F, 0x3E, + 0x00, 0x26, 0x3E, 0x3F, 0x00, 0x1E, 0x3E, 0x05, 0x00, 0x31, 0x26, 0x00, 0x00, 0x2C, 0x41, 0x23, + 0x00, 0x35, 0x40, 0x41, 0x00, 0x2A, 0x35, 0x00, 0x00, 0x21, 0x3E, 0x3F, 0x3C, 0x1E, 0x3E, 0x1D, + 0x00, 0x33, 0x26, 0x34, 0x3C, 0x35, 0x40, 0x28, 0x00, 0x06, 0x3C, 0x3C, 0x40, 0x31, 0x26, 0x00, + 0x00, 0x35, 0x40, 0x2E, 0x00, 0x1E, 0x40, 0x0A, 0x00, 0x35, 0x41, 0x32, 0x00, 0x34, 0x41, 0x00, + 0x00, 0x35, 0x42, 0x24, 0x00, 0x2C, 0x41, 0x16, 0x00, 0x31, 0x41, 0x00, 0x00, 0x35, 0x41, 0x0F, + 0x00, 0x1E, 0x41, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xF5, 0xFF, 0xFF, 0x31, 0x26, 0x00, + 0x00, 0x35, 0x40, 0x2C, 0x00, 0x2C, 0x42, 0x24, 0x00, 0x25, 0x41, 0x40, 0x42, 0x1E, 0x41, 0x08, + 0x00, 0x32, 0x26, 0x20, 0x00, 0x35, 0x40, 0x30, 0x00, 0x2C, 0x40, 0x16, 0x00, 0x31, 0x40, 0x00, + 0x00, 0x35, 0x40, 0x0F, 0x00, 0x1E, 0x40, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xE3, 0xFF, + 0xFF, 0x1C, 0x9D, 0xFF, 0xFF, 0x2C, 0x36, 0x16, 0x00, 0x31, 0x36, 0x00, 0x00, 0x35, 0x36, 0x0F, + 0x00, 0x1E, 0x36, 0x02, 0x00, 0x1C, 0x14, 0x00, 0x00, 0x31, 0x26, 0x00, 0x00, 0x35, 0x37, 0x2E, + 0x00, 0x1E, 0x37, 0x0A, 0x00, 0x35, 0x38, 0x32, 0x00, 0x34, 0x38, 0x00, 0x00, 0x35, 0x39, 0x24, + 0x00, 0x2C, 0x38, 0x16, 0x00, 0x31, 0x38, 0x00, 0x00, 0x35, 0x38, 0x0F, 0x00, 0x1E, 0x38, 0x02, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0xF5, 0xFF, 0xFF, 0x31, 0x26, 0x00, 0x00, 0x35, 0x37, 0x2C, + 0x00, 0x2C, 0x39, 0x24, 0x00, 0x25, 0x38, 0x37, 0x39, 0x1E, 0x38, 0x03, 0x00, 0x32, 0x26, 0x20, + 0x00, 0x35, 0x37, 0x30, 0x00, 0x2C, 0x36, 0x16, 0x00, 0x28, 0x37, 0x00, 0x00, 0x3C, 0x0F, 0x36, + 0x37, 0x2C, 0x36, 0x17, 0x00, 0x33, 0x0F, 0x36, 0x0F, 0x2C, 0x36, 0x18, 0x00, 0x36, 0x36, 0x00, + 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x05, 0x01, 0x12, 0xDA, 0x18, + 0xDA, 0x82, 0x04, 0xD8, 0x07, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0xBF, 0xFF, 0x00, 0x00, + 0xDA, 0x85, 0xD2, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x85, + 0xD4, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0xD6, 0xBF, + 0xFF, 0x00, 0x06, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, + 0x08, 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, + 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xDC, + 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x85, 0xDE, 0xBF, 0xFF, + 0x00, 0x0F, 0xDA, 0x85, 0xDF, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0x00, 0x05, 0x00, 0xDA, + 0x82, 0x26, 0x00, 0x05, 0x01, 0xDA, 0x6D, 0x2C, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x0F, 0x33, + 0x02, 0x00, 0x03, 0x2C, 0x02, 0x01, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x89, 0xF1, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x02, 0xCE, 0x08, 0x65, 0x76, 0x61, 0x6C, 0x75, + 0x61, 0x74, 0x65, 0xDA, 0x18, 0x00, 0x01, 0x00, 0xDA, 0x1E, 0x00, 0x01, 0x01, 0xCF, 0x08, 0x65, + 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x36, 0x00, 0x00, 0x00, 0x89, 0xF6, 0x29, 0xCD, 0x02, + 0xFE, 0x00, 0x00, 0x0D, 0x03, 0x01, 0x03, 0x02, 0x1E, 0x01, 0x01, 0x23, 0xCE, 0x05, 0x65, 0x76, + 0x61, 0x6C, 0x31, 0xDA, 0x18, 0xDA, 0x81, 0x6B, 0xD8, 0x11, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, + 0x63, 0x61, 0x6E, 0x2D, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x3F, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x85, 0xD2, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x85, 0xD4, + 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0xD6, 0xBF, 0xFF, + 0x00, 0x06, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x08, + 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, + 0xDA, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xDC, 0xBF, + 0xFF, 0x00, 0x0D, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x85, 0xDE, 0xBF, 0xFF, 0x00, + 0x0F, 0xDA, 0x85, 0xDF, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x11, 0xDA, + 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0xD7, + 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, + 0x00, 0x1B, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x1F, + 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x20, 0xDA, 0x85, 0xAB, 0xBF, 0xFF, 0x00, 0x22, 0xDA, 0x85, + 0xE0, 0x00, 0x1E, 0x00, 0xCF, 0x06, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x00, 0x1E, 0x01, 0xCF, + 0x01, 0x6C, 0x00, 0x1E, 0x02, 0xDA, 0x82, 0x11, 0x00, 0x1E, 0x03, 0xDA, 0x85, 0xE1, 0x08, 0x1E, + 0x05, 0xDA, 0x85, 0xF8, 0x09, 0x1E, 0x06, 0xCF, 0x04, 0x67, 0x6F, 0x6F, 0x64, 0x0A, 0x1E, 0x07, + 0xCF, 0x09, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x76, 0x61, 0x6C, 0x11, 0x1E, 0x08, 0xDA, 0x80, + 0xAA, 0x17, 0x1D, 0x0C, 0xDA, 0x80, 0xAD, 0x2D, 0x05, 0x00, 0x0E, 0x1E, 0x05, 0x06, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2D, 0x06, 0x00, 0x0E, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x29, 0x06, 0x00, 0x00, 0x28, + 0x07, 0x00, 0x00, 0x30, 0x08, 0x00, 0x00, 0x2D, 0x09, 0x00, 0x1F, 0x2D, 0x0A, 0x00, 0x0F, 0x33, + 0x08, 0x09, 0x0A, 0x2C, 0x0A, 0x00, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x08, 0x09, 0x00, 0x31, + 0x08, 0x00, 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1E, 0x0A, 0x08, 0x00, 0x37, + 0x0B, 0x08, 0x07, 0x1B, 0x0C, 0x0B, 0x00, 0x1E, 0x06, 0x04, 0x00, 0x32, 0x08, 0x0C, 0x00, 0x2D, + 0x0B, 0x00, 0x13, 0x35, 0x07, 0x0B, 0x00, 0x1C, 0xF6, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0xBF, + 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0D, 0x80, 0x95, 0x02, 0x3A, 0xDA, + 0x18, 0xD8, 0x0B, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xDA, 0x81, + 0x35, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x00, 0x05, 0x00, 0x02, + 0xCE, 0x06, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x3F, 0xDA, 0x18, 0x00, 0x05, 0x00, 0xDA, 0x82, 0x74, + 0x00, 0x05, 0x01, 0xCF, 0x06, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x3F, 0x28, 0x03, 0x00, 0x00, 0x49, + 0x02, 0x00, 0x03, 0x28, 0x04, 0x00, 0x00, 0x25, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, 0x00, 0x75, + 0x32, 0x00, 0x32, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0xD0, 0x0B, 0x6C, 0x69, 0x6E, 0x74, 0x2D, + 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x73, 0xD5, 0x05, 0xDA, 0x84, 0xC0, 0xC8, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xF0, 0x7F, 0xD0, 0x04, 0x6E, 0x6F, 0x6E, 0x65, 0x00, 0xD0, 0x07, 0x72, 0x65, 0x6C, + 0x61, 0x78, 0x65, 0x64, 0x01, 0xD0, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x03, 0xD0, 0x06, + 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x02, 0xD0, 0x0A, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0xD0, 0x09, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x77, 0x61, 0x72, 0x6E, 0xDA, 0x65, + 0xDA, 0x84, 0x40, 0xD0, 0x06, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0xD0, 0x04, 0x6C, 0x69, 0x6E, + 0x65, 0xDA, 0x84, 0x9C, 0xDA, 0x81, 0x72, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, 0xD2, 0xBF, 0xFF, + 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x85, + 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x85, 0xD8, 0xBF, + 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, + 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, + 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x85, 0xDE, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0xDF, + 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x85, 0xD8, 0xBF, 0xFF, + 0x00, 0x13, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x17, + 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x85, + 0xDC, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x85, 0xD6, 0xBF, + 0xFF, 0x00, 0x20, 0xDA, 0x85, 0xAB, 0xBF, 0xFF, 0x00, 0x22, 0xDA, 0x85, 0xE0, 0xBF, 0xFF, 0x01, + 0x00, 0xDA, 0x85, 0xF8, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x85, 0xF9, 0xBF, 0xFF, 0x01, 0x02, 0xDA, + 0x82, 0x11, 0xBF, 0xFF, 0x01, 0x03, 0xDA, 0x85, 0xE1, 0xBF, 0xFF, 0x01, 0x05, 0xDA, 0x85, 0xF8, + 0xBF, 0xFF, 0x01, 0x06, 0xDA, 0x85, 0xFA, 0xBF, 0xFF, 0x01, 0x07, 0xDA, 0x85, 0xFB, 0x0C, 0x80, + 0x95, 0x02, 0xDA, 0x80, 0xAD, 0x18, 0x6A, 0x05, 0xCF, 0x06, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x73, + 0x1C, 0x6A, 0x06, 0xCF, 0x0A, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x6A, 0x07, 0xCF, 0x0C, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, + 0x24, 0x29, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x75, 0x29, 0x6A, 0x08, 0xDA, + 0x86, 0x0C, 0x2D, 0x32, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x76, 0x32, 0x6A, + 0x09, 0xDA, 0x86, 0x0D, 0x33, 0x6A, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x78, + 0x36, 0x6A, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x77, 0x3A, 0x6A, 0x0D, 0xDA, + 0x85, 0x88, 0x3C, 0x6A, 0x0E, 0xDA, 0x82, 0x66, 0x3E, 0x6A, 0x0F, 0xDA, 0x85, 0xAC, 0x40, 0x6A, + 0x10, 0xDA, 0x85, 0xB8, 0x45, 0x6A, 0x0C, 0xCF, 0x03, 0x6C, 0x76, 0x6C, 0x49, 0x4E, 0x0E, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x79, 0x4D, 0x52, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x7A, 0x5A, 0x5F, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x5E, 0x63, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x42, 0x7D, 0x80, 0x94, 0x05, + 0xCF, 0x06, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x80, 0x80, 0x80, 0x94, 0x06, 0xDA, 0x82, 0x66, + 0x80, 0x83, 0x80, 0x94, 0x07, 0xCF, 0x04, 0x65, 0x72, 0x72, 0x66, 0x80, 0x86, 0x80, 0x94, 0x08, + 0xDA, 0x59, 0x80, 0x86, 0x80, 0x8B, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x80, 0x8A, 0x80, 0x8F, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x44, 0x2D, 0x00, + 0x00, 0x22, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x35, 0x00, 0x01, 0x00, 0x2D, 0x01, + 0x01, 0x05, 0x2D, 0x02, 0x00, 0x0F, 0x2D, 0x03, 0x00, 0x20, 0x33, 0x01, 0x02, 0x03, 0x2D, 0x01, + 0x00, 0x22, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x35, 0x01, 0x02, 0x00, 0x1B, 0x02, + 0x01, 0x00, 0x2D, 0x03, 0x00, 0x22, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, + 0x04, 0x00, 0x1E, 0x03, 0x02, 0x00, 0x1C, 0x58, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x0F, 0x2C, 0x06, + 0x03, 0x00, 0x3B, 0x04, 0x05, 0x06, 0x20, 0x04, 0x02, 0x00, 0x2C, 0x04, 0x04, 0x00, 0x1B, 0x05, + 0x04, 0x00, 0x2D, 0x06, 0x00, 0x0F, 0x2C, 0x07, 0x05, 0x00, 0x3B, 0x04, 0x06, 0x07, 0x1B, 0x06, + 0x04, 0x00, 0x2D, 0x07, 0x00, 0x0F, 0x2C, 0x08, 0x06, 0x00, 0x3B, 0x04, 0x07, 0x08, 0x1B, 0x07, + 0x04, 0x00, 0x3B, 0x04, 0x05, 0x06, 0x20, 0x04, 0x02, 0x00, 0x1B, 0x04, 0x06, 0x00, 0x1B, 0x08, + 0x04, 0x00, 0x1E, 0x08, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x04, + 0x00, 0x00, 0x1B, 0x08, 0x04, 0x00, 0x3B, 0x04, 0x05, 0x07, 0x20, 0x04, 0x02, 0x00, 0x1B, 0x04, + 0x07, 0x00, 0x1B, 0x09, 0x04, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x04, 0x09, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x2B, 0x04, 0x02, 0x00, 0x1B, 0x09, 0x04, 0x00, 0x2D, 0x04, 0x00, 0x22, 0x28, 0x0B, + 0x00, 0x00, 0x49, 0x0A, 0x04, 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1F, 0x0B, 0x33, 0x00, 0x3A, 0x0A, + 0x04, 0x0B, 0x3D, 0x0C, 0x0A, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x3D, 0x0C, 0x0A, 0x01, 0x1B, 0x0E, + 0x0C, 0x00, 0x3D, 0x0C, 0x0A, 0x02, 0x1B, 0x0F, 0x0C, 0x00, 0x3D, 0x0C, 0x0A, 0x03, 0x1B, 0x10, + 0x0C, 0x00, 0x2C, 0x0C, 0x04, 0x00, 0x3B, 0x0A, 0x0C, 0x0D, 0x20, 0x0A, 0x02, 0x00, 0x2B, 0x0A, + 0x00, 0x00, 0x1B, 0x0C, 0x0A, 0x00, 0x48, 0x0A, 0x0C, 0x08, 0x1E, 0x0A, 0x12, 0x00, 0x2A, 0x11, + 0x00, 0x00, 0x2F, 0x11, 0x01, 0x06, 0x1E, 0x0E, 0x03, 0x00, 0x1B, 0x11, 0x0E, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x2D, 0x11, 0x01, 0x01, 0x1E, 0x0F, 0x03, 0x00, 0x1B, 0x12, 0x0F, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x2D, 0x12, 0x01, 0x02, 0x28, 0x13, 0x00, 0x00, 0x2D, 0x14, 0x00, 0x20, 0x33, 0x10, + 0x13, 0x14, 0x32, 0x11, 0x12, 0x00, 0x2D, 0x14, 0x00, 0x15, 0x35, 0x13, 0x14, 0x00, 0x1C, 0x10, + 0x00, 0x00, 0x48, 0x11, 0x0C, 0x09, 0x1E, 0x11, 0x0E, 0x00, 0x1E, 0x0E, 0x03, 0x00, 0x1B, 0x12, + 0x0E, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2D, 0x12, 0x01, 0x01, 0x1E, 0x0F, 0x03, 0x00, 0x1B, 0x13, + 0x0F, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2D, 0x13, 0x01, 0x02, 0x2D, 0x14, 0x00, 0x20, 0x33, 0x10, + 0x0D, 0x14, 0x32, 0x12, 0x13, 0x00, 0x2D, 0x15, 0x00, 0x17, 0x35, 0x14, 0x15, 0x00, 0x49, 0x0B, + 0x04, 0x0B, 0x1C, 0xCE, 0xFF, 0xFF, 0x2D, 0x03, 0x01, 0x06, 0x1E, 0x03, 0x29, 0x00, 0x31, 0x02, + 0x00, 0x00, 0x2C, 0x04, 0x07, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2C, 0x05, 0x08, 0x00, 0x25, 0x04, + 0x03, 0x05, 0x1E, 0x04, 0x08, 0x00, 0x2D, 0x03, 0x01, 0x05, 0x2D, 0x05, 0x00, 0x0F, 0x33, 0x02, + 0x03, 0x05, 0x2D, 0x03, 0x00, 0x20, 0x31, 0x03, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x1B, 0x36, 0x03, + 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x2F, 0x03, 0x01, 0x06, 0x2C, 0x05, 0x09, 0x00, 0x3A, 0x03, + 0x02, 0x05, 0x1B, 0x05, 0x03, 0x00, 0x2C, 0x06, 0x0A, 0x00, 0x3A, 0x03, 0x02, 0x06, 0x1B, 0x06, + 0x03, 0x00, 0x2C, 0x07, 0x0B, 0x00, 0x3A, 0x03, 0x02, 0x07, 0x1B, 0x07, 0x03, 0x00, 0x2C, 0x08, + 0x0C, 0x00, 0x3A, 0x03, 0x02, 0x08, 0x1B, 0x08, 0x03, 0x00, 0x1E, 0x06, 0x03, 0x00, 0x1B, 0x03, + 0x06, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x01, 0x01, 0x1E, 0x05, 0x03, 0x00, 0x1B, 0x09, + 0x05, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2D, 0x09, 0x01, 0x02, 0x2D, 0x0A, 0x00, 0x20, 0x33, 0x08, + 0x07, 0x0A, 0x32, 0x03, 0x09, 0x00, 0x2D, 0x0A, 0x00, 0x15, 0x36, 0x0A, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8A, 0x08, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x14, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0B, + 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x0B, 0x00, 0x0B, 0x02, 0x19, 0x00, 0x19, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x0D, 0x01, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0D, + 0x01, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0D, 0x01, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x1D, + 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0D, 0x01, 0x23, 0x00, 0x23, 0x00, 0x23, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, + 0x00, 0x0F, 0x02, 0x11, 0xBF, 0xFF, 0x0F, 0x02, 0x27, 0x00, 0x27, 0x01, 0x47, 0x00, 0x47, 0x00, + 0x47, 0x00, 0x47, 0x00, 0x53, 0x00, 0x53, 0x00, 0x53, 0x00, 0x53, 0x00, 0x27, 0x00, 0x27, 0x00, + 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, 0xBF, 0xFD, 0x0F, 0x04, 0x11, 0xBF, 0xFC, 0x0F, 0x04, + 0x4B, 0x00, 0x4B, 0x00, 0x4B, 0x00, 0x4B, 0x00, 0x57, 0x00, 0x57, 0x00, 0x57, 0x00, 0x57, 0x00, + 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, 0xBF, 0xFA, 0x0D, 0x00, 0x0D, 0x07, 0x0B, + 0x00, 0x0B, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x01, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x02, 0x11, 0x00, 0x11, + 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x01, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, 0x32, + 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x11, 0xBF, 0xFA, 0x0B, 0x8A, 0x02, 0x11, 0x00, 0x11, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x05, 0x01, 0x05, 0x01, 0x05, 0x03, 0x09, 0xBF, 0xFF, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x1C, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x05, 0x01, 0x10, 0x00, 0x07, 0x01, 0x07, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, + 0xBF, 0xFE, 0x05, 0x00, 0x05, 0x66, 0x00, 0x00, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x08, 0x02, + 0x02, 0x02, 0x03, 0x0D, 0x01, 0x01, 0x25, 0xCE, 0x09, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x65, + 0x72, 0x72, 0xDA, 0x18, 0xDA, 0x81, 0xAD, 0xDA, 0x81, 0x6B, 0xD8, 0x0C, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, 0xD2, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, + 0x04, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x06, 0xDA, + 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x85, 0xD8, + 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, + 0x00, 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0D, + 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x85, 0xDE, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, + 0xDF, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x85, 0xD8, 0xBF, + 0xFF, 0x00, 0x13, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, + 0x17, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, + 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x85, 0xD6, + 0xBF, 0xFF, 0x00, 0x20, 0xDA, 0x85, 0xAB, 0xBF, 0xFF, 0x00, 0x22, 0xDA, 0x85, 0xE0, 0xBF, 0xFF, + 0x00, 0x24, 0xDA, 0x85, 0xE1, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xE2, 0xBF, 0xFF, 0x00, 0x26, + 0xDA, 0x6D, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x85, 0xE3, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x85, 0xE4, + 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x85, 0xE5, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x85, 0xE6, 0x00, 0x0D, + 0x00, 0xDA, 0x6D, 0x00, 0x0D, 0x01, 0xDA, 0x85, 0xAB, 0x00, 0x0D, 0x02, 0xDA, 0x85, 0xE7, 0x05, + 0x0D, 0x03, 0xDA, 0x80, 0xAA, 0x30, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x32, 0x03, 0x04, + 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x2D, 0x05, 0x00, + 0x0F, 0x32, 0x03, 0x05, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x28, 0x07, 0x00, + 0x00, 0x37, 0x06, 0x03, 0x07, 0x03, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x05, 0x02, 0x24, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, + 0xD2, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x85, 0xD4, 0xBF, + 0xFF, 0x00, 0x04, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x08, 0xDA, + 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xDA, + 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, + 0x00, 0x0D, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x85, 0xDE, 0xBF, 0xFF, 0x00, 0x0F, + 0xDA, 0x85, 0xDF, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x85, + 0xD8, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0xD7, 0xBF, + 0xFF, 0x00, 0x17, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, + 0x1B, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, + 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x20, 0xDA, 0x85, 0xAB, 0xBF, 0xFF, 0x00, 0x22, 0xDA, 0x85, 0xE0, + 0xBF, 0xFF, 0x00, 0x24, 0xDA, 0x85, 0xE1, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xE2, 0xBF, 0xFF, + 0x00, 0x26, 0xDA, 0x6D, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x85, 0xE3, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, + 0x85, 0xE4, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x85, 0xE5, 0xBF, 0xFF, 0x00, 0x2E, 0xDA, 0x85, 0xE6, + 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x6D, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x85, 0xAB, 0xBF, 0xFF, 0x01, + 0x02, 0xDA, 0x85, 0xE7, 0x2D, 0x00, 0x01, 0x00, 0x2D, 0x01, 0x01, 0x01, 0x32, 0x00, 0x01, 0x00, + 0x2D, 0x00, 0x00, 0x19, 0x36, 0x00, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8A, 0x36, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x8A, 0x36, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x03, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x0F, + 0x01, 0x24, 0xCE, 0x07, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0xDA, 0x18, 0xDA, 0x81, 0x00, + 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, 0xD2, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x85, 0xD3, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x05, + 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, + 0xD7, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x85, 0xD9, 0xBF, + 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xDB, 0xBF, 0xFF, 0x00, + 0x0C, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, + 0x85, 0xDE, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0xDF, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, + 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x85, 0xDA, 0xBF, 0xFF, + 0x00, 0x15, 0xDA, 0x85, 0xD7, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x85, 0xDD, 0xBF, 0xFF, 0x00, 0x19, + 0xDA, 0x85, 0xD5, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x85, + 0xDB, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x85, 0xD6, 0xBF, 0xFF, 0x00, 0x20, 0xDA, 0x85, 0xAB, 0xBF, + 0xFF, 0x00, 0x22, 0xDA, 0x85, 0xE0, 0xBF, 0xFF, 0x00, 0x24, 0xDA, 0x85, 0xE1, 0xBF, 0xFF, 0x00, + 0x09, 0xDA, 0x85, 0xE2, 0xBF, 0xFF, 0x00, 0x26, 0xDA, 0x6D, 0xBF, 0xFF, 0x00, 0x28, 0xDA, 0x85, + 0xE3, 0xBF, 0xFF, 0x00, 0x2A, 0xDA, 0x85, 0xE4, 0xBF, 0xFF, 0x00, 0x2C, 0xDA, 0x85, 0xE5, 0xBF, + 0xFF, 0x00, 0x2E, 0xDA, 0x85, 0xE6, 0xBF, 0xFF, 0x00, 0x30, 0xDA, 0x85, 0xE7, 0x00, 0x0F, 0x00, + 0xDA, 0x85, 0xE8, 0x05, 0x0F, 0x02, 0xCF, 0x03, 0x74, 0x75, 0x70, 0x2D, 0x01, 0x00, 0x26, 0x29, + 0x02, 0x00, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2D, 0x02, 0x00, 0x2A, 0x35, 0x01, 0x02, 0x00, 0x1B, + 0x02, 0x01, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3A, 0x03, 0x02, 0x04, 0x31, 0x02, 0x00, 0x00, 0x2C, + 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x31, 0x03, 0x00, 0x00, 0x34, 0x04, 0x00, 0x00, 0x45, + 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8A, 0x3B, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x06, 0x00, 0x06, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x89, 0xE4, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x0C, 0x03, 0x00, 0x22, 0x00, 0x22, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x13, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x16, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x03, 0x02, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x01, + 0x05, 0x00, 0x05, 0x03, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x25, 0x03, 0x02, 0x0B, 0x00, + 0x0B, 0x00, 0x07, 0x00, 0x1A, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x05, + 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x03, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x03, 0x01, 0x13, + 0x00, 0x13, 0x00, 0x13, 0x00, 0x03, 0x02, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, 0x05, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x05, 0x00, 0x15, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x04, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, + 0x00, 0x09, 0xBF, 0xFB, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x09, + 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0xBF, 0xF5, 0x05, + 0x0E, 0x09, 0x01, 0x09, 0x01, 0x12, 0x00, 0x09, 0x01, 0x0F, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x01, 0x0B, 0x01, 0x10, 0x00, 0x09, 0x01, 0x16, 0x00, 0x16, 0x00, 0x0B, 0x01, 0x12, + 0x00, 0x12, 0x00, 0x0B, 0x01, 0x15, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x0D, 0x00, 0x1D, 0xBF, 0xFE, 0x0B, 0x03, 0x14, 0x00, 0x14, 0x00, 0x11, 0x00, 0x11, 0x00, + 0x0B, 0x01, 0x0D, 0x00, 0x0D, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x00, 0x1D, 0xBF, + 0xF9, 0x09, 0xBF, 0xE9, 0x03, 0x21, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x01, + 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x07, 0x00, 0x07, 0x01, 0x0B, 0x00, 0x0B, 0x00, + 0x0B, 0x00, 0x07, 0x00, 0x17, 0xBF, 0xFE, 0x05, 0x03, 0x0E, 0x00, 0x0E, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0xC0, 0xA8, 0x8A, 0x45, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xCE, 0x0E, 0x65, 0x78, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5B, + 0xDA, 0x85, 0x3E, 0xD0, 0x0C, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x2D, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x00, 0x3C, 0x00, 0xCF, 0x05, 0x66, 0x69, 0x62, 0x65, 0x72, 0x00, 0x3C, 0x01, 0xDA, 0x85, + 0x88, 0x00, 0x3C, 0x02, 0xDA, 0x84, 0x90, 0x04, 0x3C, 0x04, 0xDA, 0x85, 0x88, 0x0B, 0x3C, 0x05, + 0xCF, 0x07, 0x6E, 0x65, 0x78, 0x74, 0x65, 0x6E, 0x76, 0x1A, 0x3C, 0x09, 0xCF, 0x0F, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x2D, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x20, 0x01, 0x03, + 0x00, 0x2B, 0x03, 0x01, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x01, 0x00, 0x1B, 0x04, 0x03, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, + 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x2C, 0x07, 0x02, + 0x00, 0x3C, 0x05, 0x07, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x3C, 0x05, 0x07, 0x04, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x08, 0x04, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x3C, 0x05, 0x08, + 0x07, 0x2C, 0x07, 0x06, 0x00, 0x32, 0x05, 0x07, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x35, 0x07, 0x08, + 0x00, 0x30, 0x08, 0x00, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x2C, 0x0A, 0x08, 0x00, 0x2C, 0x0B, 0x09, + 0x00, 0x33, 0x0A, 0x04, 0x0B, 0x2C, 0x0B, 0x0A, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x2C, 0x0C, 0x0B, + 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x2B, 0x0D, 0x01, 0x00, 0x06, 0x0C, 0x0D, 0x04, 0x29, 0x0D, 0x00, + 0x00, 0x33, 0x05, 0x0C, 0x0D, 0x2C, 0x0E, 0x0C, 0x00, 0x3D, 0x0E, 0x0E, 0x00, 0x35, 0x0D, 0x0E, + 0x00, 0x2C, 0x0C, 0x0D, 0x00, 0x2C, 0x0E, 0x0E, 0x00, 0x33, 0x0C, 0x09, 0x0E, 0x2C, 0x0C, 0x0F, + 0x00, 0x33, 0x0D, 0x0C, 0x05, 0x43, 0x0C, 0x00, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x2C, 0x0E, 0x10, + 0x00, 0x35, 0x0D, 0x0E, 0x00, 0x2C, 0x0C, 0x11, 0x00, 0x2C, 0x0E, 0x12, 0x00, 0x33, 0x0C, 0x04, + 0x0E, 0x2C, 0x0E, 0x0A, 0x00, 0x35, 0x0C, 0x0E, 0x00, 0x2C, 0x0F, 0x0B, 0x00, 0x35, 0x0E, 0x0F, + 0x00, 0x2C, 0x0F, 0x13, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x0A, 0x02, 0x02, 0x02, 0x09, 0x1B, 0x01, 0x0B, 0xCE, 0x0F, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x67, 0x65, 0x72, 0x2D, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0xDA, 0x18, 0xD0, 0x0A, 0x64, + 0x65, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0x73, 0xD0, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, + 0xDA, 0x85, 0xC4, 0xCE, 0x06, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5B, 0xCE, 0x02, 0x5D, 0x3A, 0xDA, + 0x85, 0xA3, 0xDA, 0x85, 0x49, 0xDA, 0x81, 0x12, 0xDA, 0x85, 0xF3, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x86, 0x21, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x85, 0x88, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x84, 0x90, + 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x85, 0x88, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x86, 0x22, 0x00, 0x1B, + 0x00, 0xDA, 0x82, 0x26, 0x00, 0x1B, 0x01, 0xDA, 0x6D, 0x00, 0x1B, 0x02, 0xDA, 0x86, 0x23, 0x04, + 0x1B, 0x04, 0xCF, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x0B, 0x1B, 0x05, 0xDA, 0x82, 0x11, + 0x16, 0x1B, 0x08, 0xCF, 0x04, 0x70, 0x72, 0x70, 0x74, 0x2C, 0x03, 0x00, 0x00, 0x32, 0x01, 0x03, + 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, + 0x00, 0x35, 0x06, 0x05, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x2D, 0x08, 0x00, + 0x04, 0x2C, 0x09, 0x04, 0x00, 0x33, 0x07, 0x08, 0x09, 0x2C, 0x07, 0x05, 0x00, 0x33, 0x05, 0x07, + 0x04, 0x2C, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x35, 0x07, 0x08, + 0x00, 0x1B, 0x08, 0x07, 0x00, 0x2D, 0x09, 0x00, 0x05, 0x33, 0x08, 0x00, 0x09, 0x2C, 0x09, 0x08, + 0x00, 0x36, 0x09, 0x00, 0x00, 0xBF, 0xFF, 0x8B, 0x5E, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x05, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, + 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x8B, 0x56, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, + 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x03, 0x00, 0x03, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x05, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0x03, 0x31, 0x00, 0x31, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, + 0x11, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x04, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x30, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x80, + 0x81, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x29, 0x0A, 0x0A, 0x52, 0x75, + 0x6E, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x2D, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x70, + 0x61, 0x73, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x20, + 0x74, 0x6F, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x74, 0x65, + 0x20, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, + 0x73, 0x2E, 0xCF, 0x0B, 0x2A, 0x65, 0x72, 0x72, 0x2D, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x2A, 0xD3, + 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x61, 0x01, 0xDA, + 0x06, 0xDA, 0x85, 0x22, 0xDA, 0x08, 0xCE, 0x51, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x6F, 0x72, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6F, + 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x69, 0x6E, 0x67, + 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2E, 0xCF, 0x04, 0x6A, 0x75, 0x78, 0x74, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xB1, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x0B, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x08, 0x22, 0x00, 0x07, + 0xCE, 0x04, 0x6A, 0x75, 0x78, 0x74, 0xDA, 0x18, 0xCF, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xDA, + 0x51, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x03, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, + 0x00, 0x0C, 0xCE, 0x05, 0x61, 0x70, 0x70, 0x6C, 0x79, 0x3F, 0x02, 0x01, 0x00, 0x26, 0x03, 0x02, + 0x00, 0x1D, 0x03, 0x09, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3A, 0x05, 0x01, 0x04, 0x05, 0x04, 0x04, + 0x01, 0x25, 0x03, 0x04, 0x02, 0x1D, 0x03, 0x03, 0x00, 0x31, 0x05, 0x00, 0x00, 0x1C, 0xFB, 0xFF, + 0xFF, 0x34, 0x05, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0xDA, 0x80, 0xE7, 0xDA, 0x80, 0xA8, 0xCF, + 0x01, 0x26, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0x9B, 0x00, 0x22, 0x00, 0xCF, 0x04, 0x66, 0x75, 0x6E, + 0x73, 0x00, 0x22, 0x01, 0xDA, 0x86, 0x30, 0x03, 0x22, 0x03, 0xDA, 0x81, 0x9F, 0x06, 0x22, 0x05, + 0xCF, 0x05, 0x24, 0x61, 0x72, 0x67, 0x73, 0x06, 0x16, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x4B, 0x09, 0x16, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x4A, 0x0C, + 0x16, 0x08, 0xDA, 0x80, 0xAA, 0x2C, 0x02, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, + 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, + 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, 0x06, 0x00, 0x07, 0x1B, 0x07, 0x06, 0x00, 0x1F, 0x07, 0x0C, + 0x00, 0x3A, 0x06, 0x00, 0x07, 0x1B, 0x08, 0x06, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x33, 0x06, 0x08, + 0x05, 0x2C, 0x09, 0x03, 0x00, 0x35, 0x06, 0x09, 0x00, 0x32, 0x03, 0x06, 0x00, 0x2C, 0x0A, 0x04, + 0x00, 0x35, 0x09, 0x0A, 0x00, 0x49, 0x07, 0x00, 0x07, 0x1C, 0xF5, 0xFF, 0xFF, 0x2C, 0x06, 0x05, + 0x00, 0x32, 0x06, 0x05, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2B, 0x07, 0x00, + 0x00, 0x32, 0x03, 0x07, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x07, + 0x00, 0x33, 0x08, 0x06, 0x07, 0x2C, 0x08, 0x03, 0x00, 0x36, 0x08, 0x00, 0x00, 0x84, 0xB4, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x02, 0x0E, 0x00, 0x0E, 0x00, + 0x0E, 0x00, 0x0E, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x47, 0x28, 0x6A, 0x75, 0x78, 0x74, 0x20, 0x26, 0x20, 0x66, + 0x75, 0x6E, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x20, 0x6F, 0x66, 0x20, 0x60, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0x60, 0x2E, 0x20, 0x53, 0x61, 0x6D, + 0x65, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6F, 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6D, + 0x6F, 0x72, 0x65, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x37, + 0xCB, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x6F, 0x77, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x32, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x70, 0x6F, 0x77, 0xDA, 0x08, 0xCE, 0x2C, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x6F, + 0x77, 0x20, 0x61, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6F, 0x77, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x09, 0x70, 0x65, 0x67, 0x2F, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x6D, 0x87, 0x06, 0x01, 0xDA, 0x06, 0xD8, 0x09, + 0x70, 0x65, 0x67, 0x2F, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xDA, 0x08, 0xCE, 0x80, 0xFA, 0x28, 0x70, + 0x65, 0x67, 0x2F, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x70, 0x65, 0x67, 0x20, 0x74, 0x65, 0x78, + 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x26, 0x20, 0x61, + 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x20, 0x50, 0x61, + 0x72, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x47, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, + 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, + 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, + 0x61, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, + 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x70, 0x65, 0x67, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x6F, 0x66, 0x20, + 0x50, 0x45, 0x47, 0x73, 0x20, 0x69, 0x73, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, + 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x2E, 0xCF, 0x08, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, + 0x6E, 0x3F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x70, 0x01, 0xDA, 0x06, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x08, + 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xD0, 0x07, 0x62, 0x6F, + 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x86, 0x48, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, + 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x70, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, 0x2F, + 0x00, 0x2F, 0x00, 0x2F, 0xDA, 0x08, 0xCE, 0x26, 0x28, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, + 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x08, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x67, 0x63, 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0x57, 0x81, 0x51, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x67, 0x63, + 0x64, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x67, 0x63, 0x64, 0x20, 0x78, + 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x6F, 0x6E, + 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, + 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x79, 0x2E, 0xCF, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2F, 0x77, 0x65, 0x61, 0x6B, 0x2D, 0x6B, 0x65, 0x79, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x62, 0x81, 0x56, 0x01, 0xDA, 0x06, 0xD8, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2F, 0x77, 0x65, 0x61, 0x6B, 0x2D, 0x6B, 0x65, 0x79, 0x73, 0xDA, 0x08, 0xCE, 0x80, 0xA2, 0x28, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, 0x65, 0x61, 0x6B, 0x2D, 0x6B, 0x65, 0x79, 0x73, 0x20, + 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x77, 0x65, 0x61, 0x6B, 0x20, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6B, 0x65, 0x79, + 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x73, 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2E, 0xCF, 0x0D, 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x63, 0x76, 0x2D, 0x66, 0x72, 0x6F, 0x6D, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x70, 0x01, 0xDA, 0x06, 0xD8, 0x0D, + 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x63, 0x76, 0x2D, 0x66, 0x72, 0x6F, 0x6D, 0xDA, 0x08, 0xCE, + 0x80, 0xE1, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x63, 0x76, 0x2D, 0x66, 0x72, 0x6F, 0x6D, + 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x6E, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x62, + 0x75, 0x66, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x74, + 0x72, 0x65, 0x61, 0x6D, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x75, 0x74, 0x73, 0x20, 0x69, 0x74, + 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x63, 0x6B, + 0x65, 0x74, 0x2D, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x63, 0x61, 0x6D, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x2E, + 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, + 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x65, + 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, 0x68, 0x69, + 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, + 0x69, 0x6C, 0x2E, 0xCF, 0x0C, 0x6F, 0x73, 0x2F, 0x63, 0x70, 0x75, 0x2D, 0x63, 0x6F, 0x75, 0x6E, + 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x81, 0x03, 0x01, 0xDA, 0x06, 0xD8, + 0x0C, 0x6F, 0x73, 0x2F, 0x63, 0x70, 0x75, 0x2D, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xDA, 0x08, 0xCE, + 0x80, 0xA6, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x70, 0x75, 0x2D, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, + 0x61, 0x6E, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0x69, 0x6D, 0x61, 0x74, 0x65, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x43, 0x50, 0x55, 0x73, 0x20, 0x61, 0x76, + 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x75, + 0x73, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x75, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x6F, + 0x20, 0x67, 0x65, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0x69, 0x6D, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x2E, 0xCF, 0x0C, 0x70, 0x65, 0x67, 0x2F, 0x66, 0x69, + 0x6E, 0x64, 0x2D, 0x61, 0x6C, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x6D, + 0x87, 0x1A, 0x01, 0xDA, 0x06, 0xD8, 0x0C, 0x70, 0x65, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, + 0x61, 0x6C, 0x6C, 0xDA, 0x08, 0xCE, 0x78, 0x28, 0x70, 0x65, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, + 0x2D, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x65, 0x67, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, + 0x0A, 0x0A, 0x46, 0x69, 0x6E, 0x64, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x67, + 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x65, 0x78, 0x74, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x2E, 0xCF, + 0x10, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, + 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0x9D, 0x01, 0xDA, 0x06, + 0xDA, 0x80, 0xA9, 0xDA, 0x08, 0xCE, 0x80, 0x8F, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, + 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x20, 0x6F, 0x66, 0x20, 0x60, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x60, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x6F, + 0x20, 0x60, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x60, 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x13, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x70, 0x75, 0x73, 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x36, 0x34, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0xBD, 0x01, 0xDA, 0x06, 0xD8, 0x13, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x36, 0x34, + 0xDA, 0x08, 0xCE, 0x80, 0x92, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, + 0x68, 0x2D, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x36, 0x34, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x29, 0x0A, 0x0A, 0x50, 0x75, + 0x73, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6E, 0x64, 0x65, 0x72, 0x6C, 0x79, 0x69, 0x6E, + 0x67, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x36, 0x34, 0x20, + 0x62, 0x69, 0x74, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6F, + 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x0F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, + 0x68, 0x61, 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x83, 0x57, 0x83, 0xE5, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x3A, 0xDA, 0x08, 0xCE, 0x51, 0x28, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, + 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2E, 0xCF, + 0x10, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, + 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x10, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2E, 0x63, 0x81, 0x88, 0x01, 0xDA, 0x06, 0xDA, + 0x85, 0x26, 0xDA, 0x08, 0xCE, 0x80, 0xED, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, + 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x65, 0x72, 0x72, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x29, 0x0A, + 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x69, 0x63, 0x65, 0x20, 0x6C, + 0x6F, 0x6F, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, + 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x43, + 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x70, 0x72, + 0x6F, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, + 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x6B, 0x69, + 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6C, 0x69, 0x6E, 0x65, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2E, 0xCF, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0xE2, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x07, 0x02, 0x02, 0x02, 0x06, 0x17, 0x00, 0x03, 0xCE, 0x09, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0xDA, 0x18, 0xDA, 0x83, 0x76, 0xDA, 0x80, 0xE0, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x10, 0x03, 0x03, 0x03, 0x02, 0x1C, 0x00, 0x0B, 0xCE, 0x0F, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, + 0x18, 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0x00, 0x1C, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x1C, 0x01, + 0xDA, 0x81, 0x9E, 0x00, 0x1C, 0x02, 0xDA, 0x1F, 0x00, 0x1C, 0x03, 0xCF, 0x0F, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x00, 0x1C, 0x04, 0xDA, + 0x82, 0x5F, 0x01, 0x1C, 0x05, 0xDA, 0x82, 0x60, 0x03, 0x1C, 0x07, 0xDA, 0x81, 0x25, 0x05, 0x1C, + 0x09, 0xDA, 0x81, 0x9F, 0x09, 0x1C, 0x0B, 0xDA, 0x23, 0x0A, 0x14, 0x0C, 0xDA, 0x22, 0x0A, 0x14, + 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x2B, 0x04, 0x00, 0x00, 0x1B, 0x05, + 0x01, 0x00, 0x3F, 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x0D, 0x08, 0x07, 0x01, 0x1B, 0x09, + 0x08, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x0B, + 0x0A, 0x00, 0x2B, 0x0C, 0x00, 0x00, 0x23, 0x0D, 0x0C, 0x09, 0x1E, 0x0D, 0x08, 0x00, 0x33, 0x02, + 0x04, 0x05, 0x35, 0x0E, 0x00, 0x00, 0x3C, 0x0B, 0x0C, 0x0E, 0x1B, 0x04, 0x05, 0x00, 0x06, 0x05, + 0x05, 0x01, 0x05, 0x0C, 0x0C, 0x01, 0x1C, 0xF8, 0xFF, 0xFF, 0x23, 0x0C, 0x04, 0x07, 0x1E, 0x0C, + 0x06, 0x00, 0x32, 0x02, 0x04, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x32, 0x0B, 0x0D, 0x00, 0x2C, 0x0F, + 0x01, 0x00, 0x35, 0x0E, 0x0F, 0x00, 0x03, 0x0B, 0x00, 0x00, 0x86, 0xD6, 0x03, 0x00, 0x03, 0x01, + 0x0C, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x01, 0x05, 0xBF, + 0xFD, 0x03, 0x00, 0x03, 0x04, 0x07, 0x00, 0x03, 0x01, 0x15, 0x00, 0x15, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0xBF, 0xF5, 0x01, 0xDA, 0x2B, 0xDA, 0x82, 0x03, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x08, 0x01, 0x01, 0x01, 0x03, 0x23, 0x00, 0x0B, 0xCE, 0x06, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x73, 0xDA, 0x18, 0xD8, 0x0B, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x61, 0x62, 0x6C, 0x65, 0x3F, + 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0x00, 0x23, 0x00, 0xDA, 0x1E, 0x00, 0x23, 0x01, 0xCF, 0x06, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x08, 0x15, 0x03, 0xCF, 0x03, 0x61, 0x72, 0x72, 0x09, 0x15, + 0x04, 0xDA, 0x80, 0xC3, 0x09, 0x14, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x48, + 0x0C, 0x14, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x47, 0x0F, 0x14, 0x07, 0xDA, + 0x5A, 0x16, 0x23, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x49, 0x16, 0x22, 0x00, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x4B, 0x19, 0x22, 0x05, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x4A, 0x1C, 0x22, 0x06, 0xDA, 0x5A, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, + 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x12, 0x00, 0x3F, 0x03, 0x00, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x2B, 0x04, + 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, + 0x07, 0x00, 0x3A, 0x05, 0x00, 0x06, 0x1B, 0x07, 0x05, 0x00, 0x3C, 0x03, 0x04, 0x07, 0x05, 0x04, + 0x04, 0x01, 0x49, 0x06, 0x00, 0x06, 0x1C, 0xFA, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x40, 0x03, + 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x03, 0x00, 0x05, 0x1B, 0x05, + 0x03, 0x00, 0x1F, 0x05, 0x08, 0x00, 0x3A, 0x03, 0x00, 0x05, 0x1B, 0x06, 0x03, 0x00, 0x32, 0x04, + 0x06, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x03, 0x07, 0x00, 0x49, 0x05, 0x00, 0x05, 0x1C, 0xF9, + 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x86, 0x51, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x02, + 0x22, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x07, 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x09, 0x01, 0x09, 0xBF, 0xFE, 0x07, 0x00, 0x07, + 0xBF, 0xFD, 0x05, 0x07, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x17, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x17, 0x01, 0xDA, 0x1F, 0x00, 0x17, 0x02, 0xDA, 0x86, 0x7A, + 0x31, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x05, 0x00, + 0x2C, 0x04, 0x01, 0x00, 0x33, 0x04, 0x00, 0x01, 0x2C, 0x04, 0x02, 0x00, 0x36, 0x04, 0x00, 0x00, + 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x05, 0x00, + 0x2C, 0x05, 0x04, 0x00, 0x33, 0x05, 0x00, 0x01, 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, + 0x31, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2C, 0x06, 0x01, 0x00, + 0x33, 0x06, 0x00, 0x05, 0x2C, 0x06, 0x02, 0x00, 0x36, 0x06, 0x00, 0x00, 0x86, 0xE7, 0x05, 0x00, + 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x05, + 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, + 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x08, 0xCE, + 0x6A, 0x28, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6E, 0x20, 0x69, 0x6E, + 0x64, 0x29, 0x0A, 0x0A, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x6E, + 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x0A, 0x6F, 0x66, 0x20, 0x73, 0x69, 0x7A, + 0x65, 0x20, 0x60, 0x6E, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x0E, 0x2A, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, 0x65, 0x2A, 0xD3, 0x04, 0xDA, 0x81, 0xC9, + 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xD2, 0x01, 0xDA, 0x06, 0xD0, 0x0C, 0x6D, + 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, 0x65, 0xDA, 0x08, 0xCE, 0x2D, 0x44, + 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x6D, + 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, 0x65, 0x60, 0xCF, 0x04, 0x73, 0x70, + 0x69, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0xFA, 0x01, 0xDA, 0x06, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x03, 0x02, 0x03, 0x07, 0x19, 0x00, 0x06, 0xCE, + 0x04, 0x73, 0x70, 0x69, 0x74, 0xDA, 0x18, 0xD0, 0x02, 0x77, 0x62, 0xDA, 0x84, 0xBE, 0xDA, 0x84, + 0xBF, 0xCE, 0x0B, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0xDA, 0x81, + 0x12, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xDA, 0x84, 0xC2, + 0x00, 0x19, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x19, 0x01, 0xDA, 0x84, 0xC5, 0x00, 0x19, 0x02, 0xDA, + 0x82, 0x31, 0x00, 0x19, 0x03, 0xDA, 0x86, 0x93, 0x04, 0x19, 0x05, 0xDA, 0x82, 0x31, 0x08, 0x19, + 0x07, 0xDA, 0x80, 0xAA, 0x20, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x1B, 0x04, 0x02, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x32, 0x00, 0x05, 0x00, 0x2C, 0x07, 0x01, 0x00, + 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x07, 0x02, 0x00, 0x1C, 0x08, 0x00, 0x00, + 0x2C, 0x08, 0x02, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x33, 0x08, 0x00, 0x09, 0x31, 0x05, 0x00, 0x00, + 0x2C, 0x09, 0x04, 0x00, 0x35, 0x08, 0x09, 0x00, 0x01, 0x08, 0x00, 0x00, 0x32, 0x07, 0x01, 0x00, + 0x2C, 0x09, 0x05, 0x00, 0x35, 0x08, 0x09, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0A, 0x06, 0x00, + 0x35, 0x09, 0x0A, 0x00, 0x04, 0x00, 0x00, 0x00, 0x86, 0xFD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0D, 0x01, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xF9, 0x01, 0xDA, 0x08, 0xCE, 0x68, + 0x28, 0x73, 0x70, 0x69, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x29, 0x0A, 0x0A, + 0x57, 0x72, 0x69, 0x74, 0x65, 0x20, 0x60, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x60, + 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x74, 0x20, 0x60, 0x70, + 0x61, 0x74, 0x68, 0x60, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, + 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xCF, 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x69, + 0x73, 0x74, 0x65, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x82, 0x89, 0x01, + 0xDA, 0x06, 0xDA, 0x43, 0xDA, 0x08, 0xCE, 0x81, 0xA0, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x6C, 0x69, + 0x73, 0x74, 0x65, 0x6E, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, + 0x6D, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x69, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6E, 0x6F, 0x72, 0x20, 0x77, + 0x72, 0x69, 0x74, 0x65, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x20, 0x6E, 0x65, + 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x65, 0x74, 0x2F, + 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x65, 0x20, 0x74, + 0x6F, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x6F, 0x66, 0x20, 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x63, 0x6F, 0x6E, 0x6E, + 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, + 0x20, 0x3A, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x28, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, + 0x79, 0x20, 0x74, 0x63, 0x70, 0x29, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x3A, 0x64, 0x61, 0x74, 0x61, + 0x67, 0x72, 0x61, 0x6D, 0x20, 0x28, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x75, 0x64, + 0x70, 0x29, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x3A, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6E, 0x65, 0x74, + 0x2F, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2E, 0xCF, 0x06, 0x65, 0x66, 0x6C, 0x75, 0x73, + 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0xBC, 0x01, 0xDA, 0x06, + 0xDA, 0x85, 0x8C, 0xDA, 0x08, 0xCE, 0x4A, 0x28, 0x65, 0x66, 0x6C, 0x75, 0x73, 0x68, 0x29, 0x0A, + 0x0A, 0x46, 0x6C, 0x75, 0x73, 0x68, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x65, 0x72, + 0x72, 0x20, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x29, 0x60, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, + 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x68, 0x69, 0x6E, 0x67, + 0x2E, 0xCF, 0x0D, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0x2D, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x84, 0x82, 0x01, 0xDA, 0x06, 0xD8, 0x0D, + 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0x2D, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xDA, 0x08, 0xCE, + 0x80, 0x83, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0x2D, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0x20, 0x63, 0x68, 0x61, 0x6E, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x61, 0x20, + 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x2E, 0x20, 0x41, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0x64, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, + 0x61, 0x75, 0x73, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x72, 0x65, 0x61, 0x64, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x6E, 0x65, 0x6C, 0x2E, 0xCF, 0x03, 0x73, 0x65, 0x71, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x82, 0x5F, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, + 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x16, 0x00, 0x04, 0xCE, 0x03, 0x73, 0x65, 0x71, + 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x58, 0xDA, 0x80, 0xA8, 0xCF, 0x04, 0x6C, 0x6F, 0x6F, + 0x70, 0x00, 0x16, 0x00, 0xCF, 0x04, 0x68, 0x65, 0x61, 0x64, 0x00, 0x16, 0x01, 0xDA, 0x81, 0x74, + 0x00, 0x16, 0x02, 0xDA, 0x86, 0xA9, 0x02, 0x16, 0x04, 0xCF, 0x06, 0x24, 0x61, 0x63, 0x63, 0x75, + 0x6D, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x40, 0x05, 0x00, + 0x00, 0x2C, 0x07, 0x01, 0x00, 0x33, 0x07, 0x04, 0x05, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, + 0x00, 0x31, 0x07, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x08, 0x03, + 0x00, 0x33, 0x08, 0x04, 0x05, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x33, 0x08, 0x00, + 0x07, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x33, 0x08, 0x06, 0x05, 0x31, 0x04, 0x00, + 0x00, 0x45, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x82, 0x63, 0x0F, 0x00, 0x0F, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x7B, 0x28, 0x73, 0x65, 0x71, 0x20, 0x68, + 0x65, 0x61, 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, + 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x2C, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x2E, 0x0A, 0x53, 0x65, + 0x65, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x61, 0x6C, + 0x69, 0x67, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x81, 0xD5, 0x01, 0xDA, + 0x06, 0xD8, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x61, 0x6C, 0x69, 0x67, 0x6E, 0xDA, 0x08, 0xCE, 0x38, + 0x28, 0x66, 0x66, 0x69, 0x2F, 0x61, 0x6C, 0x69, 0x67, 0x6E, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x6C, 0x69, 0x67, 0x6E, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x66, 0x66, 0x69, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, + 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2E, 0xCF, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, + 0x81, 0xFE, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x76, 0xDA, 0x08, 0xCE, 0x80, 0xA3, 0x28, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x7A, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6F, + 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x69, 0x65, 0x73, 0x20, 0x69, + 0x74, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x72, 0x65, + 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, + 0x20, 0x73, 0x6F, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x65, 0x66, + 0x66, 0x69, 0x63, 0x69, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, 0x72, 0x65, 0x66, 0x69, 0x6C, 0x6C, + 0x65, 0x64, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, + 0xCF, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x77, 0x6F, + 0x72, 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0x21, 0x01, 0xDA, + 0x06, 0xD8, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x77, + 0x6F, 0x72, 0x64, 0xDA, 0x08, 0xCE, 0x80, 0xF0, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x70, 0x75, 0x73, 0x68, 0x2D, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x6D, + 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x20, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x34, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x77, 0x6F, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x6C, 0x69, 0x74, 0x74, 0x6C, 0x65, 0x20, 0x65, 0x6E, 0x64, + 0x69, 0x61, 0x6E, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2C, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, + 0x6E, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x78, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, + 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x76, + 0x65, 0x72, 0x66, 0x6C, 0x6F, 0x77, 0x73, 0x2E, 0xCF, 0x0C, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x69, + 0x6E, 0x74, 0x2D, 0x6D, 0x61, 0x78, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, + 0x81, 0xA2, 0x01, 0xDA, 0x06, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x43, 0xDA, 0x08, + 0xCE, 0x42, 0x54, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x63, 0x6F, + 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x62, + 0x79, 0x20, 0x61, 0x20, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x20, 0x28, 0x2D, 0x28, 0x32, 0x5E, + 0x35, 0x33, 0x29, 0x29, 0xCF, 0x10, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, + 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8C, + 0x4A, 0x01, 0xDA, 0x06, 0xD8, 0x10, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, + 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x65, 0x76, 0x2F, 0x72, 0x65, + 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x72, 0x77, 0x6C, 0x6F, + 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, 0x61, 0x20, 0x77, + 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x72, + 0x65, 0x61, 0x64, 0x2D, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0xCF, 0x08, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0x57, 0x7D, 0x01, 0xDA, 0x06, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, + 0xDA, 0x08, 0xCE, 0x80, 0xD5, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x73, 0x65, 0x65, 0x64, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x50, 0x73, 0x65, 0x75, 0x64, 0x6F, 0x2D, 0x52, 0x61, 0x6E, 0x64, + 0x6F, 0x6D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, + 0x74, 0x6F, 0x72, 0x2C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, + 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x65, 0x65, 0x64, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x65, 0x64, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x6E, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x33, 0x32, 0x20, 0x62, 0x69, + 0x74, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x44, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x6F, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x61, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x72, 0x6E, 0x67, 0x20, 0x61, 0x62, 0x73, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0xCF, 0x0D, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x83, 0x57, 0x83, 0xFB, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x38, 0xDA, 0x08, 0xCE, 0x81, 0x02, + 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, + 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x70, 0x65, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x2D, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x2E, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x2D, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x65, + 0x6E, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, 0x65, 0x64, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, + 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x72, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x72, 0x65, 0x61, + 0x64, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x6F, 0x72, + 0x20, 0x73, 0x61, 0x66, 0x65, 0x6C, 0x79, 0x20, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x61, 0x74, + 0x65, 0x2E, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2D, 0x62, 0x79, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x7F, 0x01, 0xDA, 0x06, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x02, 0x02, 0x02, 0x01, 0x26, 0x00, 0x0B, 0xCE, 0x0C, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2D, 0x62, 0x79, 0xDA, 0x18, 0xDA, 0x80, 0xA8, + 0x00, 0x26, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x26, 0x01, 0xDA, 0x1F, 0x00, 0x26, 0x02, 0xDA, 0x86, + 0xD3, 0x01, 0x26, 0x04, 0xDA, 0x23, 0x02, 0x26, 0x05, 0xCF, 0x04, 0x73, 0x70, 0x61, 0x6E, 0x03, + 0x26, 0x06, 0xCF, 0x08, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6F, 0x72, 0x79, 0x04, 0x26, 0x07, 0xCF, + 0x06, 0x69, 0x73, 0x2D, 0x6E, 0x65, 0x77, 0x04, 0x25, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x56, 0x07, 0x25, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x55, 0x0A, + 0x25, 0x0A, 0xDA, 0x1E, 0x0D, 0x25, 0x0B, 0xDA, 0x80, 0xD9, 0x40, 0x03, 0x00, 0x00, 0x1B, 0x04, + 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x29, 0x07, 0x00, 0x00, 0x28, 0x09, + 0x00, 0x00, 0x49, 0x08, 0x01, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x1F, 0x09, 0x1D, 0x00, 0x3A, 0x08, + 0x01, 0x09, 0x1B, 0x0A, 0x08, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x08, 0x00, 0x00, 0x1B, 0x0B, + 0x08, 0x00, 0x1E, 0x07, 0x09, 0x00, 0x2A, 0x07, 0x00, 0x00, 0x1B, 0x06, 0x0B, 0x00, 0x31, 0x0A, + 0x00, 0x00, 0x40, 0x05, 0x00, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x08, + 0x0C, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x25, 0x08, 0x0B, 0x06, 0x1E, 0x08, 0x05, 0x00, 0x32, 0x05, + 0x0A, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1B, 0x06, + 0x0B, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x40, 0x05, 0x00, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x0D, + 0x00, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x49, 0x09, 0x01, 0x09, 0x1C, 0xE4, 0xFF, 0xFF, 0x03, 0x04, + 0x00, 0x00, 0x86, 0x84, 0x03, 0x00, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, + 0x05, 0x01, 0x12, 0x00, 0x25, 0x00, 0x36, 0x00, 0x36, 0x00, 0x46, 0x00, 0x46, 0x00, 0x46, 0xBF, + 0xFF, 0x05, 0x02, 0x07, 0xBF, 0xFE, 0x05, 0x02, 0x16, 0x00, 0x16, 0x00, 0x16, 0xBF, 0xFE, 0x05, + 0x03, 0x0B, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0xBF, 0xFB, 0x03, 0x00, + 0x03, 0xBF, 0xF7, 0x01, 0xDA, 0x08, 0xCE, 0x80, 0xE6, 0x28, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6F, 0x6E, 0x2D, 0x62, 0x79, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x74, 0x69, 0x61, + 0x6C, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x66, + 0x60, 0x2E, 0x20, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x0A, 0x73, 0x70, + 0x6C, 0x69, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x60, 0x28, 0x66, 0x20, 0x78, 0x29, 0x60, + 0x20, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, + 0x77, 0x68, 0x65, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x60, 0x78, 0x60, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x0A, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2E, 0xCF, + 0x09, 0x2A, 0x73, 0x79, 0x73, 0x70, 0x61, 0x74, 0x68, 0x2A, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x50, 0x01, 0xDA, 0x06, 0xD0, 0x07, 0x73, 0x79, + 0x73, 0x70, 0x61, 0x74, 0x68, 0xDA, 0x08, 0xCE, 0x2E, 0x50, 0x61, 0x74, 0x68, 0x20, 0x6F, 0x66, + 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x6F, + 0x61, 0x64, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, + 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x2E, 0xCF, 0x0E, 0x2A, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, + 0x74, 0x2D, 0x66, 0x69, 0x6C, 0x65, 0x2A, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x84, 0xE7, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xC9, 0xDA, 0x08, 0xCE, 0x32, + 0x42, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, 0x6D, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x6C, 0x79, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x6C, + 0x65, 0x2E, 0xCF, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x29, 0x81, 0xF3, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xF6, 0xDA, 0x08, 0xCE, 0x80, 0xCC, + 0x28, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x26, 0x20, 0x6B, 0x76, 0x73, 0x29, 0x0A, 0x0A, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x2E, 0x20, 0x6B, 0x76, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6B, 0x31, 0x2C, 0x20, 0x76, 0x31, + 0x2C, 0x20, 0x6B, 0x32, 0x2C, 0x20, 0x76, 0x32, 0x2C, 0x20, 0x6B, 0x33, 0x2C, 0x20, 0x76, 0x33, + 0x2C, 0x20, 0x2E, 0x2E, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6B, 0x76, 0x73, 0x20, 0x68, 0x61, 0x73, + 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x64, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x72, + 0x6F, 0x77, 0x6E, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0xDA, 0x83, 0x7B, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0x13, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x79, + 0xDA, 0x08, 0xCE, 0x76, 0x28, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, + 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x66, + 0x6C, 0x74, 0x29, 0x0A, 0x0A, 0x46, 0x69, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x60, 0x70, + 0x72, 0x65, 0x64, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x64, 0x66, 0x6C, 0x74, 0x60, 0x20, 0x69, 0x66, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, 0x85, 0xB2, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x89, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xB0, 0xDA, 0x08, + 0xCE, 0x17, 0x28, 0x64, 0x65, 0x63, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x78, 0x20, 0x2D, 0x20, 0x31, 0x2E, 0xCF, 0x0F, 0x70, 0x65, 0x67, 0x2F, 0x72, + 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0x6D, 0x87, 0x47, 0x01, 0xDA, 0x06, 0xD8, 0x0F, 0x70, 0x65, 0x67, 0x2F, 0x72, + 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xDA, 0x08, 0xCE, 0x81, 0x17, 0x28, + 0x70, 0x65, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0x20, + 0x70, 0x65, 0x67, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6D, + 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x70, 0x65, 0x67, 0x60, 0x20, + 0x69, 0x6E, 0x20, 0x60, 0x74, 0x65, 0x78, 0x74, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, + 0x73, 0x75, 0x62, 0x73, 0x74, 0x60, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x70, 0x65, 0x67, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x6E, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x63, 0x61, + 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x64, 0x6F, 0x20, 0x72, 0x65, 0x70, + 0x6C, 0x61, 0x63, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x73, 0x75, + 0x62, 0x73, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, + 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x66, 0x6F, 0x6C, + 0x6C, 0x6F, 0x77, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x63, 0x61, 0x70, + 0x74, 0x75, 0x72, 0x65, 0x73, 0x2E, 0xCF, 0x06, 0x6F, 0x73, 0x2F, 0x64, 0x69, 0x72, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, 0x30, 0x01, 0xDA, 0x06, 0xD8, 0x06, 0x6F, 0x73, + 0x2F, 0x64, 0x69, 0x72, 0xDA, 0x08, 0xCE, 0x80, 0xA8, 0x28, 0x6F, 0x73, 0x2F, 0x64, 0x69, 0x72, + 0x20, 0x64, 0x69, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x29, + 0x0A, 0x0A, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x75, 0x62, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x6F, 0x72, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x68, + 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x2C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6F, 0x6E, + 0x6C, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6E, 0x61, 0x6D, 0x65, + 0x20, 0x6F, 0x72, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x2E, 0xCF, 0x08, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x2D, 0x66, 0x6E, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x88, 0xED, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, + 0x17, 0x02, 0x01, 0x02, 0x09, 0x3A, 0x00, 0x02, 0x0F, 0xCE, 0x08, 0x73, 0x68, 0x6F, 0x72, 0x74, + 0x2D, 0x66, 0x6E, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x91, 0xDA, 0x80, 0xFA, 0xCF, 0x01, 0x24, + 0xD8, 0x06, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0xDA, 0x80, 0xA8, 0xCF, 0x02, 0x24, 0x26, 0xDA, + 0x86, 0x38, 0xDA, 0x80, 0x9B, 0x00, 0x3A, 0x00, 0xCF, 0x03, 0x61, 0x72, 0x67, 0x00, 0x3A, 0x01, + 0xDA, 0x81, 0xBE, 0x00, 0x3A, 0x02, 0xDA, 0x86, 0xFB, 0x00, 0x3A, 0x03, 0xCF, 0x0E, 0x6D, 0x61, + 0x78, 0x2D, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x2D, 0x73, 0x65, 0x65, 0x6E, 0x01, 0x3A, 0x04, 0xCF, + 0x06, 0x76, 0x61, 0x72, 0x61, 0x72, 0x67, 0x03, 0x3A, 0x06, 0xCF, 0x0F, 0x73, 0x61, 0x77, 0x2D, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6C, 0x2D, 0x61, 0x72, 0x67, 0x06, 0x3A, 0x08, 0xCF, 0x06, + 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x08, 0x3A, 0x0A, 0xDA, 0x80, 0xCC, 0x0C, 0x3A, 0x0C, 0xCF, + 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x65, 0x64, 0x13, 0x3A, 0x0E, 0xCF, 0x0B, 0x6E, 0x61, + 0x6D, 0x65, 0x2D, 0x73, 0x70, 0x6C, 0x69, 0x63, 0x65, 0x15, 0x26, 0x10, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x6A, 0x16, 0x26, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x6B, 0x19, 0x26, 0x12, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x6C, 0x1C, 0x26, 0x13, + 0xDA, 0x80, 0xC3, 0x25, 0x3A, 0x10, 0xCF, 0x07, 0x66, 0x6E, 0x2D, 0x61, 0x72, 0x67, 0x73, 0x2B, + 0x03, 0xFF, 0xFF, 0x2A, 0x04, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x2C, + 0x08, 0x00, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x30, 0x09, 0x01, 0x00, 0x1B, + 0x0A, 0x09, 0x00, 0x32, 0x00, 0x0A, 0x00, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, + 0x0C, 0x0B, 0x00, 0x1E, 0x01, 0x05, 0x00, 0x31, 0x01, 0x00, 0x00, 0x45, 0x0E, 0x00, 0x00, 0x1B, + 0x0D, 0x0E, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x0D, 0x02, 0x00, 0x1B, 0x0E, 0x0D, 0x00, 0x40, + 0x0F, 0x00, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x2B, 0x12, 0x01, 0x00, 0x06, + 0x11, 0x12, 0x03, 0x1B, 0x12, 0x11, 0x00, 0x23, 0x11, 0x0F, 0x12, 0x1E, 0x11, 0x0B, 0x00, 0x1B, + 0x13, 0x0F, 0x00, 0x2C, 0x14, 0x03, 0x00, 0x33, 0x08, 0x14, 0x13, 0x2C, 0x15, 0x04, 0x00, 0x35, + 0x14, 0x15, 0x00, 0x32, 0x10, 0x14, 0x00, 0x2C, 0x16, 0x05, 0x00, 0x35, 0x15, 0x16, 0x00, 0x05, + 0x0F, 0x0F, 0x01, 0x1C, 0xF5, 0xFF, 0xFF, 0x1E, 0x04, 0x0A, 0x00, 0x2C, 0x11, 0x06, 0x00, 0x32, + 0x08, 0x11, 0x00, 0x2C, 0x12, 0x04, 0x00, 0x35, 0x11, 0x12, 0x00, 0x2C, 0x12, 0x07, 0x00, 0x32, + 0x12, 0x11, 0x00, 0x45, 0x11, 0x00, 0x00, 0x1B, 0x0F, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, + 0x0F, 0x02, 0x00, 0x34, 0x10, 0x00, 0x00, 0x34, 0x0F, 0x00, 0x00, 0x46, 0x11, 0x00, 0x00, 0x2C, + 0x12, 0x08, 0x00, 0x31, 0x12, 0x00, 0x00, 0x34, 0x0E, 0x00, 0x00, 0x32, 0x11, 0x0C, 0x00, 0x45, + 0x0F, 0x00, 0x00, 0x03, 0x0F, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, + 0x01, 0x07, 0x01, 0x07, 0xCE, 0x0F, 0x73, 0x61, 0x77, 0x2D, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, + 0x6C, 0x2D, 0x61, 0x72, 0x67, 0xDA, 0x18, 0xDA, 0x85, 0x60, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x87, + 0x03, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, 0xBE, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x86, 0xFB, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x87, 0x04, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x87, 0x05, 0x00, 0x07, 0x00, + 0xCF, 0x03, 0x6E, 0x75, 0x6D, 0x00, 0x07, 0x01, 0xDA, 0x87, 0x06, 0x2D, 0x02, 0x00, 0x03, 0x32, + 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2F, 0x02, 0x00, 0x03, 0x2D, + 0x03, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x89, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x05, 0x00, 0x05, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x01, + 0x01, 0x08, 0x30, 0x01, 0x0A, 0xCE, 0x0A, 0x6F, 0x6E, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, + 0x67, 0xDA, 0x18, 0xDA, 0x87, 0x00, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x68, + 0x61, 0x73, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x3F, 0xCF, 0x02, 0x24, 0x30, 0xDA, 0x87, + 0x01, 0xDA, 0x87, 0x02, 0xDA, 0x82, 0x03, 0xD8, 0x0B, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0xD8, 0x04, 0x6E, 0x61, 0x74, 0x3F, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x87, + 0x03, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, 0xBE, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x86, 0xFB, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x87, 0x04, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x87, 0x05, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x87, 0x06, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x87, 0x07, 0x00, 0x30, 0x00, 0xDA, 0x1E, + 0x00, 0x30, 0x01, 0xDA, 0x80, 0xCC, 0x21, 0x2E, 0x05, 0xDA, 0x87, 0x0F, 0x2C, 0x02, 0x00, 0x00, + 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x2B, 0x00, + 0x2C, 0x04, 0x00, 0x00, 0x25, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x0A, 0x00, 0x2B, 0x04, 0x00, 0x00, + 0x31, 0x04, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x06, 0x35, 0x04, 0x05, 0x00, 0x2D, 0x04, 0x00, 0x08, + 0x2C, 0x05, 0x02, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x36, 0x04, 0x00, 0x00, + 0x2C, 0x05, 0x04, 0x00, 0x25, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x07, 0x00, 0x29, 0x05, 0x00, 0x00, + 0x2F, 0x05, 0x00, 0x04, 0x2D, 0x05, 0x00, 0x08, 0x32, 0x05, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, + 0x36, 0x05, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x32, 0x00, 0x05, 0x00, 0x2C, 0x06, 0x05, 0x00, + 0x35, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1B, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x07, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1E, 0x06, 0x08, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2D, 0x08, 0x00, 0x06, 0x35, 0x07, 0x08, 0x00, + 0x2D, 0x07, 0x00, 0x08, 0x32, 0x07, 0x00, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x36, 0x07, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x89, 0x04, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x02, 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x07, + 0x03, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x01, 0x09, 0x00, 0x09, 0xBF, 0xFB, 0x07, 0x07, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x03, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x14, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x0B, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0B, 0x02, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFD, 0x0B, 0xBF, 0xF4, + 0x07, 0xBF, 0xFF, 0x05, 0x88, 0xFC, 0x03, 0x01, 0x03, 0x01, 0x03, 0x00, 0x03, 0x03, 0x0F, 0x00, + 0x0F, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x15, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x03, 0x01, + 0x14, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x03, 0x01, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x22, 0x00, 0x22, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x39, 0x00, 0x39, 0x00, 0x39, 0x00, 0x39, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x01, 0x23, 0x00, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, 0x2E, 0x00, 0x2E, 0x00, + 0x2E, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x58, 0x01, 0x00, 0x00, 0xDA, 0x08, 0xCE, + 0x82, 0x38, 0x28, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x2D, 0x66, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, + 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x66, 0x6E, 0x60, 0x2E, 0x20, + 0x41, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x67, 0x69, + 0x76, 0x65, 0x6E, 0x20, 0x61, 0x73, 0x20, 0x60, 0x24, 0x6E, 0x60, 0x2C, 0x20, 0x77, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x30, 0x2D, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x0A, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x2E, 0x20, 0x60, 0x24, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x28, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x30, 0x29, 0x20, 0x61, + 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x60, 0x24, 0x26, + 0x60, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, + 0x6B, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x6E, 0x6F, 0x6E, 0x79, 0x6D, 0x6F, 0x75, 0x73, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x64, + 0x69, 0x63, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x65, + 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x61, + 0x6C, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x0A, 0x0A, 0x45, 0x78, + 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x75, 0x73, 0x61, 0x67, 0x65, 0x3A, 0x0A, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x28, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x2D, 0x66, 0x6E, 0x20, 0x28, 0x2B, 0x20, 0x24, + 0x20, 0x24, 0x29, 0x29, 0x20, 0x23, 0x20, 0x41, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x69, + 0x74, 0x73, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x28, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x2D, 0x66, 0x6E, 0x20, 0x28, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x20, 0x24, 0x30, 0x20, 0x24, 0x31, 0x29, 0x29, 0x20, 0x23, 0x20, 0x61, 0x63, + 0x63, 0x65, 0x70, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, + 0x20, 0x61, 0x72, 0x67, 0x73, 0x2E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x7C, 0x28, 0x2B, 0x20, 0x24, + 0x20, 0x24, 0x29, 0x20, 0x23, 0x20, 0x75, 0x73, 0x65, 0x20, 0x70, 0x69, 0x70, 0x65, 0x20, 0x72, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x74, 0x65, 0x72, 0x73, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6C, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6C, 0x73, 0x2E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x7C, 0x28, 0x2B, + 0x20, 0x24, 0x26, 0x29, 0x20, 0x20, 0x23, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x64, 0x69, 0x63, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDA, 0x37, 0xCB, 0xDA, 0x80, 0xF2, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0xAD, 0x01, 0xDA, 0x06, 0xDA, 0x80, + 0xEF, 0xDA, 0x08, 0xCE, 0x78, 0x28, 0x6B, 0x76, 0x73, 0x20, 0x64, 0x69, 0x63, 0x74, 0x29, 0x0A, + 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, + 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x0A, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x40, 0x5B, 0x6B, 0x20, 0x76, 0x20, 0x6B, 0x20, + 0x76, 0x20, 0x2E, 0x2E, 0x2E, 0x5D, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x12, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x3F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x47, 0x01, 0xDA, 0x06, + 0xDA, 0x87, 0x11, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x68, + 0x61, 0x73, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x3F, 0x20, 0x70, 0x66, 0x78, 0x20, 0x73, + 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x54, 0x65, 0x73, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x70, 0x66, 0x78, 0x60, 0x2E, 0xCF, 0x04, 0x6B, 0x65, 0x79, + 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x41, 0x01, 0xDA, 0x06, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x03, 0x21, 0x00, 0x0B, 0xCE, 0x04, + 0x6B, 0x65, 0x79, 0x73, 0xDA, 0x18, 0xDA, 0x86, 0x85, 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0x00, + 0x21, 0x00, 0xDA, 0x1E, 0x00, 0x21, 0x01, 0xDA, 0x87, 0x1D, 0x08, 0x14, 0x03, 0xDA, 0x86, 0x87, + 0x09, 0x14, 0x04, 0xDA, 0x80, 0xC3, 0x09, 0x13, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x43, 0x0C, 0x13, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x42, 0x0E, 0x13, + 0x05, 0xDA, 0x22, 0x15, 0x21, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x15, + 0x20, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x46, 0x18, 0x20, 0x05, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x1A, 0x20, 0x03, 0xDA, 0x22, 0x31, 0x00, 0x00, 0x00, + 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x11, 0x00, 0x3F, 0x03, 0x00, 0x00, + 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x03, 0x04, 0x00, + 0x2B, 0x04, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, 0x06, 0x1B, 0x06, 0x05, 0x00, + 0x1F, 0x06, 0x06, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x3C, 0x03, 0x04, 0x05, 0x05, 0x04, 0x04, 0x01, + 0x49, 0x06, 0x00, 0x06, 0x1C, 0xFB, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, + 0x1B, 0x04, 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x03, 0x00, 0x05, 0x1B, 0x05, 0x03, 0x00, + 0x1F, 0x05, 0x07, 0x00, 0x1B, 0x03, 0x05, 0x00, 0x32, 0x04, 0x03, 0x00, 0x2C, 0x07, 0x02, 0x00, + 0x35, 0x06, 0x07, 0x00, 0x49, 0x05, 0x00, 0x05, 0x1C, 0xFA, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, + 0x86, 0x44, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x02, 0x22, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x07, 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x09, 0x01, 0x09, 0xBF, 0xFE, 0x07, 0x00, 0x07, 0xBF, 0xFD, 0x05, 0x07, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x08, 0xCE, 0x38, 0x28, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x78, + 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x2E, 0xCF, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x73, 0x65, + 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x82, 0x33, 0x01, 0xDA, 0x06, + 0xD8, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x73, 0x65, 0x74, + 0xDA, 0x08, 0xCE, 0x57, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, + 0x73, 0x65, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x20, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x69, 0x74, + 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x09, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, + 0x81, 0x0B, 0x01, 0xDA, 0x06, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, + 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0x20, 0x78, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x72, 0x63, 0x73, 0x69, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x06, 0x67, 0x65, 0x74, + 0x2D, 0x69, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xF2, 0x01, 0xDA, + 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x03, 0x02, 0x03, 0x02, 0x18, 0x00, 0x08, + 0xCE, 0x06, 0x67, 0x65, 0x74, 0x2D, 0x69, 0x6E, 0xDA, 0x18, 0xDA, 0x83, 0x7D, 0xDA, 0x82, 0x30, + 0x00, 0x18, 0x00, 0xDA, 0x24, 0x00, 0x18, 0x01, 0xCF, 0x02, 0x6B, 0x73, 0x00, 0x18, 0x02, 0xDA, + 0x20, 0x00, 0x18, 0x03, 0xDA, 0x87, 0x32, 0x00, 0x18, 0x04, 0xDA, 0x82, 0x70, 0x00, 0x13, 0x01, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x71, 0x03, 0x13, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x70, 0x06, 0x13, 0x07, 0xDA, 0x22, 0x1B, 0x04, 0x00, 0x00, 0x28, 0x06, + 0x00, 0x00, 0x49, 0x05, 0x01, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x0F, 0x00, 0x3A, 0x05, + 0x01, 0x06, 0x1B, 0x07, 0x05, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x05, + 0x08, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1E, 0x08, + 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3B, 0x04, 0x04, 0x07, 0x49, 0x06, + 0x01, 0x06, 0x1C, 0xF2, 0xFF, 0xFF, 0x28, 0x06, 0x00, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, + 0x02, 0x00, 0x03, 0x02, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x85, 0xF6, 0x03, 0x01, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, + 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x31, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x08, 0xCE, 0x80, 0xB9, + 0x28, 0x67, 0x65, 0x74, 0x2D, 0x69, 0x6E, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x73, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x29, 0x0A, 0x0A, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x2E, 0x20, 0x4C, 0x6F, 0x6F, 0x6B, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x76, 0x69, 0x61, 0x0A, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x64, 0x66, 0x6C, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, + 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x60, 0x64, 0x66, 0x6C, 0x74, 0x60, 0x2E, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, + 0x81, 0xF4, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x65, 0xDA, 0x08, 0xCE, 0x81, 0x55, 0x28, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x62, 0x6F, 0x74, + 0x68, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6C, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, + 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x78, 0x20, 0x69, 0x6E, + 0x20, 0x78, 0x73, 0x2C, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, + 0x74, 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, + 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x65, + 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x75, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x65, + 0x73, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x62, 0x6F, 0x74, 0x68, 0x20, 0x60, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x60, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, + 0x68, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, + 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x66, 0x6C, 0x6F, 0x77, + 0x73, 0x2E, 0xCF, 0x0D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x82, 0x8A, 0x01, 0xDA, 0x06, + 0xDA, 0x83, 0x04, 0xDA, 0x08, 0xCE, 0x80, 0x81, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x6F, + 0x72, 0x6D, 0x61, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x6E, + 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x70, 0x72, + 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2F, 0x70, 0x65, 0x65, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, + 0xC1, 0x01, 0xDA, 0x06, 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x65, 0x65, 0x6B, + 0xDA, 0x08, 0xCE, 0x53, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x65, 0x65, 0x6B, 0x20, + 0x61, 0x72, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6F, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x44, 0x6F, 0x65, + 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x0D, 0x6F, 0x73, 0x2F, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x6F, 0x72, 0x61, 0x6E, 0x64, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, + 0x86, 0x01, 0xDA, 0x06, 0xD8, 0x0D, 0x6F, 0x73, 0x2F, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x72, + 0x61, 0x6E, 0x64, 0xDA, 0x08, 0xCE, 0x80, 0x82, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x6F, 0x72, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x75, + 0x66, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, + 0x64, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x67, + 0x6F, 0x6F, 0x64, 0x20, 0x71, 0x75, 0x61, 0x6C, 0x69, 0x74, 0x79, 0x20, 0x72, 0x61, 0x6E, 0x64, + 0x6F, 0x6D, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4F, 0x53, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x6F, 0x72, 0x20, 0x60, 0x62, 0x75, 0x66, 0x60, 0x2E, 0xCF, 0x04, 0x62, 0x78, 0x6F, 0x72, + 0xD3, 0x02, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x0F, 0x06, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x04, 0x62, 0x78, 0x6F, 0x72, 0x3F, 0x01, 0x00, 0x00, 0x26, + 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, + 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x12, + 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, + 0x04, 0x00, 0x05, 0x12, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, + 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x59, 0x28, 0x62, 0x78, 0x6F, 0x72, + 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x2D, 0x77, 0x69, 0x73, 0x65, 0x20, 0x78, 0x6F, 0x72, + 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, + 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x67, 0x65, 0x72, 0x2E, 0xCF, 0x07, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0xED, 0x01, 0xDA, 0x06, 0xD7, 0x00, 0xCD, 0x00, 0xDD, + 0x00, 0x00, 0x05, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x06, 0x00, 0x03, 0xCE, 0x07, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0xF6, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x13, 0x03, 0x03, 0x03, 0x0F, 0x48, 0x00, 0x0C, 0xCE, 0x09, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x2D, 0x31, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x0E, + 0x01, 0x01, 0x01, 0x0F, 0x4D, 0x00, 0x01, 0x0E, 0xCE, 0x0B, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, + 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x18, 0xD0, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, + 0x70, 0x61, 0x74, 0x68, 0x73, 0xD1, 0x11, 0xD2, 0x03, 0x00, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x04, 0x01, 0x01, 0x01, 0x03, 0x09, 0x00, 0x02, 0xCE, 0x09, 0x69, 0x73, 0x2D, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x64, 0xDA, 0x18, 0xDA, 0x86, 0x91, 0xD3, 0x00, 0xDA, 0x80, 0xFB, 0x00, 0x09, + 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x09, 0x01, 0xCF, 0x09, 0x69, 0x73, 0x2D, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x64, 0x2C, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, 0x02, 0x03, 0x00, 0x2C, 0x03, + 0x02, 0x00, 0x35, 0x02, 0x03, 0x00, 0x3A, 0x03, 0x02, 0x00, 0x1E, 0x03, 0x02, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8B, 0x05, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, + 0x3C, 0x00, 0x38, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0xD0, 0x07, 0x70, 0x72, 0x65, 0x6C, 0x6F, + 0x61, 0x64, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x02, 0x07, 0x00, + 0x02, 0xCE, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x6E, 0x6F, 0x74, 0x2D, 0x72, 0x65, 0x6C, + 0x61, 0x74, 0x69, 0x76, 0x65, 0xDA, 0x18, 0xCE, 0x01, 0x2E, 0xDA, 0x87, 0x11, 0x00, 0x07, 0x00, + 0xDA, 0x1E, 0x00, 0x07, 0x01, 0xCF, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x6E, 0x6F, 0x74, + 0x2D, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, + 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x8A, 0xCE, 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0xD2, 0x03, 0x00, 0xCE, 0x12, 0x3A, 0x63, 0x75, 0x72, 0x3A, 0x2F, 0x3A, + 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD0, 0x05, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x02, 0x07, 0x00, + 0x02, 0xCE, 0x0E, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, + 0x65, 0xDA, 0x18, 0xDA, 0x87, 0x64, 0xDA, 0x87, 0x11, 0x00, 0x07, 0x00, 0xDA, 0x1E, 0x00, 0x07, + 0x01, 0xCF, 0x0E, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, + 0x00, 0x1E, 0x02, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8A, 0xCD, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0xD2, 0x03, 0x00, 0xCE, + 0x11, 0x3A, 0x63, 0x75, 0x72, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x61, 0x6E, + 0x65, 0x74, 0xDA, 0x84, 0xBA, 0xDA, 0x87, 0x69, 0xD2, 0x03, 0x00, 0xCE, 0x16, 0x3A, 0x63, 0x75, + 0x72, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x69, 0x6E, 0x69, 0x74, 0x2E, 0x6A, 0x61, + 0x6E, 0x65, 0x74, 0xDA, 0x84, 0xBA, 0xDA, 0x87, 0x69, 0xD2, 0x03, 0x00, 0xCE, 0x13, 0x3A, 0x63, + 0x75, 0x72, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x3A, 0xD0, 0x06, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xDA, 0x87, 0x69, 0xD2, 0x03, 0x00, 0xCE, + 0x12, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, + 0x61, 0x67, 0x65, 0xDA, 0x87, 0x68, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, + 0x01, 0x04, 0x19, 0x00, 0x04, 0xCE, 0x0C, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x69, 0x73, 0x2D, + 0x64, 0x65, 0x70, 0xDA, 0x18, 0xDA, 0x82, 0xDE, 0xDA, 0x87, 0x11, 0xCE, 0x01, 0x40, 0xDA, 0x87, + 0x64, 0x00, 0x19, 0x00, 0xDA, 0x1E, 0x00, 0x19, 0x01, 0xCF, 0x0C, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x2D, 0x69, 0x73, 0x2D, 0x64, 0x65, 0x70, 0x04, 0x16, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x4F, 0x0C, 0x15, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x4E, 0x2C, + 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x1E, 0x03, 0x03, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x1C, 0x0F, 0x00, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, + 0x05, 0x04, 0x00, 0x1E, 0x05, 0x03, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, + 0x06, 0x03, 0x00, 0x32, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, + 0x04, 0x06, 0x00, 0x1B, 0x02, 0x04, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x00, 0x00, 0x8A, 0xCF, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x21, 0x00, 0x21, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x21, 0x00, 0x21, 0x00, 0x5B, 0x00, 0x5B, 0x00, 0x5B, 0x00, 0x5B, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0xD2, 0x03, 0x00, 0xCE, 0x11, 0x3A, 0x73, 0x79, 0x73, 0x3A, + 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x84, 0xBA, 0xDA, + 0x87, 0x75, 0xD2, 0x03, 0x00, 0xCE, 0x16, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, + 0x6C, 0x3A, 0x2F, 0x69, 0x6E, 0x69, 0x74, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x84, 0xBA, + 0xDA, 0x87, 0x75, 0xD2, 0x03, 0x00, 0xCE, 0x13, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, + 0x6C, 0x6C, 0x3A, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x87, 0x72, 0xDA, 0x87, + 0x75, 0xD2, 0x03, 0x00, 0xCE, 0x0D, 0x2E, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, + 0x61, 0x67, 0x65, 0xDA, 0x87, 0x68, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, + 0x01, 0x02, 0x07, 0x00, 0x02, 0xCE, 0x16, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x70, 0x72, 0x6F, + 0x6A, 0x65, 0x63, 0x74, 0x2D, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0xDA, 0x18, 0xDA, + 0x82, 0xDE, 0xDA, 0x87, 0x11, 0x00, 0x07, 0x00, 0xDA, 0x1E, 0x00, 0x07, 0x01, 0xCF, 0x16, 0x63, + 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x70, 0x72, 0x6F, 0x6A, 0x65, 0x63, 0x74, 0x2D, 0x72, 0x65, 0x6C, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, + 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x8A, 0xD0, 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, + 0xD2, 0x03, 0x00, 0xCE, 0x0C, 0x2E, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x61, 0x6E, 0x65, + 0x74, 0xDA, 0x84, 0xBA, 0xDA, 0x87, 0x83, 0xD2, 0x03, 0x00, 0xCE, 0x11, 0x2E, 0x3A, 0x61, 0x6C, + 0x6C, 0x3A, 0x2F, 0x69, 0x6E, 0x69, 0x74, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x84, 0xBA, + 0xDA, 0x87, 0x83, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x2E, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x3A, 0x6E, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x87, 0x72, 0xDA, 0x87, 0x83, 0xD2, 0x03, 0x00, 0xCE, + 0x0D, 0x3A, 0x40, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x87, + 0x68, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x02, 0x07, 0x00, 0x02, + 0xCE, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x64, 0x79, 0x6E, 0x2D, 0x72, 0x65, 0x6C, 0x61, + 0x74, 0x69, 0x76, 0x65, 0xDA, 0x18, 0xDA, 0x87, 0x77, 0xDA, 0x87, 0x11, 0x00, 0x07, 0x00, 0xDA, + 0x1E, 0x00, 0x07, 0x01, 0xCF, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x64, 0x79, 0x6E, 0x2D, + 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, + 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x8A, 0xCC, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x1F, 0x00, + 0x1F, 0x00, 0x1F, 0xD2, 0x03, 0x00, 0xCE, 0x0C, 0x3A, 0x40, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, + 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x84, 0xBA, 0xDA, 0x87, 0x8E, 0xD2, 0x03, 0x00, 0xCE, 0x11, 0x3A, + 0x40, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x69, 0x6E, 0x69, 0x74, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, + 0xDA, 0x84, 0xBA, 0xDA, 0x87, 0x8E, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x3A, 0x40, 0x61, 0x6C, 0x6C, + 0x3A, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x87, 0x72, 0xDA, 0x87, 0x8E, 0xDA, + 0x80, 0xFB, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x02, 0x02, 0x02, 0x04, 0x10, 0x00, + 0x04, 0xCE, 0x0A, 0x6D, 0x6F, 0x64, 0x2D, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0xDA, 0x18, 0xDA, + 0x65, 0xD0, 0x03, 0x6E, 0x69, 0x6C, 0xDA, 0x83, 0x0B, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x3F, 0x00, 0x10, 0x00, + 0xDA, 0x1E, 0x00, 0x10, 0x01, 0xDA, 0x84, 0xC3, 0x00, 0x10, 0x02, 0xCF, 0x0A, 0x6D, 0x6F, 0x64, + 0x2D, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x03, 0x10, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x53, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, + 0x04, 0x03, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x25, 0x03, 0x04, 0x05, 0x1E, 0x03, 0x02, 0x00, 0x03, + 0x01, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x25, 0x05, 0x04, 0x06, 0x1E, 0x05, 0x04, 0x00, 0x32, + 0x00, 0x01, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x36, 0x06, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x36, + 0x00, 0x00, 0x00, 0x8B, 0x15, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x0D, 0x00, 0x0D, 0x00, 0x0D, + 0x01, 0x05, 0x00, 0x05, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, + 0x06, 0x00, 0x02, 0xCE, 0x09, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xDA, 0x18, + 0xDA, 0x65, 0xDA, 0x84, 0x40, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x09, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, + 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, + 0x6A, 0x46, 0x00, 0x46, 0x00, 0x46, 0x00, 0x43, 0x00, 0x43, 0x00, 0x43, 0xD8, 0x12, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, + 0xDA, 0x81, 0x12, 0xDA, 0x85, 0x43, 0xDA, 0x80, 0xA6, 0xDA, 0x80, 0xA0, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x0A, 0x02, 0x02, 0x02, 0x01, 0x11, 0x00, 0x07, 0xCE, 0x06, 0x66, 0x69, 0x6C, + 0x74, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0x00, 0x11, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x11, + 0x01, 0xDA, 0x1F, 0x00, 0x11, 0x02, 0xCF, 0x06, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x01, 0x11, + 0x04, 0xDA, 0x80, 0xAD, 0x01, 0x10, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, + 0x04, 0x10, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x07, 0x10, 0x07, 0xDA, + 0x83, 0x7C, 0x40, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, + 0x01, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x0B, 0x00, 0x3A, 0x05, 0x01, 0x06, 0x1B, 0x07, + 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x05, 0x00, 0x00, 0x1E, 0x05, 0x04, 0x00, 0x32, 0x04, + 0x07, 0x00, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x08, 0x09, 0x00, 0x49, 0x06, 0x01, 0x06, 0x1C, 0xF6, + 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x83, 0xFB, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, + 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xCE, 0x05, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0C, 0x02, 0x02, 0x02, 0x03, 0x2C, 0x00, + 0x07, 0xCE, 0x09, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x73, 0x65, 0xDA, 0x18, 0xDA, 0x86, + 0x85, 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0x00, 0x2C, 0x00, 0xCF, 0x03, 0x73, 0x65, 0x70, 0x00, + 0x2C, 0x01, 0xDA, 0x1F, 0x00, 0x2C, 0x02, 0xCF, 0x09, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, + 0x73, 0x65, 0x02, 0x2C, 0x04, 0xDA, 0x22, 0x11, 0x1C, 0x07, 0xDA, 0x23, 0x12, 0x1C, 0x08, 0xDA, + 0x80, 0xC3, 0x1F, 0x2A, 0x08, 0xDA, 0x23, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, 0x04, 0x1B, + 0x04, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x4A, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x25, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1E, 0x06, 0x13, 0x00, 0x3F, + 0x07, 0x01, 0x00, 0x2B, 0x09, 0x02, 0x00, 0x0A, 0x08, 0x09, 0x07, 0x07, 0x07, 0x08, 0x01, 0x32, + 0x07, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, 0x07, 0x08, 0x00, 0x2B, + 0x08, 0x00, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x4A, 0x09, 0x0A, 0x04, 0x1E, 0x09, 0x06, 0x00, 0x3A, + 0x0A, 0x01, 0x04, 0x3C, 0x07, 0x08, 0x0A, 0x49, 0x04, 0x01, 0x04, 0x05, 0x08, 0x08, 0x02, 0x1C, + 0xF9, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x3A, 0x07, 0x01, 0x04, 0x31, 0x07, 0x00, 0x00, 0x40, + 0x07, 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x49, 0x04, 0x01, 0x04, 0x28, 0x09, 0x00, 0x00, 0x4A, + 0x07, 0x09, 0x04, 0x1E, 0x07, 0x06, 0x00, 0x3A, 0x09, 0x01, 0x04, 0x33, 0x08, 0x00, 0x09, 0x2C, + 0x0B, 0x02, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1C, 0xF8, 0xFF, 0xFF, 0x03, 0x08, 0x00, 0x00, 0x40, + 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x86, 0xC2, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x07, + 0x00, 0x07, 0x00, 0x03, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x02, 0x2C, 0x00, 0x27, + 0x00, 0x27, 0x00, 0x24, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x09, 0x01, 0x09, 0x01, 0x10, + 0x00, 0x10, 0x00, 0x09, 0x01, 0x16, 0x00, 0x0B, 0x01, 0x12, 0x01, 0x0B, 0xBF, 0xFD, 0x09, 0xBF, + 0xFD, 0x07, 0x09, 0x14, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x21, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x09, 0x01, 0x1F, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x09, 0xBF, 0xFE, 0x07, + 0xBF, 0xF6, 0x03, 0x00, 0x03, 0xCE, 0x16, 0x63, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0xCE, 0x06, 0x3A, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x00, 0x4D, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x4D, 0x01, 0xCF, 0x0B, + 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x00, 0x4D, 0x02, 0xDA, 0x23, + 0x06, 0x4D, 0x04, 0xCF, 0x02, 0x6D, 0x70, 0x06, 0x32, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x55, 0x09, 0x32, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x54, 0x0D, + 0x32, 0x08, 0xDA, 0x6D, 0x0F, 0x32, 0x09, 0xCF, 0x08, 0x6D, 0x6F, 0x64, 0x2D, 0x6B, 0x69, 0x6E, + 0x64, 0x11, 0x32, 0x0A, 0xCF, 0x07, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x65, 0x72, 0x1C, 0x21, 0x0C, + 0xDA, 0x80, 0xAD, 0x28, 0x30, 0x0B, 0xCF, 0x08, 0x66, 0x75, 0x6C, 0x6C, 0x70, 0x61, 0x74, 0x68, + 0x35, 0x4D, 0x06, 0xCF, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x65, 0x72, 0x3D, 0x4D, 0x05, + 0xCF, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x42, 0x4D, 0x08, 0xCF, 0x09, 0x73, 0x74, 0x72, 0x2D, + 0x70, 0x61, 0x72, 0x74, 0x73, 0x28, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, + 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x04, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x28, + 0x00, 0x3A, 0x05, 0x04, 0x06, 0x3D, 0x07, 0x05, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x3D, 0x07, 0x05, + 0x01, 0x1B, 0x09, 0x07, 0x00, 0x3D, 0x07, 0x05, 0x02, 0x1B, 0x0A, 0x07, 0x00, 0x32, 0x0A, 0x00, + 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x05, 0x07, 0x00, 0x1E, 0x05, 0x1B, 0x00, 0x31, 0x08, 0x00, + 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x35, 0x07, 0x0B, 0x00, 0x1E, 0x07, 0x09, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x35, 0x0B, 0x08, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x1E, 0x0B, 0x04, 0x00, 0x32, 0x0C, 0x09, + 0x00, 0x45, 0x02, 0x00, 0x00, 0x1C, 0x12, 0x00, 0x00, 0x1C, 0x0F, 0x00, 0x00, 0x32, 0x00, 0x08, + 0x00, 0x2C, 0x0C, 0x05, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x06, + 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1B, 0x0B, 0x0C, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x07, + 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1E, 0x0C, 0x04, 0x00, 0x32, 0x0B, 0x09, 0x00, 0x45, 0x02, 0x00, + 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x06, 0x04, 0x06, 0x1C, 0xD9, 0xFF, 0xFF, 0x1E, 0x02, 0x02, + 0x00, 0x03, 0x02, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x32, 0x06, 0x04, + 0x00, 0x2C, 0x07, 0x08, 0x00, 0x35, 0x05, 0x07, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x32, 0x07, 0x05, + 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x05, 0x07, 0x00, 0x2C, 0x07, 0x0B, + 0x00, 0x32, 0x07, 0x05, 0x00, 0x2C, 0x08, 0x0C, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x08, 0x07, + 0x00, 0x2C, 0x07, 0x0D, 0x00, 0x2C, 0x09, 0x0E, 0x00, 0x33, 0x07, 0x00, 0x09, 0x34, 0x08, 0x00, + 0x00, 0x2C, 0x09, 0x06, 0x00, 0x35, 0x07, 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x32, 0x09, 0x07, + 0x00, 0x45, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x06, 0x01, + 0x01, 0x01, 0x03, 0x14, 0x01, 0x0E, 0xDA, 0x18, 0xDA, 0x85, 0xA7, 0xDA, 0x87, 0x98, 0xDA, 0x87, + 0xA1, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x87, 0xAE, 0xBF, + 0xFF, 0x00, 0x02, 0xDA, 0x23, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x87, 0xAF, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x87, 0xB0, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x87, 0xB1, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x6D, + 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x87, 0xB2, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x87, 0xB3, 0xBF, 0xFF, + 0x00, 0x0C, 0xDA, 0x80, 0xAD, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x87, 0xB4, 0x01, 0x14, 0x02, 0xDA, + 0x80, 0xDB, 0x03, 0x14, 0x03, 0xDA, 0x85, 0x58, 0x04, 0x14, 0x04, 0xCF, 0x03, 0x63, 0x68, 0x6B, + 0x3D, 0x01, 0x00, 0x00, 0x1B, 0x02, 0x01, 0x00, 0x3D, 0x01, 0x00, 0x01, 0x3D, 0x01, 0x00, 0x02, + 0x1B, 0x04, 0x01, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x35, 0x00, 0x01, 0x00, + 0x1E, 0x00, 0x0B, 0x00, 0x2D, 0x01, 0x00, 0x00, 0x32, 0x04, 0x01, 0x00, 0x2C, 0x05, 0x01, 0x00, + 0x35, 0x01, 0x05, 0x00, 0x1E, 0x01, 0x05, 0x00, 0x2D, 0x05, 0x00, 0x00, 0x32, 0x05, 0x02, 0x00, + 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0xBF, 0xFF, 0x8B, 0x30, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x1C, 0x00, + 0x1C, 0x00, 0x1C, 0x00, 0x16, 0x01, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x18, 0x01, + 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0xBF, 0xFF, 0x18, 0xBF, 0xFF, 0x16, 0x8B, 0x22, 0x03, + 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x07, 0x01, 0x18, 0x00, 0x18, 0x00, 0x09, 0x00, 0x09, 0x01, 0x14, 0x00, 0x14, 0x01, 0x0B, + 0xBF, 0xFD, 0x07, 0x05, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, + 0x0B, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x0B, 0x01, 0x16, 0x00, 0x16, 0x01, 0x0D, 0xBF, + 0xF6, 0x03, 0x00, 0x03, 0x0B, 0x03, 0x00, 0x03, 0x01, 0x14, 0x00, 0x05, 0x04, 0x22, 0x00, 0x22, + 0x00, 0x22, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, 0xFC, 0x05, 0x05, 0x15, 0x00, + 0x15, 0x00, 0x15, 0x00, 0x15, 0xBF, 0xFB, 0x05, 0x06, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x00, 0x00, 0x00, + 0xDA, 0x86, 0x91, 0xDA, 0x87, 0x5F, 0xDA, 0x80, 0xFB, 0xD0, 0x0E, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0xD3, 0x00, 0xD0, 0x0E, 0x6D, 0x6F, 0x64, + 0x75, 0x6C, 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x73, 0xD3, 0x04, 0xDA, 0x87, 0x68, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, + 0x06, 0x00, 0x02, 0xCE, 0x0C, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, + 0x72, 0xDA, 0x18, 0xDA, 0x84, 0xBB, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x02, 0xCE, 0x0A, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, + 0x65, 0xDA, 0x18, 0xD3, 0x82, 0x86, 0xDA, 0x01, 0xDA, 0x07, 0xDA, 0x0A, 0xDA, 0x0E, 0xDA, 0x10, + 0xDA, 0x14, 0xDA, 0x16, 0xDA, 0x1A, 0xDA, 0x27, 0xDA, 0x2B, 0xDA, 0x2D, 0xDA, 0x30, 0xDA, 0x38, + 0xDA, 0x3C, 0xDA, 0x3E, 0xDA, 0x41, 0xDA, 0x4C, 0xDA, 0x4F, 0xDA, 0x5C, 0xDA, 0x5F, 0xDA, 0x70, + 0xDA, 0x73, 0xDA, 0x75, 0xDA, 0x78, 0xDA, 0x7A, 0xDA, 0x7D, 0xDA, 0x80, 0x80, 0xDA, 0x80, 0x84, + 0xDA, 0x80, 0x86, 0xDA, 0x80, 0x89, 0xDA, 0x81, 0x2C, 0xDA, 0x81, 0x2E, 0xDA, 0x81, 0x31, 0xDA, + 0x81, 0x35, 0xDA, 0x81, 0x37, 0xDA, 0x81, 0x3A, 0xDA, 0x81, 0x3C, 0xDA, 0x81, 0x3F, 0xDA, 0x81, + 0x43, 0xDA, 0x81, 0x45, 0xDA, 0x81, 0x48, 0xDA, 0x81, 0x4B, 0xDA, 0x81, 0x4D, 0xDA, 0x81, 0x50, + 0xDA, 0x81, 0x55, 0xDA, 0x81, 0x59, 0xDA, 0x81, 0x5B, 0xDA, 0x80, 0xA4, 0xDA, 0x81, 0x60, 0xDA, + 0x81, 0x64, 0xDA, 0x81, 0x66, 0xDA, 0x81, 0x69, 0xDA, 0x81, 0x76, 0xDA, 0x81, 0x79, 0xDA, 0x81, + 0x7B, 0xDA, 0x81, 0x7E, 0xDA, 0x81, 0x81, 0xDA, 0x81, 0x84, 0xDA, 0x81, 0x8D, 0xDA, 0x81, 0x90, + 0xDA, 0x81, 0xA1, 0xDA, 0x81, 0xA5, 0xDA, 0x81, 0xA7, 0xDA, 0x81, 0xAA, 0xDA, 0x81, 0xAF, 0xDA, + 0x81, 0xB2, 0xDA, 0x81, 0xB4, 0xDA, 0x81, 0xB7, 0xDA, 0x81, 0xB9, 0xDA, 0x81, 0xBC, 0xDA, 0x81, + 0xC1, 0xDA, 0x81, 0xC5, 0xDA, 0x81, 0xC7, 0xDA, 0x81, 0xCB, 0xDA, 0x81, 0xCD, 0xDA, 0x81, 0xD0, + 0xDA, 0x81, 0xE0, 0xDA, 0x81, 0xE3, 0xDA, 0x81, 0xE5, 0xDA, 0x81, 0xE8, 0xDA, 0x82, 0xA6, 0xDA, + 0x82, 0xA9, 0xDA, 0x82, 0xAB, 0xDA, 0x82, 0xAE, 0xDA, 0x82, 0xB0, 0xDA, 0x82, 0xB3, 0xDA, 0x82, + 0xB7, 0xDA, 0x82, 0xBA, 0xDA, 0x82, 0xCB, 0xDA, 0x82, 0xCE, 0xDA, 0x82, 0xD0, 0xDA, 0x82, 0xD3, + 0xDA, 0x82, 0x4C, 0xDA, 0x82, 0x4A, 0xDA, 0x82, 0xD8, 0xDA, 0x82, 0xDB, 0xDA, 0x82, 0xE0, 0xDA, + 0x81, 0x70, 0xDA, 0x82, 0xE3, 0xDA, 0x82, 0xE6, 0xDA, 0x82, 0xE8, 0xDA, 0x82, 0xEB, 0xDA, 0x82, + 0xED, 0xDA, 0x82, 0xF0, 0xDA, 0x82, 0xFB, 0xDA, 0x82, 0xFE, 0xDA, 0x83, 0x0E, 0xDA, 0x83, 0x11, + 0xDA, 0x83, 0x13, 0xDA, 0x83, 0x16, 0xDA, 0x83, 0x18, 0xDA, 0x83, 0x1B, 0xDA, 0x83, 0x1F, 0xDA, + 0x83, 0x22, 0xDA, 0x83, 0x24, 0xDA, 0x83, 0x27, 0xDA, 0x83, 0x29, 0xDA, 0x80, 0xCA, 0xDA, 0x83, + 0x2D, 0xDA, 0x83, 0x30, 0xDA, 0x83, 0x32, 0xDA, 0x83, 0x35, 0xDA, 0x83, 0x37, 0xDA, 0x83, 0x3A, + 0xDA, 0x83, 0x3C, 0xDA, 0x83, 0x3F, 0xDA, 0x83, 0x41, 0xDA, 0x81, 0x06, 0xDA, 0x83, 0x45, 0xDA, + 0x83, 0x48, 0xDA, 0x83, 0x4B, 0xDA, 0x83, 0x4E, 0xDA, 0x83, 0x50, 0xDA, 0x83, 0x52, 0xDA, 0x83, + 0x55, 0xDA, 0x83, 0x59, 0xDA, 0x83, 0x5B, 0xDA, 0x83, 0x5E, 0xDA, 0x83, 0x60, 0xDA, 0x83, 0x63, + 0xDA, 0x83, 0x65, 0xDA, 0x83, 0x69, 0xDA, 0x83, 0x6B, 0xDA, 0x83, 0x6F, 0xDA, 0x83, 0x71, 0xDA, + 0x83, 0x74, 0xDA, 0x83, 0x92, 0xDA, 0x81, 0x6F, 0xDA, 0x83, 0x97, 0xDA, 0x83, 0x9A, 0xDA, 0x83, + 0x9C, 0xDA, 0x83, 0x9F, 0xDA, 0x80, 0xCD, 0xDA, 0x80, 0x93, 0xDA, 0x83, 0xA4, 0xDA, 0x83, 0xA7, + 0xDA, 0x83, 0xB0, 0xDA, 0x83, 0xB3, 0xDA, 0x83, 0xB5, 0xDA, 0x83, 0xB8, 0xDA, 0x83, 0xBA, 0xDA, + 0x83, 0xBD, 0xDA, 0x83, 0xBF, 0xDA, 0x83, 0xC2, 0xDA, 0x83, 0xC4, 0xDA, 0x83, 0xC7, 0xDA, 0x83, + 0xD4, 0xDA, 0x83, 0xD7, 0xDA, 0x83, 0xD9, 0xDA, 0x83, 0xDC, 0xDA, 0x83, 0xDE, 0xDA, 0x83, 0xE1, + 0xDA, 0x83, 0xE3, 0xDA, 0x83, 0xE6, 0xDA, 0x83, 0xE8, 0xDA, 0x83, 0xEB, 0xDA, 0x83, 0xED, 0xDA, + 0x83, 0xF0, 0xDA, 0x83, 0xFD, 0xDA, 0x84, 0x00, 0xDA, 0x83, 0xF7, 0xDA, 0x83, 0xFB, 0xDA, 0x84, + 0x02, 0xDA, 0x84, 0x05, 0xDA, 0x84, 0x07, 0xDA, 0x84, 0x0A, 0xDA, 0x84, 0x11, 0xDA, 0x84, 0x14, + 0xDA, 0x84, 0x16, 0xDA, 0x84, 0x19, 0xDA, 0x84, 0x1B, 0xDA, 0x84, 0x1E, 0xDA, 0x84, 0x27, 0xDA, + 0x84, 0x2A, 0xDA, 0x84, 0x2C, 0xDA, 0x80, 0xE0, 0xDA, 0x84, 0x30, 0xDA, 0x84, 0x33, 0xDA, 0x84, + 0x45, 0xDA, 0x84, 0x47, 0xDA, 0x84, 0x4E, 0xDA, 0x84, 0x51, 0xDA, 0x84, 0x53, 0xDA, 0x84, 0x56, + 0xDA, 0x84, 0x5D, 0xDA, 0x82, 0x03, 0xDA, 0x84, 0x61, 0xDA, 0x84, 0x64, 0xDA, 0x84, 0x66, 0xDA, + 0x84, 0x69, 0xDA, 0x84, 0x6B, 0xDA, 0x84, 0x6E, 0xDA, 0x84, 0x74, 0xDA, 0x84, 0x76, 0xDA, 0x84, + 0x79, 0xDA, 0x84, 0x7C, 0xDA, 0x84, 0x86, 0xDA, 0x84, 0x89, 0xDA, 0x84, 0x8B, 0xDA, 0x84, 0x8E, + 0xDA, 0x84, 0x90, 0xDA, 0x84, 0x93, 0xDA, 0x86, 0x2C, 0xDA, 0x85, 0x22, 0xDA, 0x86, 0x30, 0xDA, + 0x86, 0x33, 0xDA, 0x86, 0x3E, 0xDA, 0x86, 0x41, 0xDA, 0x86, 0x43, 0xDA, 0x86, 0x46, 0xDA, 0x86, + 0x48, 0xDA, 0x86, 0x4B, 0xDA, 0x86, 0x4F, 0xDA, 0x86, 0x52, 0xDA, 0x86, 0x54, 0xDA, 0x86, 0x57, + 0xDA, 0x86, 0x59, 0xDA, 0x86, 0x5C, 0xDA, 0x86, 0x5E, 0xDA, 0x86, 0x61, 0xDA, 0x86, 0x63, 0xDA, + 0x86, 0x66, 0xDA, 0x86, 0x68, 0xDA, 0x80, 0xA9, 0xDA, 0x86, 0x6C, 0xDA, 0x86, 0x6F, 0xDA, 0x86, + 0x71, 0xDA, 0x84, 0x3A, 0xDA, 0x86, 0x7A, 0xDA, 0x86, 0x7D, 0xDA, 0x86, 0x75, 0xDA, 0x85, 0x26, + 0xDA, 0x86, 0x8E, 0xDA, 0x86, 0x91, 0xDA, 0x86, 0x93, 0xDA, 0x86, 0x96, 0xDA, 0x86, 0x9C, 0xDA, + 0x43, 0xDA, 0x86, 0xA0, 0xDA, 0x85, 0x8C, 0xDA, 0x86, 0xA4, 0xDA, 0x86, 0xA7, 0xDA, 0x86, 0xA9, + 0xDA, 0x86, 0xAC, 0xDA, 0x86, 0xB2, 0xDA, 0x86, 0xB5, 0xDA, 0x86, 0xB7, 0xDA, 0x82, 0x76, 0xDA, + 0x86, 0xBB, 0xDA, 0x86, 0xBE, 0xDA, 0x86, 0xC5, 0xDA, 0x86, 0xC8, 0xDA, 0x86, 0xCA, 0xDA, 0x86, + 0xCD, 0xDA, 0x86, 0xCF, 0xDA, 0x84, 0x38, 0xDA, 0x86, 0xD3, 0xDA, 0x86, 0xD6, 0xDA, 0x86, 0xDE, + 0xDA, 0x86, 0xE1, 0xDA, 0x86, 0xE3, 0xDA, 0x85, 0xC9, 0xDA, 0x86, 0xE7, 0xDA, 0x80, 0xF6, 0xDA, + 0x83, 0x7B, 0xDA, 0x83, 0x79, 0xDA, 0x85, 0xB2, 0xDA, 0x85, 0xB0, 0xDA, 0x86, 0xF1, 0xDA, 0x86, + 0xF4, 0xDA, 0x86, 0xF6, 0xDA, 0x86, 0xF9, 0xDA, 0x86, 0xFB, 0xDA, 0x86, 0xFE, 0xDA, 0x80, 0xF2, + 0xDA, 0x80, 0xEF, 0xDA, 0x87, 0x19, 0xDA, 0x87, 0x11, 0xDA, 0x87, 0x1D, 0xDA, 0x87, 0x20, 0xDA, + 0x87, 0x28, 0xDA, 0x87, 0x2B, 0xDA, 0x87, 0x2D, 0xDA, 0x87, 0x30, 0xDA, 0x87, 0x32, 0xDA, 0x87, + 0x35, 0xDA, 0x87, 0x3B, 0xDA, 0x82, 0x65, 0xDA, 0x87, 0x3F, 0xDA, 0x83, 0x04, 0xDA, 0x87, 0x43, + 0xDA, 0x87, 0x46, 0xDA, 0x87, 0x48, 0xDA, 0x87, 0x4B, 0xDA, 0x87, 0x4D, 0xDA, 0x87, 0x4F, 0xDA, + 0x87, 0x52, 0xDA, 0x87, 0x55, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6C, 0x6C, + 0xD8, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6C, 0x6C, 0xCF, 0x09, 0x66, 0x69, 0x6C, + 0x65, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0xDA, 0x84, 0xBE, 0xCF, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0xD8, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0xCF, 0x09, 0x63, 0x6F, 0x6D, 0x70, 0x61, + 0x72, 0x65, 0x3C, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x10, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x01, 0x29, 0x00, 0x09, 0xCE, 0x09, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, + 0x3C, 0x3D, 0xDA, 0x18, 0xDA, 0x84, 0x5A, 0x00, 0x29, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x29, 0x01, + 0xDA, 0x87, 0xC7, 0x00, 0x29, 0x02, 0xDA, 0x80, 0xAD, 0x03, 0x29, 0x04, 0xDA, 0x1E, 0x04, 0x28, + 0x03, 0xDA, 0x80, 0xC3, 0x06, 0x28, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x6A, + 0x0A, 0x26, 0x08, 0xDA, 0x80, 0xD9, 0x0D, 0x1F, 0x0A, 0xDA, 0x80, 0xAA, 0x15, 0x1E, 0x0D, 0xDA, + 0x80, 0xAA, 0x29, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3B, 0x03, 0x00, 0x04, 0x1B, 0x04, + 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x23, 0x05, + 0x03, 0x06, 0x1E, 0x05, 0x20, 0x00, 0x3A, 0x07, 0x00, 0x03, 0x1B, 0x08, 0x07, 0x00, 0x2C, 0x0A, + 0x00, 0x00, 0x3B, 0x09, 0x04, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, 0x09, 0x05, 0x00, 0x32, 0x04, + 0x08, 0x00, 0x35, 0x0B, 0x0A, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x2C, 0x0D, + 0x00, 0x00, 0x3B, 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, 0x0C, 0x06, 0x00, 0x32, 0x08, + 0x04, 0x00, 0x35, 0x0E, 0x0D, 0x00, 0x09, 0x0F, 0x0E, 0xFF, 0x1B, 0x0B, 0x0F, 0x00, 0x1C, 0x03, + 0x00, 0x00, 0x27, 0x0E, 0x04, 0x08, 0x1B, 0x0B, 0x0E, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x2B, 0x0A, + 0x00, 0x00, 0x48, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, 0x03, + 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, 0xE0, + 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x83, 0x28, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x77, 0x68, 0x65, 0x6E, 0x2D, + 0x6C, 0x65, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, + 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, 0xCE, 0x08, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x6C, 0x65, 0x74, + 0xDA, 0x18, 0xDA, 0x58, 0xDA, 0x80, 0x86, 0x00, 0x08, 0x00, 0xDA, 0x81, 0x22, 0x00, 0x08, 0x01, + 0xDA, 0x81, 0x74, 0x00, 0x08, 0x02, 0xDA, 0x87, 0xCB, 0x2C, 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, + 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, + 0x03, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x82, 0xB8, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x87, 0xA0, 0xDA, 0x87, 0x9E, + 0xCF, 0x0C, 0x2A, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2A, 0xDA, 0x86, + 0x07, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x72, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0xD8, 0x09, 0x6F, 0x73, + 0x2F, 0x72, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0xCF, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xDA, 0x55, + 0xCF, 0x06, 0x69, 0x66, 0x2D, 0x6E, 0x6F, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, + 0x03, 0x02, 0x03, 0x01, 0x05, 0x00, 0x04, 0xCE, 0x06, 0x69, 0x66, 0x2D, 0x6E, 0x6F, 0x74, 0xDA, + 0x18, 0xDA, 0x57, 0x00, 0x05, 0x00, 0xDA, 0x82, 0xB5, 0x00, 0x05, 0x01, 0xCF, 0x04, 0x74, 0x68, + 0x65, 0x6E, 0x00, 0x05, 0x02, 0xCF, 0x04, 0x65, 0x6C, 0x73, 0x65, 0x00, 0x05, 0x03, 0xDA, 0x87, + 0xD2, 0x2C, 0x05, 0x00, 0x00, 0x33, 0x05, 0x00, 0x02, 0x31, 0x01, 0x00, 0x00, 0x45, 0x04, 0x00, + 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0xAE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0xCF, 0x05, 0x78, 0x70, 0x72, 0x69, 0x6E, 0xD8, 0x05, 0x78, 0x70, 0x72, 0x69, 0x6E, 0xCF, 0x0B, + 0x6F, 0x73, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x6B, 0xD8, 0x0B, 0x6F, 0x73, 0x2F, + 0x72, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x6B, 0xCF, 0x0A, 0x65, 0x76, 0x2F, 0x72, 0x73, 0x65, + 0x6C, 0x65, 0x63, 0x74, 0xD8, 0x0A, 0x65, 0x76, 0x2F, 0x72, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, + 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x63, 0x6F, 0x73, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6D, 0x70, 0xD8, + 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6D, 0x70, 0xCF, 0x07, 0x73, 0x61, 0x6E, 0x64, + 0x62, 0x6F, 0x78, 0xD8, 0x07, 0x73, 0x61, 0x6E, 0x64, 0x62, 0x6F, 0x78, 0xCF, 0x0B, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x69, 0x6C, 0x6C, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x66, 0x69, 0x6C, 0x6C, 0xCF, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, + 0x65, 0x77, 0xD8, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x81, + 0x13, 0xDA, 0x81, 0x0F, 0xCF, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x65, 0x65, 0x64, 0x72, + 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xD8, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x65, 0x65, 0x64, + 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xCF, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, + 0x69, 0x6C, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x02, 0x02, 0x02, 0x07, 0x37, 0x00, + 0x0C, 0xCE, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xDA, 0x18, 0xDA, + 0x83, 0x76, 0xDA, 0x80, 0xE0, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x03, 0x03, 0x03, + 0x02, 0x11, 0x00, 0x07, 0xCE, 0x10, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, + 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x18, 0xDA, 0x83, 0x79, 0xDA, 0x83, 0x7D, 0x00, 0x11, + 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x11, 0x01, 0xDA, 0x81, 0xD2, 0x00, 0x11, 0x02, 0xDA, 0x1F, 0x00, + 0x11, 0x03, 0xCF, 0x10, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x2D, 0x73, + 0x6C, 0x69, 0x63, 0x65, 0x01, 0x11, 0x05, 0xDA, 0x81, 0x25, 0x05, 0x11, 0x07, 0xDA, 0x80, 0xC3, + 0x0D, 0x11, 0x09, 0xDA, 0x82, 0x60, 0x3F, 0x04, 0x02, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x32, 0x01, + 0x02, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, + 0x00, 0x00, 0x2C, 0x0A, 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x08, + 0x05, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x2B, 0x0A, + 0x00, 0x00, 0x33, 0x02, 0x0A, 0x09, 0x36, 0x00, 0x00, 0x00, 0x84, 0x58, 0x0C, 0x00, 0x03, 0x01, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x2B, 0xDA, + 0x82, 0x03, 0xD8, 0x0B, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x72, 0x79, 0x3F, 0xDA, + 0x80, 0xA8, 0x00, 0x37, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x37, 0x01, 0xDA, 0x1F, 0x00, 0x37, 0x02, + 0xDA, 0x87, 0xE9, 0x15, 0x25, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x77, 0x15, + 0x24, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x79, 0x18, 0x24, 0x08, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x78, 0x1B, 0x24, 0x09, 0xDA, 0x80, 0xC3, 0x1C, 0x24, 0x0A, + 0xDA, 0x1E, 0x26, 0x37, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x7A, 0x26, 0x36, + 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x42, 0x29, 0x36, 0x08, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x2C, 0x36, 0x09, 0xDA, 0x1E, 0x31, 0x01, 0x00, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x05, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, + 0x04, 0x00, 0x01, 0x2C, 0x04, 0x02, 0x00, 0x36, 0x04, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, + 0x05, 0x03, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x05, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x33, + 0x05, 0x00, 0x01, 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, + 0x06, 0x05, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x12, 0x00, 0x44, 0x06, 0x00, 0x00, 0x1B, + 0x07, 0x06, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x06, 0x01, 0x08, 0x1B, 0x08, 0x06, 0x00, 0x1F, + 0x08, 0x0B, 0x00, 0x3A, 0x06, 0x01, 0x08, 0x1B, 0x09, 0x08, 0x00, 0x1B, 0x0A, 0x06, 0x00, 0x31, + 0x0A, 0x00, 0x00, 0x35, 0x06, 0x00, 0x00, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, + 0x07, 0x09, 0x0A, 0x49, 0x08, 0x01, 0x08, 0x1C, 0xF6, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x40, + 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x06, 0x01, 0x08, 0x1B, + 0x08, 0x06, 0x00, 0x1F, 0x08, 0x0C, 0x00, 0x3A, 0x06, 0x01, 0x08, 0x1B, 0x09, 0x06, 0x00, 0x31, + 0x09, 0x00, 0x00, 0x35, 0x06, 0x00, 0x00, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x32, + 0x07, 0x09, 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x35, 0x06, 0x0A, 0x00, 0x49, 0x08, 0x01, 0x08, 0x1C, + 0xF5, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x84, 0x61, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, + 0x03, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, + 0xFE, 0x03, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xBF, 0xFD, 0x03, 0x03, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, + 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x38, 0x00, 0x38, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, + 0x17, 0x00, 0x17, 0x00, 0x17, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCF, 0x09, 0x63, 0x6F, 0x6D, 0x70, 0x61, + 0x72, 0x65, 0x3E, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x10, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x01, 0x29, 0x00, 0x09, 0xCE, 0x09, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, + 0x3E, 0x3D, 0xDA, 0x18, 0xDA, 0x84, 0x5A, 0x00, 0x29, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x29, 0x01, + 0xDA, 0x87, 0xF6, 0x00, 0x29, 0x02, 0xDA, 0x80, 0xAD, 0x03, 0x29, 0x04, 0xDA, 0x1E, 0x04, 0x28, + 0x03, 0xDA, 0x80, 0xC3, 0x06, 0x28, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x6C, + 0x0A, 0x26, 0x08, 0xDA, 0x80, 0xD9, 0x0D, 0x1F, 0x0A, 0xDA, 0x80, 0xAA, 0x15, 0x1E, 0x0D, 0xDA, + 0x80, 0xAA, 0x29, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3B, 0x03, 0x00, 0x04, 0x1B, 0x04, + 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x23, 0x05, + 0x03, 0x06, 0x1E, 0x05, 0x20, 0x00, 0x3A, 0x07, 0x00, 0x03, 0x1B, 0x08, 0x07, 0x00, 0x2C, 0x0A, + 0x00, 0x00, 0x3B, 0x09, 0x04, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, 0x09, 0x05, 0x00, 0x32, 0x04, + 0x08, 0x00, 0x35, 0x0B, 0x0A, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x2C, 0x0D, + 0x00, 0x00, 0x3B, 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, 0x0C, 0x06, 0x00, 0x32, 0x08, + 0x04, 0x00, 0x35, 0x0E, 0x0D, 0x00, 0x09, 0x0F, 0x0E, 0xFF, 0x1B, 0x0B, 0x0F, 0x00, 0x1C, 0x03, + 0x00, 0x00, 0x27, 0x0E, 0x04, 0x08, 0x1B, 0x0B, 0x0E, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x2B, 0x0A, + 0x00, 0x00, 0x47, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, 0x03, + 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, 0xE0, + 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x83, 0x32, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, + 0x72, 0xD8, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0xCF, 0x02, 0x3C, 0x3D, 0xD7, 0x00, 0xCD, + 0x00, 0x09, 0x00, 0x17, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0xCE, 0x02, + 0x3C, 0x3D, 0x3F, 0x01, 0x00, 0x00, 0x24, 0x02, 0x01, 0x02, 0x1D, 0x02, 0x0A, 0x00, 0x3D, 0x03, + 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x48, 0x02, 0x03, 0x04, 0x1E, 0x02, + 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, 0x03, 0x04, 0x00, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, + 0xFA, 0xFF, 0x29, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, + 0x00, 0x00, 0xCF, 0x10, 0x65, 0x76, 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x72, + 0x6C, 0x6F, 0x63, 0x6B, 0xD8, 0x10, 0x65, 0x76, 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x2D, 0x72, 0x6C, 0x6F, 0x63, 0x6B, 0xCF, 0x0E, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x6C, + 0x6F, 0x61, 0x64, 0x65, 0x72, 0x73, 0xDA, 0x87, 0xBC, 0xCF, 0x09, 0x65, 0x76, 0x2F, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0xD8, 0x09, 0x65, 0x76, 0x2F, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0xCF, + 0x03, 0x64, 0x69, 0x76, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x21, 0x06, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x03, 0x64, 0x69, 0x76, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, + 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, + 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x0D, 0x03, + 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, + 0x00, 0x05, 0x0D, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, + 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x11, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x61, + 0x6E, 0x2D, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x3F, 0xDA, 0x85, 0xF7, 0xDA, 0x85, 0xD3, 0xDA, + 0x85, 0x96, 0xCF, 0x0B, 0x66, 0x66, 0x69, 0x2F, 0x64, 0x65, 0x66, 0x62, 0x69, 0x6E, 0x64, 0xD7, + 0x01, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x20, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0D, 0x63, + 0x01, 0x04, 0x15, 0xCE, 0x0B, 0x66, 0x66, 0x69, 0x2F, 0x64, 0x65, 0x66, 0x62, 0x69, 0x6E, 0x64, + 0xDA, 0x18, 0xDA, 0x84, 0x3D, 0xD8, 0x05, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x82, 0x87, 0xDA, + 0x86, 0x7D, 0xDA, 0x80, 0xA6, 0xDA, 0x80, 0xFB, 0xCE, 0x14, 0x6E, 0x6F, 0x20, 0x66, 0x66, 0x69, + 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0xD0, 0x04, + 0x6C, 0x61, 0x7A, 0x79, 0xD0, 0x0B, 0x6D, 0x61, 0x70, 0x2D, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, + 0x73, 0xD0, 0x0B, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2D, 0x6C, 0x61, 0x7A, 0x79, 0xDA, 0x87, + 0x72, 0xD8, 0x08, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0xDA, 0x82, 0xFB, 0xBF, 0xFF, + 0x00, 0x00, 0xCF, 0x0D, 0x2A, 0x66, 0x66, 0x69, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, + 0x2A, 0xBF, 0xFF, 0x00, 0x02, 0xCF, 0x0E, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2D, 0x6D, + 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xBF, 0xFF, 0x00, 0x03, 0xCF, 0x0B, 0x66, 0x66, 0x69, 0x2F, 0x63, + 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x00, 0x63, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x63, 0x01, 0xCF, + 0x08, 0x72, 0x65, 0x74, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x00, 0x63, 0x02, 0xDA, 0x81, 0x74, 0x00, + 0x63, 0x03, 0xDA, 0x88, 0x08, 0x03, 0x63, 0x05, 0xCF, 0x0D, 0x72, 0x65, 0x61, 0x6C, 0x2D, 0x72, + 0x65, 0x74, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x09, 0x63, 0x07, 0xCF, 0x04, 0x6D, 0x65, 0x74, 0x61, + 0x11, 0x63, 0x08, 0xCF, 0x09, 0x61, 0x72, 0x67, 0x2D, 0x70, 0x61, 0x69, 0x72, 0x73, 0x16, 0x63, + 0x0B, 0xCF, 0x0B, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x2D, 0x61, 0x72, 0x67, 0x73, 0x1B, 0x63, + 0x0D, 0xCF, 0x09, 0x74, 0x79, 0x70, 0x65, 0x2D, 0x61, 0x72, 0x67, 0x73, 0x21, 0x63, 0x0E, 0xCF, + 0x12, 0x63, 0x6F, 0x6D, 0x70, 0x75, 0x74, 0x65, 0x64, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x2D, 0x61, + 0x72, 0x67, 0x73, 0x26, 0x2D, 0x11, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x2F, + 0x63, 0x12, 0xCF, 0x04, 0x6C, 0x61, 0x7A, 0x79, 0x32, 0x63, 0x13, 0xCF, 0x02, 0x6D, 0x73, 0x35, + 0x63, 0x14, 0xCF, 0x04, 0x6C, 0x6C, 0x69, 0x62, 0x38, 0x63, 0x15, 0xCF, 0x03, 0x6C, 0x69, 0x62, + 0x3B, 0x63, 0x16, 0xCF, 0x0A, 0x72, 0x61, 0x77, 0x2D, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x3D, + 0x63, 0x18, 0xCF, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x73, 0x69, 0x67, 0x3F, 0x63, 0x1A, 0xCF, + 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x70, 0x74, 0x72, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x00, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x2B, 0x07, 0xFE, + 0xFF, 0x33, 0x02, 0x06, 0x07, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, + 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x09, 0x02, 0x00, 0x35, 0x08, 0x09, 0x00, 0x2B, 0x09, 0x02, + 0x00, 0x32, 0x09, 0x08, 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x08, 0x09, + 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x32, 0x0A, 0x08, 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x35, 0x0A, 0x0B, + 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x2B, 0x0C, 0x01, 0x00, 0x32, 0x0C, 0x08, 0x00, 0x2C, 0x0D, 0x04, + 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x34, 0x0D, 0x00, 0x00, 0x46, 0x0E, 0x00, + 0x00, 0x31, 0x0E, 0x00, 0x00, 0x2C, 0x10, 0x00, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x1B, 0x0E, 0x0F, + 0x00, 0x2D, 0x10, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x2C, 0x11, 0x05, 0x00, 0x35, 0x10, 0x11, + 0x00, 0x1B, 0x11, 0x10, 0x00, 0x1E, 0x11, 0x03, 0x00, 0x1B, 0x10, 0x11, 0x00, 0x1C, 0x04, 0x00, + 0x00, 0x2C, 0x12, 0x06, 0x00, 0x01, 0x12, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x2C, 0x12, 0x07, + 0x00, 0x3A, 0x11, 0x10, 0x12, 0x1B, 0x12, 0x11, 0x00, 0x2C, 0x13, 0x08, 0x00, 0x3A, 0x11, 0x10, + 0x13, 0x1B, 0x13, 0x11, 0x00, 0x2C, 0x14, 0x09, 0x00, 0x3A, 0x11, 0x10, 0x14, 0x1B, 0x14, 0x11, + 0x00, 0x2C, 0x15, 0x0A, 0x00, 0x3A, 0x11, 0x10, 0x15, 0x1B, 0x15, 0x11, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x35, 0x11, 0x13, 0x00, 0x1B, 0x16, 0x11, 0x00, 0x30, 0x17, 0x00, 0x00, 0x1B, 0x18, 0x17, + 0x00, 0x30, 0x19, 0x01, 0x00, 0x1B, 0x1A, 0x19, 0x00, 0x1E, 0x12, 0x15, 0x00, 0x34, 0x0B, 0x00, + 0x00, 0x46, 0x1B, 0x00, 0x00, 0x30, 0x1C, 0x02, 0x00, 0x35, 0x1D, 0x1C, 0x00, 0x31, 0x1D, 0x00, + 0x00, 0x45, 0x1C, 0x00, 0x00, 0x30, 0x1D, 0x03, 0x00, 0x35, 0x1E, 0x1D, 0x00, 0x31, 0x1E, 0x00, + 0x00, 0x45, 0x1D, 0x00, 0x00, 0x2C, 0x1F, 0x0B, 0x00, 0x33, 0x1F, 0x1C, 0x1D, 0x34, 0x0B, 0x00, + 0x00, 0x45, 0x1E, 0x00, 0x00, 0x2C, 0x1D, 0x0C, 0x00, 0x32, 0x1D, 0x00, 0x00, 0x34, 0x07, 0x00, + 0x00, 0x32, 0x1B, 0x1E, 0x00, 0x45, 0x1C, 0x00, 0x00, 0x03, 0x1C, 0x00, 0x00, 0x34, 0x0B, 0x00, + 0x00, 0x46, 0x1B, 0x00, 0x00, 0x35, 0x1C, 0x1A, 0x00, 0x35, 0x1D, 0x18, 0x00, 0x2C, 0x1F, 0x0B, + 0x00, 0x33, 0x1F, 0x1C, 0x1D, 0x34, 0x0B, 0x00, 0x00, 0x45, 0x1E, 0x00, 0x00, 0x2C, 0x1D, 0x0C, + 0x00, 0x32, 0x1D, 0x00, 0x00, 0x34, 0x07, 0x00, 0x00, 0x32, 0x1B, 0x1E, 0x00, 0x45, 0x1C, 0x00, + 0x00, 0x03, 0x1C, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x02, 0x07, 0x01, 0x11, 0xCE, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x73, 0x69, 0x67, 0xDA, 0x18, + 0xD0, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xDA, 0x73, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x81, 0xBE, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x14, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x74, + 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x08, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x88, 0x15, 0xBF, 0xFF, + 0x00, 0x07, 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x88, 0x17, 0xBF, 0xFF, 0x00, 0x0B, + 0xDA, 0x88, 0x18, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x88, 0x19, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, + 0x1A, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x88, 0x1B, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x1C, 0xBF, + 0xFF, 0x00, 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, 0x00, 0x14, 0xDA, 0x88, 0x1E, 0xBF, 0xFF, 0x00, + 0x15, 0xDA, 0x88, 0x1F, 0xBF, 0xFF, 0x00, 0x16, 0xDA, 0x88, 0x20, 0x00, 0x07, 0x00, 0xDA, 0x88, + 0x21, 0x2C, 0x01, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x05, 0x32, 0x01, 0x02, 0x00, 0x2D, 0x01, 0x00, + 0x0E, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x8F, + 0x1F, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x15, 0x01, 0x13, 0xCE, 0x08, 0x6D, 0x61, 0x6B, + 0x65, 0x2D, 0x70, 0x74, 0x72, 0xDA, 0x18, 0xDA, 0x84, 0x05, 0xCE, 0x1A, 0x66, 0x61, 0x69, 0x6C, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x66, 0x66, 0x69, 0x20, 0x73, + 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0xDA, 0x81, 0x12, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x81, 0xBE, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x14, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x74, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x88, 0x08, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x88, 0x15, 0xBF, 0xFF, 0x00, 0x07, + 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x88, 0x17, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x88, + 0x18, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x88, 0x19, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x1A, 0xBF, + 0xFF, 0x00, 0x11, 0xDA, 0x88, 0x1B, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, 0x00, 0x14, 0xDA, 0x88, 0x1E, 0xBF, 0xFF, 0x00, 0x15, 0xDA, + 0x88, 0x1F, 0xBF, 0xFF, 0x00, 0x16, 0xDA, 0x88, 0x20, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x88, 0x21, + 0x00, 0x15, 0x00, 0xDA, 0x88, 0x22, 0x0B, 0x15, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x67, 0x2D, 0x02, 0x00, 0x12, 0x1E, 0x02, 0x05, 0x00, 0x2D, 0x03, 0x00, 0x14, 0x35, 0x02, + 0x03, 0x00, 0x1B, 0x01, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x15, 0x2D, 0x02, + 0x00, 0x16, 0x32, 0x01, 0x02, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x01, + 0x02, 0x00, 0x1E, 0x01, 0x02, 0x00, 0x03, 0x01, 0x00, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x2D, 0x03, + 0x00, 0x16, 0x32, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x35, 0x02, 0x03, 0x00, 0x01, 0x02, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0x21, 0x1B, 0x00, 0x1B, 0x00, 0x24, 0x00, + 0x24, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, + 0x07, 0x00, 0x07, 0xCD, 0x02, 0xF6, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x01, + 0x14, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x81, 0xBE, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, + 0x14, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x74, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x08, 0xBF, + 0xFF, 0x00, 0x05, 0xDA, 0x88, 0x15, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x00, + 0x08, 0xDA, 0x88, 0x17, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x88, 0x18, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, + 0x88, 0x19, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x1A, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x88, 0x1B, + 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, + 0x00, 0x14, 0xDA, 0x88, 0x1E, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x88, 0x1F, 0xBF, 0xFF, 0x00, 0x16, + 0xDA, 0x88, 0x20, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x88, 0x21, 0xBF, 0xFF, 0x00, 0x1A, 0xDA, 0x88, + 0x22, 0x00, 0x04, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x68, 0x01, 0x04, 0x01, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x69, 0x28, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, + 0x00, 0x30, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x02, 0x14, 0xDA, 0x18, 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x81, + 0xBE, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x88, 0x14, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x81, 0x74, 0xBF, + 0xFF, 0x01, 0x03, 0xDA, 0x88, 0x08, 0xBF, 0xFF, 0x01, 0x05, 0xDA, 0x88, 0x15, 0xBF, 0xFF, 0x01, + 0x07, 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x01, 0x08, 0xDA, 0x88, 0x17, 0xBF, 0xFF, 0x01, 0x0B, 0xDA, + 0x88, 0x18, 0xBF, 0xFF, 0x01, 0x0D, 0xDA, 0x88, 0x19, 0xBF, 0xFF, 0x01, 0x0E, 0xDA, 0x88, 0x1A, + 0xBF, 0xFF, 0x01, 0x11, 0xDA, 0x88, 0x1B, 0xBF, 0xFF, 0x01, 0x12, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, + 0x01, 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, 0x01, 0x14, 0xDA, 0x88, 0x1E, 0xBF, 0xFF, 0x01, 0x15, + 0xDA, 0x88, 0x1F, 0xBF, 0xFF, 0x01, 0x16, 0xDA, 0x88, 0x20, 0xBF, 0xFF, 0x01, 0x18, 0xDA, 0x88, + 0x21, 0xBF, 0xFF, 0x01, 0x1A, 0xDA, 0x88, 0x22, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x88, 0x28, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x29, 0x2D, 0x00, 0x00, 0x01, 0x1E, 0x00, 0x03, 0x00, 0x2D, 0x00, + 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x01, 0x2D, 0x01, + 0x01, 0x1A, 0x35, 0x00, 0x01, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8F, 0x24, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x17, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x17, 0x00, 0x17, 0x8F, 0x24, 0x17, 0x00, + 0x17, 0x00, 0x17, 0x00, 0x17, 0x03, 0x00, 0x00, 0x00, 0xCD, 0x02, 0xF6, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x00, 0x04, 0x01, 0x01, 0x14, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x81, 0xBE, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x14, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x74, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x88, 0x08, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x88, 0x15, 0xBF, 0xFF, 0x00, 0x07, + 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x88, 0x17, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x88, + 0x18, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x88, 0x19, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x1A, 0xBF, + 0xFF, 0x00, 0x11, 0xDA, 0x88, 0x1B, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, 0x00, + 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, 0x00, 0x14, 0xDA, 0x88, 0x1E, 0xBF, 0xFF, 0x00, 0x15, 0xDA, + 0x88, 0x1F, 0xBF, 0xFF, 0x00, 0x16, 0xDA, 0x88, 0x20, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x88, 0x21, + 0xBF, 0xFF, 0x00, 0x1A, 0xDA, 0x88, 0x22, 0x00, 0x04, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x6A, 0x01, 0x04, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x6B, 0x28, + 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, 0x30, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, + 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x02, 0x14, 0xDA, 0x18, + 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x81, 0xBE, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x88, 0x14, 0xBF, 0xFF, + 0x01, 0x02, 0xDA, 0x81, 0x74, 0xBF, 0xFF, 0x01, 0x03, 0xDA, 0x88, 0x08, 0xBF, 0xFF, 0x01, 0x05, + 0xDA, 0x88, 0x15, 0xBF, 0xFF, 0x01, 0x07, 0xDA, 0x88, 0x16, 0xBF, 0xFF, 0x01, 0x08, 0xDA, 0x88, + 0x17, 0xBF, 0xFF, 0x01, 0x0B, 0xDA, 0x88, 0x18, 0xBF, 0xFF, 0x01, 0x0D, 0xDA, 0x88, 0x19, 0xBF, + 0xFF, 0x01, 0x0E, 0xDA, 0x88, 0x1A, 0xBF, 0xFF, 0x01, 0x11, 0xDA, 0x88, 0x1B, 0xBF, 0xFF, 0x01, + 0x12, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, 0x01, 0x13, 0xDA, 0x88, 0x1D, 0xBF, 0xFF, 0x01, 0x14, 0xDA, + 0x88, 0x1E, 0xBF, 0xFF, 0x01, 0x15, 0xDA, 0x88, 0x1F, 0xBF, 0xFF, 0x01, 0x16, 0xDA, 0x88, 0x20, + 0xBF, 0xFF, 0x01, 0x18, 0xDA, 0x88, 0x21, 0xBF, 0xFF, 0x01, 0x1A, 0xDA, 0x88, 0x22, 0xBF, 0xFF, + 0x00, 0x00, 0xDA, 0x88, 0x2A, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x2B, 0x2D, 0x00, 0x00, 0x01, + 0x1E, 0x00, 0x03, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x2F, 0x00, 0x00, 0x01, 0x2D, 0x01, 0x01, 0x18, 0x35, 0x00, 0x01, 0x00, 0x2F, 0x00, 0x00, 0x00, + 0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8F, 0x24, 0x2D, 0x00, 0x2D, + 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x2D, + 0x00, 0x2D, 0x8F, 0x24, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x03, 0x00, 0x00, 0x00, 0x8F, + 0x13, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x05, 0x01, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, + 0x00, 0x14, 0x00, 0x05, 0x01, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x05, 0x01, 0x14, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0x01, 0x23, 0x00, 0x23, 0x00, 0x1D, 0x00, 0x1D, + 0x00, 0x1D, 0x00, 0x05, 0x04, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0xBF, 0xFD, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x04, 0x15, 0x00, 0x15, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x02, 0x05, 0x00, + 0x05, 0x02, 0x05, 0x01, 0x07, 0x00, 0x07, 0x01, 0x17, 0x00, 0x17, 0xBF, 0xFF, 0x07, 0x00, 0x07, + 0x01, 0x2D, 0x00, 0x2D, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x02, 0x07, 0x00, + 0x07, 0x01, 0x16, 0x00, 0x22, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x20, 0x40, 0x74, 0x05, 0x00, 0x06, + 0xD0, 0x0B, 0x66, 0x66, 0x69, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0xC9, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x05, 0x00, + 0x02, 0xCE, 0x0E, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2D, 0x6D, 0x61, 0x6E, 0x67, 0x6C, + 0x65, 0xDA, 0x18, 0xDA, 0x81, 0x53, 0xDA, 0x81, 0xFE, 0xDA, 0x82, 0x5D, 0x00, 0x05, 0x00, 0xDA, + 0x81, 0xBE, 0x00, 0x05, 0x01, 0xDA, 0x88, 0x12, 0x2C, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, + 0x33, 0x02, 0x03, 0x00, 0x2C, 0x02, 0x02, 0x00, 0x36, 0x02, 0x00, 0x00, 0x8F, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xC9, 0xC9, 0xC9, 0xCF, 0x0C, 0x6E, 0x65, 0x74, 0x2F, + 0x73, 0x68, 0x75, 0x74, 0x64, 0x6F, 0x77, 0x6E, 0xD8, 0x0C, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x68, + 0x75, 0x74, 0x64, 0x6F, 0x77, 0x6E, 0xCF, 0x07, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x01, + 0x00, 0x01, 0xCE, 0x07, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0xDA, 0x18, 0x00, 0x01, 0x00, + 0xDA, 0x88, 0x31, 0x04, 0x00, 0x00, 0x00, 0x80, 0xA7, 0x01, 0xCF, 0x06, 0x74, 0x61, 0x62, 0x73, + 0x65, 0x71, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0A, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x05, 0x17, 0x00, 0x05, 0xCE, 0x06, 0x74, 0x61, 0x62, 0x73, 0x65, 0x71, 0xDA, 0x18, 0xDA, + 0x51, 0xDA, 0x52, 0xDA, 0x58, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x07, 0x03, 0x03, 0x03, 0x03, + 0x00, 0x02, 0xCE, 0x03, 0x70, 0x75, 0x74, 0x3C, 0x00, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0xDA, + 0x86, 0xAE, 0x00, 0x17, 0x00, 0xDA, 0x86, 0xAF, 0x00, 0x17, 0x01, 0xCF, 0x08, 0x6B, 0x65, 0x79, + 0x2D, 0x62, 0x6F, 0x64, 0x79, 0x00, 0x17, 0x02, 0xCF, 0x0A, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2D, + 0x62, 0x6F, 0x64, 0x79, 0x00, 0x17, 0x03, 0xDA, 0x88, 0x34, 0x02, 0x17, 0x05, 0xDA, 0x86, 0xB0, + 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x44, 0x06, 0x00, 0x00, + 0x2C, 0x08, 0x01, 0x00, 0x33, 0x08, 0x05, 0x06, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, + 0x31, 0x08, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x09, 0x03, 0x00, + 0x33, 0x09, 0x05, 0x01, 0x31, 0x06, 0x00, 0x00, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x04, 0x00, + 0x33, 0x09, 0x00, 0x08, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x09, 0x02, 0x00, 0x33, 0x09, 0x07, 0x06, + 0x31, 0x05, 0x00, 0x00, 0x45, 0x08, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x82, 0x71, 0x0F, 0x00, + 0x0F, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0C, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x84, 0xDA, 0xCF, 0x12, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x3F, + 0xDA, 0x87, 0x9B, 0xCF, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x76, 0x61, 0x72, 0x73, 0xD7, 0x00, + 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x12, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x10, 0x80, 0x81, + 0x00, 0x1B, 0xCE, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x76, 0x61, 0x72, 0x73, 0xDA, 0x18, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x01, 0x09, 0x00, 0x02, 0xCE, 0x05, + 0x65, 0x76, 0x65, 0x6E, 0x3F, 0xDA, 0x18, 0xDA, 0x84, 0x58, 0x00, 0x09, 0x00, 0xDA, 0x1E, 0x00, + 0x09, 0x01, 0xCF, 0x05, 0x65, 0x76, 0x65, 0x6E, 0x3F, 0x2B, 0x03, 0x02, 0x00, 0x0E, 0x02, 0x00, + 0x03, 0x2B, 0x03, 0x00, 0x00, 0x32, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, + 0x00, 0x2B, 0x04, 0x00, 0x00, 0x25, 0x02, 0x04, 0x03, 0x03, 0x02, 0x00, 0x00, 0x83, 0x38, 0x37, + 0x00, 0x37, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x27, 0x00, 0x27, 0x00, 0x27, + 0xCE, 0x28, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x76, 0x61, 0x72, 0x73, 0xDA, 0x51, 0xDA, 0x80, 0xA8, 0xDA, + 0x52, 0xDA, 0x34, 0xDA, 0x80, 0x9B, 0xDA, 0x81, 0x6B, 0xDA, 0x81, 0x86, 0xDA, 0x81, 0x6D, 0xDA, + 0x81, 0x6F, 0xDA, 0x81, 0x87, 0xDA, 0x81, 0x88, 0xDA, 0x81, 0x89, 0xDA, 0x57, 0xDA, 0x58, 0x00, + 0x80, 0x81, 0x00, 0xCF, 0x04, 0x76, 0x61, 0x72, 0x73, 0x00, 0x80, 0x81, 0x01, 0xDA, 0x81, 0x74, + 0x00, 0x80, 0x81, 0x02, 0xDA, 0x88, 0x3D, 0x01, 0x80, 0x81, 0x04, 0xDA, 0x81, 0x25, 0x0A, 0x16, + 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x0B, 0x16, 0x05, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x0B, 0x16, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x34, 0x0E, 0x16, 0x08, 0xDA, 0x80, 0xC3, 0x15, 0x80, 0x81, 0x06, 0xCF, 0x04, 0x74, 0x65, + 0x6D, 0x70, 0x17, 0x29, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x18, 0x29, + 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x18, 0x29, 0x04, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x1B, 0x29, 0x09, 0xDA, 0x80, 0xC3, 0x28, 0x80, 0x81, 0x07, + 0xCF, 0x07, 0x73, 0x61, 0x76, 0x65, 0x6F, 0x6C, 0x64, 0x2A, 0x3C, 0x08, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x2B, 0x3C, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x39, 0x2B, 0x3C, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x2E, 0x3C, 0x0A, + 0xDA, 0x80, 0xC3, 0x3B, 0x80, 0x81, 0x08, 0xCF, 0x06, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x77, 0x3D, + 0x4F, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x3E, 0x4F, 0x05, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x63, 0x3E, 0x4F, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x64, 0x41, 0x4F, 0x0B, 0xDA, 0x80, 0xC3, 0x4E, 0x80, 0x81, 0x09, 0xCF, 0x0A, 0x72, + 0x65, 0x73, 0x74, 0x6F, 0x72, 0x65, 0x6F, 0x6C, 0x64, 0x51, 0x80, 0x81, 0x0A, 0xDA, 0x23, 0x54, + 0x80, 0x81, 0x0B, 0xDA, 0x80, 0xAA, 0x57, 0x80, 0x81, 0x0C, 0xDA, 0x49, 0x3F, 0x03, 0x00, 0x00, + 0x1B, 0x04, 0x03, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, + 0x1E, 0x05, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x01, 0x06, 0x00, 0x00, + 0x40, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x23, 0x07, 0x05, 0x04, + 0x1E, 0x07, 0x09, 0x00, 0x1B, 0x08, 0x05, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x35, 0x09, 0x0A, 0x00, + 0x32, 0x06, 0x09, 0x00, 0x2C, 0x0B, 0x03, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x05, 0x05, 0x05, 0x02, + 0x1C, 0xF7, 0xFF, 0xFF, 0x40, 0x05, 0x00, 0x00, 0x1B, 0x07, 0x05, 0x00, 0x2B, 0x05, 0x00, 0x00, + 0x23, 0x08, 0x05, 0x04, 0x1E, 0x08, 0x0F, 0x00, 0x1B, 0x09, 0x05, 0x00, 0x0B, 0x0A, 0x09, 0x02, + 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0B, 0x06, 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x0A, 0x00, 0x00, + 0x2C, 0x0C, 0x04, 0x00, 0x33, 0x0C, 0x0B, 0x0A, 0x45, 0x0A, 0x00, 0x00, 0x32, 0x07, 0x0A, 0x00, + 0x2C, 0x0C, 0x03, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x05, 0x05, 0x05, 0x02, 0x1C, 0xF1, 0xFF, 0xFF, + 0x40, 0x05, 0x00, 0x00, 0x1B, 0x08, 0x05, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x23, 0x09, 0x05, 0x04, + 0x1E, 0x09, 0x0F, 0x00, 0x1B, 0x0A, 0x05, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0B, 0x00, 0x00, + 0x05, 0x0C, 0x0A, 0x01, 0x31, 0x0C, 0x00, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x2C, 0x0C, 0x05, 0x00, + 0x33, 0x0C, 0x0B, 0x0D, 0x45, 0x0B, 0x00, 0x00, 0x32, 0x08, 0x0B, 0x00, 0x2C, 0x0D, 0x03, 0x00, + 0x35, 0x0C, 0x0D, 0x00, 0x05, 0x05, 0x05, 0x02, 0x1C, 0xF1, 0xFF, 0xFF, 0x40, 0x05, 0x00, 0x00, + 0x1B, 0x09, 0x05, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x23, 0x0A, 0x05, 0x04, 0x1E, 0x0A, 0x0F, 0x00, + 0x1B, 0x0B, 0x05, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x35, 0x0C, 0x00, 0x00, 0x0B, 0x0D, 0x0B, 0x02, + 0x31, 0x0D, 0x00, 0x00, 0x35, 0x0E, 0x06, 0x00, 0x2C, 0x0D, 0x05, 0x00, 0x33, 0x0D, 0x0C, 0x0E, + 0x45, 0x0C, 0x00, 0x00, 0x32, 0x09, 0x0C, 0x00, 0x2C, 0x0E, 0x03, 0x00, 0x35, 0x0D, 0x0E, 0x00, + 0x05, 0x05, 0x05, 0x02, 0x1C, 0xF1, 0xFF, 0xFF, 0x2C, 0x0A, 0x02, 0x00, 0x35, 0x05, 0x0A, 0x00, + 0x1B, 0x0A, 0x05, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x35, 0x05, 0x0B, 0x00, 0x1B, 0x0B, 0x05, 0x00, + 0x2C, 0x0C, 0x02, 0x00, 0x35, 0x05, 0x0C, 0x00, 0x1B, 0x0C, 0x05, 0x00, 0x46, 0x05, 0x00, 0x00, + 0x2C, 0x0E, 0x06, 0x00, 0x32, 0x0E, 0x05, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x45, 0x0D, 0x00, 0x00, 0x2C, 0x0E, 0x07, 0x00, 0x2C, 0x0F, 0x08, 0x00, 0x33, 0x0E, 0x0D, 0x0F, + 0x45, 0x05, 0x00, 0x00, 0x2C, 0x0E, 0x04, 0x00, 0x33, 0x0E, 0x0B, 0x05, 0x45, 0x0D, 0x00, 0x00, + 0x2C, 0x0E, 0x09, 0x00, 0x32, 0x0E, 0x0B, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x0F, 0x04, 0x00, + 0x33, 0x0F, 0x0A, 0x05, 0x45, 0x0E, 0x00, 0x00, 0x2C, 0x0F, 0x0A, 0x00, 0x32, 0x0F, 0x0B, 0x00, + 0x45, 0x05, 0x00, 0x00, 0x2C, 0x10, 0x0B, 0x00, 0x2C, 0x11, 0x0C, 0x00, 0x33, 0x10, 0x05, 0x11, + 0x45, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x0D, 0x00, 0x33, 0x10, 0x0A, 0x0B, 0x45, 0x05, 0x00, 0x00, + 0x2C, 0x11, 0x0E, 0x00, 0x33, 0x11, 0x0F, 0x0A, 0x31, 0x05, 0x00, 0x00, 0x45, 0x10, 0x00, 0x00, + 0x2C, 0x0F, 0x0F, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x34, 0x07, 0x00, 0x00, 0x32, 0x0D, 0x0E, 0x00, + 0x34, 0x09, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x45, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, + 0x85, 0x96, 0x0C, 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x17, 0x00, 0x17, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x27, 0x00, 0x27, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x36, 0x00, 0x30, 0x00, 0x30, 0x00, + 0x3F, 0x00, 0x3F, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x2F, 0x00, 0x2F, 0x00, 0x3E, 0x00, 0x38, 0x00, 0x38, 0x00, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, + 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x33, 0x00, 0x33, 0x00, 0x42, 0x00, 0x3C, 0x00, 0x3C, 0x00, + 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x01, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0xCF, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x02, 0x06, 0x00, 0x03, 0xCE, 0x0A, + 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x84, 0x70, 0xDA, + 0x87, 0xEA, 0x00, 0x06, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x06, 0x01, 0xDA, 0x1F, 0x00, 0x06, 0x02, + 0xDA, 0x88, 0x55, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x32, + 0x03, 0x01, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x84, 0x6A, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x05, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xD7, + 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x2D, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x17, 0x81, + 0x0D, 0x00, 0x06, 0x2F, 0xCE, 0x05, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xDA, 0x18, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x01, 0x09, 0x00, 0x02, 0xDA, 0x80, 0x8D, 0xDA, + 0x18, 0xDA, 0x84, 0x58, 0x00, 0x09, 0x00, 0xDA, 0x1E, 0x00, 0x09, 0x01, 0xDA, 0x80, 0x8E, 0x2B, + 0x03, 0x02, 0x00, 0x0E, 0x02, 0x00, 0x03, 0x2B, 0x03, 0x01, 0x00, 0x32, 0x03, 0x02, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x25, 0x02, 0x04, 0x03, 0x03, + 0x02, 0x00, 0x00, 0x83, 0x39, 0x35, 0x00, 0x35, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, + 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0xDA, 0x82, 0x87, 0xDA, 0x88, 0x0B, 0xDA, 0x86, 0x7D, 0xDA, + 0x83, 0xA9, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x80, 0xA8, 0xD2, 0x02, 0x00, 0xC9, 0xC9, 0xCF, 0x03, + 0x61, 0x6E, 0x64, 0xDA, 0x84, 0x7F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x02, 0x01, + 0x02, 0x02, 0x0C, 0x00, 0x04, 0xCE, 0x04, 0x73, 0x6F, 0x72, 0x74, 0xDA, 0x18, 0xD7, 0x00, 0xCD, + 0x00, 0x09, 0x00, 0x15, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0xCE, 0x01, + 0x3C, 0x3F, 0x01, 0x00, 0x00, 0x24, 0x02, 0x01, 0x02, 0x1D, 0x02, 0x0A, 0x00, 0x3D, 0x03, 0x00, + 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x23, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x07, + 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, 0x03, 0x04, 0x00, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFA, + 0xFF, 0x29, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, + 0x00, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x12, 0x04, 0x04, 0x04, 0x02, 0x68, 0x00, 0x0D, + 0xCE, 0x09, 0x73, 0x6F, 0x72, 0x74, 0x2D, 0x68, 0x65, 0x6C, 0x70, 0xDA, 0x18, 0xDA, 0x88, 0x60, + 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x14, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x10, 0xCE, 0x01, 0x3E, 0x3F, 0x01, 0x00, 0x00, 0x24, 0x02, 0x01, 0x02, 0x1D, 0x02, 0x0A, 0x00, + 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x21, 0x02, 0x03, 0x04, + 0x1E, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, 0x03, 0x04, 0x00, 0x25, 0x02, 0x05, 0x01, + 0x1E, 0x02, 0xFA, 0xFF, 0x29, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, + 0x03, 0x03, 0x00, 0x00, 0x00, 0x68, 0x00, 0xCF, 0x01, 0x61, 0x00, 0x68, 0x01, 0xCF, 0x02, 0x6C, + 0x6F, 0x00, 0x68, 0x02, 0xCF, 0x02, 0x68, 0x69, 0x00, 0x68, 0x03, 0xCF, 0x07, 0x62, 0x65, 0x66, + 0x6F, 0x72, 0x65, 0x3F, 0x00, 0x68, 0x04, 0xCF, 0x09, 0x73, 0x6F, 0x72, 0x74, 0x2D, 0x68, 0x65, + 0x6C, 0x70, 0x09, 0x67, 0x09, 0xDA, 0x1E, 0x0A, 0x67, 0x0A, 0xDA, 0x80, 0xD9, 0x0B, 0x67, 0x0B, + 0xCF, 0x01, 0x7A, 0x25, 0x67, 0x0C, 0xCF, 0x05, 0x70, 0x69, 0x76, 0x6F, 0x74, 0x26, 0x67, 0x08, + 0xDA, 0x83, 0xCF, 0x27, 0x67, 0x0D, 0xCF, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x27, 0x50, 0x03, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x6D, 0x53, 0x59, 0x10, 0xCF, 0x03, 0x74, 0x6D, + 0x70, 0x2E, 0x04, 0x00, 0x00, 0x23, 0x05, 0x01, 0x02, 0x1E, 0x05, 0x65, 0x00, 0x3A, 0x06, 0x00, + 0x01, 0x06, 0x07, 0x01, 0x02, 0x2B, 0x09, 0x02, 0x00, 0x0D, 0x08, 0x07, 0x09, 0x3A, 0x07, 0x00, + 0x08, 0x3A, 0x08, 0x00, 0x02, 0x1B, 0x09, 0x06, 0x00, 0x1B, 0x0A, 0x07, 0x00, 0x1B, 0x0B, 0x08, + 0x00, 0x48, 0x0C, 0x09, 0x0A, 0x1E, 0x0C, 0x0D, 0x00, 0x48, 0x0E, 0x0A, 0x0B, 0x1E, 0x0E, 0x03, + 0x00, 0x1B, 0x0D, 0x0A, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x48, 0x10, 0x0B, 0x09, 0x1E, 0x10, 0x03, + 0x00, 0x1B, 0x0F, 0x09, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0F, 0x0B, 0x00, 0x1B, 0x0D, 0x0F, + 0x00, 0x1B, 0x08, 0x0D, 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x48, 0x0E, 0x0B, 0x0A, 0x1E, 0x0E, 0x03, + 0x00, 0x1B, 0x0D, 0x0A, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x48, 0x10, 0x09, 0x0B, 0x1E, 0x10, 0x03, + 0x00, 0x1B, 0x0F, 0x09, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0F, 0x0B, 0x00, 0x1B, 0x0D, 0x0F, + 0x00, 0x1B, 0x08, 0x0D, 0x00, 0x1B, 0x0C, 0x08, 0x00, 0x1B, 0x08, 0x01, 0x00, 0x1B, 0x0D, 0x02, + 0x00, 0x2C, 0x0F, 0x00, 0x00, 0x25, 0x0E, 0x03, 0x0F, 0x1E, 0x0E, 0x0C, 0x00, 0x3A, 0x0F, 0x00, + 0x08, 0x23, 0x10, 0x0F, 0x0C, 0x1E, 0x10, 0x03, 0x00, 0x05, 0x08, 0x08, 0x01, 0x1C, 0xFC, 0xFF, + 0xFF, 0x3A, 0x0F, 0x00, 0x0D, 0x23, 0x10, 0x0C, 0x0F, 0x1E, 0x10, 0x03, 0x00, 0x07, 0x0D, 0x0D, + 0x01, 0x1C, 0xFC, 0xFF, 0xFF, 0x1C, 0x1B, 0x00, 0x00, 0x2C, 0x10, 0x01, 0x00, 0x25, 0x0F, 0x03, + 0x10, 0x1E, 0x0F, 0x0C, 0x00, 0x3A, 0x10, 0x00, 0x08, 0x21, 0x11, 0x10, 0x0C, 0x1E, 0x11, 0x03, + 0x00, 0x05, 0x08, 0x08, 0x01, 0x1C, 0xFC, 0xFF, 0xFF, 0x3A, 0x10, 0x00, 0x0D, 0x21, 0x11, 0x0C, + 0x10, 0x1E, 0x11, 0x03, 0x00, 0x07, 0x0D, 0x0D, 0x01, 0x1C, 0xFC, 0xFF, 0xFF, 0x1C, 0x0D, 0x00, + 0x00, 0x3A, 0x10, 0x00, 0x08, 0x32, 0x10, 0x0C, 0x00, 0x35, 0x11, 0x03, 0x00, 0x1E, 0x11, 0x03, + 0x00, 0x05, 0x08, 0x08, 0x01, 0x1C, 0xFB, 0xFF, 0xFF, 0x3A, 0x10, 0x00, 0x0D, 0x32, 0x0C, 0x10, + 0x00, 0x35, 0x11, 0x03, 0x00, 0x1E, 0x11, 0x03, 0x00, 0x07, 0x0D, 0x0D, 0x01, 0x1C, 0xFB, 0xFF, + 0xFF, 0x48, 0x0E, 0x08, 0x0D, 0x1E, 0x0E, 0x08, 0x00, 0x3A, 0x0F, 0x00, 0x08, 0x1B, 0x10, 0x0F, + 0x00, 0x3A, 0x0F, 0x00, 0x0D, 0x3C, 0x00, 0x08, 0x0F, 0x3C, 0x00, 0x0D, 0x10, 0x05, 0x08, 0x08, + 0x01, 0x07, 0x0D, 0x0D, 0x01, 0x47, 0x0E, 0x08, 0x0D, 0x1E, 0x0E, 0x02, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1C, 0xCC, 0xFF, 0xFF, 0x23, 0x0E, 0x01, 0x0D, 0x1E, 0x0E, 0x04, 0x00, 0x33, 0x00, 0x01, + 0x0D, 0x31, 0x03, 0x00, 0x00, 0x35, 0x0F, 0x04, 0x00, 0x23, 0x0E, 0x08, 0x02, 0x1E, 0x0E, 0x04, + 0x00, 0x33, 0x00, 0x08, 0x02, 0x31, 0x03, 0x00, 0x00, 0x35, 0x0F, 0x04, 0x00, 0x03, 0x00, 0x00, + 0x00, 0x83, 0x4D, 0x01, 0x01, 0x09, 0x00, 0x03, 0x01, 0x13, 0x01, 0x1E, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x13, 0x01, 0x13, 0xBF, 0xFE, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, + 0x05, 0x01, 0x05, 0x02, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x02, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x07, 0x03, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x0D, 0x00, 0x07, 0x01, 0x12, 0x00, 0x09, 0x01, 0x17, 0x00, + 0x09, 0x01, 0x09, 0x01, 0x09, 0x01, 0x09, 0x01, 0x0B, 0x00, 0x07, 0x00, 0x1B, 0xBF, 0xF5, 0x05, + 0x0C, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x09, 0x00, 0x05, 0x01, 0x07, + 0x00, 0x07, 0x00, 0x07, 0xBF, 0xE9, 0x01, 0x00, 0x0C, 0x00, 0xDA, 0x1F, 0x00, 0x0C, 0x01, 0xDA, + 0x88, 0x69, 0x00, 0x0C, 0x02, 0xCF, 0x04, 0x73, 0x6F, 0x72, 0x74, 0x04, 0x0C, 0x04, 0xDA, 0x88, + 0x69, 0x20, 0x01, 0x03, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x01, + 0x00, 0x1B, 0x04, 0x03, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x07, 0x06, 0x05, 0x01, 0x2B, 0x05, 0x00, + 0x00, 0x33, 0x00, 0x05, 0x06, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x36, 0x05, 0x00, + 0x00, 0x83, 0x6C, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x17, 0x00, 0x14, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x80, 0xE3, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x03, 0x27, 0x00, 0x0B, 0xCE, 0x05, 0x70, 0x61, + 0x69, 0x72, 0x73, 0xDA, 0x18, 0xDA, 0x86, 0x85, 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0x00, 0x27, + 0x00, 0xDA, 0x1E, 0x00, 0x27, 0x01, 0xCF, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x08, 0x17, 0x03, + 0xDA, 0x86, 0x87, 0x09, 0x17, 0x04, 0xDA, 0x80, 0xC3, 0x09, 0x16, 0x00, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x4D, 0x0C, 0x16, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x4C, 0x11, 0x16, 0x07, 0xDA, 0x6D, 0x18, 0x27, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x4E, 0x18, 0x26, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x50, 0x1B, 0x26, + 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x4F, 0x20, 0x26, 0x06, 0xDA, 0x6D, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x14, 0x00, 0x3F, + 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, + 0x03, 0x04, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, 0x06, 0x1B, + 0x06, 0x05, 0x00, 0x1F, 0x06, 0x09, 0x00, 0x3A, 0x05, 0x00, 0x06, 0x32, 0x06, 0x05, 0x00, 0x45, + 0x05, 0x00, 0x00, 0x1B, 0x07, 0x05, 0x00, 0x3C, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x01, 0x49, + 0x06, 0x00, 0x06, 0x1C, 0xF8, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x1B, + 0x04, 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x03, 0x00, 0x05, 0x1B, 0x05, 0x03, 0x00, 0x1F, + 0x05, 0x0A, 0x00, 0x3A, 0x03, 0x00, 0x05, 0x32, 0x05, 0x03, 0x00, 0x45, 0x03, 0x00, 0x00, 0x1B, + 0x06, 0x03, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x03, 0x07, 0x00, 0x49, + 0x05, 0x00, 0x05, 0x1C, 0xF7, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x86, 0x5E, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x03, 0x02, 0x22, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x07, 0x01, 0x07, + 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x01, 0x09, 0x01, 0x09, 0xBF, 0xFE, 0x07, 0x00, 0x07, 0xBF, 0xFD, 0x05, 0x07, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x82, 0x72, 0xDA, + 0x85, 0xFD, 0xDA, 0x58, 0xDA, 0x80, 0xE0, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, + 0x01, 0x01, 0x06, 0x2F, 0x00, 0x0B, 0xCE, 0x07, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xDA, + 0x18, 0xDA, 0x86, 0x85, 0xDA, 0x2B, 0xD8, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, + 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0xDA, 0x80, 0xA9, 0xDA, 0x80, 0xA8, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x00, 0x0E, 0x00, 0x05, 0xCE, 0x08, + 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x21, 0xDA, 0x18, 0x00, 0x0E, 0x00, 0xDA, 0x80, 0xDB, + 0x00, 0x0E, 0x01, 0xCF, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x21, 0x00, 0x0E, 0x02, + 0xDA, 0x80, 0xC3, 0x02, 0x0E, 0x04, 0xCF, 0x01, 0x6A, 0x07, 0x0D, 0x07, 0xCF, 0x02, 0x74, 0x69, + 0x2B, 0x02, 0x00, 0x00, 0x3F, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x07, 0x04, 0x04, 0x01, + 0x23, 0x05, 0x02, 0x04, 0x1E, 0x05, 0x08, 0x00, 0x3A, 0x06, 0x00, 0x02, 0x1B, 0x07, 0x06, 0x00, + 0x3A, 0x06, 0x00, 0x04, 0x3C, 0x00, 0x02, 0x06, 0x3C, 0x00, 0x04, 0x07, 0x05, 0x02, 0x02, 0x01, + 0x1C, 0xF7, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x85, 0xC0, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, + 0x0F, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x0D, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x05, 0x01, 0x05, 0x01, + 0x05, 0xBF, 0xFC, 0x03, 0xBF, 0xFA, 0x01, 0x00, 0x2F, 0x00, 0xDA, 0x80, 0xDB, 0x00, 0x2F, 0x01, + 0xCF, 0x07, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x05, 0x1F, 0x04, 0xDA, 0x81, 0x9E, 0x13, + 0x1F, 0x05, 0xDA, 0x23, 0x13, 0x1E, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x6A, + 0x16, 0x1E, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x69, 0x19, 0x1E, 0x07, 0xDA, + 0x5A, 0x20, 0x2C, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x6B, 0x20, 0x2C, 0x00, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x6D, 0x23, 0x2C, 0x05, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x6C, 0x26, 0x2C, 0x06, 0xDA, 0x5A, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, + 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x1C, 0x00, 0x3F, 0x03, 0x00, 0x00, 0x1B, 0x04, + 0x03, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, + 0x06, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x03, + 0x06, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, + 0x07, 0x00, 0x1B, 0x03, 0x06, 0x00, 0x1B, 0x05, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x03, + 0x00, 0x06, 0x1B, 0x06, 0x03, 0x00, 0x1F, 0x06, 0x07, 0x00, 0x3A, 0x03, 0x00, 0x06, 0x1B, 0x07, + 0x03, 0x00, 0x07, 0x04, 0x04, 0x01, 0x3C, 0x05, 0x04, 0x07, 0x49, 0x06, 0x00, 0x06, 0x1C, 0xFA, + 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x05, + 0x00, 0x00, 0x49, 0x03, 0x00, 0x05, 0x1B, 0x05, 0x03, 0x00, 0x1F, 0x05, 0x08, 0x00, 0x3A, 0x03, + 0x00, 0x05, 0x1B, 0x06, 0x03, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x03, + 0x07, 0x00, 0x49, 0x05, 0x00, 0x05, 0x1C, 0xF9, 0xFF, 0xFF, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x03, + 0x05, 0x00, 0x36, 0x03, 0x00, 0x00, 0x85, 0xCD, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x02, + 0x0E, 0x00, 0x07, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, 0x01, 0x12, 0x00, 0x12, 0x00, + 0x12, 0xBF, 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFE, 0x10, 0x00, + 0x07, 0x03, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x12, 0x00, + 0x09, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0xBF, 0xFB, 0x05, 0x08, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xD0, 0x06, 0x62, 0x72, 0x61, 0x6E, 0x63, + 0x68, 0xDA, 0x83, 0xFB, 0xDA, 0x57, 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x72, 0x65, + 0x6D, 0x6F, 0x76, 0x65, 0x00, 0x81, 0x0D, 0x00, 0xDA, 0x1E, 0x00, 0x81, 0x0D, 0x01, 0xCF, 0x05, + 0x63, 0x61, 0x73, 0x65, 0x73, 0x00, 0x81, 0x0D, 0x02, 0xDA, 0x88, 0x58, 0x04, 0x81, 0x0D, 0x03, + 0xCF, 0x06, 0x6F, 0x64, 0x64, 0x6C, 0x65, 0x6E, 0x0C, 0x81, 0x0D, 0x06, 0xDA, 0x87, 0xD6, 0x1A, + 0x81, 0x0D, 0x07, 0xCF, 0x08, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x24, 0x81, 0x0D, + 0x0A, 0xCF, 0x05, 0x78, 0x2D, 0x73, 0x79, 0x6D, 0x26, 0x81, 0x0D, 0x0C, 0xDA, 0x81, 0x96, 0x32, + 0x81, 0x0D, 0x0E, 0xCF, 0x07, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x34, 0x81, 0x0D, 0x10, + 0xCF, 0x0E, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, + 0x36, 0x81, 0x0D, 0x12, 0xCF, 0x04, 0x65, 0x6D, 0x69, 0x74, 0x38, 0x81, 0x0D, 0x14, 0xCF, 0x0B, + 0x65, 0x6D, 0x69, 0x74, 0x2D, 0x62, 0x72, 0x61, 0x6E, 0x63, 0x68, 0x3A, 0x81, 0x0D, 0x16, 0xCF, + 0x07, 0x67, 0x65, 0x74, 0x2D, 0x73, 0x79, 0x6D, 0x3C, 0x81, 0x0D, 0x18, 0xCF, 0x0E, 0x67, 0x65, + 0x74, 0x2D, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x3E, 0x81, 0x0D, 0x1A, + 0xCF, 0x0F, 0x76, 0x69, 0x73, 0x69, 0x74, 0x2D, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2D, + 0x31, 0x40, 0x81, 0x0D, 0x1C, 0xCF, 0x0F, 0x76, 0x69, 0x73, 0x69, 0x74, 0x2D, 0x70, 0x61, 0x74, + 0x74, 0x65, 0x72, 0x6E, 0x2D, 0x32, 0x40, 0x80, 0xC4, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x77, 0x43, 0x80, 0xC4, 0x1E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x76, + 0x47, 0x80, 0xC4, 0x20, 0xCF, 0x07, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x49, 0x80, 0xC4, + 0x21, 0xCF, 0x0A, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x4B, 0x80, 0xC4, + 0x1F, 0xCF, 0x03, 0x62, 0x32, 0x67, 0x4D, 0x80, 0xC4, 0x22, 0xCF, 0x03, 0x67, 0x75, 0x6E, 0x4F, + 0x80, 0xC4, 0x23, 0xCF, 0x05, 0x70, 0x72, 0x65, 0x64, 0x73, 0x58, 0x80, 0xC4, 0x24, 0xCF, 0x04, + 0x61, 0x6E, 0x64, 0x61, 0x5F, 0x80, 0xC4, 0x25, 0xCF, 0x05, 0x75, 0x6E, 0x69, 0x66, 0x79, 0x5F, + 0x73, 0x1F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x79, 0x62, 0x73, 0x26, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x78, 0x65, 0x73, 0x27, 0xCF, 0x04, 0x73, 0x79, 0x6D, 0x73, + 0x72, 0x80, 0x83, 0x22, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x41, 0x75, 0x80, 0x83, + 0x26, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x7A, 0x78, 0x80, 0x83, 0x27, 0xDA, 0x82, + 0xF6, 0x79, 0x80, 0x83, 0x28, 0xDA, 0x88, 0xA0, 0x80, 0x8A, 0x80, 0xA6, 0x26, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x42, 0x80, 0x91, 0x80, 0xA6, 0x1D, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x44, 0x80, 0x94, 0x80, 0xA6, 0x28, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x43, 0x80, 0x98, 0x80, 0xA6, 0x2A, 0xDA, 0x22, 0x80, 0x9A, 0x80, 0xA6, 0x2B, 0xDA, 0x5A, + 0x80, 0xA5, 0x80, 0xC4, 0x26, 0xCF, 0x04, 0x64, 0x65, 0x66, 0x73, 0x80, 0xB4, 0x80, 0xB8, 0x27, + 0xCF, 0x09, 0x70, 0x72, 0x65, 0x64, 0x2D, 0x6A, 0x6F, 0x69, 0x6E, 0x80, 0xC6, 0x81, 0x0D, 0x1E, + 0xDA, 0x82, 0x10, 0x80, 0xCA, 0x81, 0x05, 0x20, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x46, 0x80, 0xCD, 0x81, 0x05, 0x21, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x80, + 0xD0, 0x81, 0x05, 0x22, 0xDA, 0x81, 0x99, 0x80, 0xD7, 0x80, 0xFF, 0x24, 0xDA, 0x82, 0xB5, 0x80, + 0xDB, 0x80, 0xFF, 0x25, 0xCF, 0x06, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x80, 0xDD, 0x80, 0xF2, + 0x26, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x47, 0x80, 0xF6, 0x80, 0xFF, 0x23, 0xCF, + 0x07, 0x69, 0x66, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x3F, 0x03, 0x01, 0x00, 0x31, 0x03, 0x00, 0x00, + 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x06, 0x00, + 0x31, 0x01, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x28, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x03, 0x08, 0x00, + 0x2B, 0x08, 0x00, 0x00, 0x2B, 0x09, 0xFE, 0xFF, 0x33, 0x01, 0x08, 0x09, 0x2C, 0x09, 0x02, 0x00, + 0x35, 0x08, 0x09, 0x00, 0x1B, 0x07, 0x08, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x07, 0x01, 0x00, + 0x2B, 0x08, 0x02, 0x00, 0x32, 0x08, 0x07, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x35, 0x08, 0x09, 0x00, + 0x1B, 0x07, 0x08, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x35, 0x0A, 0x0B, 0x00, + 0x1E, 0x0A, 0x03, 0x00, 0x1B, 0x09, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x0C, 0x05, 0x00, + 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x09, 0x0B, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x40, 0x0B, 0x00, 0x00, + 0x1B, 0x0C, 0x0B, 0x00, 0x4A, 0x0D, 0x00, 0x0A, 0x1E, 0x0D, 0x07, 0x00, 0x2C, 0x0E, 0x06, 0x00, + 0x33, 0x0E, 0x0A, 0x00, 0x45, 0x0E, 0x00, 0x00, 0x32, 0x0C, 0x0E, 0x00, 0x2C, 0x10, 0x07, 0x00, + 0x35, 0x0F, 0x10, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x32, 0x0D, 0x0A, 0x00, 0x44, 0x0D, 0x00, 0x00, + 0x1B, 0x0E, 0x0D, 0x00, 0x44, 0x0F, 0x00, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x30, 0x11, 0x00, 0x00, + 0x1B, 0x12, 0x11, 0x00, 0x30, 0x13, 0x01, 0x00, 0x1B, 0x14, 0x13, 0x00, 0x30, 0x15, 0x02, 0x00, + 0x1B, 0x16, 0x15, 0x00, 0x30, 0x17, 0x03, 0x00, 0x1B, 0x18, 0x17, 0x00, 0x30, 0x19, 0x04, 0x00, + 0x1B, 0x1A, 0x19, 0x00, 0x30, 0x1B, 0x05, 0x00, 0x1B, 0x1C, 0x1B, 0x00, 0x28, 0x1E, 0x00, 0x00, + 0x49, 0x1D, 0x07, 0x1E, 0x1B, 0x1E, 0x1D, 0x00, 0x1F, 0x1E, 0x80, 0x00, 0x3A, 0x1D, 0x07, 0x1E, + 0x3D, 0x1F, 0x1D, 0x00, 0x1B, 0x20, 0x1F, 0x00, 0x3D, 0x1F, 0x1D, 0x01, 0x1B, 0x21, 0x1F, 0x00, + 0x44, 0x1D, 0x00, 0x00, 0x1B, 0x1F, 0x1D, 0x00, 0x44, 0x1D, 0x00, 0x00, 0x1B, 0x22, 0x1D, 0x00, + 0x40, 0x1D, 0x00, 0x00, 0x1B, 0x23, 0x1D, 0x00, 0x28, 0x1D, 0x00, 0x00, 0x28, 0x24, 0x00, 0x00, + 0x33, 0x1F, 0x1D, 0x24, 0x31, 0x20, 0x00, 0x00, 0x35, 0x1D, 0x1A, 0x00, 0x2C, 0x1D, 0x09, 0x00, + 0x31, 0x1D, 0x00, 0x00, 0x40, 0x1D, 0x00, 0x00, 0x1B, 0x24, 0x1D, 0x00, 0x33, 0x24, 0x22, 0x23, + 0x28, 0x1D, 0x00, 0x00, 0x28, 0x25, 0x00, 0x00, 0x33, 0x1D, 0x25, 0x20, 0x35, 0x1D, 0x1C, 0x00, + 0x40, 0x1D, 0x00, 0x00, 0x1B, 0x25, 0x1D, 0x00, 0x28, 0x26, 0x00, 0x00, 0x49, 0x1D, 0x1F, 0x26, + 0x1B, 0x26, 0x1D, 0x00, 0x1F, 0x26, 0x10, 0x00, 0x3A, 0x1D, 0x1F, 0x26, 0x1B, 0x27, 0x1D, 0x00, + 0x3F, 0x1D, 0x27, 0x00, 0x2B, 0x29, 0x01, 0x00, 0x23, 0x28, 0x29, 0x1D, 0x1E, 0x28, 0x08, 0x00, + 0x2C, 0x1D, 0x0A, 0x00, 0x31, 0x1D, 0x00, 0x00, 0x34, 0x27, 0x00, 0x00, 0x45, 0x1D, 0x00, 0x00, + 0x32, 0x25, 0x1D, 0x00, 0x2C, 0x2A, 0x07, 0x00, 0x35, 0x29, 0x2A, 0x00, 0x49, 0x26, 0x1F, 0x26, + 0x1C, 0xF1, 0xFF, 0xFF, 0x28, 0x26, 0x00, 0x00, 0x49, 0x1D, 0x22, 0x26, 0x1B, 0x26, 0x1D, 0x00, + 0x1F, 0x26, 0x0D, 0x00, 0x3A, 0x1D, 0x22, 0x26, 0x1B, 0x27, 0x26, 0x00, 0x1B, 0x28, 0x1D, 0x00, + 0x2C, 0x1D, 0x0A, 0x00, 0x32, 0x1D, 0x27, 0x00, 0x34, 0x28, 0x00, 0x00, 0x45, 0x1D, 0x00, 0x00, + 0x32, 0x25, 0x1D, 0x00, 0x2C, 0x2A, 0x07, 0x00, 0x35, 0x29, 0x2A, 0x00, 0x49, 0x26, 0x22, 0x26, + 0x1C, 0xF4, 0xFF, 0xFF, 0x31, 0x25, 0x00, 0x00, 0x2C, 0x26, 0x0B, 0x00, 0x35, 0x1D, 0x26, 0x00, + 0x32, 0x24, 0x25, 0x00, 0x2C, 0x26, 0x0C, 0x00, 0x35, 0x1D, 0x26, 0x00, 0x40, 0x1D, 0x00, 0x00, + 0x1B, 0x26, 0x1D, 0x00, 0x31, 0x1F, 0x00, 0x00, 0x2C, 0x27, 0x0D, 0x00, 0x35, 0x1D, 0x27, 0x00, + 0x31, 0x1D, 0x00, 0x00, 0x2C, 0x28, 0x0B, 0x00, 0x35, 0x27, 0x28, 0x00, 0x1B, 0x1D, 0x27, 0x00, + 0x28, 0x28, 0x00, 0x00, 0x49, 0x27, 0x1D, 0x28, 0x1B, 0x28, 0x27, 0x00, 0x1F, 0x28, 0x11, 0x00, + 0x3A, 0x27, 0x1D, 0x28, 0x3D, 0x29, 0x27, 0x00, 0x1B, 0x2A, 0x29, 0x00, 0x3D, 0x29, 0x27, 0x01, + 0x1B, 0x2B, 0x29, 0x00, 0x31, 0x2B, 0x00, 0x00, 0x2C, 0x29, 0x0E, 0x00, 0x35, 0x27, 0x29, 0x00, + 0x2C, 0x29, 0x06, 0x00, 0x33, 0x29, 0x2A, 0x27, 0x45, 0x27, 0x00, 0x00, 0x32, 0x26, 0x27, 0x00, + 0x2C, 0x2C, 0x07, 0x00, 0x35, 0x29, 0x2C, 0x00, 0x49, 0x28, 0x1D, 0x28, 0x1C, 0xF0, 0xFF, 0xFF, + 0x31, 0x23, 0x00, 0x00, 0x2C, 0x27, 0x0F, 0x00, 0x35, 0x1D, 0x27, 0x00, 0x1E, 0x1D, 0x02, 0x00, + 0x1C, 0x0E, 0x00, 0x00, 0x2C, 0x28, 0x09, 0x00, 0x31, 0x28, 0x00, 0x00, 0x34, 0x23, 0x00, 0x00, + 0x45, 0x27, 0x00, 0x00, 0x2C, 0x29, 0x10, 0x00, 0x31, 0x29, 0x00, 0x00, 0x34, 0x26, 0x00, 0x00, + 0x31, 0x27, 0x00, 0x00, 0x45, 0x28, 0x00, 0x00, 0x1B, 0x27, 0x28, 0x00, 0x32, 0x24, 0x27, 0x00, + 0x2C, 0x29, 0x07, 0x00, 0x35, 0x28, 0x29, 0x00, 0x31, 0x24, 0x00, 0x00, 0x2C, 0x27, 0x11, 0x00, + 0x35, 0x1D, 0x27, 0x00, 0x2C, 0x27, 0x10, 0x00, 0x31, 0x27, 0x00, 0x00, 0x34, 0x26, 0x00, 0x00, + 0x31, 0x21, 0x00, 0x00, 0x45, 0x27, 0x00, 0x00, 0x32, 0x1D, 0x27, 0x00, 0x35, 0x28, 0x14, 0x00, + 0x49, 0x1E, 0x07, 0x1E, 0x1C, 0x81, 0xFF, 0xFF, 0x31, 0x06, 0x00, 0x00, 0x40, 0x1D, 0x00, 0x00, + 0x1B, 0x1E, 0x1D, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x2C, 0x20, 0x12, 0x00, 0x35, 0x1F, 0x20, 0x00, + 0x1B, 0x20, 0x1F, 0x00, 0x28, 0x21, 0x00, 0x00, 0x49, 0x1F, 0x20, 0x21, 0x1B, 0x21, 0x1F, 0x00, + 0x1F, 0x21, 0x37, 0x00, 0x3A, 0x1F, 0x20, 0x21, 0x1B, 0x22, 0x1F, 0x00, 0x2C, 0x23, 0x13, 0x00, + 0x25, 0x1F, 0x23, 0x22, 0x1E, 0x1F, 0x2D, 0x00, 0x31, 0x1E, 0x00, 0x00, 0x2C, 0x24, 0x14, 0x00, + 0x35, 0x23, 0x24, 0x00, 0x1B, 0x24, 0x23, 0x00, 0x31, 0x1E, 0x00, 0x00, 0x2C, 0x25, 0x14, 0x00, + 0x35, 0x23, 0x25, 0x00, 0x1B, 0x25, 0x23, 0x00, 0x3F, 0x23, 0x1E, 0x00, 0x1B, 0x26, 0x23, 0x00, + 0x26, 0x27, 0x26, 0x00, 0x1E, 0x27, 0x03, 0x00, 0x28, 0x23, 0x00, 0x00, 0x1C, 0x11, 0x00, 0x00, + 0x26, 0x29, 0x26, 0x01, 0x1E, 0x29, 0x06, 0x00, 0x2B, 0x2A, 0x00, 0x00, 0x31, 0x2A, 0x00, 0x00, + 0x35, 0x2A, 0x1E, 0x00, 0x1B, 0x28, 0x2A, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x31, 0x1E, 0x00, 0x00, + 0x2C, 0x2B, 0x12, 0x00, 0x35, 0x2A, 0x2B, 0x00, 0x2C, 0x2C, 0x10, 0x00, 0x31, 0x2C, 0x00, 0x00, + 0x34, 0x2A, 0x00, 0x00, 0x45, 0x2B, 0x00, 0x00, 0x1B, 0x28, 0x2B, 0x00, 0x1B, 0x23, 0x28, 0x00, + 0x2C, 0x27, 0x15, 0x00, 0x33, 0x27, 0x24, 0x25, 0x31, 0x23, 0x00, 0x00, 0x45, 0x26, 0x00, 0x00, + 0x1B, 0x23, 0x26, 0x00, 0x3F, 0x26, 0x1E, 0x00, 0x2B, 0x27, 0x00, 0x00, 0x33, 0x1E, 0x27, 0x26, + 0x2C, 0x28, 0x16, 0x00, 0x35, 0x27, 0x28, 0x00, 0x32, 0x1E, 0x23, 0x00, 0x2C, 0x27, 0x07, 0x00, + 0x35, 0x26, 0x27, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x32, 0x1E, 0x22, 0x00, 0x2C, 0x24, 0x07, 0x00, + 0x35, 0x23, 0x24, 0x00, 0x49, 0x21, 0x20, 0x21, 0x1C, 0xCA, 0xFF, 0xFF, 0x31, 0x1E, 0x00, 0x00, + 0x2C, 0x20, 0x12, 0x00, 0x35, 0x1F, 0x20, 0x00, 0x2C, 0x21, 0x10, 0x00, 0x31, 0x21, 0x00, 0x00, + 0x34, 0x1F, 0x00, 0x00, 0x45, 0x20, 0x00, 0x00, 0x03, 0x20, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x0C, 0xCE, 0x04, 0x65, 0x6D, 0x69, 0x74, 0xDA, + 0x18, 0xDA, 0x80, 0xA8, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, + 0x89, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x8A, 0xBF, + 0xFF, 0x00, 0x06, 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x8B, 0xBF, 0xFF, 0x00, + 0x0A, 0xDA, 0x88, 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, 0x96, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, + 0x88, 0x8D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0x00, 0x04, 0x00, 0xDA, 0x1E, 0x00, 0x04, + 0x01, 0xDA, 0x88, 0x8F, 0x2D, 0x02, 0x00, 0x0C, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, + 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x87, 0x49, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x02, 0x06, 0x01, 0x0E, 0xCE, 0x0B, 0x65, 0x6D, + 0x69, 0x74, 0x2D, 0x62, 0x72, 0x61, 0x6E, 0x63, 0x68, 0xDA, 0x18, 0xDA, 0x88, 0x87, 0xDA, 0x80, + 0xA8, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x89, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x8A, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x8B, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x88, + 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, 0x96, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x8D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x8F, 0x00, 0x06, 0x00, + 0xDA, 0x82, 0xB5, 0x00, 0x06, 0x01, 0xCF, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x00, 0x06, + 0x02, 0xDA, 0x88, 0x90, 0x2D, 0x03, 0x00, 0x0C, 0x2C, 0x04, 0x00, 0x00, 0x33, 0x03, 0x04, 0x00, + 0x31, 0x01, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x87, 0x4A, + 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0A, 0x02, 0x02, 0x02, 0x03, 0x17, 0x01, 0x12, 0xCE, 0x07, 0x67, 0x65, 0x74, 0x2D, 0x73, 0x79, + 0x6D, 0xDA, 0x18, 0xDA, 0x51, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x1B, 0x04, 0x03, 0x02, 0x03, + 0x00, 0x06, 0xCE, 0x03, 0x67, 0x65, 0x74, 0x3B, 0x00, 0x00, 0x01, 0x28, 0x03, 0x00, 0x00, 0x25, + 0x03, 0x00, 0x03, 0x1D, 0x03, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xDA, + 0x52, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x89, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x8A, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x8B, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x88, + 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, 0x96, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x8D, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x8F, 0xBF, 0xFF, 0x00, + 0x14, 0xDA, 0x88, 0x90, 0x00, 0x17, 0x00, 0xCF, 0x0A, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x2D, + 0x73, 0x79, 0x6D, 0x00, 0x17, 0x01, 0xDA, 0x80, 0xDE, 0x00, 0x17, 0x02, 0xDA, 0x88, 0x91, 0x02, + 0x17, 0x04, 0xCF, 0x0A, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2D, 0x6B, 0x65, 0x79, 0x05, 0x17, + 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x0A, 0x17, 0x07, 0xDA, 0x49, 0x32, + 0x00, 0x01, 0x00, 0x45, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2D, 0x06, 0x00, 0x0E, 0x3B, + 0x05, 0x06, 0x04, 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x06, 0x02, 0x00, 0x03, 0x06, 0x00, 0x00, 0x2C, + 0x07, 0x00, 0x00, 0x35, 0x05, 0x07, 0x00, 0x1B, 0x07, 0x05, 0x00, 0x2D, 0x05, 0x00, 0x0E, 0x3C, + 0x05, 0x04, 0x07, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, 0x01, 0x45, 0x05, 0x00, 0x00, 0x2C, + 0x08, 0x02, 0x00, 0x33, 0x08, 0x07, 0x05, 0x45, 0x05, 0x00, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2D, + 0x09, 0x00, 0x12, 0x35, 0x08, 0x09, 0x00, 0x03, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x87, 0x4E, 0x15, + 0x00, 0x15, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x11, + 0x00, 0x11, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x09, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x05, 0x1A, 0x01, 0x11, 0xCE, 0x0E, 0x67, 0x65, 0x74, 0x2D, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x83, + 0x76, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x08, 0x01, 0x01, 0x01, 0x01, 0x00, 0x02, 0xCE, 0x06, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x3F, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x57, + 0xDA, 0x52, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x89, 0xBF, + 0xFF, 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x8A, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x8B, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, + 0x88, 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, 0x96, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x8D, + 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x8F, 0xBF, 0xFF, + 0x00, 0x14, 0xDA, 0x88, 0x90, 0xBF, 0xFF, 0x00, 0x16, 0xDA, 0x88, 0x91, 0x00, 0x1A, 0x00, 0xDA, + 0x88, 0xB3, 0x00, 0x1A, 0x01, 0xDA, 0x88, 0x92, 0x02, 0x1A, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x36, 0x07, 0x1A, 0x04, 0xDA, 0x49, 0x2D, 0x03, 0x00, 0x10, 0x3B, 0x02, 0x03, + 0x00, 0x1B, 0x03, 0x02, 0x00, 0x1E, 0x03, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x00, + 0x00, 0x35, 0x02, 0x04, 0x00, 0x1B, 0x04, 0x02, 0x00, 0x2D, 0x02, 0x00, 0x10, 0x3C, 0x02, 0x00, + 0x04, 0x2C, 0x02, 0x01, 0x00, 0x32, 0x02, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x05, 0x02, + 0x00, 0x32, 0x05, 0x00, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x33, 0x06, 0x02, + 0x05, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x33, 0x05, 0x04, 0x02, 0x45, 0x02, 0x00, + 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x06, 0x00, 0x12, 0x35, 0x05, 0x06, 0x00, 0x03, 0x04, 0x00, + 0x00, 0xBF, 0xFF, 0x87, 0x57, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x11, + 0x00, 0x11, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x01, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x34, + 0x00, 0x34, 0x00, 0x34, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x09, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x17, 0x04, + 0x04, 0x04, 0x13, 0x80, 0xD2, 0x01, 0x27, 0xCE, 0x0F, 0x76, 0x69, 0x73, 0x69, 0x74, 0x2D, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2D, 0x31, 0xDA, 0x18, 0xDA, 0x85, 0x58, 0xDA, 0x65, 0xDA, + 0x66, 0xDA, 0x80, 0xA3, 0xDA, 0x80, 0xA4, 0xDA, 0x80, 0xA5, 0xDA, 0x80, 0x97, 0xDA, 0x80, 0xA8, + 0xDA, 0x80, 0x9F, 0xDA, 0x80, 0xC9, 0xDA, 0x80, 0xCB, 0xDA, 0x86, 0x38, 0xDA, 0x7D, 0xCE, 0x26, + 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, + 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x26, 0x20, 0x69, 0x6E, 0x20, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0xDA, 0x81, 0x3F, 0xDA, 0x88, 0x0B, 0xCE, 0x37, 0x65, 0x78, + 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, + 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x27, 0x26, + 0x20, 0x69, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2C, 0x20, 0x66, 0x6F, 0x75, + 0x6E, 0x64, 0x20, 0x25, 0x71, 0xCE, 0x30, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, + 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, + 0x20, 0x26, 0x20, 0x69, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2C, 0x20, 0x66, + 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x25, 0x71, 0xCF, 0x01, 0x40, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x89, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x88, 0x8A, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, + 0xDA, 0x88, 0x8B, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x88, 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, + 0x96, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x88, 0x8D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0xBF, + 0xFF, 0x00, 0x12, 0xDA, 0x88, 0x8F, 0xBF, 0xFF, 0x00, 0x14, 0xDA, 0x88, 0x90, 0xBF, 0xFF, 0x00, + 0x16, 0xDA, 0x88, 0x91, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x88, 0x92, 0x00, 0x80, 0xD2, 0x00, 0xDA, + 0x88, 0x99, 0x00, 0x80, 0xD2, 0x01, 0xDA, 0x88, 0xB3, 0x00, 0x80, 0xD2, 0x02, 0xDA, 0x80, 0xDE, + 0x00, 0x80, 0xD2, 0x03, 0xDA, 0x88, 0x97, 0x00, 0x80, 0xD2, 0x04, 0xDA, 0x88, 0x93, 0x08, 0x80, + 0xD2, 0x06, 0xDA, 0x49, 0x0C, 0x80, 0xD2, 0x08, 0xDA, 0x80, 0xDB, 0x0F, 0x20, 0x0A, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x15, 0x1F, 0x0D, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x20, 0x80, 0xD2, 0x0A, 0xCF, 0x05, 0x69, 0x73, 0x61, 0x72, 0x72, 0x25, 0x2F, + 0x0D, 0xDA, 0x1E, 0x31, 0x43, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x36, + 0x40, 0x10, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x48, 0x4F, 0x0E, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x4F, 0x5D, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x64, 0x52, 0x5D, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x55, + 0x5C, 0x10, 0xDA, 0x80, 0xC3, 0x56, 0x5C, 0x11, 0xCF, 0x0B, 0x73, 0x75, 0x62, 0x2D, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6E, 0x60, 0x80, 0xA9, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x66, 0x63, 0x80, 0xA9, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x65, 0x66, + 0x80, 0xA8, 0x10, 0xDA, 0x80, 0xC3, 0x67, 0x80, 0xA8, 0x11, 0xDA, 0x88, 0xC7, 0x80, 0xAB, 0x80, + 0xBD, 0x10, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x68, 0x80, 0xB0, 0x80, 0xBA, 0x12, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x67, 0x80, 0xC2, 0x80, 0xCA, 0x11, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x69, 0x2E, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x25, + 0x05, 0x03, 0x06, 0x1E, 0x05, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2D, + 0x06, 0x00, 0x16, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, + 0x08, 0x01, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x25, + 0x09, 0x08, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, 0x0A, 0x03, 0x00, 0x1B, 0x09, 0x0A, 0x00, 0x1C, + 0x0E, 0x00, 0x00, 0x2C, 0x0D, 0x03, 0x00, 0x25, 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, + 0x0C, 0x08, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x0F, 0x04, 0x00, 0x35, 0x0E, 0x0F, 0x00, 0x2C, + 0x10, 0x05, 0x00, 0x25, 0x0F, 0x0E, 0x10, 0x1B, 0x0B, 0x0F, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, + 0x0B, 0x0D, 0x00, 0x1B, 0x09, 0x0B, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x25, + 0x0B, 0x08, 0x0C, 0x1E, 0x0B, 0x0C, 0x00, 0x3A, 0x0C, 0x00, 0x03, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, + 0x0C, 0x04, 0x00, 0x32, 0x0D, 0x06, 0x00, 0x2C, 0x0E, 0x07, 0x00, 0x36, 0x0E, 0x00, 0x00, 0x31, + 0x06, 0x00, 0x00, 0x40, 0x0E, 0x00, 0x00, 0x1B, 0x0F, 0x00, 0x00, 0x3C, 0x0F, 0x03, 0x0E, 0x03, + 0x0F, 0x00, 0x00, 0x2C, 0x0E, 0x03, 0x00, 0x25, 0x0D, 0x08, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1E, + 0x0D, 0x10, 0x00, 0x3F, 0x10, 0x03, 0x00, 0x2B, 0x12, 0x02, 0x00, 0x25, 0x11, 0x12, 0x10, 0x1B, + 0x10, 0x11, 0x00, 0x1E, 0x11, 0x08, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x31, 0x12, 0x00, 0x00, 0x35, + 0x12, 0x03, 0x00, 0x2C, 0x14, 0x08, 0x00, 0x25, 0x13, 0x14, 0x12, 0x1B, 0x0F, 0x13, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x0F, 0x10, 0x00, 0x1B, 0x0C, 0x0F, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, + 0x0C, 0x0E, 0x00, 0x1E, 0x0C, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, + 0x0E, 0x09, 0x00, 0x25, 0x0D, 0x08, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1E, 0x0E, 0x03, 0x00, 0x1B, + 0x0D, 0x0E, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x10, 0x0A, 0x00, 0x25, 0x0F, 0x08, 0x10, 0x1B, + 0x0D, 0x0F, 0x00, 0x1E, 0x0D, 0x0E, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0E, 0x03, 0x0F, 0x1B, + 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x09, 0x00, 0x3A, 0x0E, 0x03, 0x0F, 0x1B, 0x10, 0x0F, 0x00, 0x1B, + 0x11, 0x0E, 0x00, 0x33, 0x00, 0x06, 0x10, 0x31, 0x11, 0x00, 0x00, 0x35, 0x0E, 0x04, 0x00, 0x49, + 0x0F, 0x03, 0x0F, 0x1C, 0xF8, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x1E, 0x0A, 0x4C, 0x00, 0x31, + 0x06, 0x00, 0x00, 0x2D, 0x0F, 0x00, 0x18, 0x35, 0x0E, 0x0F, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, + 0x0E, 0x03, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x44, 0x00, 0x3A, 0x0E, 0x03, 0x0F, 0x1B, + 0x10, 0x0F, 0x00, 0x1B, 0x11, 0x0E, 0x00, 0x2C, 0x12, 0x0B, 0x00, 0x25, 0x0E, 0x11, 0x12, 0x1E, + 0x0E, 0x39, 0x00, 0x3F, 0x12, 0x03, 0x00, 0x31, 0x10, 0x00, 0x00, 0x2C, 0x14, 0x0C, 0x00, 0x35, + 0x13, 0x14, 0x00, 0x48, 0x14, 0x12, 0x13, 0x1E, 0x14, 0x05, 0x00, 0x2C, 0x12, 0x0D, 0x00, 0x31, + 0x12, 0x00, 0x00, 0x2C, 0x13, 0x0E, 0x00, 0x35, 0x12, 0x13, 0x00, 0x05, 0x12, 0x10, 0x02, 0x3F, + 0x13, 0x03, 0x00, 0x23, 0x14, 0x12, 0x13, 0x1E, 0x14, 0x0B, 0x00, 0x31, 0x10, 0x00, 0x00, 0x2C, + 0x13, 0x0C, 0x00, 0x35, 0x12, 0x13, 0x00, 0x32, 0x03, 0x12, 0x00, 0x2C, 0x15, 0x0F, 0x00, 0x35, + 0x13, 0x15, 0x00, 0x2C, 0x12, 0x10, 0x00, 0x32, 0x12, 0x13, 0x00, 0x2C, 0x15, 0x0E, 0x00, 0x35, + 0x12, 0x15, 0x00, 0x31, 0x10, 0x00, 0x00, 0x2C, 0x13, 0x0C, 0x00, 0x35, 0x12, 0x13, 0x00, 0x31, + 0x12, 0x00, 0x00, 0x35, 0x13, 0x03, 0x00, 0x31, 0x13, 0x00, 0x00, 0x2C, 0x14, 0x01, 0x00, 0x35, + 0x12, 0x14, 0x00, 0x2C, 0x14, 0x06, 0x00, 0x4A, 0x13, 0x12, 0x14, 0x1E, 0x13, 0x0A, 0x00, 0x31, + 0x10, 0x00, 0x00, 0x2C, 0x14, 0x0C, 0x00, 0x35, 0x12, 0x14, 0x00, 0x31, 0x12, 0x00, 0x00, 0x35, + 0x14, 0x03, 0x00, 0x2C, 0x12, 0x11, 0x00, 0x32, 0x12, 0x14, 0x00, 0x2C, 0x15, 0x0E, 0x00, 0x35, + 0x12, 0x15, 0x00, 0x31, 0x10, 0x00, 0x00, 0x2C, 0x13, 0x0C, 0x00, 0x35, 0x12, 0x13, 0x00, 0x31, + 0x12, 0x00, 0x00, 0x35, 0x13, 0x03, 0x00, 0x2C, 0x12, 0x0F, 0x00, 0x33, 0x12, 0x06, 0x10, 0x45, + 0x12, 0x00, 0x00, 0x31, 0x12, 0x00, 0x00, 0x40, 0x12, 0x00, 0x00, 0x3C, 0x00, 0x13, 0x12, 0x1C, + 0x06, 0x00, 0x00, 0x33, 0x00, 0x06, 0x10, 0x31, 0x11, 0x00, 0x00, 0x35, 0x0E, 0x04, 0x00, 0x49, + 0x0F, 0x03, 0x0F, 0x1C, 0xBD, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x10, 0x03, 0x00, 0x25, + 0x0F, 0x08, 0x10, 0x1B, 0x10, 0x0F, 0x00, 0x1E, 0x0F, 0x10, 0x00, 0x3F, 0x12, 0x03, 0x00, 0x2B, + 0x14, 0x02, 0x00, 0x25, 0x13, 0x14, 0x12, 0x1B, 0x12, 0x13, 0x00, 0x1E, 0x13, 0x08, 0x00, 0x2B, + 0x14, 0x00, 0x00, 0x31, 0x14, 0x00, 0x00, 0x35, 0x14, 0x03, 0x00, 0x2C, 0x16, 0x12, 0x00, 0x25, + 0x15, 0x16, 0x14, 0x1B, 0x11, 0x15, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x11, 0x12, 0x00, 0x1B, + 0x0E, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0E, 0x10, 0x00, 0x1E, 0x0E, 0x03, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x11, 0x03, 0x00, 0x25, 0x10, 0x08, 0x11, 0x1B, + 0x11, 0x10, 0x00, 0x1E, 0x10, 0x06, 0x00, 0x3F, 0x12, 0x03, 0x00, 0x2B, 0x14, 0x02, 0x00, 0x47, + 0x13, 0x12, 0x14, 0x1B, 0x0F, 0x13, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0F, 0x11, 0x00, 0x1E, + 0x0F, 0x07, 0x00, 0x2B, 0x10, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x35, 0x10, 0x03, 0x00, 0x33, + 0x00, 0x01, 0x02, 0x31, 0x10, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, + 0xFF, 0x87, 0x5D, 0x03, 0x02, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x18, 0x01, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, + 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x26, 0x00, 0x26, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x36, 0x00, 0x36, 0x00, 0x36, 0x00, 0x33, 0x00, 0x33, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x10, 0x00, 0x05, 0x04, 0x07, 0x00, 0x07, 0xBF, 0xFD, 0x05, 0x04, 0x12, 0x00, 0x07, 0x00, + 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1E, 0x00, 0x19, 0x00, 0x19, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x30, 0x00, 0x30, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xF7, 0x05, 0x0A, 0x07, 0x00, 0x07, + 0x03, 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x07, 0xBF, 0xF3, 0x05, 0x0E, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, + 0xBF, 0xF2, 0x05, 0x13, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x11, 0x00, 0x11, 0x00, 0x0B, 0x01, 0x17, 0x00, + 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x13, 0x00, 0x0D, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x02, 0x16, 0x00, 0x1E, 0x00, 0x13, 0x00, 0x0D, 0x01, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, + 0x51, 0x00, 0x51, 0x00, 0x51, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x02, 0x28, 0x00, + 0x28, 0x00, 0x28, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x13, 0x00, + 0x13, 0x00, 0x0D, 0x01, 0x53, 0x00, 0x53, 0x00, 0x53, 0x00, 0x4A, 0x00, 0x4A, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x02, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x16, 0x00, 0x16, 0x00, + 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x01, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0xBF, 0xF3, 0x09, 0x00, 0x09, 0x00, 0x09, 0x10, 0x0C, 0x00, 0x0C, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x1E, 0x00, 0x19, 0x00, 0x19, 0x00, 0x07, 0x00, 0x07, 0x00, 0x36, 0x00, 0x36, + 0x00, 0x36, 0x00, 0x30, 0x00, 0x30, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0xBF, 0xDC, 0x05, 0x25, 0x07, 0x00, 0x07, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x1D, 0x00, 0x19, 0x00, 0x19, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xD8, 0x05, + 0x2A, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xD6, 0x05, 0xCD, + 0x00, 0xFC, 0x00, 0x00, 0x19, 0x06, 0x06, 0x06, 0x12, 0x80, 0xD4, 0x01, 0x01, 0x2C, 0xCE, 0x0F, + 0x76, 0x69, 0x73, 0x69, 0x74, 0x2D, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2D, 0x32, 0xDA, + 0x18, 0xDA, 0x85, 0x58, 0xDA, 0x65, 0xDA, 0x66, 0xDA, 0x80, 0xA3, 0xDA, 0x80, 0xA4, 0xDA, 0x80, + 0xA5, 0xDA, 0x80, 0xA8, 0xDA, 0x83, 0x79, 0xDA, 0x87, 0xFD, 0xDA, 0x80, 0xC9, 0xDA, 0x80, 0xCB, + 0xDA, 0x81, 0x70, 0xDA, 0x86, 0x38, 0xDA, 0x80, 0x97, 0xDA, 0x80, 0x9F, 0xDA, 0x81, 0x87, 0xDA, + 0x88, 0xBE, 0xDA, 0x88, 0x0B, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x88, 0x89, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x88, 0x58, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x8A, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x87, 0xD6, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x88, 0x8B, 0xBF, 0xFF, + 0x00, 0x0A, 0xDA, 0x88, 0x8C, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x81, 0x96, 0xBF, 0xFF, 0x00, 0x0E, + 0xDA, 0x88, 0x8D, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x88, 0x8E, 0xBF, 0xFF, 0x00, 0x12, 0xDA, 0x88, + 0x8F, 0xBF, 0xFF, 0x00, 0x14, 0xDA, 0x88, 0x90, 0xBF, 0xFF, 0x00, 0x16, 0xDA, 0x88, 0x91, 0xBF, + 0xFF, 0x00, 0x18, 0xDA, 0x88, 0x92, 0xBF, 0xFF, 0x00, 0x1A, 0xDA, 0x88, 0x93, 0x00, 0x80, 0xD4, + 0x00, 0xDA, 0x88, 0x9C, 0x00, 0x80, 0xD4, 0x01, 0xDA, 0x88, 0x9A, 0x00, 0x80, 0xD4, 0x02, 0xDA, + 0x88, 0x9B, 0x00, 0x80, 0xD4, 0x03, 0xDA, 0x88, 0xB3, 0x00, 0x80, 0xD4, 0x04, 0xDA, 0x80, 0xDE, + 0x00, 0x80, 0xD4, 0x05, 0xDA, 0x88, 0x97, 0x00, 0x80, 0xD4, 0x06, 0xDA, 0x88, 0x94, 0x08, 0x80, + 0xD4, 0x08, 0xDA, 0x49, 0x0C, 0x80, 0xD4, 0x0A, 0xDA, 0x80, 0xDB, 0x0F, 0x20, 0x0C, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x6A, 0x15, 0x1F, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x6B, 0x20, 0x80, 0xD4, 0x0C, 0xDA, 0x88, 0xC1, 0x2C, 0x32, 0x0E, 0xCF, 0x08, 0x72, + 0x65, 0x73, 0x74, 0x2D, 0x69, 0x64, 0x78, 0x32, 0x3C, 0x0E, 0xCF, 0x0B, 0x70, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6E, 0x2D, 0x6C, 0x65, 0x6E, 0x3E, 0x45, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x6C, 0x45, 0x5D, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x6E, 0x48, + 0x5D, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x6D, 0x4B, 0x5C, 0x10, 0xDA, 0x80, + 0xC3, 0x4C, 0x5C, 0x11, 0xDA, 0x88, 0xC7, 0x5D, 0x6F, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x70, 0x60, 0x6F, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x6F, 0x63, + 0x6E, 0x10, 0xDA, 0x80, 0xC3, 0x64, 0x6E, 0x11, 0xDA, 0x88, 0xC7, 0x76, 0x80, 0x88, 0x11, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x72, 0x7B, 0x80, 0x85, 0x13, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x71, 0x80, 0x91, 0x80, 0xA3, 0x12, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x74, 0x80, 0x96, 0x80, 0xA0, 0x14, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x73, 0x80, 0xA8, 0x80, 0xB5, 0x11, 0xDA, 0x1E, 0x80, 0xB7, 0x80, 0xBF, 0x13, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x75, 0x2E, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x25, 0x07, + 0x05, 0x08, 0x1E, 0x07, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2D, 0x08, + 0x00, 0x16, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x0A, + 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x2C, 0x0C, 0x02, 0x00, 0x25, 0x0B, + 0x0A, 0x0C, 0x1B, 0x0C, 0x0B, 0x00, 0x1E, 0x0C, 0x03, 0x00, 0x1B, 0x0B, 0x0C, 0x00, 0x1C, 0x0E, + 0x00, 0x00, 0x2C, 0x0F, 0x03, 0x00, 0x25, 0x0E, 0x0A, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1E, 0x0E, + 0x08, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x11, 0x04, 0x00, 0x35, 0x10, 0x11, 0x00, 0x2C, 0x12, + 0x05, 0x00, 0x25, 0x11, 0x10, 0x12, 0x1B, 0x0D, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0D, + 0x0F, 0x00, 0x1B, 0x0B, 0x0D, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x1E, 0x0C, 0x1B, 0x00, 0x31, 0x08, + 0x00, 0x00, 0x2D, 0x0E, 0x00, 0x18, 0x35, 0x0D, 0x0E, 0x00, 0x32, 0x00, 0x0D, 0x00, 0x2C, 0x0F, + 0x06, 0x00, 0x35, 0x0E, 0x0F, 0x00, 0x30, 0x0E, 0x00, 0x00, 0x32, 0x0E, 0x05, 0x00, 0x2C, 0x10, + 0x07, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x1B, 0x0E, 0x0F, 0x00, 0x1E, 0x0F, 0x03, 0x00, 0x1B, 0x0D, + 0x0E, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x3F, 0x10, 0x05, 0x00, 0x1B, 0x0D, 0x10, 0x00, 0x1B, 0x0E, + 0x0D, 0x00, 0x31, 0x08, 0x00, 0x00, 0x2D, 0x0F, 0x00, 0x18, 0x35, 0x0D, 0x0F, 0x00, 0x2C, 0x0F, + 0x08, 0x00, 0x33, 0x0F, 0x0E, 0x0D, 0x45, 0x0D, 0x00, 0x00, 0x32, 0x00, 0x0D, 0x00, 0x2C, 0x10, + 0x06, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x2C, 0x0E, 0x09, 0x00, 0x25, 0x0D, 0x0A, 0x0E, 0x1B, 0x0E, + 0x0D, 0x00, 0x1E, 0x0E, 0x03, 0x00, 0x1B, 0x0D, 0x0E, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x10, + 0x0A, 0x00, 0x25, 0x0F, 0x0A, 0x10, 0x1B, 0x0D, 0x0F, 0x00, 0x1E, 0x0D, 0x18, 0x00, 0x28, 0x0F, + 0x00, 0x00, 0x49, 0x0E, 0x05, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x13, 0x00, 0x3A, 0x0E, + 0x05, 0x0F, 0x1B, 0x10, 0x0F, 0x00, 0x1B, 0x11, 0x0E, 0x00, 0x32, 0x08, 0x10, 0x00, 0x2D, 0x12, + 0x00, 0x16, 0x35, 0x0E, 0x12, 0x00, 0x2C, 0x12, 0x0B, 0x00, 0x28, 0x13, 0x00, 0x00, 0x33, 0x12, + 0x13, 0x0E, 0x45, 0x0E, 0x00, 0x00, 0x32, 0x00, 0x0E, 0x00, 0x2C, 0x13, 0x06, 0x00, 0x35, 0x12, + 0x13, 0x00, 0x33, 0x00, 0x01, 0x02, 0x33, 0x08, 0x10, 0x11, 0x35, 0x0E, 0x06, 0x00, 0x49, 0x0F, + 0x05, 0x0F, 0x1C, 0xEE, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x1E, 0x0C, 0x12, 0x00, 0x28, 0x0F, + 0x00, 0x00, 0x49, 0x0E, 0x05, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x0D, 0x00, 0x3A, 0x0E, + 0x05, 0x0F, 0x1B, 0x10, 0x0F, 0x00, 0x1B, 0x11, 0x0E, 0x00, 0x2C, 0x12, 0x0C, 0x00, 0x25, 0x0E, + 0x11, 0x12, 0x1E, 0x0E, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x33, 0x00, 0x01, 0x02, 0x33, 0x08, + 0x10, 0x11, 0x35, 0x0E, 0x06, 0x00, 0x49, 0x0F, 0x05, 0x0F, 0x1C, 0xF4, 0xFF, 0xFF, 0x04, 0x00, + 0x00, 0x00, 0x2C, 0x0F, 0x0D, 0x00, 0x25, 0x0E, 0x0A, 0x0F, 0x1E, 0x0E, 0x03, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x11, 0x03, 0x00, 0x25, 0x10, 0x0A, 0x11, 0x1B, 0x11, + 0x10, 0x00, 0x1E, 0x10, 0x10, 0x00, 0x3F, 0x13, 0x05, 0x00, 0x2B, 0x15, 0x02, 0x00, 0x25, 0x14, + 0x15, 0x13, 0x1B, 0x13, 0x14, 0x00, 0x1E, 0x14, 0x08, 0x00, 0x2B, 0x15, 0x00, 0x00, 0x31, 0x15, + 0x00, 0x00, 0x35, 0x15, 0x05, 0x00, 0x2C, 0x17, 0x0E, 0x00, 0x25, 0x16, 0x17, 0x15, 0x1B, 0x12, + 0x16, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x12, 0x13, 0x00, 0x1B, 0x0F, 0x12, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x1B, 0x0F, 0x11, 0x00, 0x1E, 0x0F, 0x07, 0x00, 0x2C, 0x10, 0x0F, 0x00, 0x33, 0x10, + 0x08, 0x05, 0x45, 0x10, 0x00, 0x00, 0x32, 0x00, 0x10, 0x00, 0x2C, 0x11, 0x06, 0x00, 0x36, 0x11, + 0x00, 0x00, 0x2C, 0x12, 0x03, 0x00, 0x25, 0x11, 0x0A, 0x12, 0x1B, 0x12, 0x11, 0x00, 0x1E, 0x11, + 0x10, 0x00, 0x3F, 0x14, 0x05, 0x00, 0x2B, 0x16, 0x02, 0x00, 0x25, 0x15, 0x16, 0x14, 0x1B, 0x14, + 0x15, 0x00, 0x1E, 0x15, 0x08, 0x00, 0x2B, 0x16, 0x00, 0x00, 0x31, 0x16, 0x00, 0x00, 0x35, 0x16, + 0x05, 0x00, 0x2C, 0x18, 0x10, 0x00, 0x25, 0x17, 0x18, 0x16, 0x1B, 0x13, 0x17, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x1B, 0x13, 0x14, 0x00, 0x1B, 0x10, 0x13, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x10, + 0x12, 0x00, 0x1E, 0x10, 0x12, 0x00, 0x2B, 0x11, 0x01, 0x00, 0x31, 0x11, 0x00, 0x00, 0x35, 0x11, + 0x05, 0x00, 0x3A, 0x12, 0x01, 0x11, 0x1B, 0x11, 0x12, 0x00, 0x1E, 0x12, 0x04, 0x00, 0x32, 0x11, + 0x08, 0x00, 0x2C, 0x13, 0x06, 0x00, 0x36, 0x13, 0x00, 0x00, 0x2B, 0x13, 0x01, 0x00, 0x31, 0x13, + 0x00, 0x00, 0x35, 0x13, 0x05, 0x00, 0x31, 0x08, 0x00, 0x00, 0x40, 0x14, 0x00, 0x00, 0x1B, 0x15, + 0x01, 0x00, 0x3C, 0x15, 0x13, 0x14, 0x03, 0x15, 0x00, 0x00, 0x2C, 0x13, 0x03, 0x00, 0x25, 0x12, + 0x0A, 0x13, 0x1B, 0x13, 0x12, 0x00, 0x1E, 0x12, 0x06, 0x00, 0x3F, 0x14, 0x05, 0x00, 0x2B, 0x16, + 0x02, 0x00, 0x47, 0x15, 0x14, 0x16, 0x1B, 0x11, 0x15, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x11, + 0x13, 0x00, 0x1E, 0x11, 0x0F, 0x00, 0x2B, 0x12, 0x01, 0x00, 0x32, 0x05, 0x12, 0x00, 0x2C, 0x13, + 0x11, 0x00, 0x35, 0x12, 0x13, 0x00, 0x31, 0x02, 0x00, 0x00, 0x34, 0x12, 0x00, 0x00, 0x2C, 0x14, + 0x06, 0x00, 0x35, 0x13, 0x14, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x31, 0x12, 0x00, 0x00, 0x35, 0x12, + 0x05, 0x00, 0x33, 0x00, 0x01, 0x02, 0x33, 0x03, 0x04, 0x12, 0x36, 0x06, 0x00, 0x00, 0x2C, 0x12, + 0x0F, 0x00, 0x33, 0x12, 0x08, 0x05, 0x45, 0x12, 0x00, 0x00, 0x32, 0x00, 0x12, 0x00, 0x2C, 0x13, + 0x06, 0x00, 0x36, 0x13, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, + 0x01, 0x01, 0x03, 0x00, 0x01, 0xDA, 0x18, 0xDA, 0x86, 0x38, 0x00, 0x03, 0x00, 0xDA, 0x1E, 0x2C, + 0x02, 0x00, 0x00, 0x25, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00, 0x87, 0x98, 0x2F, 0x00, 0x2F, + 0x00, 0x2F, 0x87, 0x8F, 0x03, 0x02, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x18, 0x01, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x14, 0x00, + 0x14, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x26, 0x00, 0x26, 0x00, 0x21, 0x00, + 0x21, 0x00, 0x36, 0x00, 0x36, 0x00, 0x36, 0x00, 0x33, 0x00, 0x33, 0x00, 0x21, 0x00, 0x21, 0x00, + 0x21, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x02, 0x27, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x02, 0x0B, 0xBF, 0xFE, 0x09, 0xBF, 0xFF, 0x07, 0x04, 0x28, 0x00, 0x28, 0x00, + 0x28, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x04, 0x0B, 0x00, + 0x0B, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x19, 0x00, 0x19, 0x00, 0x07, 0xBF, + 0xFD, 0x05, 0x04, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x01, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x07, 0x00, 0x07, 0x00, + 0x07, 0xBF, 0xFC, 0x05, 0x09, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x02, 0x0F, 0x00, 0x0F, 0x00, 0x09, 0x01, 0x0B, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0xBF, 0xFC, 0x07, 0x00, 0x07, 0x00, 0x07, 0x07, 0x07, 0x00, 0x07, 0xBF, 0xF0, 0x05, 0x10, 0x15, + 0x00, 0x15, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1E, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x30, 0x00, 0x30, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xED, 0x05, 0x14, 0x18, 0x00, + 0x18, 0x00, 0x18, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x1E, 0x00, 0x19, 0x00, 0x19, 0x00, 0x07, 0x00, 0x07, 0x00, 0x36, 0x00, 0x36, 0x00, + 0x36, 0x00, 0x30, 0x00, 0x30, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0xBF, 0xE9, 0x05, 0x18, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x12, 0x00, 0x07, 0x00, 0x07, + 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1D, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xE3, 0x05, 0x1F, 0x1C, 0x00, + 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x38, 0x00, + 0x38, 0x00, 0x38, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x03, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x87, 0x3C, 0x15, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, + 0x01, 0x0D, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, + 0x01, 0x1E, 0x00, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x1E, 0x00, 0x1E, + 0x00, 0x1E, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x03, 0x03, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x24, 0x00, 0x24, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x01, 0x07, 0x00, 0x03, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0x00, 0x16, + 0x00, 0x16, 0x00, 0x16, 0x03, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x02, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x02, 0x03, 0x00, 0x03, 0x09, 0x03, 0x00, 0x03, + 0x08, 0x03, 0x00, 0x03, 0x32, 0x03, 0x00, 0x03, 0x33, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, + 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x02, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x01, 0x12, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x07, 0x01, 0x1B, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x1B, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x05, 0x00, 0x05, 0x04, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x19, 0x00, 0x19, 0x00, + 0x19, 0x00, 0x19, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x02, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x0F, 0x00, 0x0F, 0x00, 0x25, + 0x00, 0x25, 0x00, 0x25, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x3B, + 0x00, 0x3B, 0x00, 0x3B, 0x00, 0x33, 0x00, 0x33, 0x00, 0x33, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x02, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x05, 0x00, 0x05, 0x01, 0x16, + 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, + 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x25, + 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xE9, 0x03, 0x00, + 0x03, 0x1A, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x09, 0x00, 0x09, 0x00, + 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x07, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0xBF, + 0xFF, 0x07, 0x03, 0x1F, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x19, 0x02, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0xBF, 0xFE, 0x19, 0x00, 0x19, 0x03, 0x22, 0x00, + 0x22, 0x00, 0x22, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0xBF, 0xFD, 0x19, 0x00, 0x19, + 0xBF, 0xFF, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0xBF, 0xFE, 0x07, 0x07, 0x1F, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xF7, 0x05, 0x0A, + 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xF5, 0x03, 0x00, 0x03, 0x0D, 0x0A, 0x00, 0x0A, 0x00, 0x0A, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x50, 0x45, 0x01, 0x00, 0x00, + 0x00, 0x00, 0xDA, 0x81, 0x1E, 0xDA, 0x80, 0x91, 0xDA, 0x84, 0x9A, 0xDA, 0x84, 0x96, 0xCF, 0x08, + 0x65, 0x76, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xD8, 0x08, 0x65, 0x76, 0x2F, 0x77, 0x72, 0x69, + 0x74, 0x65, 0xCF, 0x02, 0x3E, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x16, 0x06, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0xCE, 0x02, 0x3E, 0x3D, 0x3F, 0x01, 0x00, 0x00, 0x24, + 0x02, 0x01, 0x02, 0x1D, 0x02, 0x0A, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, + 0x04, 0x00, 0x05, 0x47, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x1B, + 0x03, 0x04, 0x00, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFA, 0xFF, 0x29, 0x03, 0x00, 0x00, 0x03, + 0x03, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x04, 0x64, 0x6F, 0x63, + 0x2A, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x01, 0x13, 0x45, 0x00, 0x01, + 0x06, 0xCE, 0x04, 0x64, 0x6F, 0x63, 0x2A, 0xDA, 0x18, 0xDA, 0x85, 0xA7, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x0D, 0x3C, 0x00, 0x04, 0xCE, 0x0B, 0x70, 0x72, 0x69, + 0x6E, 0x74, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x04, 0x02, 0x00, 0x02, 0x02, 0x04, 0x00, 0x03, 0xCE, 0x0C, 0x61, 0x6C, 0x6C, 0x2D, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x18, 0xDA, 0x80, 0x95, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x10, 0x03, 0x01, 0x03, 0x06, 0x33, 0x00, 0x0E, 0xCE, 0x08, 0x65, 0x6E, 0x76, + 0x2D, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x18, 0xDA, 0x83, 0xEB, 0xDA, 0x84, 0x95, 0xDA, 0x80, 0xA8, + 0xD8, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, + 0xDA, 0x87, 0x20, 0xDA, 0x88, 0x5E, 0x00, 0x33, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x33, 0x01, 0xDA, + 0x85, 0x87, 0x00, 0x33, 0x02, 0xCF, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00, 0x33, 0x03, 0xCF, + 0x08, 0x65, 0x6E, 0x76, 0x2D, 0x77, 0x61, 0x6C, 0x6B, 0x09, 0x33, 0x05, 0xDA, 0x85, 0x87, 0x0B, + 0x33, 0x07, 0xCF, 0x04, 0x65, 0x6E, 0x76, 0x73, 0x0C, 0x17, 0x08, 0xDA, 0x85, 0x91, 0x18, 0x33, + 0x09, 0xCF, 0x07, 0x72, 0x65, 0x74, 0x2D, 0x73, 0x65, 0x74, 0x18, 0x2D, 0x07, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x63, 0x1B, 0x2D, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x62, 0x1E, 0x2D, 0x0C, 0xCF, 0x04, 0x65, 0x6E, 0x76, 0x69, 0x1E, 0x2B, 0x0C, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x61, 0x21, 0x2B, 0x0D, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x39, 0x23, 0x2B, 0x0A, 0xDA, 0x22, 0x20, 0x01, 0x08, 0x00, 0x2C, 0x06, 0x00, 0x00, + 0x35, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x1B, 0x04, 0x06, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x04, 0x01, 0x00, 0x1B, 0x05, 0x04, 0x00, + 0x40, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1B, 0x08, 0x05, 0x00, 0x1E, 0x08, 0x0A, 0x00, + 0x32, 0x07, 0x08, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x31, 0x08, 0x00, 0x00, + 0x2C, 0x09, 0x03, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x1C, 0xF7, 0xFF, 0xFF, 0x44, 0x08, 0x00, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x28, 0x0B, 0x00, 0x00, + 0x49, 0x0A, 0x07, 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1F, 0x0B, 0x11, 0x00, 0x3A, 0x0A, 0x07, 0x0B, + 0x1B, 0x0C, 0x0A, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x49, 0x0A, 0x0C, 0x0D, 0x1B, 0x0D, 0x0A, 0x00, + 0x1F, 0x0D, 0x09, 0x00, 0x1B, 0x0A, 0x0D, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0E, 0x00, 0x00, + 0x1E, 0x0E, 0x03, 0x00, 0x29, 0x0F, 0x00, 0x00, 0x3C, 0x09, 0x0A, 0x0F, 0x49, 0x0D, 0x0C, 0x0D, + 0x1C, 0xF8, 0xFF, 0xFF, 0x49, 0x0B, 0x07, 0x0B, 0x1C, 0xF0, 0xFF, 0xFF, 0x31, 0x09, 0x00, 0x00, + 0x2C, 0x0B, 0x04, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x05, 0x00, + 0x36, 0x0B, 0x00, 0x00, 0x8C, 0x2B, 0x03, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x07, 0x00, + 0x13, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x37, 0x00, 0x37, 0x00, 0x37, 0x00, 0x4B, 0x00, + 0x55, 0x00, 0x13, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x10, 0x00, + 0x10, 0xBF, 0xFE, 0x03, 0x03, 0x05, 0x00, 0x05, 0xBF, 0xFD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x04, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x04, 0x00, + 0xDA, 0x85, 0x87, 0x00, 0x04, 0x01, 0xDA, 0x88, 0xEB, 0x00, 0x04, 0x02, 0xCF, 0x0C, 0x61, 0x6C, + 0x6C, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x2C, 0x03, 0x00, 0x00, 0x33, 0x03, + 0x00, 0x01, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8C, 0x3A, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xDA, 0x87, 0xA2, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x02, 0x00, + 0x02, 0x02, 0x04, 0x00, 0x03, 0xCE, 0x0C, 0x61, 0x6C, 0x6C, 0x2D, 0x64, 0x79, 0x6E, 0x61, 0x6D, + 0x69, 0x63, 0x73, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, + 0x02, 0x06, 0x00, 0x02, 0xCE, 0x08, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3F, 0xDA, 0x18, + 0xDA, 0x65, 0xD0, 0x07, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x00, 0x06, 0x00, 0xDA, 0x1E, + 0x00, 0x06, 0x01, 0xCF, 0x08, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3F, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, + 0x04, 0x03, 0x03, 0x00, 0x00, 0x68, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, 0x2F, 0x00, 0x2F, 0x00, + 0x2F, 0xDA, 0x88, 0xE8, 0x00, 0x04, 0x00, 0xDA, 0x85, 0x87, 0x00, 0x04, 0x01, 0xDA, 0x88, 0xEB, + 0x00, 0x04, 0x02, 0xCF, 0x0C, 0x61, 0x6C, 0x6C, 0x2D, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, + 0x73, 0x2C, 0x03, 0x00, 0x00, 0x33, 0x03, 0x00, 0x01, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, + 0x00, 0x8C, 0x41, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xD8, 0x08, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0xDA, 0x80, 0xA6, 0xDA, 0x83, 0xBD, 0xDA, 0x82, 0x5A, 0xDA, 0x85, 0x4B, + 0xCE, 0x0B, 0x42, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x3A, 0x0A, 0x0A, 0xDA, 0x81, 0x12, + 0xDA, 0x81, 0xE8, 0xCE, 0x0B, 0x44, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x73, 0x3A, 0x0A, 0x0A, + 0xCE, 0x36, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x55, 0x73, 0x65, 0x20, 0x28, 0x64, 0x6F, 0x63, 0x20, + 0x73, 0x79, 0x6D, 0x29, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x69, 0x6E, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x0A, 0x00, 0x3C, 0x00, 0xCF, 0x04, 0x66, 0x6C, 0x74, + 0x72, 0x00, 0x3C, 0x01, 0xCF, 0x0B, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x05, 0x3C, 0x02, 0xDA, 0x81, 0x22, 0x0F, 0x3C, 0x05, 0xCF, 0x08, 0x64, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x73, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x32, 0x00, 0x02, 0x00, + 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x2C, 0x05, 0x02, 0x00, + 0x35, 0x04, 0x05, 0x00, 0x32, 0x00, 0x04, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, 0x05, 0x06, 0x00, + 0x2C, 0x04, 0x03, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x35, 0x04, 0x06, 0x00, + 0x1B, 0x05, 0x04, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2C, 0x07, 0x06, 0x00, + 0x32, 0x02, 0x07, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x08, 0x00, + 0x32, 0x08, 0x07, 0x00, 0x2C, 0x09, 0x09, 0x00, 0x35, 0x08, 0x09, 0x00, 0x28, 0x07, 0x00, 0x00, + 0x28, 0x09, 0x00, 0x00, 0x33, 0x08, 0x07, 0x09, 0x2A, 0x07, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, + 0x2C, 0x09, 0x0A, 0x00, 0x35, 0x07, 0x09, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x05, 0x00, + 0x35, 0x08, 0x09, 0x00, 0x2C, 0x09, 0x05, 0x00, 0x35, 0x07, 0x09, 0x00, 0x2C, 0x09, 0x06, 0x00, + 0x32, 0x05, 0x09, 0x00, 0x2C, 0x0A, 0x07, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x2C, 0x0A, 0x0B, 0x00, + 0x32, 0x0A, 0x09, 0x00, 0x2C, 0x0B, 0x09, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x28, 0x09, 0x00, 0x00, + 0x28, 0x0B, 0x00, 0x00, 0x33, 0x0A, 0x09, 0x0B, 0x2A, 0x09, 0x00, 0x00, 0x31, 0x09, 0x00, 0x00, + 0x2C, 0x0B, 0x0A, 0x00, 0x35, 0x09, 0x0B, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x0B, 0x05, 0x00, + 0x35, 0x0A, 0x0B, 0x00, 0x2C, 0x09, 0x0C, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x09, 0x05, 0x00, + 0x36, 0x09, 0x00, 0x00, 0x8D, 0x57, 0x1E, 0x00, 0x1E, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, + 0x03, 0x01, 0x2C, 0x00, 0x2C, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x11, 0x00, 0x11, 0x00, + 0x11, 0x00, 0x11, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x2E, 0x00, 0x2E, 0x00, 0x2E, 0x00, + 0x2E, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, + 0x03, 0x01, 0x2E, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, + 0x16, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x80, 0xFB, + 0xDA, 0x82, 0x30, 0xD2, 0x0D, 0x01, 0xDA, 0x80, 0x9A, 0xDA, 0x52, 0xDA, 0x58, 0xDA, 0x80, 0x9B, + 0xDA, 0x57, 0xDA, 0x80, 0x99, 0xDA, 0x80, 0x9F, 0xDA, 0x34, 0xCF, 0x06, 0x73, 0x70, 0x6C, 0x69, + 0x63, 0x65, 0xDA, 0x80, 0xEE, 0xDA, 0x80, 0x9D, 0xDA, 0x80, 0x9C, 0xDA, 0x80, 0x9E, 0xDA, 0x1C, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x07, 0x12, 0x00, 0x02, 0xCE, + 0x18, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6C, 0x2D, 0x66, + 0x6F, 0x72, 0x6D, 0x2D, 0x65, 0x6E, 0x74, 0x72, 0x79, 0xDA, 0x18, 0xCE, 0x12, 0x20, 0x20, 0x20, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x0A, 0xDA, + 0x81, 0x12, 0xCE, 0x05, 0x20, 0x20, 0x20, 0x20, 0x28, 0xCE, 0x07, 0x20, 0x2E, 0x2E, 0x2E, 0x29, + 0x0A, 0x0A, 0xCE, 0x33, 0x20, 0x20, 0x20, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, + 0x73, 0x3A, 0x2F, 0x2F, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x2E, 0x6F, + 0x72, 0x67, 0x2F, 0x64, 0x6F, 0x63, 0x73, 0x2F, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6C, 0x73, + 0x2E, 0x68, 0x74, 0x6D, 0x6C, 0x0A, 0x0A, 0xCE, 0x02, 0x0A, 0x0A, 0xDA, 0x83, 0xBD, 0x00, 0x12, + 0x00, 0xDA, 0x1E, 0x00, 0x12, 0x01, 0xCF, 0x18, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x61, 0x6C, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x2D, 0x65, 0x6E, 0x74, 0x72, 0x79, + 0x2C, 0x02, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x2C, 0x03, 0x02, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x33, 0x03, 0x00, 0x04, 0x2C, 0x04, 0x01, 0x00, + 0x35, 0x03, 0x04, 0x00, 0x2C, 0x04, 0x04, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, + 0x35, 0x04, 0x05, 0x00, 0x2C, 0x05, 0x05, 0x00, 0x33, 0x05, 0x02, 0x03, 0x31, 0x04, 0x00, 0x00, + 0x2C, 0x05, 0x06, 0x00, 0x36, 0x05, 0x00, 0x00, 0x8D, 0x77, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x01, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x0A, 0xBF, 0xFD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x81, + 0x12, 0xDA, 0x87, 0x59, 0xDA, 0x87, 0x5F, 0xDA, 0x08, 0xDA, 0x03, 0xD0, 0x04, 0x6B, 0x69, 0x6E, + 0x64, 0xD0, 0x06, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x10, 0x01, 0x01, 0x01, 0x15, 0x7E, 0x00, 0x0A, 0xCE, 0x12, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2D, + 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2D, 0x65, 0x6E, 0x74, 0x72, 0x79, 0xDA, 0x18, 0xDA, 0x82, + 0xCE, 0xDA, 0x61, 0xDA, 0x65, 0xD0, 0x03, 0x76, 0x61, 0x72, 0xCE, 0x02, 0x20, 0x28, 0xCE, 0x01, + 0x29, 0xDA, 0x81, 0x12, 0xDA, 0x37, 0xDA, 0x89, 0x0E, 0xDA, 0x89, 0x0D, 0xDA, 0x06, 0xCE, 0x04, + 0x20, 0x20, 0x20, 0x20, 0xDA, 0x82, 0x5C, 0xDA, 0x03, 0xDA, 0x08, 0xCE, 0x09, 0x20, 0x6F, 0x6E, + 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0xDA, 0x85, 0x4F, 0xDA, 0x81, 0xE8, 0xCE, 0x1D, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x6E, 0x6F, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x0A, 0xDA, 0x89, 0x0B, 0xDA, 0x83, + 0xBD, 0x00, 0x7E, 0x00, 0xDA, 0x1E, 0x00, 0x7E, 0x01, 0xCF, 0x12, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0x2D, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2D, 0x65, 0x6E, 0x74, 0x72, 0x79, 0x48, 0x7E, 0x02, + 0xCF, 0x09, 0x62, 0x69, 0x6E, 0x64, 0x2D, 0x74, 0x79, 0x70, 0x65, 0x4C, 0x7E, 0x05, 0xCF, 0x02, + 0x73, 0x6D, 0x50, 0x7E, 0x07, 0xDA, 0x82, 0x70, 0x50, 0x6D, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x46, 0x53, 0x6A, 0x0A, 0xDA, 0x84, 0xC3, 0x55, 0x6A, 0x0B, 0xDA, 0x82, 0x66, + 0x57, 0x6A, 0x0C, 0xDA, 0x85, 0xAC, 0x57, 0x5C, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x47, 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x1E, 0x03, + 0x0B, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x31, 0x04, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x2B, 0x06, + 0x00, 0x00, 0x3A, 0x05, 0x04, 0x06, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x04, + 0x06, 0x00, 0x1B, 0x02, 0x04, 0x00, 0x1C, 0x36, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x31, 0x05, + 0x00, 0x00, 0x35, 0x05, 0x00, 0x00, 0x1E, 0x05, 0x12, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x35, 0x06, 0x00, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x3A, 0x07, 0x06, 0x08, 0x31, 0x07, + 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x35, 0x06, 0x08, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x2C, 0x08, + 0x04, 0x00, 0x33, 0x07, 0x08, 0x06, 0x2C, 0x07, 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x08, + 0x06, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x04, 0x07, 0x00, 0x1C, 0x20, 0x00, 0x00, 0x2C, 0x07, + 0x07, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x07, 0x00, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x2C, 0x06, + 0x07, 0x00, 0x1C, 0x19, 0x00, 0x00, 0x2C, 0x09, 0x08, 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x09, + 0x00, 0x00, 0x1E, 0x09, 0x0D, 0x00, 0x2C, 0x0A, 0x09, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0A, + 0x00, 0x00, 0x2C, 0x0B, 0x08, 0x00, 0x2C, 0x0C, 0x04, 0x00, 0x33, 0x0B, 0x0C, 0x0A, 0x2C, 0x0B, + 0x05, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x08, + 0x0B, 0x00, 0x1C, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x0A, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0A, + 0x00, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x02, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x08, + 0x0B, 0x00, 0x1B, 0x06, 0x08, 0x00, 0x1B, 0x04, 0x06, 0x00, 0x1B, 0x02, 0x04, 0x00, 0x2C, 0x03, + 0x0B, 0x00, 0x2C, 0x04, 0x0C, 0x00, 0x33, 0x03, 0x02, 0x04, 0x2C, 0x04, 0x06, 0x00, 0x35, 0x03, + 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x0D, 0x00, 0x31, 0x04, 0x00, 0x00, 0x35, 0x04, + 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2C, 0x06, 0x0E, 0x00, 0x31, 0x06, 0x00, 0x00, 0x35, 0x06, + 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x05, 0x1B, 0x00, 0x3D, 0x09, 0x05, 0x00, 0x1B, 0x0A, + 0x09, 0x00, 0x3D, 0x09, 0x05, 0x01, 0x1B, 0x0B, 0x09, 0x00, 0x3D, 0x09, 0x05, 0x02, 0x1B, 0x0C, + 0x09, 0x00, 0x1E, 0x0B, 0x03, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0D, + 0x0B, 0x00, 0x1E, 0x0D, 0x09, 0x00, 0x2C, 0x0E, 0x0F, 0x00, 0x2C, 0x0F, 0x10, 0x00, 0x33, 0x0E, + 0x0B, 0x0F, 0x31, 0x0C, 0x00, 0x00, 0x2C, 0x0F, 0x06, 0x00, 0x35, 0x0E, 0x0F, 0x00, 0x1B, 0x09, + 0x0E, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x09, 0x00, 0x00, 0x2C, 0x0D, 0x0B, 0x00, 0x33, 0x0D, + 0x0A, 0x09, 0x2C, 0x0E, 0x06, 0x00, 0x35, 0x0D, 0x0E, 0x00, 0x1B, 0x08, 0x0D, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x28, 0x08, 0x00, 0x00, 0x1E, 0x05, 0x03, 0x00, 0x2C, 0x09, 0x0C, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x28, 0x09, 0x00, 0x00, 0x1E, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0C, + 0x11, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x0A, 0x0B, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x0A, + 0x12, 0x00, 0x2C, 0x0B, 0x13, 0x00, 0x33, 0x0B, 0x02, 0x08, 0x2C, 0x0B, 0x0C, 0x00, 0x33, 0x09, + 0x0A, 0x0B, 0x2C, 0x0B, 0x14, 0x00, 0x36, 0x0B, 0x00, 0x00, 0x8D, 0x64, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0xBF, 0xFF, 0x0D, 0x01, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x20, 0x00, 0x20, 0x00, 0x1A, + 0x00, 0x1A, 0x00, 0x1A, 0xBF, 0xFF, 0x0D, 0x00, 0x0D, 0x02, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, + 0xFE, 0x0D, 0x02, 0x34, 0x00, 0x34, 0x00, 0x34, 0x00, 0x30, 0x00, 0x30, 0x00, 0x2A, 0x00, 0x2A, + 0x00, 0x2A, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, + 0xBF, 0xFE, 0x0D, 0x00, 0x0D, 0x03, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFD, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x04, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFC, 0x0D, 0x04, 0x30, 0x00, 0x30, 0x00, + 0x30, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0xBF, + 0xFC, 0x0D, 0x00, 0x0D, 0x05, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0xBF, 0xFB, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x09, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x03, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x01, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x20, 0x00, + 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x20, 0x00, 0x20, 0x00, + 0x20, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFF, 0x0A, 0x00, 0x0A, 0x00, 0x0A, + 0x02, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x01, 0x0A, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0xBF, 0xFB, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xCE, 0x07, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0xCE, 0x0B, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, 0x83, 0xBD, 0xDA, 0x80, 0xA0, 0x00, + 0x45, 0x00, 0xDA, 0x69, 0x00, 0x45, 0x01, 0xDA, 0x88, 0xE1, 0x0C, 0x41, 0x04, 0xDA, 0x1E, 0x20, + 0x3E, 0x08, 0xDA, 0x87, 0xB4, 0x22, 0x3E, 0x09, 0xDA, 0x87, 0xB2, 0x25, 0x3E, 0x07, 0xCF, 0x07, + 0x6D, 0x6F, 0x64, 0x2D, 0x65, 0x6E, 0x76, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x1E, 0x02, 0x05, 0x00, 0x30, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x1E, 0x00, 0x39, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, + 0x05, 0x03, 0x00, 0x35, 0x03, 0x05, 0x00, 0x1E, 0x03, 0x2E, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x32, + 0x00, 0x05, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x04, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x36, 0x06, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x07, 0x07, 0x00, 0x35, 0x06, 0x07, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x08, 0x00, 0x35, + 0x07, 0x08, 0x00, 0x3D, 0x06, 0x07, 0x00, 0x1B, 0x08, 0x06, 0x00, 0x3D, 0x06, 0x07, 0x01, 0x1B, + 0x09, 0x06, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x3A, 0x06, 0x07, 0x08, 0x1B, 0x07, 0x06, 0x00, 0x1E, + 0x06, 0x13, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x33, 0x08, 0x0A, 0x0B, 0x45, + 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x0A, 0x00, 0x3A, 0x0B, 0x07, 0x0C, 0x2C, 0x0C, 0x0B, 0x00, 0x2C, + 0x0D, 0x0C, 0x00, 0x33, 0x0C, 0x0A, 0x0D, 0x2C, 0x0C, 0x0D, 0x00, 0x29, 0x0D, 0x00, 0x00, 0x33, + 0x09, 0x0C, 0x0D, 0x2C, 0x0C, 0x0A, 0x00, 0x32, 0x0C, 0x0B, 0x00, 0x43, 0x0A, 0x00, 0x00, 0x31, + 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x0E, 0x00, 0x36, 0x0B, 0x00, 0x00, 0x2C, 0x0A, 0x0F, 0x00, 0x2C, + 0x0B, 0x10, 0x00, 0x33, 0x0A, 0x00, 0x0B, 0x2C, 0x0A, 0x11, 0x00, 0x36, 0x0A, 0x00, 0x00, 0x31, + 0x04, 0x00, 0x00, 0x2C, 0x05, 0x0E, 0x00, 0x36, 0x05, 0x00, 0x00, 0x2C, 0x03, 0x12, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x02, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x03, 0xDA, 0x18, 0xDA, 0x83, 0xB8, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x69, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0xE1, 0x00, 0x04, 0x00, 0xDA, 0x1E, 0x2D, + 0x01, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0xBF, + 0xFF, 0x8D, 0x81, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x8D, 0x80, 0x05, 0x00, 0x05, 0x00, + 0x05, 0xBF, 0xFF, 0x03, 0x02, 0x12, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x06, + 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x01, + 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x02, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x02, + 0x33, 0x00, 0x33, 0x00, 0x33, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0x00, 0x0D, 0x01, 0x1E, 0x00, 0x1E, 0x00, 0x0D, 0x00, 0x0D, 0x03, 0x30, 0x00, 0x30, 0x00, + 0x30, 0x00, 0x30, 0x01, 0x29, 0x00, 0x29, 0xBF, 0xFD, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x04, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x03, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00, 0xCF, 0x03, 0x62, 0x6F, + 0x72, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x0E, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, + 0x00, 0x13, 0xCE, 0x03, 0x62, 0x6F, 0x72, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, + 0x02, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, + 0x02, 0x05, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x11, 0x03, 0x03, 0x04, 0x03, + 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x11, + 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, + 0x03, 0x00, 0x00, 0xCF, 0x06, 0x74, 0x72, 0x61, 0x63, 0x65, 0x76, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x15, 0x01, 0x01, 0x01, 0x15, 0x4C, 0x00, 0x0A, 0xCE, 0x06, 0x74, 0x72, 0x61, 0x63, + 0x65, 0x76, 0xDA, 0x18, 0xDA, 0x81, 0x06, 0xDA, 0x80, 0xFA, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0x00, + 0xDA, 0x85, 0xC9, 0xCE, 0x0A, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x5B, 0x25, 0x73, 0x5D, 0xDA, + 0x54, 0xCE, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, + 0x01, 0x01, 0x01, 0x01, 0x06, 0x00, 0x02, 0xCE, 0x04, 0x6E, 0x65, 0x67, 0x3F, 0xDA, 0x18, 0xDA, + 0x84, 0x58, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x04, 0x6E, 0x65, 0x67, 0x3F, + 0x2B, 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x26, 0x03, 0x02, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x83, 0x36, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, + 0x30, 0x00, 0x2D, 0x00, 0x2D, 0xDA, 0x85, 0xA3, 0xCE, 0x17, 0x20, 0x6F, 0x6E, 0x20, 0x6C, 0x69, + 0x6E, 0x65, 0x20, 0x25, 0x64, 0x2C, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x25, 0x64, + 0x3A, 0xCE, 0x07, 0x20, 0x25, 0x6A, 0x20, 0x69, 0x73, 0x20, 0xDA, 0x81, 0x12, 0xDA, 0x51, 0xDA, + 0x52, 0xDA, 0x80, 0x9F, 0xDA, 0x85, 0x4D, 0xDA, 0x84, 0x0C, 0xDA, 0x84, 0x0D, 0xDA, 0x85, 0x41, + 0xDA, 0x80, 0x9D, 0x00, 0x4C, 0x00, 0xDA, 0x1E, 0x00, 0x4C, 0x01, 0xDA, 0x89, 0x22, 0x09, 0x4C, + 0x04, 0xDA, 0x85, 0xF9, 0x0B, 0x4C, 0x05, 0xDA, 0x82, 0x11, 0x10, 0x4C, 0x06, 0xCF, 0x02, 0x63, + 0x66, 0x19, 0x4C, 0x08, 0xCF, 0x05, 0x66, 0x6D, 0x74, 0x2D, 0x31, 0x1D, 0x25, 0x0B, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x4F, 0x2D, 0x4C, 0x0A, 0xCF, 0x05, 0x66, 0x6D, 0x74, 0x2D, + 0x32, 0x32, 0x4C, 0x0C, 0xDA, 0x81, 0x41, 0x35, 0x4C, 0x0E, 0xDA, 0x49, 0x2C, 0x02, 0x00, 0x00, + 0x2C, 0x03, 0x01, 0x00, 0x32, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x35, 0x03, 0x04, 0x00, 0x3D, 0x02, 0x03, 0x00, + 0x1B, 0x04, 0x02, 0x00, 0x3D, 0x02, 0x03, 0x01, 0x1B, 0x05, 0x02, 0x00, 0x2C, 0x02, 0x04, 0x00, + 0x31, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x02, 0x06, 0x00, 0x1B, 0x06, 0x02, 0x00, + 0x1E, 0x06, 0x07, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x32, 0x08, 0x06, 0x00, 0x2C, 0x09, 0x06, 0x00, + 0x35, 0x08, 0x09, 0x00, 0x1B, 0x07, 0x08, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x07, 0x07, 0x00, + 0x1B, 0x08, 0x07, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x0B, 0x08, 0x00, 0x35, 0x0A, 0x0B, 0x00, + 0x1B, 0x0B, 0x0A, 0x00, 0x1E, 0x0B, 0x03, 0x00, 0x1B, 0x0A, 0x0B, 0x00, 0x1C, 0x05, 0x00, 0x00, + 0x31, 0x05, 0x00, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1B, 0x0A, 0x0C, 0x00, + 0x1E, 0x0A, 0x03, 0x00, 0x2C, 0x09, 0x09, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x0B, 0x0A, 0x00, + 0x33, 0x0B, 0x04, 0x05, 0x2C, 0x0C, 0x06, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x09, 0x0B, 0x00, + 0x1B, 0x0A, 0x09, 0x00, 0x2C, 0x0B, 0x0B, 0x00, 0x33, 0x08, 0x0A, 0x0B, 0x2C, 0x0C, 0x0C, 0x00, + 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x2C, 0x0E, 0x0D, 0x00, 0x35, 0x0D, 0x0E, 0x00, + 0x1B, 0x0E, 0x0D, 0x00, 0x2C, 0x10, 0x0E, 0x00, 0x33, 0x10, 0x0E, 0x00, 0x45, 0x0F, 0x00, 0x00, + 0x2C, 0x11, 0x0F, 0x00, 0x32, 0x11, 0x00, 0x00, 0x45, 0x10, 0x00, 0x00, 0x2C, 0x12, 0x10, 0x00, + 0x33, 0x12, 0x0C, 0x10, 0x45, 0x11, 0x00, 0x00, 0x2C, 0x12, 0x02, 0x00, 0x2C, 0x13, 0x11, 0x00, + 0x2C, 0x14, 0x12, 0x00, 0x33, 0x12, 0x13, 0x14, 0x45, 0x10, 0x00, 0x00, 0x2C, 0x13, 0x13, 0x00, + 0x33, 0x13, 0x10, 0x0E, 0x45, 0x12, 0x00, 0x00, 0x2C, 0x13, 0x14, 0x00, 0x33, 0x13, 0x0F, 0x11, + 0x32, 0x12, 0x0E, 0x00, 0x45, 0x10, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x84, 0xEE, 0x1F, 0x00, + 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, + 0x0E, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, + 0x03, 0x01, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, + 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x2D, 0x00, + 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xD8, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, + 0x2D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xCF, 0x05, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDA, 0x80, + 0xF5, 0xCF, 0x07, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xD0, 0x06, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x00, 0x06, + 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x89, 0x33, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, + 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, + 0x00, 0x64, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0xCF, 0x03, 0x2D, + 0x3E, 0x3E, 0xD7, 0x00, 0xCD, 0x00, 0xFD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x01, 0x05, 0x00, 0x01, 0x04, 0xCE, 0x03, 0x2D, 0x3E, 0x3E, 0xDA, 0x18, 0xDA, 0x81, 0x92, + 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, 0xDA, 0x81, 0x9A, 0x00, 0x05, 0x02, 0xDA, 0x89, + 0x37, 0x01, 0x05, 0x04, 0xDA, 0x81, 0x9B, 0x30, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x33, + 0x04, 0x00, 0x01, 0x2C, 0x05, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0A, 0x02, 0x02, 0x02, 0x06, 0x25, 0x00, 0x06, 0xDA, 0x81, 0x9C, 0xDA, 0x18, 0xDA, 0x65, 0xDA, + 0x80, 0xA3, 0xDA, 0x81, 0x9D, 0xDA, 0x80, 0xE7, 0xDA, 0x80, 0xE3, 0xDA, 0x81, 0x08, 0x00, 0x25, + 0x00, 0xDA, 0x80, 0xE4, 0x00, 0x25, 0x01, 0xDA, 0x81, 0x9E, 0x00, 0x25, 0x02, 0xDA, 0x81, 0x9B, + 0x17, 0x25, 0x05, 0xDA, 0x81, 0x0B, 0x19, 0x25, 0x06, 0xDA, 0x80, 0xDB, 0x21, 0x25, 0x04, 0xDA, + 0x81, 0x9F, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, + 0x01, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x0C, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3A, 0x04, + 0x01, 0x06, 0x2B, 0x06, 0x01, 0x00, 0x32, 0x01, 0x06, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, + 0x07, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x03, + 0x07, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x32, 0x01, 0x04, 0x00, 0x2C, 0x07, + 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x03, 0x06, 0x00, 0x3D, 0x04, 0x03, 0x00, 0x1B, 0x05, + 0x04, 0x00, 0x3D, 0x04, 0x03, 0x01, 0x1B, 0x06, 0x04, 0x00, 0x31, 0x05, 0x00, 0x00, 0x40, 0x04, + 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x40, 0x07, 0x00, 0x00, 0x33, 0x04, 0x06, 0x07, 0x2C, 0x09, + 0x04, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x32, 0x01, 0x04, 0x00, 0x2C, 0x07, + 0x05, 0x00, 0x36, 0x07, 0x00, 0x00, 0x85, 0x24, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x14, 0x00, + 0x14, 0x00, 0x10, 0x01, 0x19, 0x00, 0x19, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x12, 0xBF, 0xFE, 0x10, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x85, 0x23, 0x03, 0x00, 0x03, 0x06, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0C, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0xD8, 0x0C, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0xCF, 0x09, 0x65, 0x76, 0x2F, 0x63, + 0x61, 0x6E, 0x63, 0x65, 0x6C, 0xD8, 0x09, 0x65, 0x76, 0x2F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, + 0xDA, 0x21, 0xDA, 0x1C, 0xCF, 0x11, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, 0x65, 0x61, 0x6B, + 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0xD8, 0x11, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, + 0x65, 0x61, 0x6B, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0xCF, 0x05, 0x61, 0x73, 0x3F, 0x2D, + 0x3E, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x07, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, + 0x03, 0x07, 0x00, 0x02, 0x05, 0xCE, 0x05, 0x61, 0x73, 0x3F, 0x2D, 0x3E, 0xDA, 0x18, 0xDA, 0x51, + 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x01, 0x07, 0x00, 0x01, 0x03, + 0xCE, 0x08, 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x18, 0xDA, 0x82, 0xBC, 0x00, + 0x07, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x07, 0x01, 0xDA, 0x81, 0x8B, 0x00, 0x07, 0x02, 0xCF, 0x08, + 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 0x2E, 0x02, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, + 0x32, 0x03, 0x01, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x31, 0x04, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x01, 0x01, 0x01, 0x00, 0x04, 0x01, + 0x04, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, + 0x8B, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x89, 0x45, 0x00, 0x04, 0x00, 0xDA, 0x1E, 0x2D, 0x01, 0x00, + 0x00, 0x32, 0x01, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x02, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x85, + 0x67, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x85, 0x63, 0x01, 0x04, 0x0C, 0x00, 0x06, 0x00, + 0x06, 0x00, 0x06, 0x00, 0x03, 0x00, 0x03, 0x05, 0x00, 0x00, 0x00, 0xDA, 0x80, 0x86, 0x00, 0x07, + 0x00, 0xDA, 0x1E, 0x00, 0x07, 0x01, 0xCF, 0x02, 0x61, 0x73, 0x00, 0x07, 0x02, 0xDA, 0x81, 0x9A, + 0x00, 0x07, 0x03, 0xDA, 0x89, 0x40, 0x00, 0x07, 0x04, 0xCF, 0x04, 0x70, 0x72, 0x65, 0x76, 0x1B, + 0x04, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x02, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x30, + 0x05, 0x01, 0x00, 0x35, 0x05, 0x05, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x03, 0x01, 0x01, 0x01, 0x00, 0x06, 0x01, 0x06, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x89, 0x46, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x9A, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x89, 0x40, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x89, 0x47, 0x00, 0x06, 0x00, 0xDA, + 0x80, 0xD9, 0x2D, 0x02, 0x00, 0x01, 0x25, 0x01, 0x00, 0x02, 0x1E, 0x01, 0x03, 0x00, 0x2D, 0x02, + 0x00, 0x08, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x85, 0x83, 0x2A, 0x00, + 0x2A, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x07, 0x00, + 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x1C, 0x01, 0x01, 0x05, 0xCE, 0x06, 0x5F, 0x77, 0x68, + 0x69, 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x89, 0x43, 0xDA, 0x80, 0x86, 0xBF, 0xFF, 0x00, + 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x59, 0xBF, 0xFF, 0x00, 0x06, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x58, 0x06, 0x1C, 0x01, 0xDA, 0x81, 0x8B, 0x09, 0x1C, 0x02, + 0xDA, 0x69, 0x0E, 0x1C, 0x00, 0xCF, 0x09, 0x6E, 0x65, 0x78, 0x74, 0x2D, 0x70, 0x72, 0x65, 0x76, + 0x2D, 0x00, 0x00, 0x06, 0x20, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x02, + 0x2D, 0x02, 0x00, 0x06, 0x3A, 0x00, 0x01, 0x02, 0x1B, 0x01, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, + 0x35, 0x00, 0x02, 0x00, 0x1B, 0x02, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, + 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x04, + 0x32, 0x02, 0x04, 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x33, 0x05, 0x03, 0x00, + 0x45, 0x04, 0x00, 0x00, 0x2F, 0x04, 0x00, 0x04, 0x2D, 0x05, 0x00, 0x02, 0x2D, 0x06, 0x00, 0x06, + 0x49, 0x03, 0x05, 0x06, 0x2F, 0x03, 0x00, 0x06, 0x2E, 0x05, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, + 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x06, 0x02, 0x08, 0xDA, + 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x89, 0x46, 0xBF, 0xFF, + 0x00, 0x02, 0xDA, 0x81, 0x9A, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x89, 0x40, 0xBF, 0xFF, 0x00, 0x04, + 0xDA, 0x89, 0x47, 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x81, 0x8B, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x69, + 0x00, 0x06, 0x00, 0xDA, 0x80, 0xD9, 0x2D, 0x02, 0x00, 0x01, 0x25, 0x01, 0x00, 0x02, 0x1E, 0x01, + 0x03, 0x00, 0x2D, 0x02, 0x01, 0x02, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xBF, + 0xFF, 0x85, 0x83, 0x2A, 0x00, 0x2A, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x85, 0x81, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0E, 0x00, + 0x0E, 0x00, 0x05, 0x01, 0x1E, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0x01, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFD, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x85, 0x80, 0x03, 0x01, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xF9, 0x01, 0x56, 0x01, 0x00, 0x00, + 0xCF, 0x06, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x66, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, + 0x03, 0x02, 0x03, 0x01, 0x06, 0x00, 0x04, 0xCE, 0x06, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x66, 0xDA, + 0x18, 0xDA, 0x84, 0x3D, 0x00, 0x06, 0x00, 0xCF, 0x03, 0x63, 0x6E, 0x64, 0x00, 0x06, 0x01, 0xDA, + 0x81, 0x23, 0x00, 0x06, 0x02, 0xCF, 0x04, 0x66, 0x61, 0x6C, 0x73, 0x00, 0x06, 0x03, 0xDA, 0x89, + 0x4C, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x02, + 0x00, 0x03, 0x01, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x8A, 0xB7, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x77, 0x68, 0x65, 0x6E, + 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, + 0x0A, 0x00, 0x03, 0xCE, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x77, 0x68, 0x65, 0x6E, 0xDA, 0x18, 0xDA, + 0x84, 0x3D, 0xDA, 0x80, 0x9D, 0x00, 0x0A, 0x00, 0xDA, 0x89, 0x4F, 0x00, 0x0A, 0x01, 0xDA, 0x81, + 0x74, 0x00, 0x0A, 0x02, 0xDA, 0x89, 0x51, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, + 0x03, 0x04, 0x00, 0x1E, 0x03, 0x06, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x31, 0x05, 0x00, 0x00, 0x34, + 0x01, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8A, + 0xBE, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0xBF, 0xFF, 0x03, 0xCF, 0x0D, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2F, 0x73, + 0x6C, 0x69, 0x63, 0x65, 0xD8, 0x0D, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2F, 0x73, 0x6C, + 0x69, 0x63, 0x65, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xDA, + 0x84, 0xC2, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x6D, 0x6B, 0x64, 0x69, 0x72, 0xD8, 0x08, 0x6F, 0x73, + 0x2F, 0x6D, 0x6B, 0x64, 0x69, 0x72, 0xCF, 0x03, 0x2D, 0x3F, 0x3E, 0xD7, 0x00, 0xCD, 0x00, 0xFD, + 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x05, 0x00, 0x01, 0x04, 0xCE, + 0x03, 0x2D, 0x3F, 0x3E, 0xDA, 0x18, 0xDA, 0x81, 0x92, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, + 0x01, 0xDA, 0x81, 0x9A, 0x00, 0x05, 0x02, 0xDA, 0x89, 0x59, 0x01, 0x05, 0x04, 0xDA, 0x81, 0x9B, + 0x30, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x33, 0x04, 0x00, 0x01, 0x2C, 0x05, 0x00, 0x00, + 0x36, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x02, 0x02, 0x02, 0x09, 0x2F, 0x00, + 0x07, 0xDA, 0x81, 0x9C, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x80, 0xA3, 0xDA, 0x81, 0x9D, 0xDA, 0x80, + 0xE7, 0xDA, 0x51, 0xDA, 0x80, 0xE3, 0xDA, 0x81, 0x08, 0xDA, 0x57, 0xDA, 0x81, 0x73, 0x00, 0x2F, + 0x00, 0xDA, 0x80, 0xE4, 0x00, 0x2F, 0x01, 0xDA, 0x81, 0x9E, 0x00, 0x2F, 0x02, 0xDA, 0x81, 0x9B, + 0x17, 0x2F, 0x05, 0xDA, 0x81, 0x0B, 0x19, 0x2F, 0x06, 0xDA, 0x80, 0xDB, 0x1C, 0x2F, 0x07, 0xDA, + 0x69, 0x22, 0x2F, 0x08, 0xDA, 0x81, 0x9F, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, + 0x04, 0x05, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x0C, 0x00, 0x2B, + 0x06, 0x00, 0x00, 0x3A, 0x04, 0x01, 0x06, 0x2B, 0x06, 0x01, 0x00, 0x32, 0x01, 0x06, 0x00, 0x2C, + 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x32, 0x04, 0x06, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, + 0x07, 0x08, 0x00, 0x1B, 0x03, 0x07, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x32, + 0x01, 0x04, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x03, 0x06, 0x00, 0x3D, + 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3D, 0x04, 0x03, 0x01, 0x1B, 0x06, 0x04, 0x00, 0x2C, + 0x07, 0x04, 0x00, 0x35, 0x04, 0x07, 0x00, 0x1B, 0x07, 0x04, 0x00, 0x32, 0x05, 0x07, 0x00, 0x40, + 0x08, 0x00, 0x00, 0x32, 0x08, 0x06, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, + 0x08, 0x09, 0x00, 0x32, 0x07, 0x00, 0x00, 0x46, 0x0A, 0x00, 0x00, 0x32, 0x01, 0x08, 0x00, 0x2C, + 0x0C, 0x06, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x2C, 0x0D, 0x07, 0x00, 0x33, 0x0D, 0x07, 0x0B, 0x45, + 0x0C, 0x00, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x33, 0x0D, 0x0A, 0x0C, 0x45, 0x0B, 0x00, 0x00, 0x03, + 0x0B, 0x00, 0x00, 0x85, 0x33, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, + 0x01, 0x19, 0x00, 0x19, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x12, 0xBF, 0xFF, 0x10, 0x00, 0x10, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, + 0xFE, 0x10, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x0E, 0x00, 0x0E, 0x00, 0x05, + 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, + 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x85, 0x32, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, + 0x0E, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0xDA, + 0x87, 0xBA, 0xCF, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x73, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x0C, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x15, 0x00, 0x06, + 0xCE, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x73, 0xDA, 0x18, 0xD2, 0x01, 0x00, + 0xDA, 0x51, 0xDA, 0x80, 0xA8, 0xDA, 0x81, 0x73, 0x00, 0x15, 0x00, 0xDA, 0x88, 0xA0, 0x00, 0x15, + 0x01, 0xDA, 0x81, 0x74, 0x00, 0x15, 0x02, 0xDA, 0x89, 0x5D, 0x00, 0x15, 0x03, 0xDA, 0x80, 0xC3, + 0x02, 0x15, 0x05, 0xDA, 0x81, 0x25, 0x04, 0x15, 0x07, 0xDA, 0x81, 0x96, 0x2B, 0x03, 0x00, 0x00, + 0x3F, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x40, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, + 0x23, 0x08, 0x03, 0x05, 0x1E, 0x08, 0x08, 0x00, 0x3A, 0x09, 0x00, 0x03, 0x2C, 0x0A, 0x00, 0x00, + 0x33, 0x07, 0x09, 0x0A, 0x2C, 0x0B, 0x01, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x05, 0x03, 0x03, 0x01, + 0x1C, 0xF8, 0xFF, 0xFF, 0x34, 0x07, 0x00, 0x00, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x02, 0x00, + 0x32, 0x0A, 0x08, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x09, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00, + 0x81, 0x2E, 0x03, 0x01, 0x0C, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, + 0x17, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0xBF, 0xFE, 0x03, 0x03, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x07, 0x65, 0x78, + 0x74, 0x72, 0x65, 0x6D, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x02, 0x02, 0x02, + 0x00, 0x0F, 0x00, 0x07, 0xCE, 0x07, 0x65, 0x78, 0x74, 0x72, 0x65, 0x6D, 0x65, 0xDA, 0x18, 0x00, + 0x0F, 0x00, 0xCF, 0x05, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x00, 0x0F, 0x01, 0xDA, 0x80, 0xE8, 0x00, + 0x0F, 0x02, 0xDA, 0x89, 0x61, 0x00, 0x0F, 0x01, 0xDA, 0x24, 0x02, 0x0F, 0x04, 0xDA, 0x22, 0x04, + 0x0F, 0x05, 0xDA, 0x23, 0x08, 0x0E, 0x06, 0xDA, 0x1E, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, + 0x04, 0x1B, 0x04, 0x03, 0x00, 0x3B, 0x03, 0x01, 0x04, 0x1B, 0x05, 0x03, 0x00, 0x49, 0x04, 0x01, + 0x04, 0x1F, 0x04, 0x08, 0x00, 0x3A, 0x03, 0x01, 0x04, 0x1B, 0x06, 0x03, 0x00, 0x32, 0x06, 0x05, + 0x00, 0x35, 0x03, 0x00, 0x00, 0x1E, 0x03, 0x02, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x1C, 0xF8, 0xFF, + 0xFF, 0x03, 0x05, 0x00, 0x00, 0x82, 0xE1, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x10, 0x00, 0x10, 0xCF, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x74, 0x69, 0x6D, 0x65, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x03, 0x00, 0x02, 0xCE, 0x08, 0x63, + 0x6F, 0x6D, 0x70, 0x74, 0x69, 0x6D, 0x65, 0xDA, 0x18, 0xDA, 0x84, 0x3D, 0x00, 0x03, 0x00, 0xDA, + 0x1E, 0x00, 0x03, 0x01, 0xDA, 0x89, 0x65, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x36, + 0x02, 0x00, 0x00, 0x8A, 0xB2, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x06, 0x6C, 0x65, 0x6E, 0x67, + 0x74, 0x68, 0xDA, 0x88, 0xB7, 0xCF, 0x04, 0x68, 0x61, 0x73, 0x68, 0xD8, 0x04, 0x68, 0x61, 0x73, + 0x68, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, 0xD8, 0x09, 0x6D, 0x61, + 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0xDA, 0x84, 0x39, 0xCF, 0x0A, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, + 0x73, 0x74, 0x65, 0x70, 0xDA, 0x84, 0xCE, 0xCF, 0x04, 0x74, 0x68, 0x61, 0x77, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x01, 0x01, 0x0B, 0x2A, 0x00, 0x03, 0xCE, 0x04, 0x74, 0x68, + 0x61, 0x77, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x66, 0xDA, 0x82, 0xC3, 0xDA, 0x80, 0xA3, 0xDA, 0x80, + 0xCB, 0xD8, 0x13, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x2D, 0x66, + 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0xDA, 0x82, 0xBE, 0xDA, 0x80, 0xC9, 0xD8, 0x14, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x2F, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x2D, 0x66, 0x6C, 0x61, 0x74, 0x74, + 0x65, 0x6E, 0xDA, 0x83, 0x0B, 0xDA, 0x83, 0x01, 0x00, 0x2A, 0x00, 0xDA, 0x24, 0x00, 0x2A, 0x01, + 0xDA, 0x89, 0x6F, 0x04, 0x2A, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x67, 0x2E, + 0x01, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x04, 0x00, 0x32, + 0x01, 0x00, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x36, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x25, + 0x04, 0x03, 0x05, 0x1E, 0x04, 0x04, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x36, + 0x05, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x25, 0x05, 0x03, 0x06, 0x1E, 0x05, 0x07, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x35, 0x06, 0x07, 0x00, 0x32, 0x01, 0x06, 0x00, 0x2C, + 0x07, 0x06, 0x00, 0x36, 0x07, 0x00, 0x00, 0x2C, 0x07, 0x07, 0x00, 0x25, 0x06, 0x03, 0x07, 0x1E, + 0x06, 0x07, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x08, 0x00, 0x35, 0x07, 0x08, 0x00, 0x32, + 0x01, 0x07, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x36, 0x08, 0x00, 0x00, 0x2C, 0x08, 0x09, 0x00, 0x25, + 0x07, 0x03, 0x08, 0x1E, 0x07, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x36, + 0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x88, 0xAF, 0x01, 0x05, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFF, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFE, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x03, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFD, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x04, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x0D, 0xBF, 0xFC, 0x03, 0x00, 0x03, 0x00, 0x03, 0x05, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFB, + 0x03, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x72, 0x66, 0xD8, 0x08, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x65, 0x72, 0x66, 0xDA, 0x85, 0x7D, 0xDA, 0x85, 0x79, 0xCF, 0x0C, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD8, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xCF, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, + 0x72, 0x65, 0x61, 0x6B, 0xD8, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, + 0x6B, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x65, 0xD8, + 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x65, 0xDA, 0x67, 0xDA, + 0x63, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xD8, + 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xCF, 0x0E, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x84, 0xEF, + 0xCF, 0x0D, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xCE, + 0x06, 0x31, 0x2E, 0x33, 0x34, 0x2E, 0x30, 0xCF, 0x0F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, + 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xD8, 0x0F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xDA, 0x85, 0xFF, 0xDA, 0x85, 0xFD, 0xDA, + 0x89, 0x45, 0xDA, 0x89, 0x43, 0xCF, 0x03, 0x64, 0x6F, 0x63, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x05, 0x01, 0x00, 0x01, 0x02, 0x07, 0x00, 0x02, 0xCE, 0x03, 0x64, 0x6F, 0x63, 0xDA, 0x18, + 0xDA, 0x80, 0x9F, 0xDA, 0x88, 0xE2, 0x00, 0x07, 0x00, 0xDA, 0x69, 0x00, 0x07, 0x01, 0xDA, 0x89, + 0x84, 0x2C, 0x03, 0x00, 0x00, 0x32, 0x03, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x32, 0x04, 0x02, 0x00, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x8D, 0x9D, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x85, 0xBA, 0xDA, + 0x85, 0xA0, 0xCF, 0x14, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, 0x70, 0x72, 0x6F, 0x74, 0x6F, + 0x2D, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0xDA, 0x89, 0x73, 0xCF, 0x09, 0x64, 0x65, 0x66, + 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x05, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x03, 0xCE, 0x09, 0x64, 0x65, 0x66, 0x6D, 0x61, + 0x63, 0x72, 0x6F, 0x2D, 0xDA, 0x18, 0xDA, 0x37, 0xDA, 0x62, 0xDA, 0x82, 0xFE, 0x00, 0x06, 0x00, + 0xDA, 0x81, 0xBE, 0x00, 0x06, 0x01, 0xDA, 0x81, 0xBF, 0x00, 0x06, 0x02, 0xDA, 0x89, 0x88, 0x2C, + 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, 0x00, 0x03, 0x04, 0x34, 0x01, 0x00, 0x00, 0x2C, + 0x03, 0x02, 0x00, 0x36, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xCF, 0x06, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x05, 0x02, 0x01, 0x02, 0x02, 0x06, 0x00, 0x03, 0xCE, 0x06, 0x73, 0x6F, 0x72, 0x74, + 0x65, 0x64, 0xDA, 0x18, 0xDA, 0x81, 0x9D, 0xDA, 0x88, 0x5E, 0x00, 0x06, 0x00, 0xDA, 0x1F, 0x00, + 0x06, 0x01, 0xDA, 0x88, 0x69, 0x00, 0x06, 0x02, 0xDA, 0x89, 0x8B, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x32, 0x03, 0x01, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, + 0x04, 0x00, 0x00, 0x83, 0x7A, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0xDA, 0x88, 0xF4, 0xDA, 0x88, 0xE6, 0xCF, 0x0B, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, + 0x72, 0x79, 0x3F, 0xDA, 0x87, 0xEF, 0xDA, 0x81, 0x0A, 0xDA, 0x81, 0x08, 0xCF, 0x07, 0x2A, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x2A, 0xDA, 0x85, 0x8D, 0xDA, 0x88, 0xFB, 0xDA, 0x88, 0xF5, 0xCF, 0x08, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0xDA, 0x88, 0xFC, 0xCF, 0x13, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6C, 0x74, 0x2D, 0x70, 0x65, 0x67, 0x2D, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, + 0xD3, 0x1E, 0xD0, 0x02, 0x73, 0x2A, 0xD2, 0x02, 0x00, 0xCF, 0x03, 0x61, 0x6E, 0x79, 0xD0, 0x01, + 0x73, 0xD0, 0x02, 0x73, 0x2B, 0xD2, 0x02, 0x00, 0xCF, 0x04, 0x73, 0x6F, 0x6D, 0x65, 0xDA, 0x89, + 0x95, 0xD0, 0x01, 0x61, 0xD2, 0x03, 0x00, 0xCF, 0x05, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xCE, 0x02, + 0x61, 0x7A, 0xCE, 0x02, 0x41, 0x5A, 0xD0, 0x02, 0x77, 0x2B, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x98, + 0xD0, 0x01, 0x77, 0xD0, 0x02, 0x77, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xDA, 0x89, 0xA0, + 0xD0, 0x01, 0x64, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x9B, 0xCE, 0x02, 0x30, 0x39, 0xD0, 0x01, 0x68, + 0xD2, 0x04, 0x00, 0xDA, 0x89, 0x9B, 0xDA, 0x89, 0xA5, 0xCE, 0x02, 0x61, 0x66, 0xCE, 0x02, 0x41, + 0x46, 0xD0, 0x02, 0x41, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xD0, 0x01, 0x41, 0xD0, 0x02, + 0x41, 0x2B, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, 0xAC, 0xD0, 0x02, 0x64, 0x2A, 0xD2, + 0x02, 0x00, 0xDA, 0x89, 0x94, 0xDA, 0x89, 0xA4, 0xD0, 0x02, 0x64, 0x2B, 0xD2, 0x02, 0x00, 0xDA, + 0x89, 0x98, 0xDA, 0x89, 0xA4, 0xD0, 0x02, 0x68, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xDA, + 0x89, 0xA7, 0xDA, 0x89, 0x95, 0xD2, 0x02, 0x00, 0xDA, 0x34, 0xCE, 0x07, 0x20, 0x09, 0x0D, 0x0A, + 0x00, 0x0C, 0x0B, 0xD0, 0x02, 0x68, 0x2B, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, 0xA7, + 0xDA, 0x89, 0xA0, 0xD2, 0x04, 0x00, 0xDA, 0x89, 0x9B, 0xDA, 0x89, 0x9C, 0xDA, 0x89, 0x9D, 0xDA, + 0x89, 0xA5, 0xD0, 0x02, 0x53, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xD0, 0x01, 0x53, 0xD0, + 0x02, 0x53, 0x2B, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, 0xBC, 0xDA, 0x89, 0xAC, 0xD2, + 0x03, 0x00, 0xDA, 0x87, 0xD2, 0xDA, 0x89, 0x9A, 0x01, 0xD0, 0x02, 0x57, 0x2B, 0xD2, 0x02, 0x00, + 0xDA, 0x89, 0x98, 0xD0, 0x01, 0x57, 0xD0, 0x02, 0x57, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, + 0xDA, 0x89, 0xC2, 0xD0, 0x01, 0x44, 0xD2, 0x03, 0x00, 0xDA, 0x87, 0xD2, 0xDA, 0x89, 0xA4, 0x01, + 0xD0, 0x01, 0x48, 0xD2, 0x03, 0x00, 0xDA, 0x87, 0xD2, 0xDA, 0x89, 0xA7, 0x01, 0xD0, 0x02, 0x61, + 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xDA, 0x89, 0x9A, 0xD0, 0x02, 0x61, 0x2B, 0xD2, 0x02, + 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, 0x9A, 0xD0, 0x02, 0x44, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, + 0x94, 0xDA, 0x89, 0xC6, 0xD0, 0x02, 0x44, 0x2B, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, + 0xC6, 0xD0, 0x02, 0x48, 0x2A, 0xD2, 0x02, 0x00, 0xDA, 0x89, 0x94, 0xDA, 0x89, 0xC8, 0xDA, 0x89, + 0xBC, 0xD2, 0x03, 0x00, 0xDA, 0x87, 0xD2, 0xDA, 0x89, 0x95, 0x01, 0xD0, 0x02, 0x48, 0x2B, 0xD2, + 0x02, 0x00, 0xDA, 0x89, 0x98, 0xDA, 0x89, 0xC8, 0xDA, 0x89, 0xC2, 0xD2, 0x03, 0x00, 0xDA, 0x87, + 0xD2, 0xDA, 0x89, 0xA0, 0x01, 0xCF, 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, + 0x74, 0xD8, 0x0A, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0xCF, 0x0A, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xCF, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x67, 0x65, 0x74, + 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xDA, 0x88, 0xEA, 0xCF, 0x06, 0x64, 0x6F, 0x63, 0x2D, 0x6F, 0x66, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x01, 0x01, 0x01, 0x07, 0x32, 0x00, 0x0E, 0xCE, + 0x06, 0x64, 0x6F, 0x63, 0x2D, 0x6F, 0x66, 0xDA, 0x18, 0xD2, 0x02, 0x00, 0xD2, 0x01, 0x00, 0xDA, + 0x00, 0xDA, 0x87, 0x5F, 0xDA, 0x61, 0xDA, 0x06, 0xDA, 0x89, 0x0F, 0xCE, 0x18, 0x64, 0x6F, 0x63, + 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0xDA, 0x89, 0x1D, 0xDA, 0x83, 0xBD, 0x00, 0x32, 0x00, 0xDA, 0x1E, + 0x00, 0x32, 0x01, 0xDA, 0x89, 0xDD, 0x00, 0x32, 0x02, 0xCF, 0x05, 0x66, 0x6F, 0x75, 0x6E, 0x64, + 0x01, 0x2B, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x4D, 0x04, 0x2B, 0x05, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x4C, 0x07, 0x2B, 0x06, 0xCF, 0x0A, 0x6D, 0x6F, 0x64, + 0x75, 0x6C, 0x65, 0x2D, 0x73, 0x65, 0x74, 0x07, 0x29, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x4B, 0x0A, 0x29, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x4A, 0x0D, + 0x29, 0x08, 0xDA, 0x68, 0x0D, 0x27, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x49, + 0x10, 0x27, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x48, 0x13, 0x27, 0x0A, 0xDA, + 0x25, 0x16, 0x1D, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x4E, 0x1D, 0x25, 0x0B, + 0xCF, 0x05, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2A, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x28, + 0x05, 0x00, 0x00, 0x49, 0x04, 0x03, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x1F, 0x05, 0x26, 0x00, 0x3A, + 0x04, 0x03, 0x05, 0x1B, 0x06, 0x04, 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, 0x04, 0x06, 0x07, 0x1B, + 0x07, 0x04, 0x00, 0x1F, 0x07, 0x1E, 0x00, 0x3A, 0x04, 0x06, 0x07, 0x1B, 0x08, 0x04, 0x00, 0x28, + 0x09, 0x00, 0x00, 0x49, 0x04, 0x08, 0x09, 0x1B, 0x09, 0x04, 0x00, 0x1F, 0x09, 0x16, 0x00, 0x3A, + 0x04, 0x08, 0x09, 0x1B, 0x0A, 0x04, 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x3B, 0x04, 0x0A, 0x0B, 0x1B, + 0x0B, 0x04, 0x00, 0x1E, 0x0B, 0x03, 0x00, 0x1B, 0x04, 0x0B, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, + 0x0D, 0x02, 0x00, 0x3B, 0x0C, 0x0A, 0x0D, 0x1B, 0x04, 0x0C, 0x00, 0x1B, 0x0B, 0x04, 0x00, 0x25, + 0x04, 0x0B, 0x00, 0x1E, 0x04, 0x06, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0D, 0x03, 0x00, 0x35, + 0x0C, 0x0D, 0x00, 0x29, 0x02, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x09, 0x08, 0x09, 0x1C, + 0xEB, 0xFF, 0xFF, 0x49, 0x07, 0x06, 0x07, 0x1C, 0xE3, 0xFF, 0xFF, 0x49, 0x05, 0x03, 0x05, 0x1C, + 0xDB, 0xFF, 0xFF, 0x1E, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x2C, + 0x04, 0x05, 0x00, 0x33, 0x03, 0x00, 0x04, 0x2C, 0x03, 0x06, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8D, + 0xA3, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x03, 0x15, 0x00, 0x15, 0x00, 0x11, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x26, 0x00, 0x26, 0x00, 0x11, 0x00, 0x05, 0x01, 0x0D, 0x00, 0x07, + 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x01, 0x09, 0xBF, 0xF9, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x08, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x81, 0x04, 0xDA, 0x80, 0xFD, 0xCF, 0x0B, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD8, 0x0B, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, + 0x63, 0x6C, 0x65, 0x61, 0x72, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x6C, 0x69, 0x6E, 0x6B, 0xD8, 0x07, + 0x6F, 0x73, 0x2F, 0x6C, 0x69, 0x6E, 0x6B, 0xCF, 0x08, 0x65, 0x76, 0x2F, 0x73, 0x6C, 0x65, 0x65, + 0x70, 0xD8, 0x08, 0x65, 0x76, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0xCF, 0x08, 0x66, 0x66, 0x69, + 0x2F, 0x66, 0x72, 0x65, 0x65, 0xD8, 0x08, 0x66, 0x66, 0x69, 0x2F, 0x66, 0x72, 0x65, 0x65, 0xCF, + 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0x68, 0xD8, 0x0A, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0x68, 0xDA, 0x85, 0xC6, 0xDA, 0x85, 0xC2, 0xCF, 0x06, 0x67, + 0x65, 0x6E, 0x73, 0x79, 0x6D, 0xDA, 0x51, 0xCF, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xDA, + 0x83, 0x01, 0xCF, 0x09, 0x76, 0x61, 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x08, 0x02, 0x02, 0x02, 0x03, 0x0D, 0x00, 0x04, 0xCE, 0x09, 0x76, 0x61, + 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xDA, 0x18, 0xDA, 0x87, 0x01, 0xDA, 0x61, 0xDA, 0x81, + 0x07, 0x00, 0x0D, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x0D, 0x01, 0xDA, 0x81, 0x94, 0x00, 0x0D, 0x02, + 0xDA, 0x89, 0xF9, 0x03, 0x0D, 0x04, 0xCF, 0x05, 0x6E, 0x61, 0x6D, 0x65, 0x2A, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x40, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x32, 0x06, 0x05, 0x00, 0x44, 0x05, 0x00, + 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x5E, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, 0x05, 0x2A, 0x65, + 0x72, 0x72, 0x2A, 0xD0, 0x03, 0x65, 0x72, 0x72, 0xCF, 0x05, 0x7A, 0x65, 0x72, 0x6F, 0x3F, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x01, 0x06, 0x00, 0x02, 0xCE, 0x05, + 0x7A, 0x65, 0x72, 0x6F, 0x3F, 0xDA, 0x18, 0xDA, 0x84, 0x58, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, + 0x06, 0x01, 0xDA, 0x89, 0xFF, 0x2B, 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x00, + 0x00, 0x35, 0x02, 0x03, 0x00, 0x26, 0x03, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, 0x83, 0x34, 0x2A, + 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x27, 0x00, 0x27, 0xCF, 0x09, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x81, 0x6B, 0xDA, 0x83, 0x90, 0xDA, 0x83, 0x8E, 0xCF, 0x09, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x62, 0x72, 0x74, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x63, 0x62, 0x72, 0x74, 0xCF, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, + 0x68, 0x2D, 0x61, 0x74, 0xD8, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, + 0x68, 0x2D, 0x61, 0x74, 0xCF, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, + 0x6B, 0xDA, 0x84, 0xAF, 0xCF, 0x10, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x61, 0x64, 0x64, + 0x2D, 0x70, 0x61, 0x74, 0x68, 0x73, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x15, 0x02, 0x02, + 0x02, 0x0E, 0x41, 0x00, 0x01, 0x09, 0xCE, 0x10, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x61, + 0x64, 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x73, 0xDA, 0x18, 0xDA, 0x87, 0x5B, 0xDA, 0x87, 0x5C, + 0xDA, 0x80, 0xFB, 0xCE, 0x06, 0x3A, 0x40, 0x61, 0x6C, 0x6C, 0x3A, 0xDA, 0x81, 0x12, 0xDA, 0x87, + 0x8E, 0xDA, 0x89, 0x7E, 0xCE, 0x06, 0x2E, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0xDA, 0x87, 0x83, 0xCE, + 0x05, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0xCE, 0x0B, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, + 0x6C, 0x6C, 0x3A, 0xDA, 0x87, 0x75, 0xCE, 0x0B, 0x3A, 0x63, 0x75, 0x72, 0x3A, 0x2F, 0x3A, 0x61, + 0x6C, 0x6C, 0x3A, 0xDA, 0x87, 0x69, 0x00, 0x41, 0x00, 0xCF, 0x03, 0x65, 0x78, 0x74, 0x00, 0x41, + 0x01, 0xCF, 0x06, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x00, 0x41, 0x02, 0xDA, 0x8A, 0x08, 0x05, + 0x41, 0x04, 0xDA, 0x87, 0xAF, 0x07, 0x41, 0x06, 0xCF, 0x0B, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x70, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x0B, 0x41, 0x08, 0xCF, 0x09, 0x64, 0x79, 0x6E, 0x2D, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x19, 0x41, 0x0B, 0xCF, 0x09, 0x61, 0x6C, 0x6C, 0x2D, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x27, 0x41, 0x0E, 0xCF, 0x09, 0x73, 0x79, 0x73, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x35, + 0x41, 0x11, 0xCF, 0x0C, 0x63, 0x75, 0x72, 0x61, 0x6C, 0x6C, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, + 0x2C, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x04, 0x02, 0x00, + 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x30, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, + 0x2C, 0x07, 0x03, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x07, 0x06, 0x00, 0x1B, 0x08, 0x07, 0x00, + 0x2C, 0x09, 0x03, 0x00, 0x32, 0x09, 0x00, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x35, 0x09, 0x0A, 0x00, + 0x2C, 0x0A, 0x05, 0x00, 0x33, 0x09, 0x01, 0x0A, 0x45, 0x09, 0x00, 0x00, 0x33, 0x04, 0x08, 0x09, + 0x2C, 0x0B, 0x06, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x2C, 0x09, 0x07, 0x00, 0x31, 0x09, 0x00, 0x00, + 0x35, 0x09, 0x06, 0x00, 0x1B, 0x0B, 0x09, 0x00, 0x2C, 0x0C, 0x07, 0x00, 0x32, 0x0C, 0x00, 0x00, + 0x2C, 0x0D, 0x04, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x33, 0x0C, 0x01, 0x0D, + 0x45, 0x0C, 0x00, 0x00, 0x33, 0x04, 0x0B, 0x0C, 0x2C, 0x0E, 0x06, 0x00, 0x35, 0x0D, 0x0E, 0x00, + 0x2C, 0x0C, 0x09, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x35, 0x0C, 0x06, 0x00, 0x1B, 0x0E, 0x0C, 0x00, + 0x2C, 0x0F, 0x0A, 0x00, 0x32, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x04, 0x00, 0x35, 0x0F, 0x10, 0x00, + 0x2C, 0x10, 0x0B, 0x00, 0x33, 0x0F, 0x01, 0x10, 0x45, 0x0F, 0x00, 0x00, 0x33, 0x04, 0x0E, 0x0F, + 0x2C, 0x11, 0x06, 0x00, 0x35, 0x10, 0x11, 0x00, 0x2C, 0x0F, 0x0C, 0x00, 0x31, 0x0F, 0x00, 0x00, + 0x35, 0x0F, 0x06, 0x00, 0x1B, 0x11, 0x0F, 0x00, 0x2C, 0x12, 0x0C, 0x00, 0x32, 0x12, 0x00, 0x00, + 0x2C, 0x13, 0x04, 0x00, 0x35, 0x12, 0x13, 0x00, 0x2C, 0x13, 0x0D, 0x00, 0x33, 0x12, 0x01, 0x13, + 0x45, 0x12, 0x00, 0x00, 0x33, 0x04, 0x11, 0x12, 0x2C, 0x14, 0x06, 0x00, 0x35, 0x13, 0x14, 0x00, + 0x03, 0x04, 0x00, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x01, 0x0A, 0x01, + 0x01, 0x07, 0xCE, 0x0B, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0xDA, + 0x18, 0xDA, 0x83, 0x79, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8A, 0x10, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x8A, 0x11, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8A, 0x08, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x87, 0xAF, + 0x00, 0x0A, 0x00, 0xCF, 0x03, 0x70, 0x72, 0x65, 0x00, 0x0A, 0x01, 0xDA, 0x8A, 0x12, 0x05, 0x0A, + 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x50, 0x30, 0x02, 0x00, 0x00, 0x2D, 0x03, + 0x00, 0x04, 0x32, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, + 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x03, 0x02, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, + 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x10, 0x01, + 0x04, 0xDA, 0x18, 0xDA, 0x85, 0xA7, 0xDA, 0x87, 0x11, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8A, 0x18, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8A, 0x12, 0x00, 0x10, 0x00, 0xCF, 0x09, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x51, 0x24, 0x30, 0x06, 0x10, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x52, 0x2B, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x01, 0x02, 0x00, 0x1E, 0x02, 0x08, + 0x00, 0x2B, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x2D, 0x04, 0x00, + 0x00, 0x32, 0x04, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x03, 0x01, 0x00, + 0x00, 0xBF, 0xFF, 0x8A, 0xF6, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x43, 0x00, 0x43, 0x00, 0x43, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, + 0x00, 0x2B, 0x00, 0x15, 0x8A, 0xF6, 0x15, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00, 0x8A, 0xF3, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x03, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1E, + 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x03, 0x01, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x03, 0x01, 0x22, 0x00, 0x22, 0x00, 0x22, + 0x00, 0x22, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xEC, + 0x01, 0x10, 0x00, 0x00, 0x00, 0xCF, 0x0C, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2F, 0x73, 0x6C, + 0x69, 0x63, 0x65, 0xD8, 0x0C, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2F, 0x73, 0x6C, 0x69, 0x63, + 0x65, 0xCF, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0xDA, 0x85, + 0x4B, 0xCF, 0x05, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x03, + 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x02, 0x00, 0x01, 0x02, 0xCE, 0x05, 0x6A, 0x75, + 0x78, 0x74, 0x2A, 0xDA, 0x18, 0x00, 0x02, 0x00, 0xDA, 0x86, 0x39, 0x00, 0x02, 0x01, 0xDA, 0x8A, + 0x1F, 0x30, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0xD5, 0x00, 0x00, 0x09, 0x00, + 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x14, 0x01, 0x07, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0xDA, + 0x80, 0xE0, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x86, 0x39, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8A, 0x1F, + 0x00, 0x14, 0x00, 0xDA, 0x80, 0xE8, 0x01, 0x14, 0x02, 0xDA, 0x23, 0x02, 0x10, 0x03, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x49, 0x05, 0x10, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x48, 0x08, 0x10, 0x06, 0xDA, 0x80, 0xAA, 0x40, 0x01, 0x00, 0x00, 0x1B, 0x02, 0x01, + 0x00, 0x2D, 0x03, 0x00, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x03, 0x05, 0x1B, 0x05, 0x04, + 0x00, 0x1F, 0x05, 0x0A, 0x00, 0x3A, 0x04, 0x03, 0x05, 0x1B, 0x06, 0x04, 0x00, 0x34, 0x00, 0x00, + 0x00, 0x35, 0x04, 0x06, 0x00, 0x32, 0x02, 0x04, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x07, 0x08, + 0x00, 0x49, 0x05, 0x03, 0x05, 0x1C, 0xF7, 0xFF, 0xFF, 0x2B, 0x03, 0x00, 0x00, 0x32, 0x02, 0x03, + 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x84, 0xAC, 0x05, 0x00, 0x05, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x17, + 0x00, 0x17, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x02, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x84, 0xAB, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xCF, 0x0A, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x72, 0x75, 0x6E, 0x63, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x74, 0x72, 0x75, 0x6E, 0x63, 0xCF, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0xDA, 0x82, 0x5B, 0xCF, 0x06, 0x66, 0x69, 0x62, 0x65, 0x72, 0x3F, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, + 0x06, 0x66, 0x69, 0x62, 0x65, 0x72, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x84, 0x9C, 0x00, 0x06, + 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x8A, 0x27, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, + 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, + 0x00, 0x65, 0x2E, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0xCF, 0x03, 0x66, + 0x6F, 0x72, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x08, 0x03, 0x03, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x03, 0x08, 0x00, 0x05, 0xCE, 0x03, 0x66, 0x6F, 0x72, 0xDA, 0x18, 0xDA, 0x88, 0x60, 0xDA, + 0x32, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0C, 0x07, 0x07, 0x07, 0x03, 0x0E, 0x00, 0x09, + 0xCE, 0x0C, 0x66, 0x6F, 0x72, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0xDA, 0x18, + 0xDA, 0x51, 0xDA, 0x52, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x13, 0x07, 0x07, 0x07, 0x0B, + 0x44, 0x00, 0x0C, 0xCE, 0x10, 0x66, 0x6F, 0x72, 0x2D, 0x76, 0x61, 0x72, 0x2D, 0x74, 0x65, 0x6D, + 0x70, 0x6C, 0x61, 0x74, 0x65, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x83, 0xA9, 0xDA, 0x34, 0xDA, 0x80, + 0x9E, 0xDA, 0x80, 0x9C, 0xDA, 0x52, 0xDA, 0x80, 0xFA, 0xDA, 0x89, 0x34, 0xDA, 0x88, 0x64, 0xDA, + 0x57, 0xDA, 0x58, 0x00, 0x44, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x44, 0x01, 0xDA, 0x82, 0x5F, 0x00, + 0x44, 0x02, 0xCF, 0x04, 0x73, 0x74, 0x6F, 0x70, 0x00, 0x44, 0x03, 0xCF, 0x04, 0x73, 0x74, 0x65, + 0x70, 0x00, 0x44, 0x04, 0xCF, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6F, 0x6E, + 0x00, 0x44, 0x05, 0xDA, 0x82, 0x84, 0x00, 0x44, 0x06, 0xDA, 0x81, 0x74, 0x00, 0x44, 0x07, 0xCF, + 0x10, 0x66, 0x6F, 0x72, 0x2D, 0x76, 0x61, 0x72, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, + 0x65, 0x02, 0x44, 0x09, 0xDA, 0x49, 0x0C, 0x44, 0x0A, 0xCF, 0x02, 0x73, 0x74, 0x19, 0x44, 0x08, + 0xCF, 0x09, 0x6C, 0x6F, 0x6F, 0x70, 0x2D, 0x62, 0x6F, 0x64, 0x79, 0x2D, 0x33, 0x11, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, + 0x09, 0x08, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1E, + 0x0A, 0x03, 0x00, 0x1B, 0x08, 0x03, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, + 0x0B, 0x0C, 0x00, 0x1B, 0x08, 0x0B, 0x00, 0x1B, 0x0A, 0x08, 0x00, 0x33, 0x04, 0x00, 0x09, 0x45, + 0x08, 0x00, 0x00, 0x33, 0x05, 0x00, 0x0A, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x02, 0x00, 0x33, + 0x0D, 0x00, 0x0B, 0x45, 0x0C, 0x00, 0x00, 0x2C, 0x0D, 0x03, 0x00, 0x32, 0x0D, 0x08, 0x00, 0x34, + 0x06, 0x00, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x45, 0x0B, 0x00, 0x00, 0x1B, 0x08, 0x0B, 0x00, 0x2C, + 0x0C, 0x04, 0x00, 0x33, 0x0C, 0x00, 0x01, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x05, 0x00, 0x33, + 0x0D, 0x09, 0x02, 0x45, 0x0C, 0x00, 0x00, 0x25, 0x0E, 0x0A, 0x03, 0x1E, 0x0E, 0x03, 0x00, 0x2C, + 0x0D, 0x06, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x2C, 0x10, 0x05, 0x00, 0x33, 0x10, 0x0A, 0x03, 0x45, + 0x0F, 0x00, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x45, 0x0F, 0x00, 0x00, 0x1B, 0x0D, 0x0F, 0x00, 0x31, + 0x0A, 0x00, 0x00, 0x2C, 0x11, 0x07, 0x00, 0x35, 0x10, 0x11, 0x00, 0x1B, 0x11, 0x10, 0x00, 0x1E, + 0x10, 0x04, 0x00, 0x22, 0x12, 0x0A, 0x00, 0x1B, 0x0F, 0x12, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, + 0x0F, 0x11, 0x00, 0x1E, 0x0F, 0x03, 0x00, 0x1B, 0x0E, 0x08, 0x00, 0x1C, 0x09, 0x00, 0x00, 0x2C, + 0x11, 0x08, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x33, 0x11, 0x0A, 0x12, 0x45, 0x10, 0x00, 0x00, 0x2C, + 0x12, 0x09, 0x00, 0x33, 0x12, 0x10, 0x08, 0x45, 0x11, 0x00, 0x00, 0x1B, 0x0E, 0x11, 0x00, 0x2C, + 0x10, 0x0A, 0x00, 0x33, 0x10, 0x0B, 0x0C, 0x34, 0x0D, 0x00, 0x00, 0x31, 0x0E, 0x00, 0x00, 0x45, + 0x0F, 0x00, 0x00, 0x03, 0x0F, 0x00, 0x00, 0x81, 0x8C, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x29, 0x00, 0x29, 0x00, 0x0D, + 0x00, 0x05, 0x02, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x04, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x0E, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0A, 0x01, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x1F, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x02, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, + 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x09, 0xBF, 0xFC, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x0E, 0x00, 0xDA, 0x82, 0xF6, 0x00, 0x0E, 0x01, 0xDA, 0x82, 0x5F, 0x00, + 0x0E, 0x02, 0xDA, 0x8A, 0x31, 0x00, 0x0E, 0x03, 0xDA, 0x8A, 0x32, 0x00, 0x0E, 0x04, 0xDA, 0x8A, + 0x33, 0x00, 0x0E, 0x05, 0xDA, 0x82, 0x84, 0x00, 0x0E, 0x06, 0xDA, 0x81, 0x74, 0x00, 0x0E, 0x07, + 0xCF, 0x0C, 0x66, 0x6F, 0x72, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x02, 0x0E, + 0x09, 0xDA, 0x80, 0xC3, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, 0x09, 0x08, 0x00, + 0x2C, 0x0B, 0x01, 0x00, 0x33, 0x0B, 0x00, 0x09, 0x45, 0x0A, 0x00, 0x00, 0x31, 0x0A, 0x00, 0x00, + 0x34, 0x06, 0x00, 0x00, 0x45, 0x0A, 0x00, 0x00, 0x33, 0x09, 0x01, 0x02, 0x33, 0x03, 0x04, 0x05, + 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x36, 0x0B, 0x00, 0x00, 0x81, 0x9C, 0x0A, 0x00, + 0x0A, 0x00, 0x03, 0x02, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0xBF, + 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x08, 0x00, 0xDA, 0x80, 0xC3, + 0x00, 0x08, 0x01, 0xDA, 0x82, 0x5F, 0x00, 0x08, 0x02, 0xDA, 0x8A, 0x31, 0x00, 0x08, 0x03, 0xDA, + 0x81, 0x74, 0x00, 0x08, 0x04, 0xDA, 0x8A, 0x2A, 0x33, 0x00, 0x01, 0x02, 0x2B, 0x05, 0x01, 0x00, + 0x2C, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x33, 0x05, 0x06, 0x07, 0x31, 0x03, 0x00, 0x00, + 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x81, 0xFA, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x82, 0x75, 0xDA, 0x82, 0x72, 0xDA, + 0x82, 0xC8, 0xDA, 0x82, 0xBC, 0xCF, 0x04, 0x65, 0x61, 0x63, 0x68, 0xD7, 0x00, 0xCD, 0x00, 0xDD, + 0x00, 0x00, 0x05, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x04, 0xCE, 0x04, + 0x65, 0x61, 0x63, 0x68, 0xDA, 0x18, 0xD0, 0x04, 0x65, 0x61, 0x63, 0x68, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x12, 0x04, 0x04, 0x04, 0x0D, 0x4D, 0x00, 0x08, 0xCE, 0x0D, 0x65, 0x61, 0x63, + 0x68, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x83, + 0xA9, 0xDA, 0x52, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x1C, 0x02, 0x02, 0x01, 0x02, 0x00, 0x02, + 0xCE, 0x04, 0x6E, 0x65, 0x78, 0x74, 0x49, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x80, + 0x9C, 0xDA, 0x81, 0x70, 0xDA, 0x8A, 0x3C, 0xDA, 0x81, 0x45, 0xD0, 0x04, 0x6B, 0x65, 0x79, 0x73, + 0xD0, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0xDA, 0x34, 0xDA, 0x80, 0x9E, 0xDA, 0x58, 0x00, 0x4D, + 0x00, 0xDA, 0x82, 0xF6, 0x00, 0x4D, 0x01, 0xCF, 0x03, 0x69, 0x6E, 0x78, 0x00, 0x4D, 0x02, 0xCF, + 0x04, 0x6B, 0x69, 0x6E, 0x64, 0x00, 0x4D, 0x03, 0xDA, 0x81, 0x74, 0x00, 0x4D, 0x04, 0xCF, 0x0D, + 0x65, 0x61, 0x63, 0x68, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x02, 0x4D, 0x06, + 0xDA, 0x22, 0x0C, 0x4D, 0x07, 0xDA, 0x24, 0x1F, 0x3A, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x1B, + 0x05, 0x01, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x09, 0x00, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1B, + 0x05, 0x08, 0x00, 0x1B, 0x07, 0x05, 0x00, 0x25, 0x08, 0x07, 0x01, 0x1E, 0x08, 0x03, 0x00, 0x28, + 0x05, 0x00, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x33, 0x0A, 0x07, 0x01, 0x45, + 0x09, 0x00, 0x00, 0x1B, 0x05, 0x09, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x33, + 0x09, 0x07, 0x0A, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x33, 0x0A, 0x06, 0x08, 0x45, + 0x09, 0x00, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x33, 0x0A, 0x0B, 0x06, 0x45, + 0x08, 0x00, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x25, 0x0B, 0x02, 0x0C, 0x1E, 0x0B, 0x06, 0x00, 0x2C, + 0x0D, 0x07, 0x00, 0x33, 0x0D, 0x07, 0x06, 0x45, 0x0C, 0x00, 0x00, 0x1B, 0x0A, 0x0C, 0x00, 0x1C, + 0x13, 0x00, 0x00, 0x2C, 0x0E, 0x08, 0x00, 0x25, 0x0D, 0x02, 0x0E, 0x1E, 0x0D, 0x03, 0x00, 0x1B, + 0x0C, 0x06, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x2C, 0x10, 0x09, 0x00, 0x25, 0x0F, 0x02, 0x10, 0x1E, + 0x0F, 0x08, 0x00, 0x2C, 0x11, 0x07, 0x00, 0x33, 0x11, 0x07, 0x06, 0x45, 0x10, 0x00, 0x00, 0x32, + 0x06, 0x10, 0x00, 0x46, 0x11, 0x00, 0x00, 0x1B, 0x0E, 0x11, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, + 0x0E, 0x00, 0x00, 0x1B, 0x0C, 0x0E, 0x00, 0x1B, 0x0A, 0x0C, 0x00, 0x2C, 0x0C, 0x02, 0x00, 0x33, + 0x0C, 0x00, 0x0A, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x33, 0x0C, 0x07, 0x06, 0x45, + 0x0A, 0x00, 0x00, 0x2C, 0x0D, 0x0A, 0x00, 0x33, 0x0D, 0x06, 0x0A, 0x45, 0x0C, 0x00, 0x00, 0x2C, + 0x0D, 0x0B, 0x00, 0x33, 0x0D, 0x08, 0x0B, 0x34, 0x03, 0x00, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x45, + 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x0C, 0x00, 0x33, 0x0B, 0x05, 0x09, 0x31, 0x0A, 0x00, 0x00, 0x45, + 0x08, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x81, 0xB2, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x11, + 0x00, 0x11, 0x00, 0x11, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x27, 0x00, 0x27, 0x00, 0x0D, + 0x00, 0x05, 0x02, 0x11, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x09, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x05, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, + 0x15, 0x00, 0x15, 0x00, 0x15, 0xBF, 0xFF, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x03, 0x16, 0x00, 0x16, 0x00, 0x16, + 0x00, 0x16, 0x00, 0x16, 0xBF, 0xFD, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, + 0xFB, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, 0xDA, 0x24, + 0x00, 0x05, 0x02, 0xDA, 0x81, 0x74, 0x00, 0x05, 0x03, 0xDA, 0x8A, 0x39, 0x2C, 0x04, 0x00, 0x00, + 0x33, 0x00, 0x01, 0x04, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, + 0x82, 0x14, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x68, 0x61, 0x73, + 0x2D, 0x6B, 0x65, 0x79, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, + 0x00, 0x04, 0x00, 0x03, 0xCE, 0x08, 0x68, 0x61, 0x73, 0x2D, 0x6B, 0x65, 0x79, 0x3F, 0xDA, 0x18, + 0x00, 0x04, 0x00, 0xDA, 0x24, 0x00, 0x04, 0x01, 0xDA, 0x80, 0xDE, 0x00, 0x04, 0x02, 0xDA, 0x8A, + 0x47, 0x3B, 0x03, 0x00, 0x01, 0x28, 0x05, 0x00, 0x00, 0x4A, 0x04, 0x05, 0x03, 0x03, 0x04, 0x00, + 0x00, 0x84, 0xCA, 0x0D, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0E, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD8, 0x0E, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xCF, 0x03, 0x73, 0x75, 0x6D, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x00, 0x0B, 0x00, 0x06, 0xCE, 0x03, + 0x73, 0x75, 0x6D, 0xDA, 0x18, 0x00, 0x0B, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x0B, 0x01, 0xDA, 0x8A, + 0x4C, 0x00, 0x0B, 0x02, 0xDA, 0x81, 0x96, 0x00, 0x0A, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x62, 0x03, 0x0A, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x06, + 0x0A, 0x05, 0xDA, 0x1E, 0x2B, 0x02, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x00, 0x04, + 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x06, 0x00, 0x3A, 0x03, 0x00, 0x04, 0x1B, 0x05, 0x03, 0x00, + 0x06, 0x02, 0x02, 0x05, 0x49, 0x04, 0x00, 0x04, 0x1C, 0xFB, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, + 0x82, 0x87, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x0E, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, 0x0C, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, + 0x6E, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x02, 0x02, + 0x02, 0x02, 0x14, 0x00, 0x06, 0xCE, 0x0C, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x2D, 0x69, + 0x6E, 0x74, 0x6F, 0xDA, 0x18, 0xDA, 0x83, 0x76, 0xDA, 0x80, 0xA8, 0x00, 0x14, 0x00, 0xCF, 0x04, + 0x69, 0x6E, 0x74, 0x6F, 0x00, 0x14, 0x01, 0xDA, 0x82, 0x74, 0x00, 0x14, 0x02, 0xDA, 0x8A, 0x51, + 0x00, 0x13, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x5A, 0x03, 0x13, 0x04, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x59, 0x06, 0x13, 0x05, 0xDA, 0x1E, 0x2E, 0x02, 0x00, + 0x00, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x0F, + 0x00, 0x3A, 0x03, 0x01, 0x04, 0x1B, 0x05, 0x03, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x00, + 0x00, 0x35, 0x03, 0x06, 0x00, 0x1E, 0x03, 0x04, 0x00, 0x32, 0x00, 0x05, 0x00, 0x35, 0x06, 0x02, + 0x00, 0x1C, 0x04, 0x00, 0x00, 0x32, 0x00, 0x05, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, + 0x00, 0x49, 0x04, 0x01, 0x04, 0x1C, 0xF2, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x86, 0x9D, 0x01, + 0x04, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x02, 0x07, 0x00, 0x07, 0x00, + 0x07, 0xBF, 0xFD, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, 0x06, 0x75, 0x6E, 0x6C, 0x65, 0x73, + 0x73, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x07, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, + 0x02, 0x0A, 0x00, 0x03, 0xCE, 0x06, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0xDA, 0x18, 0xDA, 0x58, + 0xDA, 0x57, 0x00, 0x0A, 0x00, 0xDA, 0x82, 0xB5, 0x00, 0x0A, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x0A, + 0x02, 0xDA, 0x8A, 0x57, 0x2C, 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x28, 0x06, 0x00, 0x00, 0x33, 0x05, 0x00, 0x06, + 0x31, 0x03, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0xB8, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0xCF, 0x0A, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x72, 0x6F, 0x6F, 0x74, 0xD8, 0x0A, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2F, 0x72, 0x6F, 0x6F, 0x74, 0xCF, 0x0B, 0x6F, 0x73, 0x2F, 0x70, 0x65, + 0x72, 0x6D, 0x2D, 0x69, 0x6E, 0x74, 0xD8, 0x0B, 0x6F, 0x73, 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, + 0x69, 0x6E, 0x74, 0xCF, 0x0F, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, + 0x64, 0x69, 0x63, 0x74, 0xDA, 0x87, 0xC1, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, + 0x70, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0xCF, 0x0B, 0x70, 0x65, 0x67, + 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0xD8, 0x0B, 0x70, 0x65, 0x67, 0x2F, 0x72, 0x65, + 0x70, 0x6C, 0x61, 0x63, 0x65, 0xCF, 0x09, 0x67, 0x63, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, + 0xD8, 0x09, 0x67, 0x63, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0xCF, 0x06, 0x70, 0x72, 0x69, + 0x6E, 0x74, 0x66, 0xDA, 0x84, 0x0E, 0xDA, 0x83, 0xAC, 0xDA, 0x83, 0xA9, 0xCF, 0x0B, 0x6D, 0x61, + 0x74, 0x68, 0x2F, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xD8, 0x0B, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xCF, 0x09, 0x64, 0x65, 0x66, 0x67, 0x6C, 0x6F, 0x62, 0x61, + 0x6C, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x02, 0x02, 0x02, 0x03, 0x0B, 0x00, 0x04, + 0xCE, 0x09, 0x64, 0x65, 0x66, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xDA, 0x18, 0xDA, 0x87, 0x01, + 0xDA, 0x06, 0xDA, 0x81, 0x07, 0x00, 0x0B, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x0B, 0x01, 0xDA, 0x25, + 0x00, 0x0B, 0x02, 0xDA, 0x8A, 0x68, 0x03, 0x0B, 0x04, 0xDA, 0x89, 0xFC, 0x31, 0x00, 0x00, 0x00, + 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, 0x01, 0x00, + 0x32, 0x05, 0x01, 0x00, 0x44, 0x05, 0x00, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x07, 0x02, 0x00, + 0x35, 0x06, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00, 0x57, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, + 0x0A, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x0B, 0x03, 0x03, 0x03, 0x01, 0x11, 0x00, 0x09, 0xCE, 0x0A, 0x61, 0x63, 0x63, 0x75, + 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0x00, 0x11, 0x00, 0xDA, 0x80, + 0xAA, 0x00, 0x11, 0x01, 0xDA, 0x81, 0x94, 0x00, 0x11, 0x02, 0xDA, 0x1F, 0x00, 0x11, 0x03, 0xDA, + 0x8A, 0x6B, 0x00, 0x11, 0x04, 0xDA, 0x80, 0xAD, 0x02, 0x11, 0x06, 0xDA, 0x23, 0x02, 0x10, 0x02, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x71, 0x05, 0x10, 0x08, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x70, 0x08, 0x10, 0x09, 0xDA, 0x1E, 0x1B, 0x04, 0x01, 0x00, 0x40, 0x05, + 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x07, 0x02, 0x08, 0x1B, 0x08, + 0x07, 0x00, 0x1F, 0x08, 0x0A, 0x00, 0x3A, 0x07, 0x02, 0x08, 0x1B, 0x09, 0x07, 0x00, 0x32, 0x04, + 0x09, 0x00, 0x35, 0x04, 0x00, 0x00, 0x32, 0x06, 0x04, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x35, 0x07, + 0x0A, 0x00, 0x49, 0x08, 0x02, 0x08, 0x1C, 0xF7, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x00, 0x83, 0xA2, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x28, 0x00, 0x28, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x03, 0xBF, + 0xF7, 0x01, 0xDA, 0x81, 0x73, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0F, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x08, 0x25, 0x00, 0x08, 0xCE, 0x03, 0x6C, 0x65, 0x74, 0xDA, 0x18, 0xDA, + 0x80, 0x8C, 0xCE, 0x27, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x65, 0x76, 0x65, + 0x6E, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x65, 0x74, 0xDA, 0x58, 0xDA, 0x52, 0xDA, + 0x80, 0xE7, 0xDA, 0x80, 0xA8, 0xDA, 0x80, 0xE3, 0xDA, 0x80, 0xE0, 0x00, 0x25, 0x00, 0xDA, 0x81, + 0x22, 0x00, 0x25, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x25, 0x02, 0xDA, 0x81, 0x73, 0x08, 0x25, 0x04, + 0xDA, 0x81, 0x25, 0x09, 0x25, 0x05, 0xDA, 0x80, 0xC3, 0x0D, 0x25, 0x07, 0xDA, 0x81, 0x96, 0x12, + 0x1E, 0x0B, 0xDA, 0x5A, 0x14, 0x1E, 0x0C, 0xDA, 0x22, 0x3F, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, + 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x03, 0x00, 0x2C, 0x03, 0x01, + 0x00, 0x01, 0x03, 0x00, 0x00, 0x3F, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x05, 0x00, + 0x00, 0x2C, 0x06, 0x02, 0x00, 0x31, 0x06, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, + 0x00, 0x23, 0x08, 0x05, 0x04, 0x1E, 0x08, 0x0F, 0x00, 0x05, 0x0A, 0x05, 0x01, 0x3A, 0x09, 0x00, + 0x0A, 0x1B, 0x0B, 0x09, 0x00, 0x3A, 0x09, 0x00, 0x05, 0x1B, 0x0C, 0x09, 0x00, 0x2C, 0x09, 0x03, + 0x00, 0x33, 0x09, 0x0C, 0x0B, 0x2C, 0x0D, 0x04, 0x00, 0x35, 0x09, 0x0D, 0x00, 0x32, 0x07, 0x09, + 0x00, 0x2C, 0x0E, 0x05, 0x00, 0x35, 0x0D, 0x0E, 0x00, 0x05, 0x05, 0x05, 0x02, 0x1C, 0xF1, 0xFF, + 0xFF, 0x32, 0x07, 0x01, 0x00, 0x2C, 0x09, 0x06, 0x00, 0x35, 0x08, 0x09, 0x00, 0x2B, 0x09, 0x00, + 0x00, 0x32, 0x07, 0x09, 0x00, 0x2C, 0x09, 0x07, 0x00, 0x36, 0x09, 0x00, 0x00, 0x80, 0xE2, 0x0D, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, 0x20, 0x00, 0x20, 0x01, 0x0C, 0x00, 0x03, + 0x01, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, 0x0F, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0xBF, 0xFD, 0x03, 0x04, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x82, 0x94, 0xDA, 0x82, 0x92, 0xCF, + 0x07, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, + 0x74, 0xDA, 0x88, 0x42, 0xDA, 0x88, 0x40, 0xCF, 0x03, 0x75, 0x73, 0x65, 0xD7, 0x00, 0xCD, 0x00, + 0xFD, 0x00, 0x00, 0x05, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x09, 0x00, 0x01, 0x02, + 0xCE, 0x03, 0x75, 0x73, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0xA6, 0xDA, 0x58, 0x00, 0x09, 0x00, 0xCF, + 0x07, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x00, 0x09, 0x01, 0xDA, 0x8A, 0x75, 0x30, 0x02, + 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2C, 0x04, + 0x01, 0x00, 0x31, 0x04, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x03, 0x02, + 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x04, 0x0A, 0x00, 0x01, 0xDA, + 0x18, 0xDA, 0x81, 0x12, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x12, 0x01, 0x01, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x0B, 0x35, 0x00, 0x0D, 0xCE, 0x07, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x2A, + 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x00, 0x01, 0x03, 0x14, 0x00, + 0x04, 0xCE, 0x06, 0x63, 0x75, 0x72, 0x65, 0x6E, 0x76, 0xDA, 0x18, 0xDA, 0x83, 0xEB, 0xDA, 0x84, + 0x95, 0xDA, 0x88, 0xEA, 0x00, 0x14, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x14, 0x01, 0xCF, 0x06, 0x63, + 0x75, 0x72, 0x65, 0x6E, 0x76, 0x05, 0x14, 0x02, 0xDA, 0x85, 0x91, 0x07, 0x13, 0x04, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x73, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x31, + 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x1E, + 0x00, 0x0D, 0x00, 0x1B, 0x04, 0x00, 0x00, 0x22, 0x05, 0x04, 0x00, 0x1E, 0x05, 0x0A, 0x00, 0x28, + 0x07, 0x00, 0x00, 0x25, 0x06, 0x07, 0x02, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x31, + 0x02, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x02, 0x06, 0x00, 0x07, 0x04, 0x04, 0x01, 0x1C, + 0xF6, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x89, 0xB3, 0x18, 0x00, 0x18, 0x00, 0x0A, 0x00, 0x0A, + 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x13, 0x00, 0x21, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFB, + 0x01, 0xDA, 0x80, 0xF5, 0xD0, 0x02, 0x61, 0x73, 0xD0, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0xD0, 0x06, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0xDA, 0x87, 0x57, 0xDA, 0x82, 0xDE, 0xDA, 0x81, + 0x12, 0xDA, 0x81, 0xA5, 0xDA, 0x82, 0x87, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0D, 0x04, + 0x02, 0x04, 0x05, 0x23, 0x00, 0x0A, 0xCE, 0x0C, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0x95, 0xDA, 0x62, 0xDA, 0x82, 0x30, 0xDA, 0x84, + 0x98, 0xDA, 0x87, 0x01, 0x00, 0x23, 0x00, 0xDA, 0x84, 0x82, 0x00, 0x23, 0x01, 0xDA, 0x85, 0xF8, + 0x00, 0x23, 0x02, 0xDA, 0x87, 0x07, 0x00, 0x23, 0x03, 0xCF, 0x06, 0x65, 0x78, 0x70, 0x6F, 0x72, + 0x74, 0x00, 0x23, 0x04, 0xCF, 0x0C, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x00, 0x22, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x02, 0x22, + 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x05, 0x22, 0x07, 0xDA, 0x22, 0x06, + 0x22, 0x08, 0xDA, 0x5A, 0x1B, 0x20, 0x09, 0xCF, 0x04, 0x6E, 0x65, 0x77, 0x76, 0x28, 0x06, 0x00, + 0x00, 0x49, 0x05, 0x01, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x1F, 0x00, 0x3A, 0x05, 0x01, + 0x06, 0x1B, 0x07, 0x06, 0x00, 0x1B, 0x08, 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x00, + 0x00, 0x35, 0x05, 0x09, 0x00, 0x1E, 0x05, 0x16, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x31, 0x09, 0x00, + 0x00, 0x35, 0x09, 0x08, 0x00, 0x31, 0x09, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x35, 0x0A, 0x0B, + 0x00, 0x1E, 0x0A, 0x0F, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x35, 0x09, 0x0B, + 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x32, 0x0B, 0x09, 0x00, 0x44, 0x09, 0x00, 0x00, 0x32, 0x09, 0x08, + 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x09, 0x0B, 0x00, 0x32, 0x02, 0x07, + 0x00, 0x2C, 0x0C, 0x04, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x3C, 0x00, 0x0B, 0x09, 0x49, 0x06, 0x01, + 0x06, 0x1C, 0xE2, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x8B, 0xFA, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x03, + 0x00, 0x3B, 0x00, 0x3B, 0x00, 0x3B, 0x00, 0x36, 0x00, 0x36, 0x00, 0x36, 0x00, 0x03, 0x01, 0x2A, + 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x05, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0xBF, + 0xFA, 0x01, 0x00, 0x35, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x35, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x35, + 0x02, 0xCF, 0x07, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x2A, 0x02, 0x35, 0x04, 0xDA, 0x85, 0x87, + 0x06, 0x35, 0x06, 0xCF, 0x05, 0x6B, 0x61, 0x72, 0x67, 0x73, 0x09, 0x35, 0x08, 0xDA, 0x89, 0x46, + 0x0C, 0x35, 0x09, 0xDA, 0x87, 0x07, 0x0F, 0x35, 0x0A, 0xCF, 0x02, 0x65, 0x70, 0x13, 0x35, 0x0B, + 0xDA, 0x84, 0x9B, 0x13, 0x1C, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x1C, + 0x30, 0x0D, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x1F, 0x2F, 0x09, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x35, 0x0D, 0xDA, 0x87, 0x07, 0x2C, 0x04, 0x00, + 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x01, + 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x3A, 0x07, 0x06, + 0x08, 0x1B, 0x08, 0x07, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x3A, 0x07, 0x06, 0x09, 0x1B, 0x09, 0x07, + 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x3A, 0x07, 0x06, 0x0A, 0x1B, 0x0A, 0x07, 0x00, 0x33, 0x00, 0x01, + 0x06, 0x2C, 0x0B, 0x05, 0x00, 0x35, 0x07, 0x0B, 0x00, 0x1B, 0x0B, 0x07, 0x00, 0x1E, 0x08, 0x07, + 0x00, 0x2C, 0x0D, 0x06, 0x00, 0x32, 0x08, 0x0D, 0x00, 0x2C, 0x0E, 0x07, 0x00, 0x35, 0x0D, 0x0E, + 0x00, 0x1B, 0x0C, 0x0D, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x0C, 0x08, 0x00, 0x1B, 0x0D, 0x0C, + 0x00, 0x1E, 0x0D, 0x03, 0x00, 0x1B, 0x0C, 0x0D, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x1E, 0x09, 0x03, + 0x00, 0x1B, 0x0E, 0x09, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x2C, 0x0F, 0x06, 0x00, 0x32, 0x0F, 0x00, + 0x00, 0x2C, 0x10, 0x08, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x11, 0x09, + 0x00, 0x35, 0x10, 0x11, 0x00, 0x2C, 0x0F, 0x06, 0x00, 0x32, 0x10, 0x0F, 0x00, 0x2C, 0x11, 0x07, + 0x00, 0x35, 0x0F, 0x11, 0x00, 0x1B, 0x0E, 0x0F, 0x00, 0x1B, 0x0C, 0x0E, 0x00, 0x1B, 0x0D, 0x0C, + 0x00, 0x33, 0x04, 0x0B, 0x0D, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0E, 0x0A, 0x00, 0x36, 0x0E, 0x00, + 0x00, 0x8C, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x03, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x02, 0x11, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, 0xFF, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x03, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, + 0x1F, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, + 0xFD, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x04, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x8A, + 0x80, 0xDA, 0x82, 0x04, 0x00, 0x0A, 0x00, 0xCF, 0x09, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x24, 0x30, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2C, 0x03, + 0x01, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x33, 0x03, 0x01, 0x04, 0x2C, 0x03, 0x03, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x8C, 0x21, 0x1C, 0x00, 0x1C, 0x00, + 0x1C, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x8C, + 0x21, 0x0F, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0xCF, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0xDA, 0x54, 0xCF, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x2D, + 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0xDA, 0x88, 0x7B, 0xCF, 0x0F, 0x2A, 0x70, 0x72, 0x65, 0x74, + 0x74, 0x79, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x2A, 0xDA, 0x84, 0x0C, 0xDA, 0x84, 0xC4, + 0xDA, 0x84, 0xBB, 0xCF, 0x07, 0x7A, 0x69, 0x70, 0x63, 0x6F, 0x6C, 0x6C, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x09, 0x02, 0x02, 0x02, 0x00, 0x13, 0x00, 0x06, 0xCE, 0x07, 0x7A, 0x69, 0x70, + 0x63, 0x6F, 0x6C, 0x6C, 0xDA, 0x18, 0x00, 0x13, 0x00, 0xDA, 0x87, 0x37, 0x00, 0x13, 0x01, 0xCF, + 0x02, 0x76, 0x73, 0x00, 0x13, 0x02, 0xDA, 0x8A, 0x93, 0x01, 0x13, 0x04, 0xDA, 0x80, 0xAD, 0x02, + 0x13, 0x05, 0xCF, 0x02, 0x6B, 0x6B, 0x03, 0x13, 0x06, 0xCF, 0x02, 0x76, 0x6B, 0x44, 0x03, 0x00, + 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x05, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, + 0x05, 0x28, 0x08, 0x00, 0x00, 0x25, 0x07, 0x08, 0x05, 0x1E, 0x07, 0x02, 0x00, 0x1C, 0x0A, 0x00, + 0x00, 0x49, 0x06, 0x01, 0x06, 0x28, 0x08, 0x00, 0x00, 0x25, 0x07, 0x08, 0x06, 0x1E, 0x07, 0x02, + 0x00, 0x1C, 0x05, 0x00, 0x00, 0x3A, 0x07, 0x00, 0x05, 0x3A, 0x08, 0x01, 0x06, 0x3C, 0x04, 0x07, + 0x08, 0x1C, 0xF3, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x85, 0xE7, 0x03, 0x00, 0x03, 0x01, 0x03, + 0x01, 0x03, 0x02, 0x0D, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x14, 0x01, 0x0D, 0x01, 0x09, + 0x00, 0x09, 0x00, 0x05, 0x00, 0x14, 0x01, 0x0E, 0x00, 0x19, 0x00, 0x05, 0xBF, 0xFB, 0x03, 0xBF, + 0xF9, 0x01, 0xCF, 0x0A, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x70, 0x61, 0x69, 0x72, 0x73, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x01, 0x01, 0x00, 0x0F, 0x00, 0x07, 0xCE, 0x0A, 0x66, + 0x72, 0x6F, 0x6D, 0x2D, 0x70, 0x61, 0x69, 0x72, 0x73, 0xDA, 0x18, 0x00, 0x0F, 0x00, 0xCF, 0x02, + 0x70, 0x73, 0x00, 0x0F, 0x01, 0xDA, 0x8A, 0x99, 0x01, 0x0F, 0x03, 0xDA, 0x23, 0x01, 0x0E, 0x00, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x04, 0x0E, 0x05, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x08, 0x0E, 0x07, 0xDA, 0x22, 0x0A, 0x0E, 0x08, 0xDA, 0x5A, 0x44, + 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x00, 0x05, 0x1B, + 0x05, 0x04, 0x00, 0x1F, 0x05, 0x09, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x3D, 0x06, 0x04, 0x00, 0x1B, + 0x07, 0x06, 0x00, 0x3D, 0x06, 0x04, 0x01, 0x1B, 0x08, 0x06, 0x00, 0x3C, 0x03, 0x07, 0x08, 0x49, + 0x05, 0x00, 0x05, 0x1C, 0xF8, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x86, 0xB9, 0x03, 0x00, 0x03, + 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x01, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xCF, 0x07, 0x65, 0x76, + 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x05, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x04, 0x00, 0x01, 0x03, 0xCE, 0x07, 0x65, 0x76, 0x2F, 0x63, 0x61, + 0x6C, 0x6C, 0xDA, 0x18, 0xDA, 0x44, 0x00, 0x04, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x04, 0x01, 0xDA, + 0x80, 0xE8, 0x00, 0x04, 0x02, 0xDA, 0x8A, 0x9F, 0x30, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, + 0x2C, 0x04, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x04, 0xCE, 0x05, 0x5F, 0x63, 0x61, 0x6C, 0x6C, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xE8, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8A, 0x9F, 0x00, 0x04, 0x00, 0xCF, 0x05, 0x5F, 0x63, 0x61, 0x6C, + 0x6C, 0x2D, 0x01, 0x00, 0x01, 0x34, 0x01, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, + 0x00, 0xBF, 0xFF, 0x8E, 0x94, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x8E, 0x94, 0x0C, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xDA, 0x86, 0x1C, 0xDA, 0x89, 0x9B, 0xD8, 0x05, 0x72, + 0x61, 0x6E, 0x67, 0x65, 0xCF, 0x0B, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x6E, 0x64, 0x2D, 0x74, + 0x6F, 0xD8, 0x0B, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x6E, 0x64, 0x2D, 0x74, 0x6F, 0xCF, 0x05, + 0x6D, 0x65, 0x72, 0x67, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, 0x00, 0x00, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x14, 0x00, 0x09, 0xCE, 0x05, 0x6D, 0x65, 0x72, 0x67, 0x65, 0xDA, + 0x18, 0x00, 0x14, 0x00, 0xDA, 0x85, 0x7C, 0x00, 0x14, 0x01, 0xDA, 0x8A, 0xA8, 0x01, 0x14, 0x03, + 0xCF, 0x09, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x72, 0x01, 0x13, 0x00, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x04, 0x13, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x7A, 0x07, 0x13, 0x06, 0xDA, 0x82, 0x11, 0x07, 0x11, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x79, 0x0A, 0x11, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x78, 0x0C, 0x11, 0x04, 0xDA, 0x80, 0xDE, 0x44, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x28, + 0x05, 0x00, 0x00, 0x49, 0x04, 0x00, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x1F, 0x05, 0x0E, 0x00, 0x3A, + 0x04, 0x00, 0x05, 0x1B, 0x06, 0x04, 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, 0x04, 0x06, 0x07, 0x1B, + 0x07, 0x04, 0x00, 0x1F, 0x07, 0x06, 0x00, 0x1B, 0x04, 0x07, 0x00, 0x3A, 0x08, 0x06, 0x04, 0x3C, + 0x03, 0x04, 0x08, 0x49, 0x07, 0x06, 0x07, 0x1C, 0xFB, 0xFF, 0xFF, 0x49, 0x05, 0x00, 0x05, 0x1C, + 0xF3, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x86, 0x3B, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x02, 0x18, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, + 0xFA, 0x01, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x75, 0x6D, 0x61, 0x73, 0x6B, 0xD8, 0x08, 0x6F, 0x73, + 0x2F, 0x75, 0x6D, 0x61, 0x73, 0x6B, 0xCF, 0x0B, 0x2A, 0x64, 0x6F, 0x63, 0x2D, 0x63, 0x6F, 0x6C, + 0x6F, 0x72, 0x2A, 0xDA, 0x81, 0xEB, 0xCF, 0x06, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0xDA, 0x84, + 0xB2, 0xCF, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xD8, 0x0B, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xCF, 0x0D, 0x2A, 0x70, 0x65, + 0x67, 0x2D, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x2A, 0xD0, 0x0B, 0x70, 0x65, 0x67, 0x2D, + 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0xCF, 0x04, 0x61, 0x6E, 0x79, 0x3F, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x00, 0x0D, 0x00, 0x06, 0xCE, 0x04, 0x61, 0x6E, + 0x79, 0x3F, 0xDA, 0x18, 0x00, 0x0D, 0x00, 0xDA, 0x1F, 0x00, 0x0D, 0x01, 0xDA, 0x8A, 0xB8, 0x00, + 0x0D, 0x02, 0xDA, 0x80, 0xAD, 0x00, 0x0C, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x68, 0x03, 0x0C, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x67, 0x06, 0x0C, 0x05, + 0xDA, 0x1E, 0x28, 0x02, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x00, 0x04, 0x1B, 0x04, + 0x03, 0x00, 0x1F, 0x04, 0x08, 0x00, 0x3A, 0x03, 0x00, 0x04, 0x1B, 0x05, 0x03, 0x00, 0x1E, 0x02, + 0x02, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x1B, 0x02, 0x05, 0x00, 0x49, 0x04, 0x00, 0x04, 0x1C, 0xF9, + 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x85, 0xB7, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, + 0xBF, 0xFB, 0x01, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0xD7, + 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x02, 0x05, 0x00, 0x01, 0x02, 0xCE, + 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0xDA, 0x18, 0xDA, 0x81, 0xAD, + 0xDA, 0x81, 0x6B, 0x00, 0x05, 0x00, 0xCF, 0x04, 0x66, 0x69, 0x6C, 0x65, 0x00, 0x05, 0x01, 0xDA, + 0x8A, 0xBD, 0x30, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x32, 0x02, 0x03, 0x00, 0x2C, 0x03, + 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, + 0x0A, 0x01, 0x03, 0xDA, 0x18, 0xDA, 0x86, 0x0A, 0xDA, 0x84, 0xC1, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x8A, 0xC0, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8A, 0xBD, 0x05, 0x09, 0x01, 0xDA, 0x82, 0x66, 0x2D, + 0x00, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x35, + 0x00, 0x01, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x38, 0x02, 0x01, 0x03, 0x1C, + 0xF8, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x87, 0x12, 0x16, 0x00, 0x16, 0x00, 0x16, + 0x00, 0x16, 0x00, 0x16, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x07, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x87, + 0x11, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xCF, 0x0A, + 0x67, 0x63, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xD8, 0x0A, 0x67, 0x63, 0x69, 0x6E, + 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xCF, 0x0B, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x62, + 0x79, 0x74, 0x65, 0xD8, 0x0B, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x62, 0x79, 0x74, 0x65, + 0xCF, 0x0B, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xDA, 0x85, 0xFC, + 0xDA, 0x80, 0x8E, 0xDA, 0x88, 0x5B, 0xDA, 0x81, 0x95, 0xDA, 0x81, 0x92, 0xCF, 0x0F, 0x65, 0x76, + 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x0F, 0x00, 0x02, + 0xCE, 0x0F, 0x65, 0x76, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0xDA, 0x18, 0xDA, 0x86, 0x38, 0xDA, 0x80, 0x9B, 0xCF, 0x0D, 0x5F, 0x73, 0x70, 0x61, 0x77, + 0x6E, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x88, 0x03, 0xD0, 0x01, 0x6E, 0x00, 0x0F, + 0x00, 0xDA, 0x81, 0x74, 0x00, 0x0F, 0x01, 0xDA, 0x8A, 0xC6, 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x33, 0x04, + 0x05, 0x02, 0x34, 0x00, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x28, 0x05, + 0x00, 0x00, 0x33, 0x04, 0x03, 0x05, 0x2C, 0x04, 0x04, 0x00, 0x31, 0x04, 0x00, 0x00, 0x45, 0x02, + 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x8E, 0xA4, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xCF, 0x0B, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0xD8, 0x0B, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xCF, + 0x06, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, + 0x01, 0x02, 0x01, 0x06, 0x00, 0x03, 0xCE, 0x06, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0xDA, 0x18, + 0xD8, 0x06, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x00, 0x06, 0x00, 0xDA, 0x82, 0x4E, 0x00, 0x06, + 0x01, 0xDA, 0x25, 0x00, 0x06, 0x02, 0xDA, 0x8A, 0xCD, 0x32, 0x00, 0x01, 0x00, 0x45, 0x03, 0x00, + 0x00, 0x2B, 0x04, 0x00, 0x00, 0x32, 0x04, 0x03, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x36, 0x04, 0x00, + 0x00, 0x81, 0x6E, 0x0D, 0x00, 0x0D, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x82, + 0xF5, 0xDA, 0x82, 0xF3, 0xCF, 0x05, 0x2A, 0x6F, 0x75, 0x74, 0x2A, 0xD0, 0x03, 0x6F, 0x75, 0x74, + 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x69, 0x73, 0x61, 0x74, 0x74, 0x79, 0xD8, 0x09, 0x6F, 0x73, 0x2F, + 0x69, 0x73, 0x61, 0x74, 0x74, 0x79, 0xCF, 0x04, 0x6E, 0x61, 0x6E, 0x3F, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x02, 0x00, 0x02, 0xCE, 0x04, 0x6E, 0x61, 0x6E, + 0x3F, 0xDA, 0x18, 0x00, 0x02, 0x00, 0xDA, 0x1E, 0x00, 0x02, 0x01, 0xDA, 0x8A, 0xD5, 0x4A, 0x02, + 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x63, 0x25, 0x00, 0x25, 0xCF, 0x03, 0x64, 0x79, 0x6E, 0xDA, + 0x80, 0xFB, 0xCF, 0x09, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xD8, 0x09, 0x75, + 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xCF, 0x0B, 0x2A, 0x6C, 0x69, 0x6E, 0x74, 0x2D, + 0x77, 0x61, 0x72, 0x6E, 0x2A, 0xDA, 0x86, 0x08, 0xCF, 0x09, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, + 0x63, 0x74, 0x3F, 0xD8, 0x09, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x3F, 0xDA, 0x80, + 0xE4, 0xDA, 0x82, 0x87, 0xDA, 0x89, 0x29, 0xDA, 0x89, 0x27, 0xCF, 0x0D, 0x67, 0x63, 0x73, 0x65, + 0x74, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xD8, 0x0D, 0x67, 0x63, 0x73, 0x65, 0x74, + 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, + 0x65, 0x6E, 0x73, 0x75, 0x72, 0x65, 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x65, 0x6E, + 0x73, 0x75, 0x72, 0x65, 0xCF, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x67, 0x65, 0x74, 0x65, + 0x6E, 0x76, 0xDA, 0x84, 0x95, 0xCF, 0x06, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x09, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x06, 0x16, 0x00, 0x04, + 0xCE, 0x06, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x9C, 0xCF, + 0x01, 0x3E, 0xDA, 0x81, 0x4D, 0xDA, 0x80, 0x9E, 0xDA, 0x58, 0x00, 0x16, 0x00, 0xDA, 0x81, 0x9E, + 0x00, 0x16, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x16, 0x02, 0xDA, 0x8A, 0xE3, 0x02, 0x16, 0x04, 0xCF, + 0x04, 0x69, 0x74, 0x65, 0x72, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, + 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x04, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x02, + 0x00, 0x2B, 0x07, 0x00, 0x00, 0x33, 0x06, 0x04, 0x07, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x03, + 0x00, 0x32, 0x07, 0x04, 0x00, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x32, 0x08, 0x05, + 0x00, 0x34, 0x01, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x06, 0x05, + 0x00, 0x33, 0x06, 0x03, 0x07, 0x45, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x82, 0x09, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x88, 0xFA, 0xDA, 0x88, 0xF7, + 0xDA, 0x83, 0x8C, 0xDA, 0x83, 0x8A, 0xCF, 0x0F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, 0x74, + 0x6F, 0x2D, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDA, 0x83, 0x84, 0xCF, 0x0B, 0x6F, 0x73, 0x2F, 0x63, + 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x72, 0xD8, 0x0B, 0x6F, 0x73, 0x2F, 0x63, 0x6F, 0x6D, 0x70, + 0x69, 0x6C, 0x65, 0x72, 0xCF, 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0xD8, + 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0xCF, 0x0F, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x2F, 0x61, 0x72, 0x67, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD8, 0x0F, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x2F, 0x61, 0x72, 0x67, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xCF, 0x07, 0x65, 0x70, + 0x72, 0x69, 0x6E, 0x74, 0x66, 0xDA, 0x85, 0x41, 0xCF, 0x0B, 0x65, 0x76, 0x2F, 0x64, 0x65, 0x61, + 0x64, 0x6C, 0x69, 0x6E, 0x65, 0xD8, 0x0B, 0x65, 0x76, 0x2F, 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, + 0x6E, 0x65, 0xCF, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x03, 0x0C, 0x00, 0x03, 0xCE, 0x07, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6C, 0x74, 0xDA, 0x18, 0xDA, 0x84, 0x7F, 0xDA, 0x57, 0xDA, 0x52, 0x00, 0x0C, 0x00, 0xDA, + 0x69, 0x00, 0x0C, 0x01, 0xCF, 0x03, 0x76, 0x61, 0x6C, 0x00, 0x0C, 0x02, 0xDA, 0x8A, 0xF2, 0x2C, + 0x04, 0x00, 0x00, 0x28, 0x05, 0x00, 0x00, 0x33, 0x04, 0x05, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, + 0x05, 0x01, 0x00, 0x33, 0x05, 0x03, 0x01, 0x31, 0x00, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, 0x2C, + 0x05, 0x02, 0x00, 0x33, 0x05, 0x00, 0x04, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x80, + 0xA5, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0F, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, + 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0xDA, 0x4A, 0xCF, 0x07, 0x62, 0x72, 0x73, + 0x68, 0x69, 0x66, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x11, 0x06, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x07, 0x62, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x3F, 0x01, + 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x03, 0x03, + 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3D, 0x04, + 0x00, 0x00, 0x16, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, + 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x16, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, + 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, + 0x2F, 0x73, 0x65, 0x65, 0x6B, 0xD8, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x65, 0x6B, + 0xCF, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3C, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x10, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x28, 0x00, 0x09, 0xCE, 0x08, 0x63, + 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3C, 0xDA, 0x18, 0xDA, 0x84, 0x5A, 0x00, 0x28, 0x00, 0xDA, + 0x82, 0x74, 0x00, 0x28, 0x01, 0xDA, 0x8A, 0xFC, 0x00, 0x28, 0x02, 0xDA, 0x80, 0xAD, 0x03, 0x28, + 0x04, 0xDA, 0x1E, 0x04, 0x27, 0x03, 0xDA, 0x80, 0xC3, 0x06, 0x27, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x69, 0x0A, 0x25, 0x08, 0xDA, 0x80, 0xD9, 0x0D, 0x1F, 0x0A, 0xDA, 0x80, + 0xAA, 0x15, 0x1E, 0x0D, 0xDA, 0x80, 0xAA, 0x29, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3B, + 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x1B, + 0x06, 0x05, 0x00, 0x23, 0x05, 0x03, 0x06, 0x1E, 0x05, 0x1F, 0x00, 0x3A, 0x07, 0x00, 0x03, 0x1B, + 0x08, 0x07, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x3B, 0x09, 0x04, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, + 0x09, 0x05, 0x00, 0x32, 0x04, 0x08, 0x00, 0x35, 0x0B, 0x0A, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x1C, + 0x0D, 0x00, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x3B, 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, + 0x0C, 0x06, 0x00, 0x32, 0x08, 0x04, 0x00, 0x35, 0x0E, 0x0D, 0x00, 0x09, 0x0F, 0x0E, 0xFF, 0x1B, + 0x0B, 0x0F, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x27, 0x0E, 0x04, 0x08, 0x1B, 0x0B, 0x0E, 0x00, 0x1B, + 0x07, 0x0B, 0x00, 0x24, 0x09, 0x07, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, + 0x03, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, + 0xE1, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x83, 0x23, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, + 0x65, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x10, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x01, 0x28, 0x00, 0x09, 0xCE, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3D, 0xDA, + 0x18, 0xDA, 0x84, 0x5A, 0x00, 0x28, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x28, 0x01, 0xDA, 0x8B, 0x00, + 0x00, 0x28, 0x02, 0xDA, 0x80, 0xAD, 0x03, 0x28, 0x04, 0xDA, 0x1E, 0x04, 0x27, 0x03, 0xDA, 0x80, + 0xC3, 0x06, 0x27, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x68, 0x0A, 0x25, 0x08, + 0xDA, 0x80, 0xD9, 0x0D, 0x1F, 0x0A, 0xDA, 0x80, 0xAA, 0x15, 0x1E, 0x0D, 0xDA, 0x80, 0xAA, 0x29, + 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3B, 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x2B, + 0x03, 0x01, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x23, 0x05, 0x03, 0x06, 0x1E, + 0x05, 0x1F, 0x00, 0x3A, 0x07, 0x00, 0x03, 0x1B, 0x08, 0x07, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x3B, + 0x09, 0x04, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, 0x09, 0x05, 0x00, 0x32, 0x04, 0x08, 0x00, 0x35, + 0x0B, 0x0A, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x3B, + 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, 0x0C, 0x06, 0x00, 0x32, 0x08, 0x04, 0x00, 0x35, + 0x0E, 0x0D, 0x00, 0x09, 0x0F, 0x0E, 0xFF, 0x1B, 0x0B, 0x0F, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x27, + 0x0E, 0x04, 0x08, 0x1B, 0x0B, 0x0E, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x26, 0x09, 0x07, 0x00, 0x1E, + 0x09, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x1C, + 0x03, 0x00, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, 0xE1, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x83, + 0x1E, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0xCF, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3E, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x10, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x28, 0x00, 0x09, 0xCE, 0x08, 0x63, + 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3E, 0xDA, 0x18, 0xDA, 0x84, 0x5A, 0x00, 0x28, 0x00, 0xDA, + 0x82, 0x74, 0x00, 0x28, 0x01, 0xDA, 0x8B, 0x04, 0x00, 0x28, 0x02, 0xDA, 0x80, 0xAD, 0x03, 0x28, + 0x04, 0xDA, 0x1E, 0x04, 0x27, 0x03, 0xDA, 0x80, 0xC3, 0x06, 0x27, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x6B, 0x0A, 0x25, 0x08, 0xDA, 0x80, 0xD9, 0x0D, 0x1F, 0x0A, 0xDA, 0x80, + 0xAA, 0x15, 0x1E, 0x0D, 0xDA, 0x80, 0xAA, 0x29, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3B, + 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3F, 0x05, 0x00, 0x00, 0x1B, + 0x06, 0x05, 0x00, 0x23, 0x05, 0x03, 0x06, 0x1E, 0x05, 0x1F, 0x00, 0x3A, 0x07, 0x00, 0x03, 0x1B, + 0x08, 0x07, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x3B, 0x09, 0x04, 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x1E, + 0x09, 0x05, 0x00, 0x32, 0x04, 0x08, 0x00, 0x35, 0x0B, 0x0A, 0x00, 0x1B, 0x07, 0x0B, 0x00, 0x1C, + 0x0D, 0x00, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x3B, 0x0C, 0x08, 0x0D, 0x1B, 0x0D, 0x0C, 0x00, 0x1E, + 0x0C, 0x06, 0x00, 0x32, 0x08, 0x04, 0x00, 0x35, 0x0E, 0x0D, 0x00, 0x09, 0x0F, 0x0E, 0xFF, 0x1B, + 0x0B, 0x0F, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x27, 0x0E, 0x04, 0x08, 0x1B, 0x0B, 0x0E, 0x00, 0x1B, + 0x07, 0x0B, 0x00, 0x22, 0x09, 0x07, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x04, 0x08, 0x00, 0x1C, + 0x03, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x05, 0x03, 0x03, 0x01, 0x1C, + 0xE1, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x83, 0x2D, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x09, 0x65, 0x76, 0x2F, 0x67, 0x61, 0x74, + 0x68, 0x65, 0x72, 0xD7, 0x01, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x11, 0x00, 0x00, 0xCD, 0x7F, 0xFF, + 0xFF, 0xFF, 0x09, 0x49, 0x01, 0x13, 0xCE, 0x09, 0x65, 0x76, 0x2F, 0x67, 0x61, 0x74, 0x68, 0x65, + 0x72, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x81, 0x79, 0xCF, 0x03, 0x70, 0x75, 0x74, 0xDA, + 0x80, 0x9B, 0xDA, 0x44, 0xDA, 0x88, 0x37, 0xDA, 0x58, 0xDA, 0x80, 0xA8, 0xBF, 0xFF, 0x00, 0x01, + 0xCF, 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x8A, 0x9F, 0xBF, 0xFF, 0x00, 0x03, 0xCF, 0x08, 0x65, 0x76, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, + 0xBF, 0xFF, 0x00, 0x04, 0xCF, 0x0C, 0x65, 0x76, 0x2F, 0x64, 0x6F, 0x2D, 0x74, 0x68, 0x72, 0x65, + 0x61, 0x64, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8A, 0xC6, 0xBF, 0xFF, 0x00, 0x06, 0xCF, 0x10, 0x65, + 0x76, 0x2F, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x65, 0xBF, + 0xFF, 0x00, 0x07, 0xCF, 0x0A, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x2D, 0x61, 0x6C, 0x6C, 0xBF, + 0xFF, 0x00, 0x08, 0xCF, 0x0F, 0x77, 0x61, 0x69, 0x74, 0x2D, 0x66, 0x6F, 0x72, 0x2D, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x73, 0x00, 0x49, 0x00, 0xCF, 0x06, 0x62, 0x6F, 0x64, 0x69, 0x65, 0x73, 0x00, + 0x49, 0x01, 0xDA, 0x8B, 0x08, 0x02, 0x49, 0x03, 0xCF, 0x04, 0x63, 0x68, 0x61, 0x6E, 0x05, 0x49, + 0x04, 0xDA, 0x80, 0xAD, 0x08, 0x49, 0x05, 0xCF, 0x04, 0x66, 0x73, 0x65, 0x74, 0x0B, 0x49, 0x06, + 0xCF, 0x05, 0x66, 0x74, 0x65, 0x6D, 0x70, 0x1B, 0x3F, 0x0A, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x61, 0x1B, 0x3F, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x63, 0x1E, + 0x3F, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x21, 0x3F, 0x0C, 0xDA, 0x80, + 0xC3, 0x22, 0x3F, 0x0D, 0xDA, 0x81, 0x74, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x02, 0x04, 0x00, 0x1B, 0x04, 0x02, 0x00, 0x2C, + 0x05, 0x00, 0x00, 0x35, 0x02, 0x05, 0x00, 0x1B, 0x05, 0x02, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, + 0x02, 0x06, 0x00, 0x1B, 0x06, 0x02, 0x00, 0x44, 0x02, 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x33, + 0x08, 0x05, 0x02, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x31, 0x08, 0x00, 0x00, 0x45, + 0x02, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x33, 0x09, 0x03, 0x02, 0x45, 0x08, 0x00, 0x00, 0x40, + 0x02, 0x00, 0x00, 0x2C, 0x0A, 0x01, 0x00, 0x33, 0x0A, 0x04, 0x02, 0x45, 0x09, 0x00, 0x00, 0x40, + 0x02, 0x00, 0x00, 0x1B, 0x0A, 0x02, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x49, 0x02, 0x00, 0x0B, 0x1B, + 0x0B, 0x02, 0x00, 0x1F, 0x0B, 0x20, 0x00, 0x3A, 0x02, 0x00, 0x0B, 0x1B, 0x0C, 0x0B, 0x00, 0x1B, + 0x0D, 0x02, 0x00, 0x46, 0x02, 0x00, 0x00, 0x2C, 0x0F, 0x03, 0x00, 0x33, 0x0F, 0x04, 0x0C, 0x31, + 0x0D, 0x00, 0x00, 0x45, 0x0E, 0x00, 0x00, 0x2C, 0x10, 0x04, 0x00, 0x33, 0x10, 0x02, 0x0E, 0x45, + 0x0F, 0x00, 0x00, 0x2C, 0x0E, 0x05, 0x00, 0x28, 0x10, 0x00, 0x00, 0x33, 0x0E, 0x0F, 0x10, 0x31, + 0x03, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x0F, 0x01, 0x00, 0x33, 0x0F, 0x06, 0x02, 0x45, + 0x0E, 0x00, 0x00, 0x2C, 0x0F, 0x06, 0x00, 0x33, 0x0F, 0x05, 0x06, 0x31, 0x06, 0x00, 0x00, 0x45, + 0x02, 0x00, 0x00, 0x2C, 0x10, 0x07, 0x00, 0x33, 0x10, 0x0E, 0x02, 0x45, 0x0F, 0x00, 0x00, 0x32, + 0x0A, 0x0F, 0x00, 0x2C, 0x0E, 0x08, 0x00, 0x35, 0x02, 0x0E, 0x00, 0x49, 0x0B, 0x00, 0x0B, 0x1C, + 0xE1, 0xFF, 0xFF, 0x2D, 0x0B, 0x00, 0x08, 0x33, 0x0B, 0x03, 0x05, 0x45, 0x02, 0x00, 0x00, 0x2C, + 0x0C, 0x07, 0x00, 0x33, 0x0C, 0x07, 0x08, 0x31, 0x09, 0x00, 0x00, 0x34, 0x0A, 0x00, 0x00, 0x32, + 0x02, 0x04, 0x00, 0x45, 0x0B, 0x00, 0x00, 0x03, 0x0B, 0x00, 0x00, 0xBF, 0xFF, 0x8E, 0xCE, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x04, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0xBF, 0xFF, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFC, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x0B, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x09, 0x03, 0x03, 0x03, 0x03, 0x19, 0x00, 0x09, 0xCE, 0x0A, 0x63, 0x61, 0x6E, 0x63, + 0x65, 0x6C, 0x2D, 0x61, 0x6C, 0x6C, 0xDA, 0x18, 0xDA, 0x89, 0x3D, 0xDA, 0x89, 0xEE, 0xD8, 0x07, + 0x65, 0x76, 0x2F, 0x74, 0x61, 0x6B, 0x65, 0x00, 0x19, 0x00, 0xDA, 0x8B, 0x13, 0x00, 0x19, 0x01, + 0xCF, 0x06, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x00, 0x19, 0x02, 0xCF, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6F, 0x6E, 0x00, 0x19, 0x03, 0xDA, 0x8B, 0x10, 0x00, 0x0B, 0x01, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x35, 0x02, 0x0B, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x05, 0x0B, 0x06, 0xDA, 0x80, 0xAA, 0x0C, 0x19, 0x05, 0xDA, 0x81, 0x9E, 0x10, 0x19, 0x04, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x01, + 0x05, 0x1B, 0x05, 0x04, 0x00, 0x1F, 0x05, 0x08, 0x00, 0x3A, 0x04, 0x01, 0x05, 0x1B, 0x06, 0x04, + 0x00, 0x32, 0x06, 0x02, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x04, 0x07, 0x00, 0x49, 0x05, 0x01, + 0x05, 0x1C, 0xF9, 0xFF, 0xFF, 0x3F, 0x04, 0x01, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x31, 0x01, 0x00, + 0x00, 0x2C, 0x06, 0x01, 0x00, 0x35, 0x04, 0x06, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x22, 0x06, 0x04, + 0x00, 0x1E, 0x06, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x35, 0x07, 0x08, + 0x00, 0x07, 0x04, 0x04, 0x01, 0x1C, 0xFA, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x8E, 0xB8, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x0D, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0xD7, 0x01, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x08, 0x02, 0x02, 0x02, 0x05, 0x16, 0x01, 0x01, 0x0C, + 0xCE, 0x0F, 0x77, 0x61, 0x69, 0x74, 0x2D, 0x66, 0x6F, 0x72, 0x2D, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x73, 0xDA, 0x18, 0xDA, 0x81, 0x86, 0xDA, 0x81, 0x6B, 0xCE, 0x0F, 0x70, 0x61, 0x72, 0x65, 0x6E, + 0x74, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x65, 0x64, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, 0x0C, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8A, 0x9F, 0xBF, 0xFF, + 0x00, 0x03, 0xDA, 0x8B, 0x0D, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8B, 0x0E, 0xBF, 0xFF, 0x00, 0x05, + 0xDA, 0x8A, 0xC6, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8B, 0x0F, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8B, + 0x10, 0x00, 0x16, 0x00, 0xDA, 0x8B, 0x13, 0x00, 0x16, 0x01, 0xDA, 0x8B, 0x1C, 0x00, 0x16, 0x02, + 0xDA, 0x8B, 0x11, 0x05, 0x16, 0x03, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x08, + 0x16, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, + 0x03, 0x04, 0x00, 0x28, 0x05, 0x00, 0x00, 0x37, 0x04, 0x03, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x33, 0x00, 0x01, 0x04, 0x2D, 0x06, 0x00, 0x07, 0x35, 0x04, 0x06, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x35, 0x04, 0x06, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x25, + 0x06, 0x04, 0x07, 0x1E, 0x06, 0x02, 0x00, 0x03, 0x05, 0x00, 0x00, 0x39, 0x04, 0x05, 0x03, 0x03, + 0x04, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x21, + 0x02, 0x0D, 0xDA, 0x18, 0xDA, 0x8B, 0x1B, 0xD0, 0x02, 0x6F, 0x6B, 0xCE, 0x10, 0x73, 0x69, 0x62, + 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x65, 0x64, 0xDA, 0x84, 0x9E, + 0xBF, 0xFF, 0x01, 0x01, 0xDA, 0x8B, 0x0C, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x8A, 0x9F, 0xBF, 0xFF, + 0x01, 0x03, 0xDA, 0x8B, 0x0D, 0xBF, 0xFF, 0x01, 0x04, 0xDA, 0x8B, 0x0E, 0xBF, 0xFF, 0x01, 0x05, + 0xDA, 0x8A, 0xC6, 0xBF, 0xFF, 0x01, 0x06, 0xDA, 0x8B, 0x0F, 0xBF, 0xFF, 0x01, 0x07, 0xDA, 0x8B, + 0x10, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8B, 0x13, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, 0x1C, 0xBF, + 0xFF, 0x00, 0x02, 0xDA, 0x8B, 0x11, 0x02, 0x21, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x39, 0x0A, 0x20, 0x04, 0xCF, 0x03, 0x73, 0x69, 0x67, 0x0C, 0x20, 0x05, 0xDA, 0x86, 0x21, + 0x2D, 0x01, 0x00, 0x01, 0x3F, 0x00, 0x01, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x22, 0x00, 0x01, 0x00, + 0x1E, 0x00, 0x1C, 0x00, 0x2D, 0x02, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, + 0x35, 0x02, 0x03, 0x00, 0x3D, 0x03, 0x02, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x3D, 0x03, 0x02, 0x01, + 0x1B, 0x05, 0x03, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x25, 0x02, 0x04, 0x03, 0x1E, 0x02, 0x05, 0x00, + 0x2D, 0x03, 0x00, 0x01, 0x28, 0x06, 0x00, 0x00, 0x3C, 0x03, 0x05, 0x06, 0x1C, 0x0B, 0x00, 0x00, + 0x2D, 0x03, 0x00, 0x00, 0x2D, 0x06, 0x00, 0x01, 0x2C, 0x07, 0x02, 0x00, 0x33, 0x03, 0x06, 0x07, + 0x2D, 0x06, 0x01, 0x07, 0x35, 0x03, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x03, 0x00, + 0x35, 0x03, 0x06, 0x00, 0x39, 0x06, 0x03, 0x05, 0x07, 0x01, 0x01, 0x01, 0x1C, 0xE4, 0xFF, 0xFF, + 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8E, 0xC0, 0x0F, 0x00, 0x0F, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x01, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x01, 0x0D, 0x00, 0x0D, 0x00, 0x09, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, + 0x09, 0x03, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x01, 0x18, 0x00, + 0x18, 0x00, 0x18, 0x00, 0x0D, 0xBF, 0xFA, 0x07, 0x00, 0x07, 0x00, 0x07, 0x8E, 0xBF, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0xDB, 0x02, 0xC9, + 0xC9, 0xDA, 0x84, 0x41, 0xDA, 0x84, 0x3D, 0xCF, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0xD8, 0x11, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0xCF, 0x0C, 0x2A, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2A, 0xD0, 0x0A, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xCF, 0x05, 0x6F, 0x73, 0x2F, 0x63, 0x64, 0xD8, 0x05, + 0x6F, 0x73, 0x2F, 0x63, 0x64, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x72, 0x65, 0x6D, + 0x6F, 0x76, 0x65, 0xDA, 0x88, 0x88, 0xDA, 0x88, 0x81, 0xDA, 0x88, 0x79, 0xCF, 0x11, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD8, + 0x11, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, + 0x63, 0x6B, 0xCF, 0x0B, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x72, 0x66, 0x74, 0x69, 0x6D, 0x65, 0xD8, + 0x0B, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x72, 0x66, 0x74, 0x69, 0x6D, 0x65, 0xCF, 0x10, 0x65, 0x76, + 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0xD8, 0x10, + 0x65, 0x76, 0x2F, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, + 0xCF, 0x05, 0x74, 0x72, 0x75, 0x65, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, + 0x01, 0x01, 0x00, 0x03, 0x00, 0x02, 0xCE, 0x05, 0x74, 0x72, 0x75, 0x65, 0x3F, 0xDA, 0x18, 0x00, + 0x03, 0x00, 0xDA, 0x1E, 0x00, 0x03, 0x01, 0xDA, 0x8B, 0x37, 0x29, 0x03, 0x00, 0x00, 0x25, 0x02, + 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x72, 0x27, 0x00, 0x27, 0x00, 0x27, 0xCF, 0x08, 0x64, 0x69, + 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x01, + 0x01, 0x01, 0x15, 0x00, 0x07, 0xCE, 0x08, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74, 0xDA, + 0x18, 0xDA, 0x80, 0xA8, 0x00, 0x15, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x15, 0x01, 0xDA, 0x8B, 0x3A, + 0x01, 0x15, 0x03, 0xDA, 0x23, 0x03, 0x15, 0x05, 0xCF, 0x04, 0x73, 0x65, 0x65, 0x6E, 0x03, 0x14, + 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x58, 0x06, 0x14, 0x07, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x57, 0x09, 0x14, 0x08, 0xDA, 0x1E, 0x40, 0x02, 0x00, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x44, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x28, 0x07, 0x00, 0x00, 0x49, + 0x06, 0x00, 0x07, 0x1B, 0x07, 0x06, 0x00, 0x1F, 0x07, 0x0D, 0x00, 0x3A, 0x06, 0x00, 0x07, 0x1B, + 0x08, 0x06, 0x00, 0x3A, 0x06, 0x05, 0x08, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x29, + 0x09, 0x00, 0x00, 0x3C, 0x05, 0x08, 0x09, 0x32, 0x03, 0x08, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x35, + 0x09, 0x0A, 0x00, 0x49, 0x07, 0x00, 0x07, 0x1C, 0xF4, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x86, + 0x98, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x26, 0x00, 0x26, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xCF, 0x08, 0x67, 0x65, 0x74, + 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xD8, 0x08, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xCF, + 0x05, 0x79, 0x69, 0x65, 0x6C, 0x64, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x04, 0x02, 0x01, 0x00, + 0x01, 0x00, 0x02, 0xCE, 0x05, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x38, 0x00, 0x00, 0x03, 0x03, 0x00, + 0x00, 0x00, 0xCF, 0x04, 0x70, 0x72, 0x69, 0x6E, 0xD8, 0x04, 0x70, 0x72, 0x69, 0x6E, 0xCF, 0x04, + 0x63, 0x61, 0x73, 0x65, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x0C, 0x01, 0x01, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x05, 0x1C, 0x00, 0x01, 0x06, 0xCE, 0x04, 0x63, 0x61, 0x73, 0x65, 0xDA, 0x18, + 0xDA, 0x83, 0xA9, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x80, 0xE7, 0xDA, 0x58, 0x00, 0x1C, 0x00, 0xCF, + 0x08, 0x64, 0x69, 0x73, 0x70, 0x61, 0x74, 0x63, 0x68, 0x00, 0x1C, 0x01, 0xDA, 0x88, 0x73, 0x00, + 0x1C, 0x02, 0xDA, 0x8B, 0x47, 0x03, 0x1C, 0x04, 0xCF, 0x03, 0x61, 0x74, 0x6D, 0x0A, 0x1C, 0x06, + 0xDA, 0x69, 0x0C, 0x1C, 0x08, 0xDA, 0x81, 0x27, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, + 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x1E, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x00, 0x00, + 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, + 0x1B, 0x06, 0x05, 0x00, 0x30, 0x07, 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x1E, 0x04, 0x04, 0x00, + 0x2B, 0x09, 0x00, 0x00, 0x31, 0x09, 0x00, 0x00, 0x36, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x02, 0x00, + 0x33, 0x09, 0x06, 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x2B, 0x0A, 0x00, 0x00, + 0x31, 0x0A, 0x00, 0x00, 0x35, 0x0A, 0x08, 0x00, 0x2C, 0x0B, 0x04, 0x00, 0x33, 0x0B, 0x09, 0x0A, + 0x2C, 0x0B, 0x03, 0x00, 0x36, 0x0B, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x01, + 0x01, 0x03, 0x1F, 0x01, 0x08, 0xDA, 0x81, 0x28, 0xDA, 0x18, 0xDA, 0x84, 0x7F, 0xDA, 0x80, 0xE7, + 0xDA, 0x57, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8B, 0x4A, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x73, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8B, 0x47, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8B, 0x4B, 0xBF, 0xFF, + 0x00, 0x06, 0xDA, 0x69, 0x00, 0x1F, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x1F, 0x01, 0xDA, 0x81, 0x27, + 0x04, 0x1F, 0x02, 0xCF, 0x07, 0x72, 0x65, 0x73, 0x74, 0x6C, 0x65, 0x6E, 0x2E, 0x01, 0x00, 0x00, + 0x2D, 0x03, 0x00, 0x01, 0x3F, 0x02, 0x03, 0x00, 0x08, 0x03, 0x02, 0x00, 0x1B, 0x02, 0x03, 0x00, + 0x26, 0x04, 0x02, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x26, 0x05, 0x02, 0x01, + 0x1E, 0x05, 0x04, 0x00, 0x2D, 0x07, 0x00, 0x01, 0x3A, 0x06, 0x07, 0x00, 0x03, 0x06, 0x00, 0x00, + 0x2D, 0x07, 0x00, 0x01, 0x3A, 0x06, 0x07, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x2D, 0x08, 0x00, 0x06, + 0x33, 0x07, 0x08, 0x06, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x07, 0x08, 0x00, 0x05, 0x06, 0x00, 0x01, + 0x2D, 0x09, 0x00, 0x01, 0x3A, 0x08, 0x09, 0x06, 0x05, 0x06, 0x00, 0x02, 0x31, 0x06, 0x00, 0x00, + 0x35, 0x09, 0x01, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x33, 0x06, 0x07, 0x08, 0x31, 0x09, 0x00, 0x00, + 0x2C, 0x06, 0x01, 0x00, 0x36, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0x80, 0xD0, 0x03, 0x01, 0x15, 0x00, + 0x15, 0x00, 0x12, 0x00, 0x05, 0x01, 0x09, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0B, 0x00, 0x07, 0x00, + 0x19, 0x00, 0x19, 0x00, 0x19, 0x01, 0x21, 0x00, 0x21, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, + 0x14, 0x00, 0x14, 0x01, 0x1A, 0x00, 0x10, 0x00, 0x10, 0x01, 0x15, 0x00, 0x10, 0x00, 0x10, 0xBF, + 0xFE, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x80, 0xCE, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0C, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x07, 0x03, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFE, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x42, 0x00, 0x00, 0x00, 0xCF, 0x0D, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, + 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0xD8, 0x0D, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, 0x2D, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, + 0x6C, 0x69, 0x74, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x6C, 0x69, 0x74, + 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0xD8, 0x09, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0xDA, 0x88, 0x7E, 0xDA, 0x88, 0x7C, 0xCF, 0x07, 0x6F, 0x73, + 0x2F, 0x70, 0x69, 0x70, 0x65, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x70, 0x69, 0x70, 0x65, 0xDA, 0x48, + 0xDA, 0x65, 0xCF, 0x04, 0x6E, 0x61, 0x74, 0x3F, 0xDA, 0x87, 0x14, 0xCF, 0x07, 0x6F, 0x73, 0x2F, + 0x6F, 0x70, 0x65, 0x6E, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0xCF, 0x06, 0x6E, + 0x61, 0x74, 0x69, 0x76, 0x65, 0xD8, 0x06, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xCF, 0x09, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x2D, 0x69, 0x6E, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0F, + 0x03, 0x03, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x24, 0x00, 0x0E, 0xCE, 0x09, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x2D, 0x69, 0x6E, 0xDA, 0x18, 0xCE, 0x1D, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x31, 0x20, 0x6B, 0x65, + 0x79, 0x20, 0x69, 0x6E, 0x20, 0x6B, 0x73, 0xDA, 0x80, 0xF5, 0x00, 0x24, 0x00, 0xDA, 0x24, 0x00, + 0x24, 0x01, 0xDA, 0x87, 0x37, 0x00, 0x24, 0x02, 0xDA, 0x80, 0xAA, 0x00, 0x24, 0x03, 0xDA, 0x80, + 0xE8, 0x00, 0x24, 0x04, 0xDA, 0x8B, 0x5A, 0x00, 0x24, 0x05, 0xDA, 0x82, 0x70, 0x03, 0x24, 0x06, + 0xCF, 0x05, 0x6C, 0x65, 0x6E, 0x2D, 0x31, 0x08, 0x1B, 0x08, 0xDA, 0x80, 0xC3, 0x08, 0x1B, 0x06, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x72, 0x0C, 0x1B, 0x0B, 0xDA, 0x22, 0x0E, 0x1B, + 0x0C, 0xDA, 0x5A, 0x14, 0x17, 0x0E, 0xDA, 0x8A, 0x88, 0x1C, 0x24, 0x09, 0xCF, 0x08, 0x6C, 0x61, + 0x73, 0x74, 0x2D, 0x6B, 0x65, 0x79, 0x1E, 0x24, 0x0B, 0xCF, 0x08, 0x6C, 0x61, 0x73, 0x74, 0x2D, + 0x76, 0x61, 0x6C, 0x1B, 0x05, 0x00, 0x00, 0x3F, 0x06, 0x01, 0x00, 0x07, 0x07, 0x06, 0x01, 0x1B, + 0x06, 0x07, 0x00, 0x24, 0x08, 0x06, 0x00, 0x1E, 0x08, 0x03, 0x00, 0x2C, 0x09, 0x00, 0x00, 0x01, + 0x09, 0x00, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x23, 0x09, 0x08, 0x06, 0x1E, 0x09, 0x11, 0x00, 0x3B, + 0x0A, 0x01, 0x08, 0x1B, 0x0B, 0x0A, 0x00, 0x3B, 0x0A, 0x05, 0x0B, 0x1B, 0x0C, 0x0A, 0x00, 0x28, + 0x0D, 0x00, 0x00, 0x25, 0x0A, 0x0D, 0x0C, 0x1E, 0x0A, 0x07, 0x00, 0x2C, 0x0E, 0x01, 0x00, 0x35, + 0x0D, 0x0E, 0x00, 0x1B, 0x0E, 0x0D, 0x00, 0x3C, 0x05, 0x0B, 0x0E, 0x1B, 0x05, 0x0E, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x05, 0x0C, 0x00, 0x05, 0x08, 0x08, 0x01, 0x1C, 0xEF, 0xFF, 0xFF, 0x3B, + 0x08, 0x01, 0x06, 0x1B, 0x09, 0x08, 0x00, 0x3B, 0x0A, 0x05, 0x09, 0x1B, 0x0B, 0x0A, 0x00, 0x31, + 0x0B, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x35, 0x0C, 0x02, 0x00, 0x3C, 0x05, 0x09, 0x0C, 0x03, + 0x00, 0x00, 0x00, 0x86, 0x00, 0x03, 0x01, 0x11, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x07, 0x00, 0x03, + 0x00, 0x13, 0x00, 0x13, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x05, 0x01, 0x0C, + 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x12, 0x00, 0x12, 0x00, 0x07, 0x01, 0x09, + 0x01, 0x09, 0xBF, 0xFD, 0x05, 0x04, 0x07, 0xBF, 0xF9, 0x03, 0x00, 0x03, 0x08, 0x11, 0x00, 0x03, + 0x01, 0x11, 0x00, 0x03, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x03, 0xBF, 0xED, 0x01, 0xCF, + 0x05, 0x64, 0x65, 0x66, 0x6E, 0x2D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x04, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x03, 0xCE, 0x05, 0x64, 0x65, 0x66, 0x6E, 0x2D, + 0xDA, 0x18, 0xDA, 0x62, 0xDA, 0x82, 0xFE, 0x00, 0x05, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x05, 0x01, + 0xDA, 0x81, 0xBF, 0x00, 0x05, 0x02, 0xDA, 0x8B, 0x62, 0x2C, 0x03, 0x00, 0x00, 0x32, 0x00, 0x03, + 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x43, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x8B, 0x0C, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x03, 0x00, 0x02, 0xCE, 0x09, 0x6E, 0x65, 0x74, 0x2F, 0x63, + 0x6C, 0x6F, 0x73, 0x65, 0xDA, 0x18, 0xD8, 0x08, 0x65, 0x76, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0x00, 0x03, 0x00, 0xCF, 0x06, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x00, 0x03, 0x01, 0xDA, 0x8B, + 0x0C, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0x8E, 0x8C, 0x34, + 0x00, 0x34, 0x00, 0x34, 0xCF, 0x0B, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, + 0x32, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0D, 0x02, 0x02, 0x02, 0x01, 0x1B, 0x00, 0x06, + 0xCE, 0x0B, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x32, 0xDA, 0x18, 0xDA, + 0x80, 0xA8, 0x00, 0x1B, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x1B, 0x01, 0xDA, 0x1F, 0x00, 0x1B, 0x02, + 0xDA, 0x8B, 0x69, 0x02, 0x1B, 0x04, 0xDA, 0x22, 0x04, 0x1B, 0x06, 0xDA, 0x23, 0x0A, 0x1B, 0x08, + 0xDA, 0x80, 0xAD, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x40, + 0x05, 0x00, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x28, 0x08, 0x00, 0x00, 0x25, 0x07, 0x08, 0x04, 0x1E, + 0x07, 0x02, 0x00, 0x03, 0x06, 0x00, 0x00, 0x3A, 0x07, 0x01, 0x04, 0x1B, 0x08, 0x07, 0x00, 0x32, + 0x06, 0x08, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x49, 0x04, 0x01, 0x04, 0x28, + 0x0B, 0x00, 0x00, 0x4A, 0x0A, 0x0B, 0x04, 0x1E, 0x0A, 0x09, 0x00, 0x3A, 0x0B, 0x01, 0x04, 0x32, + 0x08, 0x0B, 0x00, 0x35, 0x08, 0x00, 0x00, 0x32, 0x06, 0x08, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, + 0x0B, 0x0C, 0x00, 0x49, 0x04, 0x01, 0x04, 0x1C, 0xF6, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x00, 0x83, + 0xAC, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x07, 0x00, 0x07, 0x00, 0x03, + 0x00, 0x11, 0x01, 0x0C, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0A, 0x01, 0x0A, + 0x00, 0x0A, 0x00, 0x03, 0x01, 0x15, 0x00, 0x0E, 0x00, 0x0E, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x0C, 0xBF, 0xFD, 0x03, 0xBF, 0xF5, 0x01, 0xCF, 0x06, 0x6D, 0x65, 0x6D, 0x63, 0x6D, 0x70, + 0xD8, 0x06, 0x6D, 0x65, 0x6D, 0x63, 0x6D, 0x70, 0xCF, 0x06, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x07, 0x00, 0x02, 0xCE, + 0x06, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x82, 0x30, 0xDA, 0x34, 0x00, 0x07, + 0x00, 0xDA, 0x25, 0x00, 0x07, 0x01, 0xDA, 0x8B, 0x6E, 0x2C, 0x03, 0x00, 0x00, 0x32, 0x03, 0x00, + 0x00, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, 0x04, 0x00, 0x02, 0x45, 0x03, 0x00, + 0x00, 0x03, 0x03, 0x00, 0x00, 0x52, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xCF, 0x06, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0xD8, 0x06, 0x73, 0x74, 0x64, + 0x6F, 0x75, 0x74, 0xCF, 0x06, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x66, 0xDA, 0x85, 0x4D, 0xCF, 0x13, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x2D, 0x66, 0x6C, 0x61, 0x74, + 0x74, 0x65, 0x6E, 0xDA, 0x89, 0x72, 0xCF, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0xD7, 0x00, 0xCD, + 0x00, 0x08, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x02, 0xCE, 0x05, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x38, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x07, 0x65, 0x76, 0x2F, 0x72, 0x65, + 0x61, 0x64, 0xD8, 0x07, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xCF, 0x08, 0x6F, 0x73, 0x2F, + 0x73, 0x68, 0x65, 0x6C, 0x6C, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x68, 0x65, 0x6C, 0x6C, 0xCF, + 0x06, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, + 0x01, 0x01, 0x00, 0x03, 0x00, 0x02, 0xCE, 0x06, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x3F, 0xDA, 0x18, + 0x00, 0x03, 0x00, 0xDA, 0x1E, 0x00, 0x03, 0x01, 0xDA, 0x8B, 0x7C, 0x2A, 0x03, 0x00, 0x00, 0x25, + 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x73, 0x29, 0x00, 0x29, 0x00, 0x29, 0xCF, 0x11, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, + 0xD8, 0x11, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, + 0x74, 0x65, 0x73, 0xCF, 0x05, 0x64, 0x65, 0x6C, 0x61, 0x79, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x0E, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x06, 0x2C, 0x00, 0x04, 0xCE, 0x05, 0x64, + 0x65, 0x6C, 0x61, 0x79, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x9C, 0xDA, 0x34, 0xDA, 0x58, 0xDA, + 0x57, 0xDA, 0x80, 0x9B, 0x00, 0x2C, 0x00, 0xDA, 0x81, 0x9A, 0x00, 0x2C, 0x01, 0xDA, 0x8B, 0x81, + 0x02, 0x2C, 0x03, 0xCF, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x05, 0x2C, 0x05, 0xCF, 0x06, 0x6C, + 0x6F, 0x61, 0x64, 0x65, 0x64, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, + 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x46, 0x06, 0x00, + 0x00, 0x2C, 0x08, 0x01, 0x00, 0x28, 0x09, 0x00, 0x00, 0x33, 0x08, 0x03, 0x09, 0x45, 0x07, 0x00, + 0x00, 0x2C, 0x09, 0x01, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x33, 0x09, 0x05, 0x0A, 0x45, 0x08, 0x00, + 0x00, 0x46, 0x09, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x29, 0x0C, 0x00, 0x00, 0x33, 0x0B, 0x05, + 0x0C, 0x45, 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x34, 0x00, 0x00, + 0x00, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x02, 0x00, 0x33, 0x0D, 0x03, 0x0B, 0x45, 0x0C, 0x00, + 0x00, 0x2C, 0x0D, 0x03, 0x00, 0x33, 0x0D, 0x0A, 0x0C, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0C, 0x04, + 0x00, 0x33, 0x0C, 0x05, 0x03, 0x31, 0x0B, 0x00, 0x00, 0x45, 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x05, + 0x00, 0x33, 0x0C, 0x09, 0x0A, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x33, 0x0A, 0x06, + 0x07, 0x32, 0x08, 0x0B, 0x00, 0x45, 0x09, 0x00, 0x00, 0x31, 0x09, 0x00, 0x00, 0x45, 0x06, 0x00, + 0x00, 0x03, 0x06, 0x00, 0x00, 0x8E, 0xEE, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x0F, 0x00, 0x0F, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x06, + 0x65, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xDA, 0x84, 0xC6, 0xCF, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0xD8, 0x11, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0xCF, + 0x09, 0x70, 0x72, 0x6F, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0xDA, 0x81, 0x89, 0xCF, 0x08, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, + 0x6E, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xD8, 0x0B, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0xCF, 0x08, 0x62, 0x72, 0x75, + 0x73, 0x68, 0x69, 0x66, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x12, 0x06, 0x00, 0x00, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x08, 0x62, 0x72, 0x75, 0x73, 0x68, 0x69, 0x66, 0x74, + 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, + 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, + 0x3D, 0x04, 0x00, 0x00, 0x18, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, + 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x18, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, + 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x08, 0x66, 0x6C, + 0x79, 0x63, 0x68, 0x65, 0x63, 0x6B, 0xD7, 0x00, 0xCD, 0x03, 0xFF, 0x00, 0x00, 0x0B, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0A, 0x26, 0x00, 0x01, 0x08, 0xCE, 0x08, 0x66, 0x6C, 0x79, 0x63, + 0x68, 0x65, 0x63, 0x6B, 0xDA, 0x18, 0xDA, 0x87, 0x5F, 0xDA, 0x83, 0x8D, 0xDA, 0x89, 0xEE, 0xDA, + 0x81, 0x6C, 0xDA, 0x81, 0x6B, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x72, 0xDA, 0x82, 0x04, 0xDA, 0x85, + 0x26, 0xDA, 0x85, 0x79, 0x00, 0x26, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x26, 0x01, 0xCF, 0x06, 0x6B, + 0x77, 0x61, 0x72, 0x67, 0x73, 0x00, 0x26, 0x02, 0xDA, 0x8B, 0x91, 0x04, 0x26, 0x04, 0xCF, 0x0C, + 0x6F, 0x6C, 0x64, 0x2D, 0x6D, 0x6F, 0x64, 0x63, 0x61, 0x63, 0x68, 0x65, 0x0E, 0x1D, 0x06, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x70, 0x11, 0x1D, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x71, 0x17, 0x1C, 0x08, 0xDA, 0x85, 0x91, 0x17, 0x1C, 0x06, 0xDA, 0x80, 0xAA, + 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, + 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, + 0x35, 0x05, 0x06, 0x00, 0x30, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x32, 0x06, 0x07, 0x00, + 0x2C, 0x08, 0x04, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x06, 0x07, 0x00, 0x28, 0x08, 0x00, 0x00, + 0x37, 0x07, 0x06, 0x08, 0x1B, 0x08, 0x07, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x09, 0x05, 0x00, + 0x35, 0x07, 0x09, 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x25, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x06, 0x00, + 0x2C, 0x07, 0x07, 0x00, 0x33, 0x06, 0x08, 0x07, 0x2C, 0x0A, 0x08, 0x00, 0x35, 0x07, 0x0A, 0x00, + 0x1C, 0x01, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, + 0x35, 0x06, 0x07, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x32, 0x07, 0x04, 0x00, 0x2C, 0x08, 0x09, 0x00, + 0x35, 0x07, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x04, 0x0B, 0x01, 0x04, 0xDA, 0x18, 0xDA, 0x80, 0xEF, 0xDA, 0x85, 0x9D, 0xD7, 0x00, 0xCD, + 0x00, 0xDC, 0x00, 0x00, 0x10, 0x04, 0x04, 0x04, 0x10, 0x50, 0x00, 0x0B, 0xCE, 0x12, 0x66, 0x6C, + 0x79, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, + 0xDA, 0x18, 0xDA, 0x82, 0x92, 0xD5, 0x0B, 0xDA, 0x81, 0xB9, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x04, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x0B, 0x69, 0x73, 0x2D, 0x73, 0x61, + 0x66, 0x65, 0x2D, 0x64, 0x65, 0x66, 0xDA, 0x18, 0xDA, 0x82, 0x87, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x09, 0x01, 0x01, 0x01, 0x08, 0x2B, 0x00, 0x03, 0xCE, 0x0F, 0x6E, 0x6F, 0x2D, 0x73, + 0x69, 0x64, 0x65, 0x2D, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0xDA, 0x18, 0xDA, 0x82, 0x92, + 0xDA, 0x80, 0xA4, 0xDA, 0x80, 0xA5, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x16, 0x02, 0x02, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0xB2, 0x00, 0x2F, 0xCE, 0x03, 0x61, 0x6C, 0x6C, 0xDA, + 0x18, 0xDA, 0x80, 0xA9, 0x00, 0x80, 0xB2, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x80, 0xB2, 0x01, 0xDA, + 0x1F, 0x00, 0x80, 0xB2, 0x02, 0xDA, 0x80, 0xAB, 0x00, 0x80, 0xB2, 0x03, 0xCF, 0x03, 0x61, 0x6C, + 0x6C, 0x00, 0x80, 0xB2, 0x04, 0xDA, 0x80, 0xAD, 0x02, 0x80, 0xB1, 0x06, 0xDA, 0x80, 0xAE, 0x02, + 0x80, 0xB1, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x4C, 0x04, 0x14, 0x01, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x4E, 0x07, 0x14, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x4D, 0x0A, 0x14, 0x09, 0xDA, 0x1E, 0x0D, 0x12, 0x0A, 0xDA, 0x80, 0xD9, 0x18, + 0x2F, 0x09, 0xDA, 0x80, 0xB2, 0x19, 0x2F, 0x08, 0xDA, 0x80, 0xB3, 0x19, 0x2F, 0x01, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x50, 0x1C, 0x2F, 0x0B, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x4F, 0x1F, 0x2F, 0x0C, 0xDA, 0x1E, 0x28, 0x2D, 0x0A, 0xDA, 0x80, 0xD9, 0x33, 0x53, + 0x0A, 0xDA, 0x80, 0xB2, 0x35, 0x53, 0x0B, 0xDA, 0x80, 0xB6, 0x36, 0x53, 0x09, 0xDA, 0x80, 0xB3, + 0x37, 0x53, 0x0C, 0xDA, 0x80, 0xB7, 0x37, 0x53, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x52, 0x3A, 0x53, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x51, 0x3D, 0x53, + 0x0F, 0xDA, 0x1E, 0x4C, 0x51, 0x0D, 0xDA, 0x80, 0xD9, 0x57, 0x80, 0x81, 0x0B, 0xDA, 0x80, 0xB2, + 0x59, 0x80, 0x81, 0x0C, 0xDA, 0x80, 0xB6, 0x5B, 0x80, 0x81, 0x0D, 0xDA, 0x80, 0xBA, 0x5C, 0x80, + 0x81, 0x0A, 0xDA, 0x80, 0xB3, 0x5D, 0x80, 0x81, 0x0E, 0xDA, 0x80, 0xB7, 0x5E, 0x80, 0x81, 0x0F, + 0xDA, 0x80, 0xBB, 0x5E, 0x80, 0x81, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x54, + 0x61, 0x80, 0x81, 0x11, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x53, 0x64, 0x80, 0x81, + 0x12, 0xDA, 0x1E, 0x7A, 0x7F, 0x10, 0xDA, 0x80, 0xD9, 0x80, 0x85, 0x80, 0xB1, 0x0B, 0xDA, 0x80, + 0xBE, 0x80, 0x89, 0x80, 0xB1, 0x0C, 0xDA, 0x80, 0xBF, 0x80, 0x8A, 0x80, 0xB1, 0x0A, 0xDA, 0x80, + 0xC0, 0x80, 0x8A, 0x80, 0xB1, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x56, 0x80, + 0x8D, 0x80, 0xB1, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x55, 0x80, 0x90, 0x80, + 0xB1, 0x0F, 0xDA, 0x1E, 0x80, 0x91, 0x80, 0xA5, 0x0D, 0xDA, 0x80, 0xC3, 0x80, 0x91, 0x80, 0xA5, + 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x57, 0x80, 0x95, 0x80, 0xA3, 0x12, 0xDA, + 0x80, 0xC5, 0x80, 0x97, 0x80, 0xA3, 0x13, 0xDA, 0x80, 0xC6, 0x80, 0x99, 0x80, 0xA3, 0x14, 0xDA, + 0x80, 0xC7, 0x80, 0xAA, 0x80, 0xAF, 0x10, 0xDA, 0x80, 0xD9, 0x29, 0x04, 0x00, 0x00, 0x3F, 0x05, + 0x02, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x26, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x11, 0x00, 0x28, 0x08, + 0x00, 0x00, 0x49, 0x07, 0x01, 0x08, 0x1B, 0x08, 0x07, 0x00, 0x1F, 0x08, 0x0C, 0x00, 0x3A, 0x07, + 0x01, 0x08, 0x1B, 0x09, 0x07, 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x07, 0x00, 0x00, 0x1B, 0x0A, + 0x07, 0x00, 0x1E, 0x07, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x0A, 0x00, 0x1C, 0x03, + 0x00, 0x00, 0x49, 0x08, 0x01, 0x08, 0x1C, 0xF5, 0xFF, 0xFF, 0x1C, 0x9D, 0x00, 0x00, 0x26, 0x07, + 0x06, 0x01, 0x1E, 0x07, 0x1A, 0x00, 0x3D, 0x08, 0x02, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x28, 0x08, + 0x00, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x49, 0x0A, 0x01, 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1F, 0x0B, + 0x12, 0x00, 0x3A, 0x0A, 0x01, 0x0B, 0x1B, 0x0C, 0x0A, 0x00, 0x49, 0x08, 0x09, 0x08, 0x28, 0x0D, + 0x00, 0x00, 0x25, 0x0A, 0x0D, 0x08, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x3A, 0x0A, + 0x09, 0x08, 0x32, 0x0C, 0x0A, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x1B, 0x0A, 0x0D, 0x00, 0x1E, 0x0D, + 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x0A, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x0B, + 0x01, 0x0B, 0x1C, 0xEF, 0xFF, 0xFF, 0x1C, 0x82, 0x00, 0x00, 0x26, 0x08, 0x06, 0x02, 0x1E, 0x08, + 0x23, 0x00, 0x3D, 0x09, 0x02, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x3D, 0x09, 0x02, 0x01, 0x1B, 0x0B, + 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x28, 0x0E, 0x00, 0x00, 0x49, 0x0D, + 0x01, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1F, 0x0E, 0x18, 0x00, 0x3A, 0x0D, 0x01, 0x0E, 0x1B, 0x0F, + 0x0D, 0x00, 0x49, 0x09, 0x0A, 0x09, 0x28, 0x10, 0x00, 0x00, 0x25, 0x0D, 0x10, 0x09, 0x1E, 0x0D, + 0x02, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x49, 0x0C, 0x0B, 0x0C, 0x28, 0x10, 0x00, 0x00, 0x25, 0x0D, + 0x10, 0x0C, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x3A, 0x0D, 0x0A, 0x09, 0x3A, 0x10, + 0x0B, 0x0C, 0x33, 0x0F, 0x0D, 0x10, 0x35, 0x11, 0x00, 0x00, 0x1B, 0x0D, 0x11, 0x00, 0x1E, 0x11, + 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x0D, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x0E, + 0x01, 0x0E, 0x1C, 0xE9, 0xFF, 0xFF, 0x1C, 0x5E, 0x00, 0x00, 0x26, 0x09, 0x06, 0x03, 0x1E, 0x09, + 0x2D, 0x00, 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, 0x0C, + 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x02, 0x1B, 0x0D, 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0E, + 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x28, 0x11, 0x00, 0x00, 0x49, 0x10, 0x01, 0x11, 0x1B, 0x11, + 0x10, 0x00, 0x1F, 0x11, 0x1F, 0x00, 0x3A, 0x10, 0x01, 0x11, 0x1B, 0x12, 0x10, 0x00, 0x49, 0x0A, + 0x0B, 0x0A, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, 0x0A, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x18, + 0x00, 0x00, 0x49, 0x0E, 0x0C, 0x0E, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, 0x0E, 0x1E, 0x10, + 0x02, 0x00, 0x1C, 0x13, 0x00, 0x00, 0x49, 0x0F, 0x0D, 0x0F, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, + 0x13, 0x0F, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x0E, 0x00, 0x00, 0x3A, 0x10, 0x0B, 0x0A, 0x3A, 0x13, + 0x0C, 0x0E, 0x3A, 0x14, 0x0D, 0x0F, 0x33, 0x12, 0x10, 0x13, 0x31, 0x14, 0x00, 0x00, 0x35, 0x15, + 0x00, 0x00, 0x1B, 0x10, 0x15, 0x00, 0x1E, 0x15, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x1B, 0x04, + 0x10, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x11, 0x01, 0x11, 0x1C, 0xE2, 0xFF, 0xFF, 0x1C, 0x30, + 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x0B, + 0x0A, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x0A, 0x0C, 0x00, 0x1B, 0x0C, + 0x0A, 0x00, 0x2A, 0x0A, 0x00, 0x00, 0x28, 0x0E, 0x00, 0x00, 0x49, 0x0D, 0x01, 0x0E, 0x1B, 0x0E, + 0x0D, 0x00, 0x1F, 0x0E, 0x23, 0x00, 0x3A, 0x0D, 0x01, 0x0E, 0x1B, 0x0F, 0x0D, 0x00, 0x2B, 0x0D, + 0x00, 0x00, 0x23, 0x10, 0x0D, 0x06, 0x1E, 0x10, 0x12, 0x00, 0x3A, 0x11, 0x0B, 0x0D, 0x1B, 0x12, + 0x11, 0x00, 0x3A, 0x11, 0x02, 0x0D, 0x1B, 0x13, 0x11, 0x00, 0x49, 0x11, 0x13, 0x12, 0x1B, 0x14, + 0x11, 0x00, 0x28, 0x15, 0x00, 0x00, 0x25, 0x11, 0x15, 0x14, 0x1E, 0x11, 0x04, 0x00, 0x29, 0x0A, + 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0B, 0x0D, 0x14, 0x3A, 0x15, + 0x13, 0x14, 0x3C, 0x0C, 0x0D, 0x15, 0x05, 0x0D, 0x0D, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, 0x0A, + 0x02, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x34, 0x0C, 0x00, 0x00, 0x35, 0x0D, + 0x00, 0x00, 0x1B, 0x10, 0x0D, 0x00, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x1B, 0x04, + 0x10, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x0E, 0x01, 0x0E, 0x1C, 0xDE, 0xFF, 0xFF, 0x03, 0x04, + 0x00, 0x00, 0x88, 0x6F, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFA, 0x01, 0xDA, 0x63, 0xDA, 0x87, 0xEF, 0xDA, 0x87, 0x20, + 0xDA, 0x86, 0x83, 0x00, 0x2B, 0x00, 0xDA, 0x85, 0x66, 0x00, 0x2B, 0x01, 0xCF, 0x0F, 0x6E, 0x6F, + 0x2D, 0x73, 0x69, 0x64, 0x65, 0x2D, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x20, 0x29, 0x05, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x6C, 0x2E, 0x01, 0x00, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x0B, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x25, 0x04, 0x03, + 0x05, 0x1E, 0x04, 0x04, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x03, 0x03, 0x00, 0x36, 0x03, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x04, 0x00, 0x35, 0x03, 0x04, + 0x00, 0x1E, 0x03, 0x04, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x36, 0x04, 0x00, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x05, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x10, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x06, 0x00, 0x35, 0x05, 0x06, 0x00, 0x32, 0x01, 0x05, + 0x00, 0x2C, 0x07, 0x03, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x1E, 0x06, 0x07, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x35, 0x07, 0x08, 0x00, 0x32, 0x01, 0x07, + 0x00, 0x2C, 0x08, 0x03, 0x00, 0x36, 0x08, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x29, 0x05, 0x00, + 0x00, 0x03, 0x05, 0x00, 0x00, 0x8F, 0x2E, 0x01, 0x05, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFF, + 0x03, 0x02, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, + 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x02, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFC, 0x03, 0x05, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFA, 0x03, 0x07, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x05, 0x00, 0x05, 0x01, 0x1F, + 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0xBF, 0xFF, 0x05, 0xBF, 0xF9, 0x03, + 0x00, 0x03, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xCF, 0x0B, 0x69, 0x73, 0x2D, 0x73, + 0x61, 0x66, 0x65, 0x2D, 0x64, 0x65, 0x66, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8F, + 0x3D, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0xDA, 0x82, 0xFB, 0xCB, + 0xCF, 0x05, 0x76, 0x61, 0x72, 0x66, 0x6E, 0xCB, 0xDA, 0x8A, 0x68, 0xDA, 0x8B, 0x9A, 0xCF, 0x08, + 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xCB, 0xDA, 0x80, 0x9C, 0xDA, 0x8B, 0x9A, 0xDA, + 0x8B, 0x62, 0xCB, 0xDA, 0x89, 0x88, 0xCB, 0xDA, 0x52, 0xDA, 0x8B, 0x9A, 0xCF, 0x04, 0x76, 0x61, + 0x72, 0x2D, 0xDA, 0x8B, 0x9A, 0xDA, 0x89, 0xF9, 0xDA, 0x8B, 0x9A, 0xDA, 0x80, 0x95, 0xCE, 0x07, + 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x2D, 0xDA, 0x87, 0x11, 0xDA, 0x8B, 0x9A, 0xDA, 0x87, 0x9E, + 0xDA, 0x8A, 0x75, 0xDA, 0x80, 0xE0, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x02, 0x02, + 0x02, 0x05, 0x13, 0x00, 0x06, 0xCE, 0x05, 0x75, 0x73, 0x65, 0x2D, 0x32, 0xDA, 0x18, 0xDA, 0x81, + 0x12, 0xDA, 0x8A, 0x80, 0xDA, 0x82, 0x04, 0xDA, 0x85, 0x9D, 0xDA, 0x8A, 0x79, 0x00, 0x13, 0x00, + 0xDA, 0x85, 0xDC, 0x00, 0x13, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x13, 0x02, 0xCF, 0x05, 0x75, 0x73, + 0x65, 0x2D, 0x32, 0x00, 0x13, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x6E, 0x02, + 0x13, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x6D, 0x05, 0x12, 0x05, 0xDA, 0x88, + 0x66, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x0F, + 0x00, 0x3A, 0x03, 0x01, 0x04, 0x1B, 0x05, 0x03, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x00, + 0x00, 0x35, 0x03, 0x06, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x33, 0x03, 0x06, + 0x07, 0x2C, 0x06, 0x03, 0x00, 0x32, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x06, 0x07, + 0x00, 0x49, 0x04, 0x01, 0x04, 0x1C, 0xF2, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x8F, 0x45, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0xD5, 0x04, 0xCF, 0x06, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0xCB, 0xDA, + 0x87, 0x52, 0xCB, 0xCF, 0x06, 0x64, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0xCB, 0xDA, 0x8A, 0x89, 0xCB, + 0xDA, 0x81, 0x00, 0xDA, 0x85, 0x9D, 0xDA, 0x80, 0xE7, 0xDA, 0x81, 0x01, 0xDA, 0x81, 0x35, 0x00, + 0x50, 0x00, 0xCF, 0x05, 0x74, 0x68, 0x75, 0x6E, 0x6B, 0x00, 0x50, 0x01, 0xDA, 0x85, 0xF8, 0x00, + 0x50, 0x02, 0xDA, 0x85, 0x87, 0x00, 0x50, 0x03, 0xDA, 0x85, 0xAB, 0x00, 0x50, 0x04, 0xCF, 0x12, + 0x66, 0x6C, 0x79, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x6F, 0x72, 0x08, 0x4F, 0x07, 0xDA, 0x86, 0xAF, 0x0C, 0x20, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x6F, 0x20, 0x4F, 0x08, 0xCF, 0x0A, 0x73, 0x61, 0x66, 0x65, 0x2D, 0x63, 0x68, + 0x65, 0x63, 0x6B, 0x3E, 0x4E, 0x0D, 0xDA, 0x85, 0xF9, 0x40, 0x4E, 0x0E, 0xDA, 0x82, 0x11, 0x49, + 0x4E, 0x0B, 0xCF, 0x06, 0x6E, 0x65, 0x77, 0x74, 0x75, 0x70, 0x2E, 0x04, 0x00, 0x00, 0x31, 0x01, + 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x4B, 0x00, 0x2B, 0x06, + 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x35, 0x06, 0x01, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, + 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x06, 0x08, 0x00, 0x1B, 0x08, 0x06, 0x00, 0x1E, 0x08, + 0x03, 0x00, 0x1B, 0x06, 0x08, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0B, + 0x02, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1E, 0x0A, 0x0B, 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x32, 0x0C, + 0x07, 0x00, 0x2C, 0x0D, 0x04, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1E, 0x0C, 0x03, 0x00, 0x2C, 0x0B, + 0x05, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x1B, 0x09, 0x0B, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x28, 0x09, 0x00, 0x00, 0x1B, 0x06, 0x09, 0x00, 0x1B, 0x08, 0x06, 0x00, 0x31, 0x08, + 0x00, 0x00, 0x2C, 0x09, 0x06, 0x00, 0x35, 0x06, 0x09, 0x00, 0x1E, 0x06, 0x06, 0x00, 0x31, 0x01, + 0x00, 0x00, 0x35, 0x09, 0x08, 0x00, 0x1E, 0x09, 0x02, 0x00, 0x36, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x1E, 0x08, 0x02, 0x00, 0x36, 0x00, 0x00, 0x00, 0x2C, 0x0A, 0x07, 0x00, 0x25, 0x09, + 0x0A, 0x07, 0x1E, 0x09, 0x08, 0x00, 0x2B, 0x0A, 0x01, 0x00, 0x32, 0x01, 0x0A, 0x00, 0x2C, 0x0B, + 0x08, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x32, 0x04, 0x0A, 0x00, 0x2C, 0x0B, 0x09, 0x00, 0x36, 0x0B, + 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0B, 0x0A, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1E, 0x0A, + 0x15, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x0C, 0x0B, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x3D, 0x0C, + 0x0B, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x3D, 0x0C, 0x0B, 0x01, 0x1B, 0x0E, 0x0C, 0x00, 0x34, 0x01, + 0x00, 0x00, 0x2C, 0x0B, 0x0C, 0x00, 0x32, 0x0B, 0x04, 0x00, 0x2C, 0x0C, 0x0D, 0x00, 0x35, 0x0B, + 0x0C, 0x00, 0x33, 0x0B, 0x0D, 0x0E, 0x2C, 0x0F, 0x0E, 0x00, 0x35, 0x0C, 0x0F, 0x00, 0x1B, 0x0B, + 0x0C, 0x00, 0x33, 0x0B, 0x02, 0x03, 0x2C, 0x0F, 0x0F, 0x00, 0x35, 0x0C, 0x0F, 0x00, 0x36, 0x0C, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8F, 0x47, 0x01, 0x05, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x00, 0x03, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x03, 0x09, 0x00, + 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x02, 0x0D, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x09, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x07, 0xBF, 0xFF, + 0x05, 0x07, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x05, 0x03, 0x0B, 0x00, 0x0B, 0x00, 0x07, + 0x00, 0x1F, 0x00, 0x07, 0xBF, 0xFD, 0x05, 0x06, 0x07, 0x02, 0x07, 0x00, 0x07, 0xBF, 0xF8, 0x05, + 0x09, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x02, 0x07, + 0x00, 0x07, 0x00, 0x07, 0xBF, 0xF5, 0x05, 0x0C, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, + 0x14, 0x00, 0x14, 0x00, 0x14, 0xBF, 0xFF, 0x07, 0x02, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x09, + 0xBF, 0xF2, 0x05, 0xBF, 0xF9, 0x03, 0xD7, 0x00, 0xCD, 0x03, 0xFF, 0x00, 0x00, 0x24, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x16, 0x7B, 0x00, 0x04, 0x16, 0xCE, 0x06, 0x64, 0x6F, 0x66, 0x69, + 0x6C, 0x65, 0xDA, 0x18, 0xDA, 0x85, 0x98, 0xDA, 0x85, 0x9C, 0xDA, 0x84, 0xBA, 0xDA, 0x85, 0x9D, + 0xDA, 0x85, 0x9F, 0xDA, 0x85, 0x95, 0xDA, 0x85, 0xCA, 0xDA, 0x65, 0xD0, 0x09, 0x63, 0x6F, 0x72, + 0x65, 0x2F, 0x66, 0x69, 0x6C, 0x65, 0xD0, 0x0B, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6D, 0xDA, 0x84, 0xBD, 0xDA, 0x84, 0xBE, 0xDA, 0x84, 0x96, 0xDA, 0x81, 0x12, 0xCE, + 0x14, 0x63, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x6E, 0x64, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x20, 0xDA, 0x85, 0xC7, 0xDA, 0x85, 0x99, 0xDA, 0x85, 0x9B, 0xDA, 0x85, + 0x93, 0xDA, 0x85, 0x94, 0xDA, 0x85, 0x96, 0xDA, 0x82, 0xF2, 0x00, 0x7B, 0x00, 0xDA, 0x84, 0xC3, + 0x02, 0x7B, 0x0A, 0xDA, 0x85, 0xD4, 0x05, 0x7B, 0x0B, 0xDA, 0x85, 0xD9, 0x08, 0x7B, 0x0C, 0xDA, + 0x85, 0xF8, 0x0B, 0x7B, 0x0D, 0xDA, 0x85, 0xDC, 0x0E, 0x7B, 0x0E, 0xDA, 0x87, 0xB5, 0x11, 0x7B, + 0x0F, 0xDA, 0x85, 0x87, 0x14, 0x7B, 0x10, 0xCF, 0x04, 0x65, 0x78, 0x69, 0x74, 0x15, 0x7B, 0x01, + 0xDA, 0x8B, 0xBB, 0x19, 0x2A, 0x11, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x59, 0x2A, + 0x7B, 0x11, 0xDA, 0x80, 0xAA, 0x2C, 0x7B, 0x13, 0xCF, 0x0C, 0x70, 0x61, 0x74, 0x68, 0x2D, 0x69, + 0x73, 0x2D, 0x66, 0x69, 0x6C, 0x65, 0x33, 0x7B, 0x15, 0xDA, 0x85, 0x87, 0x37, 0x7B, 0x17, 0xCF, + 0x05, 0x73, 0x70, 0x61, 0x74, 0x68, 0x37, 0x40, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x5A, 0x42, 0x7B, 0x18, 0xCF, 0x0A, 0x65, 0x78, 0x69, 0x74, 0x2D, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x43, 0x7B, 0x19, 0xCF, 0x0A, 0x65, 0x78, 0x69, 0x74, 0x2D, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x45, 0x7B, 0x1B, 0xDA, 0x85, 0xD8, 0x47, 0x7B, 0x1D, 0xCF, 0x02, 0x62, 0x70, 0x49, 0x7B, 0x1F, + 0xCF, 0x02, 0x62, 0x63, 0x51, 0x5A, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x6F, 0x7B, 0x20, 0xCF, 0x04, 0x6E, 0x65, 0x6E, 0x76, 0x2C, 0x0A, 0x00, 0x00, 0x3A, 0x09, 0x01, + 0x0A, 0x1B, 0x0A, 0x09, 0x00, 0x2C, 0x0B, 0x01, 0x00, 0x3A, 0x09, 0x01, 0x0B, 0x1B, 0x0B, 0x09, + 0x00, 0x2C, 0x0C, 0x02, 0x00, 0x3A, 0x09, 0x01, 0x0C, 0x1B, 0x0C, 0x09, 0x00, 0x2C, 0x0D, 0x03, + 0x00, 0x3A, 0x09, 0x01, 0x0D, 0x1B, 0x0D, 0x09, 0x00, 0x2C, 0x0E, 0x04, 0x00, 0x3A, 0x09, 0x01, + 0x0E, 0x1B, 0x0E, 0x09, 0x00, 0x2C, 0x0F, 0x05, 0x00, 0x3A, 0x09, 0x01, 0x0F, 0x1B, 0x0F, 0x09, + 0x00, 0x2C, 0x10, 0x06, 0x00, 0x3A, 0x09, 0x01, 0x10, 0x1B, 0x10, 0x09, 0x00, 0x2E, 0x01, 0x00, + 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x11, 0x07, 0x00, 0x35, 0x09, 0x11, 0x00, 0x1B, 0x11, 0x09, + 0x00, 0x2C, 0x13, 0x08, 0x00, 0x25, 0x12, 0x11, 0x13, 0x1E, 0x12, 0x03, 0x00, 0x1B, 0x09, 0x00, + 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x2C, 0x15, 0x09, 0x00, 0x25, 0x14, 0x11, 0x15, 0x1E, 0x14, 0x03, + 0x00, 0x1B, 0x13, 0x00, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x15, 0x0A, 0x00, 0x32, 0x00, 0x15, + 0x00, 0x2C, 0x16, 0x0B, 0x00, 0x35, 0x15, 0x16, 0x00, 0x1B, 0x13, 0x15, 0x00, 0x1B, 0x09, 0x13, + 0x00, 0x1B, 0x11, 0x09, 0x00, 0x25, 0x12, 0x11, 0x00, 0x1B, 0x13, 0x12, 0x00, 0x20, 0x0F, 0x05, + 0x00, 0x2C, 0x16, 0x0C, 0x00, 0x35, 0x15, 0x16, 0x00, 0x1B, 0x14, 0x15, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x14, 0x0F, 0x00, 0x1B, 0x15, 0x14, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x17, 0x0D, + 0x00, 0x35, 0x16, 0x17, 0x00, 0x1B, 0x17, 0x16, 0x00, 0x1E, 0x0C, 0x03, 0x00, 0x1B, 0x18, 0x0C, + 0x00, 0x1C, 0x06, 0x00, 0x00, 0x1E, 0x13, 0x03, 0x00, 0x1B, 0x19, 0x00, 0x00, 0x1C, 0x02, 0x00, + 0x00, 0x1B, 0x19, 0x17, 0x00, 0x1B, 0x18, 0x19, 0x00, 0x2C, 0x19, 0x02, 0x00, 0x3C, 0x15, 0x19, + 0x18, 0x28, 0x18, 0x00, 0x00, 0x28, 0x19, 0x00, 0x00, 0x30, 0x1A, 0x00, 0x00, 0x1B, 0x1B, 0x1A, + 0x00, 0x30, 0x1C, 0x01, 0x00, 0x1B, 0x1D, 0x1C, 0x00, 0x30, 0x1E, 0x02, 0x00, 0x1B, 0x1F, 0x1E, + 0x00, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x20, 0x0E, 0x00, 0x32, 0x20, 0x00, + 0x00, 0x2C, 0x21, 0x0D, 0x00, 0x35, 0x20, 0x21, 0x00, 0x01, 0x20, 0x00, 0x00, 0x30, 0x20, 0x03, + 0x00, 0x1E, 0x0C, 0x03, 0x00, 0x1B, 0x21, 0x0C, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x1E, 0x13, 0x03, + 0x00, 0x2C, 0x22, 0x0F, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x22, 0x17, 0x00, 0x1B, 0x21, 0x22, + 0x00, 0x2C, 0x22, 0x00, 0x00, 0x2C, 0x23, 0x10, 0x00, 0x33, 0x22, 0x0A, 0x23, 0x2C, 0x22, 0x05, + 0x00, 0x33, 0x1D, 0x22, 0x15, 0x2C, 0x22, 0x11, 0x00, 0x2C, 0x23, 0x12, 0x00, 0x33, 0x22, 0x1F, + 0x23, 0x2C, 0x22, 0x01, 0x00, 0x33, 0x1B, 0x22, 0x0B, 0x2C, 0x22, 0x13, 0x00, 0x2C, 0x23, 0x02, + 0x00, 0x33, 0x22, 0x20, 0x23, 0x2C, 0x22, 0x03, 0x00, 0x33, 0x21, 0x22, 0x0D, 0x2C, 0x22, 0x04, + 0x00, 0x32, 0x22, 0x0E, 0x00, 0x43, 0x20, 0x00, 0x00, 0x31, 0x20, 0x00, 0x00, 0x2C, 0x22, 0x14, + 0x00, 0x35, 0x21, 0x22, 0x00, 0x1B, 0x20, 0x21, 0x00, 0x1E, 0x13, 0x02, 0x00, 0x1C, 0x04, 0x00, + 0x00, 0x31, 0x11, 0x00, 0x00, 0x2C, 0x23, 0x15, 0x00, 0x35, 0x22, 0x23, 0x00, 0x1E, 0x18, 0x05, + 0x00, 0x1E, 0x19, 0x03, 0x00, 0x39, 0x22, 0x18, 0x19, 0x1C, 0x02, 0x00, 0x00, 0x01, 0x18, 0x00, + 0x00, 0x03, 0x20, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x01, 0x05, + 0x01, 0x14, 0xCE, 0x06, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0xDA, 0x18, 0xDA, 0x85, 0x98, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, + 0x0B, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xF8, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, + 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x87, 0xB5, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, + 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8B, 0xC7, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, 0xBB, 0xBF, 0xFF, + 0x00, 0x11, 0xDA, 0x8B, 0xC8, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x13, + 0xDA, 0x8B, 0xC9, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x8B, + 0xCA, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8B, 0xCB, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x8B, 0xCC, 0xBF, + 0xFF, 0x00, 0x19, 0xDA, 0x8B, 0xCD, 0x00, 0x05, 0x00, 0xDA, 0x82, 0x26, 0x00, 0x05, 0x01, 0xDA, + 0x85, 0x58, 0x00, 0x05, 0x02, 0xDA, 0x85, 0xD8, 0x2D, 0x03, 0x00, 0x11, 0x2B, 0x04, 0x00, 0x10, + 0x33, 0x03, 0x04, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8B, 0x96, + 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x08, 0x02, + 0x00, 0x02, 0x07, 0x20, 0x01, 0x01, 0x16, 0xCE, 0x02, 0x62, 0x70, 0xDA, 0x18, 0xDA, 0x85, 0xC2, + 0xDA, 0x8A, 0x74, 0xDA, 0x85, 0xCA, 0xDA, 0x82, 0x04, 0xDA, 0x84, 0x21, 0xDA, 0x81, 0x6B, 0xDA, + 0x82, 0x03, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xD4, + 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xF8, 0xBF, 0xFF, + 0x00, 0x0D, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x87, 0xB5, 0xBF, 0xFF, 0x00, 0x0F, + 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8B, 0xC7, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, + 0xBB, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x8B, 0xC8, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x80, 0xAA, 0xBF, + 0xFF, 0x00, 0x13, 0xDA, 0x8B, 0xC9, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, + 0x17, 0xDA, 0x8B, 0xCA, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8B, 0xCB, 0xBF, 0xFF, 0x00, 0x18, 0xDA, + 0x8B, 0xCC, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x8B, 0xCD, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x85, 0xD8, + 0x00, 0x20, 0x00, 0xDA, 0x1E, 0x00, 0x20, 0x01, 0xDA, 0x80, 0xD9, 0x00, 0x20, 0x02, 0xDA, 0x8B, + 0xCE, 0x10, 0x20, 0x04, 0xDA, 0x82, 0x26, 0x2D, 0x03, 0x00, 0x10, 0x1E, 0x03, 0x08, 0x00, 0x32, + 0x00, 0x01, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x2D, 0x03, 0x00, 0x15, 0x2C, + 0x04, 0x02, 0x00, 0x29, 0x05, 0x00, 0x00, 0x3C, 0x03, 0x04, 0x05, 0x2C, 0x03, 0x03, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x41, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x30, 0x05, 0x00, 0x00, 0x2C, + 0x06, 0x04, 0x00, 0x32, 0x05, 0x06, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x35, 0x06, 0x07, 0x00, 0x28, + 0x07, 0x00, 0x00, 0x37, 0x05, 0x06, 0x07, 0x2B, 0x06, 0x00, 0x00, 0x2B, 0x07, 0xFE, 0xFF, 0x33, + 0x04, 0x06, 0x07, 0x2C, 0x07, 0x06, 0x00, 0x35, 0x06, 0x07, 0x00, 0x2F, 0x06, 0x00, 0x18, 0x2D, + 0x07, 0x00, 0x18, 0x03, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x04, 0x0F, 0x01, 0x04, 0xDA, 0x18, 0xDA, 0x89, 0xFE, 0xDA, 0x81, 0x07, 0xDA, 0x85, + 0x22, 0xDA, 0x85, 0xC2, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, + 0xD9, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8B, 0xCE, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x82, 0x26, 0x2C, + 0x00, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x04, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x35, + 0x00, 0x01, 0x00, 0x2C, 0x01, 0x02, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2C, + 0x02, 0x01, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2D, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x01, 0x32, + 0x02, 0x03, 0x00, 0x2C, 0x02, 0x03, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8B, 0x9D, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x8B, 0x98, 0x05, 0x00, + 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x15, 0x00, + 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x05, 0x00, 0x05, 0x13, 0x00, 0x00, + 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x0B, 0x05, 0x00, 0x05, 0x07, 0x22, 0x01, 0x01, 0x1A, 0xCE, + 0x02, 0x62, 0x63, 0xDA, 0x18, 0xDA, 0x85, 0xA0, 0xDA, 0x8A, 0x74, 0xDA, 0x85, 0xCA, 0xDA, 0x82, + 0x04, 0xDA, 0x84, 0x21, 0xDA, 0x81, 0x6B, 0xDA, 0x82, 0x03, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x84, + 0xC3, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xD9, 0xBF, + 0xFF, 0x00, 0x0C, 0xDA, 0x85, 0xF8, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, + 0x0E, 0xDA, 0x87, 0xB5, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x8B, 0xC7, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, 0xBB, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x8B, 0xC8, + 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x8B, 0xC9, 0xBF, 0xFF, + 0x00, 0x15, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x8B, 0xCA, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x8B, 0xCB, 0xBF, 0xFF, 0x00, 0x18, 0xDA, 0x8B, 0xCC, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x8B, + 0xCD, 0xBF, 0xFF, 0x00, 0x1B, 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x8B, 0xCE, 0x00, + 0x22, 0x00, 0xDA, 0x1E, 0x00, 0x22, 0x01, 0xDA, 0x80, 0xD9, 0x00, 0x22, 0x02, 0xDA, 0x88, 0x6B, + 0x00, 0x22, 0x03, 0xDA, 0x88, 0x66, 0x00, 0x22, 0x04, 0xDA, 0x82, 0x6D, 0x00, 0x22, 0x05, 0xDA, + 0x8B, 0xCF, 0x11, 0x22, 0x07, 0xDA, 0x82, 0x26, 0x2D, 0x06, 0x00, 0x10, 0x1E, 0x06, 0x09, 0x00, + 0x33, 0x00, 0x01, 0x02, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x2B, 0x06, 0x01, 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, + 0x2D, 0x06, 0x00, 0x15, 0x2C, 0x07, 0x02, 0x00, 0x29, 0x08, 0x00, 0x00, 0x3C, 0x06, 0x07, 0x08, + 0x2C, 0x06, 0x03, 0x00, 0x31, 0x06, 0x00, 0x00, 0x41, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, + 0x30, 0x08, 0x00, 0x00, 0x2C, 0x09, 0x04, 0x00, 0x32, 0x08, 0x09, 0x00, 0x2C, 0x0A, 0x05, 0x00, + 0x35, 0x09, 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x37, 0x08, 0x09, 0x0A, 0x2B, 0x09, 0x00, 0x00, + 0x2B, 0x0A, 0xFE, 0xFF, 0x33, 0x07, 0x09, 0x0A, 0x2C, 0x0A, 0x06, 0x00, 0x35, 0x09, 0x0A, 0x00, + 0x2F, 0x09, 0x00, 0x18, 0x2F, 0x01, 0x00, 0x19, 0x2D, 0x0A, 0x00, 0x19, 0x03, 0x0A, 0x00, 0x00, + 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x13, 0x01, 0x07, 0xDA, + 0x18, 0xDA, 0x89, 0xFE, 0xDA, 0x81, 0x07, 0xDA, 0x85, 0x22, 0xDA, 0x85, 0xA0, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xD9, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x88, + 0x6B, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x88, 0x66, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x82, 0x6D, 0xBF, + 0xFF, 0x00, 0x05, 0xDA, 0x8B, 0xCF, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x82, 0x26, 0x2C, 0x00, 0x00, + 0x00, 0x2D, 0x01, 0x00, 0x07, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x35, 0x00, 0x01, + 0x00, 0x2C, 0x01, 0x02, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2C, 0x02, 0x01, + 0x00, 0x35, 0x01, 0x02, 0x00, 0x2D, 0x02, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x2D, 0x04, 0x00, + 0x02, 0x33, 0x02, 0x03, 0x04, 0x2D, 0x02, 0x00, 0x03, 0x2D, 0x03, 0x00, 0x04, 0x32, 0x02, 0x03, + 0x00, 0x2C, 0x02, 0x03, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8B, 0xA6, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x8B, 0xA1, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, + 0x15, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x9D, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x07, 0x02, 0x02, 0x02, 0x09, 0x25, 0x01, 0x16, 0xDA, 0x18, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, + 0xDA, 0x82, 0x04, 0xDA, 0x85, 0x26, 0xDA, 0x85, 0x8C, 0xDA, 0x8A, 0x74, 0xDA, 0x85, 0x8D, 0xDA, + 0x85, 0x85, 0xDA, 0x85, 0xCA, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x0A, + 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x85, + 0xF8, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x85, 0xDC, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x87, 0xB5, 0xBF, + 0xFF, 0x00, 0x0F, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8B, 0xC7, 0xBF, 0xFF, 0x00, + 0x01, 0xDA, 0x8B, 0xBB, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x8B, 0xC8, 0xBF, 0xFF, 0x00, 0x11, 0xDA, + 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x8B, 0xC9, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x85, 0x87, + 0xBF, 0xFF, 0x00, 0x17, 0xDA, 0x8B, 0xCA, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8B, 0xCB, 0xBF, 0xFF, + 0x00, 0x18, 0xDA, 0x8B, 0xCC, 0xBF, 0xFF, 0x00, 0x19, 0xDA, 0x8B, 0xCD, 0xBF, 0xFF, 0x00, 0x1B, + 0xDA, 0x85, 0xD8, 0xBF, 0xFF, 0x00, 0x1D, 0xDA, 0x8B, 0xCE, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x8B, + 0xCF, 0x00, 0x25, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x25, 0x01, 0xDA, 0x1E, 0x31, 0x00, 0x00, 0x00, + 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x4A, 0x03, 0x02, 0x04, + 0x1E, 0x03, 0x1F, 0x00, 0x2D, 0x02, 0x00, 0x10, 0x1E, 0x02, 0x0B, 0x00, 0x2C, 0x02, 0x02, 0x00, + 0x33, 0x00, 0x01, 0x02, 0x2C, 0x04, 0x03, 0x00, 0x35, 0x02, 0x04, 0x00, 0x2C, 0x04, 0x04, 0x00, + 0x35, 0x02, 0x04, 0x00, 0x2B, 0x02, 0x01, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x05, 0x00, + 0x35, 0x02, 0x04, 0x00, 0x2D, 0x04, 0x00, 0x15, 0x2C, 0x05, 0x06, 0x00, 0x3B, 0x02, 0x04, 0x05, + 0x1E, 0x02, 0x07, 0x00, 0x2D, 0x04, 0x00, 0x15, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x07, 0x00, + 0x35, 0x04, 0x05, 0x00, 0x32, 0x00, 0x01, 0x00, 0x36, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x15, + 0x2C, 0x05, 0x08, 0x00, 0x29, 0x06, 0x00, 0x00, 0x3C, 0x04, 0x05, 0x06, 0x2F, 0x01, 0x00, 0x18, + 0x2F, 0x00, 0x00, 0x19, 0x2D, 0x04, 0x00, 0x19, 0x03, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0xBF, 0xFF, 0x8B, 0xB2, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x26, 0x00, 0x26, 0x00, 0x20, 0x01, + 0x22, 0x00, 0x22, 0x01, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x01, 0x24, 0x00, 0x24, 0x01, + 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x01, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x22, 0x01, + 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x24, 0x00, 0x24, 0x02, 0x26, 0x00, 0x26, 0x00, + 0x26, 0x00, 0x26, 0x01, 0x26, 0x01, 0x26, 0x00, 0x26, 0x00, 0x26, 0xBF, 0xF6, 0x20, 0x8B, 0x86, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x06, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x03, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, + 0xFD, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x04, 0x15, 0x00, 0x03, 0x01, 0x03, 0x00, 0x10, 0x00, 0x10, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x14, + 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x09, 0x03, 0x00, 0x03, 0x0A, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x05, 0x06, 0x1E, 0x10, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, + 0x00, 0x26, 0x00, 0x1B, 0xBF, 0xEC, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, + 0xFF, 0x03, 0x16, 0x03, 0x00, 0x03, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x01, 0x03, 0x01, 0x05, + 0x01, 0x07, 0xBF, 0xFF, 0x05, 0x02, 0x07, 0xBF, 0xC0, 0x01, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, + 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8B, 0x94, + 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8B, 0x91, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8B, 0x95, 0x2D, 0x00, + 0x00, 0x01, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x35, 0x00, 0x01, 0x00, 0x2D, 0x01, + 0x00, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x33, 0x01, 0x02, 0x03, 0x34, 0x00, + 0x00, 0x00, 0x2C, 0x01, 0x03, 0x00, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0x6C, 0x31, 0x00, + 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x8F, 0x69, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x03, 0x01, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x03, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFD, 0x03, 0x04, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, + 0xF3, 0x01, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, + 0x72, 0x69, 0x6D, 0x6C, 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, + 0x6D, 0x6C, 0xCF, 0x06, 0x2A, 0x65, 0x78, 0x69, 0x74, 0x2A, 0xDA, 0x85, 0xCA, 0xCF, 0x0C, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0x72, 0xD8, 0x0C, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0x72, 0xDA, 0x84, 0x20, 0xDA, 0x81, 0x07, 0xCF, + 0x0B, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x81, 0x9D, 0xCF, + 0x05, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0xDA, 0x44, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, + 0x6F, 0x75, 0x6E, 0x64, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6F, 0x75, 0x6E, 0x64, + 0xCF, 0x05, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xDA, 0x84, 0x0F, 0xCF, 0x05, 0x73, 0x74, 0x64, 0x69, + 0x6E, 0xD8, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6E, 0xCF, 0x10, 0x2A, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x2A, 0xDA, 0x87, 0xB9, 0xCF, 0x12, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, + 0x6C, 0xDA, 0x82, 0x5D, 0xCF, 0x0A, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0xD8, 0x0A, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xCF, 0x0A, 0x6D, 0x61, + 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x32, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, + 0x74, 0x61, 0x6E, 0x32, 0xCF, 0x0C, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, 0x2D, 0x62, 0x79, 0x74, + 0x65, 0x73, 0xD8, 0x0C, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, + 0xDA, 0x8A, 0x7D, 0xDA, 0x8A, 0x7B, 0xCF, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, + 0x61, 0x74, 0x68, 0x73, 0xDA, 0x87, 0x5C, 0xCF, 0x0C, 0x65, 0x76, 0x2F, 0x61, 0x6C, 0x6C, 0x2D, + 0x74, 0x61, 0x73, 0x6B, 0x73, 0xD8, 0x0C, 0x65, 0x76, 0x2F, 0x61, 0x6C, 0x6C, 0x2D, 0x74, 0x61, + 0x73, 0x6B, 0x73, 0xCF, 0x05, 0x70, 0x61, 0x72, 0x73, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x07, 0x01, 0x01, 0x01, 0x09, 0x28, 0x00, 0x03, 0xCE, 0x05, 0x70, 0x61, 0x72, 0x73, 0x65, + 0xDA, 0x18, 0xDA, 0x84, 0x37, 0xDA, 0x83, 0x59, 0xDA, 0x84, 0x38, 0xDA, 0x81, 0x72, 0xDA, 0x84, + 0x39, 0xDA, 0x83, 0xD7, 0xDA, 0x84, 0x3A, 0xDA, 0x84, 0x3B, 0xCE, 0x08, 0x6E, 0x6F, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x00, 0x28, 0x00, 0xDA, 0x82, 0x05, 0x00, 0x28, 0x01, 0xDA, 0x8B, 0xEC, + 0x02, 0x28, 0x03, 0xDA, 0x6D, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, + 0x00, 0x32, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x02, 0x04, 0x00, 0x31, 0x03, 0x00, + 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x02, 0x04, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x25, 0x04, 0x05, + 0x02, 0x1E, 0x04, 0x05, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x35, 0x02, 0x05, + 0x00, 0x01, 0x02, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x05, 0x00, 0x35, 0x02, 0x04, + 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x35, 0x02, 0x04, 0x00, 0x1E, 0x02, 0x04, + 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x07, 0x00, 0x36, 0x04, 0x00, 0x00, 0x31, 0x03, 0x00, + 0x00, 0x2C, 0x05, 0x02, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x25, 0x05, 0x06, + 0x04, 0x1E, 0x05, 0x06, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x35, 0x04, 0x06, + 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x08, 0x00, 0x01, 0x04, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x8A, 0x82, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x07, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x09, 0x00, 0x09, + 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0xCF, 0x04, 0x66, 0x6F, 0x72, 0x76, 0xD7, 0x00, 0xCD, 0x00, + 0xDD, 0x00, 0x00, 0x08, 0x03, 0x03, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x08, 0x00, 0x05, 0xCE, + 0x04, 0x66, 0x6F, 0x72, 0x76, 0xDA, 0x18, 0xDA, 0x88, 0x60, 0xDA, 0x32, 0xDA, 0x8A, 0x2F, 0x00, + 0x08, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x08, 0x01, 0xDA, 0x82, 0x5F, 0x00, 0x08, 0x02, 0xDA, 0x8A, + 0x31, 0x00, 0x08, 0x03, 0xDA, 0x81, 0x74, 0x00, 0x08, 0x04, 0xDA, 0x8B, 0xF0, 0x33, 0x00, 0x01, + 0x02, 0x2B, 0x05, 0x01, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x33, 0x05, 0x06, + 0x07, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x81, 0xF5, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x84, + 0x3C, 0xDA, 0x84, 0x35, 0xCF, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, + 0x69, 0x69, 0x2D, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0xCF, 0x03, 0x6E, 0x6F, + 0x74, 0xDA, 0x82, 0x30, 0xCF, 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, + 0xD8, 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0xCF, 0x08, 0x65, 0x76, + 0x2F, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xD8, 0x08, 0x65, 0x76, 0x2F, 0x63, 0x6F, 0x75, 0x6E, 0x74, + 0xDA, 0x87, 0xAE, 0xDA, 0x87, 0x59, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x77, 0x72, 0x69, + 0x74, 0x65, 0xDA, 0x86, 0x9A, 0xCF, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, + 0xD8, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xCF, 0x0C, 0x6F, 0x73, 0x2F, + 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x6B, 0x69, 0x6C, 0x6C, 0xD8, 0x0C, 0x6F, 0x73, 0x2F, 0x70, 0x72, + 0x6F, 0x63, 0x2D, 0x6B, 0x69, 0x6C, 0x6C, 0xCF, 0x05, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0xD7, 0x00, + 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x07, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x0C, 0x00, + 0x03, 0xCE, 0x05, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0xDA, 0x18, 0xDA, 0x52, 0xD6, 0x00, 0xDA, 0x84, + 0x7C, 0xDA, 0x58, 0x00, 0x0C, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x0C, 0x01, 0xDA, 0x81, 0x74, 0x00, + 0x0C, 0x02, 0xDA, 0x8B, 0xFF, 0x2C, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, + 0x05, 0x45, 0x03, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x05, 0x02, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x33, 0x06, 0x03, 0x04, 0x45, 0x05, 0x00, + 0x00, 0x03, 0x05, 0x00, 0x00, 0x81, 0x67, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, + 0x12, 0x65, 0x76, 0x2F, 0x67, 0x69, 0x76, 0x65, 0x2D, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, + 0x73, 0x6F, 0x72, 0xD8, 0x12, 0x65, 0x76, 0x2F, 0x67, 0x69, 0x76, 0x65, 0x2D, 0x73, 0x75, 0x70, + 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, + 0x61, 0x6E, 0x68, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x68, 0xDA, + 0x87, 0xA4, 0xDA, 0x87, 0xA2, 0xDA, 0x8B, 0x0F, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x09, + 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x16, 0x00, 0x04, 0xCE, 0x10, 0x65, 0x76, 0x2F, + 0x77, 0x69, 0x74, 0x68, 0x2D, 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x18, 0xDA, + 0x51, 0xDA, 0x81, 0xA7, 0xDA, 0x8A, 0xF1, 0xDA, 0x81, 0x6D, 0xDA, 0x81, 0x73, 0x00, 0x16, 0x00, + 0xCF, 0x03, 0x73, 0x65, 0x63, 0x00, 0x16, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x16, 0x02, 0xDA, 0x8B, + 0x0F, 0x02, 0x16, 0x04, 0xDA, 0x80, 0xAA, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, + 0x04, 0x03, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x31, 0x05, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, + 0x03, 0x00, 0x00, 0x32, 0x04, 0x03, 0x00, 0x46, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x28, + 0x07, 0x00, 0x00, 0x33, 0x06, 0x00, 0x07, 0x31, 0x04, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, + 0x07, 0x03, 0x00, 0x32, 0x07, 0x04, 0x00, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x33, + 0x08, 0x05, 0x03, 0x31, 0x06, 0x00, 0x00, 0x45, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x8E, + 0xB2, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xDA, 0x86, 0x35, 0xDA, + 0x80, 0xE7, 0xCF, 0x07, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x05, 0x00, 0x02, 0xCE, 0x07, 0x74, 0x72, 0x75, 0x74, + 0x68, 0x79, 0x3F, 0xDA, 0x18, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, 0xDA, 0x8C, 0x0A, + 0x1E, 0x00, 0x03, 0x00, 0x29, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, + 0x03, 0x02, 0x00, 0x00, 0x71, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0xCF, 0x0A, + 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, + 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xCF, 0x07, 0x65, 0x76, 0x2F, 0x6C, 0x6F, 0x63, 0x6B, 0xD8, + 0x07, 0x65, 0x76, 0x2F, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x89, 0x98, 0xD7, 0x00, 0xCD, 0x00, 0xDD, + 0x00, 0x00, 0x16, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0xAD, 0x00, 0x2F, 0xCE, + 0x04, 0x73, 0x6F, 0x6D, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0xA9, 0x00, 0x80, 0xAD, 0x00, 0xDA, 0x81, + 0xD2, 0x00, 0x80, 0xAD, 0x01, 0xDA, 0x1F, 0x00, 0x80, 0xAD, 0x02, 0xDA, 0x80, 0xAB, 0x00, 0x80, + 0xAD, 0x03, 0xDA, 0x89, 0x98, 0x00, 0x80, 0xAD, 0x04, 0xDA, 0x80, 0xAD, 0x02, 0x80, 0xAC, 0x06, + 0xDA, 0x80, 0xAE, 0x02, 0x80, 0xAC, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x58, + 0x04, 0x13, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x5A, 0x07, 0x13, 0x08, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x33, 0x59, 0x0A, 0x13, 0x09, 0xDA, 0x1E, 0x0D, 0x11, 0x0A, + 0xDA, 0x80, 0xD9, 0x17, 0x2D, 0x09, 0xDA, 0x80, 0xB2, 0x18, 0x2D, 0x08, 0xDA, 0x80, 0xB3, 0x18, + 0x2D, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x1B, 0x2D, 0x0B, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x1E, 0x2D, 0x0C, 0xDA, 0x1E, 0x27, 0x2B, 0x0A, 0xDA, + 0x80, 0xD9, 0x31, 0x50, 0x0A, 0xDA, 0x80, 0xB2, 0x33, 0x50, 0x0B, 0xDA, 0x80, 0xB6, 0x34, 0x50, + 0x09, 0xDA, 0x80, 0xB3, 0x35, 0x50, 0x0C, 0xDA, 0x80, 0xB7, 0x35, 0x50, 0x01, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x38, 0x50, 0x0E, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x32, 0x3B, 0x50, 0x0F, 0xDA, 0x1E, 0x4A, 0x4E, 0x0D, 0xDA, 0x80, 0xD9, 0x54, 0x7D, 0x0B, + 0xDA, 0x80, 0xB2, 0x56, 0x7D, 0x0C, 0xDA, 0x80, 0xB6, 0x58, 0x7D, 0x0D, 0xDA, 0x80, 0xBA, 0x59, + 0x7D, 0x0A, 0xDA, 0x80, 0xB3, 0x5A, 0x7D, 0x0E, 0xDA, 0x80, 0xB7, 0x5B, 0x7D, 0x0F, 0xDA, 0x80, + 0xBB, 0x5B, 0x7D, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x5E, 0x7D, 0x11, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x61, 0x7D, 0x12, 0xDA, 0x1E, 0x77, 0x7B, + 0x10, 0xDA, 0x80, 0xD9, 0x80, 0x81, 0x80, 0xAC, 0x0B, 0xDA, 0x80, 0xBE, 0x80, 0x85, 0x80, 0xAC, + 0x0C, 0xDA, 0x80, 0xBF, 0x80, 0x86, 0x80, 0xAC, 0x0A, 0xDA, 0x80, 0xC0, 0x80, 0x86, 0x80, 0xAC, + 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x80, 0x89, 0x80, 0xAC, 0x0E, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x80, 0x8C, 0x80, 0xAC, 0x0F, 0xDA, 0x1E, 0x80, + 0x8D, 0x80, 0xA1, 0x0D, 0xDA, 0x80, 0xC3, 0x80, 0x8D, 0x80, 0xA1, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x80, 0x91, 0x80, 0x9F, 0x12, 0xDA, 0x80, 0xC5, 0x80, 0x93, 0x80, + 0x9F, 0x13, 0xDA, 0x80, 0xC6, 0x80, 0x95, 0x80, 0x9F, 0x14, 0xDA, 0x80, 0xC7, 0x80, 0xA6, 0x80, + 0xAA, 0x10, 0xDA, 0x80, 0xD9, 0x28, 0x04, 0x00, 0x00, 0x3F, 0x05, 0x02, 0x00, 0x1B, 0x06, 0x05, + 0x00, 0x26, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x10, 0x00, 0x28, 0x08, 0x00, 0x00, 0x49, 0x07, 0x01, + 0x08, 0x1B, 0x08, 0x07, 0x00, 0x1F, 0x08, 0x0B, 0x00, 0x3A, 0x07, 0x01, 0x08, 0x1B, 0x09, 0x07, + 0x00, 0x31, 0x09, 0x00, 0x00, 0x35, 0x07, 0x00, 0x00, 0x1B, 0x0A, 0x07, 0x00, 0x1E, 0x07, 0x03, + 0x00, 0x1B, 0x04, 0x0A, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x08, 0x01, 0x08, 0x1C, 0xF6, 0xFF, + 0xFF, 0x1C, 0x99, 0x00, 0x00, 0x26, 0x07, 0x06, 0x01, 0x1E, 0x07, 0x19, 0x00, 0x3D, 0x08, 0x02, + 0x00, 0x1B, 0x09, 0x08, 0x00, 0x28, 0x08, 0x00, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x49, 0x0A, 0x01, + 0x0B, 0x1B, 0x0B, 0x0A, 0x00, 0x1F, 0x0B, 0x11, 0x00, 0x3A, 0x0A, 0x01, 0x0B, 0x1B, 0x0C, 0x0A, + 0x00, 0x49, 0x08, 0x09, 0x08, 0x28, 0x0D, 0x00, 0x00, 0x25, 0x0A, 0x0D, 0x08, 0x1E, 0x0A, 0x02, + 0x00, 0x1C, 0x0A, 0x00, 0x00, 0x3A, 0x0A, 0x09, 0x08, 0x32, 0x0C, 0x0A, 0x00, 0x35, 0x0D, 0x00, + 0x00, 0x1B, 0x0A, 0x0D, 0x00, 0x1E, 0x0D, 0x03, 0x00, 0x1B, 0x04, 0x0A, 0x00, 0x1C, 0x03, 0x00, + 0x00, 0x49, 0x0B, 0x01, 0x0B, 0x1C, 0xF0, 0xFF, 0xFF, 0x1C, 0x7F, 0x00, 0x00, 0x26, 0x08, 0x06, + 0x02, 0x1E, 0x08, 0x22, 0x00, 0x3D, 0x09, 0x02, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x3D, 0x09, 0x02, + 0x01, 0x1B, 0x0B, 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x28, 0x0E, 0x00, + 0x00, 0x49, 0x0D, 0x01, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1F, 0x0E, 0x17, 0x00, 0x3A, 0x0D, 0x01, + 0x0E, 0x1B, 0x0F, 0x0D, 0x00, 0x49, 0x09, 0x0A, 0x09, 0x28, 0x10, 0x00, 0x00, 0x25, 0x0D, 0x10, + 0x09, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x10, 0x00, 0x00, 0x49, 0x0C, 0x0B, 0x0C, 0x28, 0x10, 0x00, + 0x00, 0x25, 0x0D, 0x10, 0x0C, 0x1E, 0x0D, 0x02, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x3A, 0x0D, 0x0A, + 0x09, 0x3A, 0x10, 0x0B, 0x0C, 0x33, 0x0F, 0x0D, 0x10, 0x35, 0x11, 0x00, 0x00, 0x1B, 0x0D, 0x11, + 0x00, 0x1E, 0x11, 0x03, 0x00, 0x1B, 0x04, 0x0D, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x0E, 0x01, + 0x0E, 0x1C, 0xEA, 0xFF, 0xFF, 0x1C, 0x5C, 0x00, 0x00, 0x26, 0x09, 0x06, 0x03, 0x1E, 0x09, 0x2C, + 0x00, 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, 0x0C, 0x0A, + 0x00, 0x3D, 0x0A, 0x02, 0x02, 0x1B, 0x0D, 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0E, 0x00, + 0x00, 0x28, 0x0F, 0x00, 0x00, 0x28, 0x11, 0x00, 0x00, 0x49, 0x10, 0x01, 0x11, 0x1B, 0x11, 0x10, + 0x00, 0x1F, 0x11, 0x1E, 0x00, 0x3A, 0x10, 0x01, 0x11, 0x1B, 0x12, 0x10, 0x00, 0x49, 0x0A, 0x0B, + 0x0A, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, 0x0A, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x17, 0x00, + 0x00, 0x49, 0x0E, 0x0C, 0x0E, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, 0x0E, 0x1E, 0x10, 0x02, + 0x00, 0x1C, 0x12, 0x00, 0x00, 0x49, 0x0F, 0x0D, 0x0F, 0x28, 0x13, 0x00, 0x00, 0x25, 0x10, 0x13, + 0x0F, 0x1E, 0x10, 0x02, 0x00, 0x1C, 0x0D, 0x00, 0x00, 0x3A, 0x10, 0x0B, 0x0A, 0x3A, 0x13, 0x0C, + 0x0E, 0x3A, 0x14, 0x0D, 0x0F, 0x33, 0x12, 0x10, 0x13, 0x31, 0x14, 0x00, 0x00, 0x35, 0x15, 0x00, + 0x00, 0x1B, 0x10, 0x15, 0x00, 0x1E, 0x15, 0x03, 0x00, 0x1B, 0x04, 0x10, 0x00, 0x1C, 0x03, 0x00, + 0x00, 0x49, 0x11, 0x01, 0x11, 0x1C, 0xE3, 0xFF, 0xFF, 0x1C, 0x2F, 0x00, 0x00, 0x31, 0x06, 0x00, + 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x31, 0x06, 0x00, + 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x0A, 0x0C, 0x00, 0x1B, 0x0C, 0x0A, 0x00, 0x2A, 0x0A, 0x00, + 0x00, 0x28, 0x0E, 0x00, 0x00, 0x49, 0x0D, 0x01, 0x0E, 0x1B, 0x0E, 0x0D, 0x00, 0x1F, 0x0E, 0x22, + 0x00, 0x3A, 0x0D, 0x01, 0x0E, 0x1B, 0x0F, 0x0D, 0x00, 0x2B, 0x0D, 0x00, 0x00, 0x23, 0x10, 0x0D, + 0x06, 0x1E, 0x10, 0x12, 0x00, 0x3A, 0x11, 0x0B, 0x0D, 0x1B, 0x12, 0x11, 0x00, 0x3A, 0x11, 0x02, + 0x0D, 0x1B, 0x13, 0x11, 0x00, 0x49, 0x11, 0x13, 0x12, 0x1B, 0x14, 0x11, 0x00, 0x28, 0x15, 0x00, + 0x00, 0x25, 0x11, 0x15, 0x14, 0x1E, 0x11, 0x04, 0x00, 0x29, 0x0A, 0x00, 0x00, 0x1C, 0x07, 0x00, + 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0B, 0x0D, 0x14, 0x3A, 0x15, 0x13, 0x14, 0x3C, 0x0C, 0x0D, + 0x15, 0x05, 0x0D, 0x0D, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x0A, 0x00, + 0x00, 0x31, 0x0F, 0x00, 0x00, 0x34, 0x0C, 0x00, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x1B, 0x10, 0x0D, + 0x00, 0x1E, 0x0D, 0x03, 0x00, 0x1B, 0x04, 0x10, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x49, 0x0E, 0x01, + 0x0E, 0x1C, 0xDF, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x88, 0x77, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xCF, 0x10, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6C, 0x61, 0x73, + 0x74, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xDA, 0x84, 0x9E, 0xCF, 0x0E, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2F, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xDA, 0x84, 0x98, 0xCF, 0x01, 0x25, + 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x1E, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x13, 0xDA, 0x85, 0x64, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, + 0x2B, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, + 0x2B, 0x03, 0x01, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x0F, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, + 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x0F, 0x03, 0x03, 0x04, + 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, + 0xCF, 0x06, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x66, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, + 0x01, 0x01, 0x01, 0x00, 0x0E, 0x00, 0x06, 0xCE, 0x06, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x66, 0xDA, + 0x18, 0x00, 0x0E, 0x00, 0xDA, 0x80, 0xE8, 0x00, 0x0E, 0x01, 0xDA, 0x8C, 0x23, 0x00, 0x0E, 0x00, + 0xDA, 0x24, 0x02, 0x0E, 0x03, 0xDA, 0x22, 0x04, 0x0E, 0x04, 0xDA, 0x23, 0x08, 0x0D, 0x05, 0xDA, + 0x1E, 0x28, 0x03, 0x00, 0x00, 0x49, 0x02, 0x00, 0x03, 0x1B, 0x03, 0x02, 0x00, 0x3B, 0x02, 0x00, + 0x03, 0x1B, 0x04, 0x02, 0x00, 0x49, 0x03, 0x00, 0x03, 0x1F, 0x03, 0x07, 0x00, 0x3A, 0x02, 0x00, + 0x03, 0x1B, 0x05, 0x02, 0x00, 0x21, 0x02, 0x05, 0x04, 0x1E, 0x02, 0x02, 0x00, 0x1B, 0x04, 0x05, + 0x00, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x82, 0xED, 0x0A, 0x00, 0x0A, 0x00, 0x0A, + 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, + 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0xCF, 0x01, 0x2A, 0xD7, 0x00, 0xCD, 0x00, 0x09, 0x00, 0x0B, + 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xDA, 0x82, 0x00, 0x3F, 0x01, 0x00, + 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, + 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x3D, 0x04, 0x00, + 0x00, 0x0A, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, + 0x00, 0x3A, 0x04, 0x00, 0x05, 0x0A, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, + 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x01, 0x2B, 0xDA, 0x32, 0xCF, 0x08, + 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, + 0x65, 0x70, 0xCF, 0x01, 0x2D, 0xDA, 0x81, 0x52, 0xCF, 0x01, 0x2F, 0xDA, 0x82, 0xDD, 0xCF, 0x0B, + 0x70, 0x65, 0x67, 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xD8, 0x0B, 0x70, 0x65, 0x67, + 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xCF, 0x0B, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, + 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xDA, 0x86, 0x85, 0xDA, 0x8B, 0xA0, 0xDA, 0x8B, 0x9E, 0xCF, 0x01, + 0x3C, 0xDA, 0x88, 0x60, 0xDA, 0x81, 0x87, 0xDA, 0x84, 0x7F, 0xDA, 0x8A, 0xE6, 0xDA, 0x88, 0x64, + 0xCF, 0x06, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0xDA, 0x8A, 0xD0, 0xCF, 0x03, 0x63, 0x68, 0x72, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x03, 0x14, 0x00, 0x03, 0xCE, + 0x03, 0x63, 0x68, 0x72, 0xDA, 0x18, 0xDA, 0x85, 0xA7, 0xCE, 0x23, 0x65, 0x78, 0x70, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x6C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x20, 0x31, 0x2C, 0x20, 0x67, 0x6F, 0x74, 0x20, 0x25, 0x76, 0xDA, 0x54, + 0x00, 0x14, 0x00, 0xDA, 0x82, 0x11, 0x00, 0x14, 0x01, 0xDA, 0x8C, 0x32, 0x03, 0x0A, 0x04, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, + 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x1E, 0x03, 0x05, 0x00, 0x3F, 0x05, 0x00, 0x00, + 0x26, 0x06, 0x05, 0x01, 0x1B, 0x02, 0x06, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x02, 0x04, 0x00, + 0x1E, 0x02, 0x02, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, 0x03, 0x00, 0x00, + 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x01, 0x03, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, + 0x31, 0x02, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x81, 0x5F, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x1F, 0x00, 0x1C, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0xCF, 0x0E, 0x2A, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, + 0x2A, 0xDA, 0x87, 0x5B, 0xCF, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x6C, 0x69, 0x6E, 0x65, + 0x61, 0x67, 0x65, 0xD8, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x61, + 0x67, 0x65, 0xCF, 0x07, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x01, 0x04, 0x00, 0x02, 0xCE, 0x07, 0x66, 0x6C, 0x61, 0x74, + 0x74, 0x65, 0x6E, 0xDA, 0x18, 0xDA, 0x8A, 0x52, 0x00, 0x04, 0x00, 0xDA, 0x82, 0x74, 0x00, 0x04, + 0x01, 0xDA, 0x8C, 0x3A, 0x40, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, + 0x36, 0x03, 0x00, 0x00, 0x86, 0xAB, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x6F, + 0x73, 0x2F, 0x72, 0x6D, 0x64, 0x69, 0x72, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x72, 0x6D, 0x64, 0x69, + 0x72, 0xCF, 0x0A, 0x65, 0x6E, 0x76, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xD8, 0x0A, 0x65, + 0x6E, 0x76, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xCF, 0x11, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x2F, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xD8, 0x11, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x2F, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xCF, + 0x0B, 0x65, 0x76, 0x2F, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0xD8, 0x0B, 0x65, 0x76, + 0x2F, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0xCF, 0x0B, 0x66, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x01, + 0x01, 0x00, 0x14, 0x00, 0x07, 0xCE, 0x0B, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x69, + 0x65, 0x73, 0xDA, 0x18, 0x00, 0x14, 0x00, 0xDA, 0x1F, 0x00, 0x14, 0x01, 0xDA, 0x8C, 0x45, 0x01, + 0x14, 0x03, 0xCF, 0x05, 0x66, 0x72, 0x65, 0x71, 0x73, 0x01, 0x13, 0x00, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x52, 0x04, 0x13, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x51, 0x07, 0x13, 0x06, 0xDA, 0x1E, 0x09, 0x13, 0x07, 0xDA, 0x81, 0x9E, 0x44, 0x02, 0x00, 0x00, + 0x1B, 0x03, 0x02, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x00, 0x05, 0x1B, 0x05, 0x04, 0x00, + 0x1F, 0x05, 0x0E, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x1B, 0x06, 0x04, 0x00, 0x3A, 0x04, 0x03, 0x06, + 0x1B, 0x07, 0x04, 0x00, 0x1E, 0x07, 0x05, 0x00, 0x2B, 0x09, 0x01, 0x00, 0x06, 0x08, 0x09, 0x07, + 0x1B, 0x04, 0x08, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x04, 0x01, 0x00, 0x3C, 0x03, 0x06, 0x04, + 0x49, 0x05, 0x00, 0x05, 0x1C, 0xF3, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x86, 0x6B, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, + 0x05, 0x01, 0x14, 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0xBF, + 0xFE, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, 0x0A, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, + 0x65, 0x61, 0x6B, 0xD8, 0x0A, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, 0x65, 0x61, 0x6B, 0xCF, + 0x0B, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0xD8, 0x0B, 0x6E, 0x65, + 0x74, 0x2F, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0xCF, 0x0F, 0x65, 0x76, 0x2F, 0x72, 0x65, + 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x6C, 0x6F, 0x63, 0x6B, 0xD8, 0x0F, 0x65, 0x76, 0x2F, 0x72, + 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x83, 0x7F, 0xDA, 0x83, + 0x7D, 0xCF, 0x0C, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x70, 0xDA, + 0x81, 0x01, 0xCF, 0x04, 0x71, 0x75, 0x69, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, + 0x01, 0x00, 0x01, 0x03, 0x0A, 0x00, 0x02, 0xCE, 0x04, 0x71, 0x75, 0x69, 0x74, 0xDA, 0x18, 0xDA, + 0x85, 0xCA, 0xDA, 0x81, 0x07, 0xDA, 0x83, 0x3A, 0x00, 0x0A, 0x00, 0xDA, 0x25, 0x00, 0x0A, 0x01, + 0xDA, 0x8C, 0x52, 0x2C, 0x02, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x32, 0x02, 0x03, 0x00, 0x2C, + 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x32, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8A, 0x71, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFA, + 0x01, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xD8, 0x09, 0x6F, 0x73, + 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xCF, 0x06, 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x66, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x00, 0x0E, 0x00, 0x06, 0xCE, 0x06, + 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x66, 0xDA, 0x18, 0x00, 0x0E, 0x00, 0xDA, 0x80, 0xE8, 0x00, 0x0E, + 0x01, 0xDA, 0x8C, 0x57, 0x00, 0x0E, 0x00, 0xDA, 0x24, 0x02, 0x0E, 0x03, 0xDA, 0x22, 0x04, 0x0E, + 0x04, 0xDA, 0x23, 0x08, 0x0D, 0x05, 0xDA, 0x1E, 0x28, 0x03, 0x00, 0x00, 0x49, 0x02, 0x00, 0x03, + 0x1B, 0x03, 0x02, 0x00, 0x3B, 0x02, 0x00, 0x03, 0x1B, 0x04, 0x02, 0x00, 0x49, 0x03, 0x00, 0x03, + 0x1F, 0x03, 0x07, 0x00, 0x3A, 0x02, 0x00, 0x03, 0x1B, 0x05, 0x02, 0x00, 0x23, 0x02, 0x05, 0x04, + 0x1E, 0x02, 0x02, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, + 0x82, 0xF1, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, + 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0xCF, 0x0E, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0xDA, 0x84, 0x3B, + 0xCF, 0x0A, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x87, 0xBF, 0xDA, + 0x88, 0x5D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0D, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x04, 0x23, 0x00, 0x07, 0xCE, 0x03, 0x61, 0x6E, 0x64, 0xDA, 0x18, 0xDA, 0x83, 0xA9, 0xDA, + 0x57, 0xDA, 0x51, 0xDA, 0x52, 0x00, 0x23, 0x00, 0xDA, 0x81, 0x9A, 0x00, 0x23, 0x01, 0xDA, 0x88, + 0x5D, 0x00, 0x23, 0x02, 0xDA, 0x23, 0x02, 0x23, 0x04, 0xDA, 0x81, 0x25, 0x03, 0x23, 0x05, 0xDA, + 0x80, 0xC3, 0x08, 0x22, 0x08, 0xDA, 0x5A, 0x19, 0x21, 0x0B, 0xDA, 0x49, 0x29, 0x02, 0x00, 0x00, + 0x3F, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x22, 0x06, 0x05, 0x00, + 0x1E, 0x06, 0x1D, 0x00, 0x07, 0x05, 0x05, 0x01, 0x3A, 0x07, 0x00, 0x05, 0x1B, 0x08, 0x07, 0x00, + 0x07, 0x07, 0x04, 0x01, 0x25, 0x09, 0x05, 0x07, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x02, 0x08, 0x00, + 0x1C, 0x14, 0x00, 0x00, 0x31, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x00, 0x00, 0x35, 0x07, 0x0A, 0x00, + 0x1E, 0x07, 0x06, 0x00, 0x2C, 0x0A, 0x01, 0x00, 0x33, 0x0A, 0x08, 0x02, 0x31, 0x08, 0x00, 0x00, + 0x45, 0x02, 0x00, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x35, 0x0A, 0x0B, 0x00, + 0x1B, 0x0B, 0x0A, 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x33, 0x0A, 0x0B, 0x08, 0x45, 0x0A, 0x00, 0x00, + 0x2C, 0x0C, 0x01, 0x00, 0x33, 0x0C, 0x0A, 0x02, 0x31, 0x0B, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, + 0x1C, 0xE3, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0x81, 0x0B, 0x03, 0x01, 0x0C, 0x00, 0x03, 0x01, + 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, 0x05, 0x01, 0x0C, 0x00, 0x05, 0x01, 0x17, 0x00, 0x12, 0x00, + 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x02, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, 0x01, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x10, 0x02, 0x1D, 0x00, 0x1D, 0x00, 0x16, 0x01, 0x19, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0xBF, 0xF8, 0x03, 0xBF, + 0xF9, 0x01, 0xDA, 0x8B, 0x0D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x00, 0x00, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x0C, 0x00, 0x02, 0xCE, 0x08, 0x65, 0x76, 0x2F, 0x73, 0x70, 0x61, + 0x77, 0x6E, 0xDA, 0x18, 0xDA, 0x86, 0x38, 0xDA, 0x80, 0x9B, 0xCF, 0x06, 0x5F, 0x73, 0x70, 0x61, + 0x77, 0x6E, 0xDA, 0x44, 0x00, 0x0C, 0x00, 0xDA, 0x81, 0x74, 0x00, 0x0C, 0x01, 0xDA, 0x8B, 0x0D, + 0x2C, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, + 0x2C, 0x05, 0x02, 0x00, 0x33, 0x04, 0x05, 0x02, 0x34, 0x00, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, + 0x2C, 0x04, 0x03, 0x00, 0x32, 0x04, 0x03, 0x00, 0x45, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, + 0x8E, 0x99, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x6D, 0x6B, + 0x74, 0x69, 0x6D, 0x65, 0xD8, 0x09, 0x6F, 0x73, 0x2F, 0x6D, 0x6B, 0x74, 0x69, 0x6D, 0x65, 0xCF, + 0x07, 0x65, 0x76, 0x2F, 0x66, 0x75, 0x6C, 0x6C, 0xD8, 0x07, 0x65, 0x76, 0x2F, 0x66, 0x75, 0x6C, + 0x6C, 0xCF, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0xD8, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0xCF, + 0x07, 0x6F, 0x73, 0x2F, 0x74, 0x69, 0x6D, 0x65, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x74, 0x69, 0x6D, + 0x65, 0xDA, 0x8B, 0xB1, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x03, 0x09, 0x00, 0x03, 0xCE, 0x08, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, + 0x6F, 0xDA, 0x18, 0xDA, 0x81, 0x07, 0xDA, 0x37, 0xDA, 0x82, 0xFE, 0x00, 0x09, 0x00, 0xDA, 0x81, + 0xBE, 0x00, 0x09, 0x01, 0xDA, 0x81, 0xBF, 0x00, 0x09, 0x02, 0xDA, 0x8B, 0xB1, 0x44, 0x03, 0x00, + 0x00, 0x32, 0x00, 0x03, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, 0x03, 0x01, + 0x00, 0x32, 0x00, 0x03, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x36, 0x03, 0x00, + 0x00, 0x30, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0xCF, 0x0D, 0x2A, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x6C, 0x65, 0x76, 0x65, 0x6C, + 0x73, 0x2A, 0xDA, 0x86, 0x00, 0xCF, 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x6E, 0x65, + 0x77, 0xDA, 0x84, 0x37, 0xCF, 0x0E, 0x6F, 0x73, 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0xD8, 0x0E, 0x6F, 0x73, 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0xCF, 0x09, 0x65, 0x76, 0x2F, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0xD8, + 0x09, 0x65, 0x76, 0x2F, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0xCF, 0x0E, 0x65, 0x76, 0x2F, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x63, 0x68, 0x61, 0x6E, 0xD8, 0x0E, 0x65, 0x76, 0x2F, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x63, 0x68, 0x61, 0x6E, 0xCF, 0x07, 0x65, 0x76, 0x2F, 0x74, + 0x61, 0x6B, 0x65, 0xDA, 0x8B, 0x1B, 0xCF, 0x07, 0x75, 0x6E, 0x74, 0x72, 0x61, 0x63, 0x65, 0xD8, + 0x07, 0x75, 0x6E, 0x74, 0x72, 0x61, 0x63, 0x65, 0xCF, 0x08, 0x61, 0x73, 0x2D, 0x6D, 0x61, 0x63, + 0x72, 0x6F, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x03, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x00, 0x02, 0x00, 0x03, 0xCE, 0x08, 0x61, 0x73, 0x2D, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xDA, + 0x18, 0x00, 0x02, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x02, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x02, 0x02, + 0xDA, 0x8C, 0x76, 0x34, 0x01, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x39, 0x03, 0x00, 0x03, 0xCF, + 0x08, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x62, 0x79, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0C, 0x02, 0x02, 0x02, 0x01, 0x18, 0x00, 0x09, 0xCE, 0x08, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, + 0x62, 0x79, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0x00, 0x18, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x18, 0x01, + 0xDA, 0x1F, 0x00, 0x18, 0x02, 0xDA, 0x8C, 0x79, 0x01, 0x18, 0x04, 0xDA, 0x23, 0x01, 0x17, 0x01, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x54, 0x04, 0x17, 0x06, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x53, 0x07, 0x17, 0x07, 0xDA, 0x1E, 0x0A, 0x17, 0x08, 0xDA, 0x80, 0xD9, + 0x0C, 0x15, 0x09, 0xDA, 0x86, 0x87, 0x44, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x28, 0x06, + 0x00, 0x00, 0x49, 0x05, 0x01, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, 0x12, 0x00, 0x3A, 0x05, + 0x01, 0x06, 0x1B, 0x07, 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x05, 0x00, 0x00, 0x1B, 0x08, + 0x05, 0x00, 0x3B, 0x05, 0x04, 0x08, 0x1B, 0x09, 0x05, 0x00, 0x1E, 0x05, 0x05, 0x00, 0x32, 0x09, + 0x07, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x35, 0x0A, 0x0B, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x31, 0x07, + 0x00, 0x00, 0x40, 0x0A, 0x00, 0x00, 0x3C, 0x04, 0x08, 0x0A, 0x49, 0x06, 0x01, 0x06, 0x1C, 0xEF, + 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0x86, 0x77, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x12, 0x00, + 0x05, 0x00, 0x05, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x02, 0x07, 0x00, 0x07, + 0x00, 0x07, 0xBF, 0xFC, 0x03, 0x00, 0x03, 0xBF, 0xF9, 0x01, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, + 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xCF, 0x07, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, 0x00, 0x0B, 0x00, 0x06, 0xCE, 0x07, + 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0xDA, 0x18, 0x00, 0x0B, 0x00, 0xDA, 0x82, 0x74, 0x00, + 0x0B, 0x01, 0xDA, 0x8C, 0x80, 0x00, 0x0B, 0x02, 0xDA, 0x81, 0x96, 0x00, 0x0A, 0x00, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x03, 0x0A, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x06, 0x0A, 0x05, 0xDA, 0x1E, 0x2B, 0x02, 0x01, 0x00, 0x28, 0x04, 0x00, 0x00, + 0x49, 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x06, 0x00, 0x3A, 0x03, 0x00, 0x04, + 0x1B, 0x05, 0x03, 0x00, 0x0A, 0x02, 0x02, 0x05, 0x49, 0x04, 0x00, 0x04, 0x1C, 0xFB, 0xFF, 0xFF, + 0x03, 0x02, 0x00, 0x00, 0x82, 0x98, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x0E, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFC, 0x01, 0xCF, 0x0B, 0x6F, 0x73, + 0x2F, 0x72, 0x65, 0x61, 0x6C, 0x70, 0x61, 0x74, 0x68, 0xD8, 0x0B, 0x6F, 0x73, 0x2F, 0x72, 0x65, + 0x61, 0x6C, 0x70, 0x61, 0x74, 0x68, 0xCF, 0x04, 0x74, 0x61, 0x6B, 0x65, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x0D, 0x02, 0x02, 0x02, 0x07, 0x38, 0x00, 0x0C, 0xCE, 0x04, 0x74, 0x61, 0x6B, + 0x65, 0xDA, 0x18, 0xDA, 0x83, 0x76, 0xDA, 0x80, 0xE0, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0D, 0x03, 0x03, 0x03, 0x00, 0x18, 0x00, 0x08, 0xCE, 0x0C, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x6E, + 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x18, 0x00, 0x18, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x18, + 0x01, 0xDA, 0x81, 0x9E, 0x00, 0x18, 0x02, 0xDA, 0x1F, 0x00, 0x18, 0x03, 0xCF, 0x0C, 0x74, 0x61, + 0x6B, 0x65, 0x2D, 0x6E, 0x2D, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x01, 0x18, 0x05, 0xDA, 0x81, 0x25, + 0x03, 0x18, 0x07, 0xDA, 0x81, 0x0D, 0x0C, 0x18, 0x09, 0xDA, 0x82, 0x5F, 0x15, 0x18, 0x0B, 0xDA, + 0x82, 0x60, 0x3F, 0x04, 0x02, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x06, 0x06, 0x05, 0x01, 0x1B, 0x07, + 0x06, 0x00, 0x24, 0x09, 0x01, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x23, 0x09, + 0x0A, 0x07, 0x1E, 0x09, 0x03, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2B, 0x08, + 0x00, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x2B, 0x0C, 0x00, 0x00, 0x48, 0x0B, 0x0C, 0x01, 0x1E, 0x0B, + 0x02, 0x00, 0x48, 0x0B, 0x01, 0x05, 0x1E, 0x0B, 0x03, 0x00, 0x1B, 0x0A, 0x01, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x1B, 0x0A, 0x05, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x33, 0x02, 0x09, 0x0B, 0x36, 0x00, + 0x00, 0x00, 0x84, 0x3E, 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, 0x12, 0x00, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x10, 0x00, + 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0xDA, 0x2B, 0xDA, 0x82, 0x03, 0xDA, 0x87, 0xEF, 0xDA, 0x80, 0xA8, 0x00, 0x38, + 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x38, 0x01, 0xDA, 0x1F, 0x00, 0x38, 0x02, 0xDA, 0x8C, 0x87, 0x14, + 0x26, 0x06, 0xDA, 0x83, 0xCF, 0x16, 0x26, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x73, 0x16, 0x25, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x75, 0x19, 0x25, 0x09, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x74, 0x1C, 0x25, 0x0A, 0xDA, 0x80, 0xC3, 0x1D, + 0x25, 0x0B, 0xDA, 0x1E, 0x27, 0x38, 0x07, 0xDA, 0x80, 0xAD, 0x28, 0x38, 0x06, 0xDA, 0x80, 0xDE, + 0x29, 0x37, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x76, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1E, 0x03, 0x05, 0x00, 0x2C, 0x04, 0x01, 0x00, + 0x33, 0x04, 0x00, 0x01, 0x2C, 0x04, 0x02, 0x00, 0x36, 0x04, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x05, 0x03, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x05, 0x00, 0x2C, 0x05, 0x04, 0x00, + 0x33, 0x05, 0x00, 0x01, 0x2C, 0x05, 0x02, 0x00, 0x36, 0x05, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, + 0x2C, 0x06, 0x05, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1E, 0x05, 0x13, 0x00, 0x1B, 0x06, 0x00, 0x00, + 0x44, 0x07, 0x00, 0x00, 0x1B, 0x08, 0x07, 0x00, 0x28, 0x09, 0x00, 0x00, 0x49, 0x07, 0x01, 0x09, + 0x1B, 0x09, 0x07, 0x00, 0x1F, 0x09, 0x0B, 0x00, 0x3A, 0x07, 0x01, 0x09, 0x1B, 0x0A, 0x09, 0x00, + 0x1B, 0x0B, 0x07, 0x00, 0x07, 0x06, 0x06, 0x01, 0x24, 0x07, 0x06, 0x00, 0x1E, 0x07, 0x02, 0x00, + 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x08, 0x0A, 0x0B, 0x49, 0x09, 0x01, 0x09, 0x1C, 0xF6, 0xFF, 0xFF, + 0x03, 0x08, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x28, 0x06, 0x00, 0x00, + 0x1B, 0x08, 0x00, 0x00, 0x22, 0x09, 0x08, 0x00, 0x1E, 0x09, 0x0C, 0x00, 0x49, 0x06, 0x01, 0x06, + 0x28, 0x0B, 0x00, 0x00, 0x25, 0x0A, 0x0B, 0x06, 0x1E, 0x0A, 0x02, 0x00, 0x1C, 0x07, 0x00, 0x00, + 0x3A, 0x0A, 0x01, 0x06, 0x32, 0x07, 0x0A, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x35, 0x0B, 0x0C, 0x00, + 0x07, 0x08, 0x08, 0x01, 0x1C, 0xF4, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x84, 0x49, 0x05, 0x00, + 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x01, 0x05, + 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFE, 0x03, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xFD, 0x03, 0x04, 0x19, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x3D, 0x00, 0x3A, + 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x02, 0x07, 0x00, 0x07, + 0x01, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, 0x07, 0x01, 0x1D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x09, + 0x00, 0x2E, 0x01, 0x19, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x07, 0x00, 0x07, 0xBF, + 0xFD, 0x05, 0xCF, 0x05, 0x61, 0x70, 0x70, 0x6C, 0x79, 0xDA, 0x86, 0x36, 0xCF, 0x0E, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x2F, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0xDA, 0x80, 0xC8, 0xCF, + 0x0A, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x05, 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x0A, 0x63, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xDA, 0x18, 0xDA, 0x65, 0xD0, 0x09, 0x63, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x8C, 0x93, + 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, 0x01, 0x00, + 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x6B, 0x33, 0x00, 0x33, 0x00, 0x33, 0x00, 0x30, + 0x00, 0x30, 0x00, 0x30, 0xCF, 0x07, 0x69, 0x6E, 0x74, 0x2F, 0x73, 0x36, 0x34, 0xD8, 0x07, 0x69, + 0x6E, 0x74, 0x2F, 0x73, 0x36, 0x34, 0xCF, 0x15, 0x66, 0x66, 0x69, 0x2F, 0x70, 0x6F, 0x69, 0x6E, + 0x74, 0x65, 0x72, 0x2D, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xD8, 0x15, 0x66, + 0x66, 0x69, 0x2F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2D, 0x63, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0xCF, 0x0E, 0x66, 0x66, 0x69, 0x2F, 0x74, 0x72, 0x61, 0x6D, 0x70, 0x6F, + 0x6C, 0x69, 0x6E, 0x65, 0xD8, 0x0E, 0x66, 0x66, 0x69, 0x2F, 0x74, 0x72, 0x61, 0x6D, 0x70, 0x6F, + 0x6C, 0x69, 0x6E, 0x65, 0xCF, 0x17, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, + 0x67, 0x2D, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xD8, 0x17, 0x66, + 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x2D, 0x63, 0x6F, 0x6E, 0x76, 0x65, + 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xCF, 0x06, 0x66, 0x72, 0x65, 0x65, 0x7A, 0x65, 0xD7, 0x00, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x01, 0x01, 0x0E, 0x43, 0x00, 0x04, 0xCE, 0x06, 0x66, + 0x72, 0x65, 0x65, 0x7A, 0x65, 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x66, 0xDA, 0x80, 0xA6, 0xDA, 0x80, + 0xE0, 0xDA, 0x80, 0xA3, 0xDA, 0x80, 0xCB, 0xDA, 0x88, 0xEA, 0xDA, 0x83, 0x8D, 0xDA, 0x8A, 0xA9, + 0xDA, 0x80, 0xEF, 0xDA, 0x80, 0xF6, 0xDA, 0x80, 0xC9, 0xDA, 0x81, 0x11, 0xDA, 0x81, 0x12, 0x00, + 0x43, 0x00, 0xDA, 0x1E, 0x00, 0x43, 0x01, 0xDA, 0x8C, 0x9F, 0x04, 0x43, 0x03, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x1D, 0x30, 0x07, 0xDA, 0x6D, 0x2E, 0x01, 0x00, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x25, 0x02, 0x03, 0x04, 0x1E, 0x02, 0x07, 0x00, 0x32, 0x01, 0x00, 0x00, 0x2C, + 0x05, 0x02, 0x00, 0x35, 0x04, 0x05, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x03, 0x00, 0x36, + 0x05, 0x00, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x25, 0x04, 0x03, 0x05, 0x1E, 0x04, 0x07, 0x00, 0x32, + 0x01, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, + 0x06, 0x03, 0x00, 0x36, 0x06, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x25, 0x05, 0x03, 0x06, 0x1E, + 0x05, 0x17, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x07, 0x06, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, + 0x07, 0x06, 0x00, 0x1E, 0x06, 0x09, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x07, 0x00, 0x35, + 0x08, 0x09, 0x00, 0x32, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x08, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x31, + 0x09, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x09, 0x09, 0x00, 0x35, + 0x08, 0x09, 0x00, 0x32, 0x01, 0x08, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x34, + 0x09, 0x00, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x36, 0x08, 0x00, 0x00, 0x2C, 0x07, 0x0B, 0x00, 0x25, + 0x06, 0x03, 0x07, 0x1E, 0x06, 0x0A, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x09, 0x00, 0x35, + 0x07, 0x08, 0x00, 0x32, 0x01, 0x07, 0x00, 0x2C, 0x09, 0x02, 0x00, 0x35, 0x08, 0x09, 0x00, 0x34, + 0x08, 0x00, 0x00, 0x2C, 0x07, 0x0A, 0x00, 0x36, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x0C, 0x00, 0x25, + 0x07, 0x03, 0x08, 0x1E, 0x07, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x0D, 0x00, 0x36, + 0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x88, 0xA0, 0x01, 0x05, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x19, 0x00, 0x19, 0x00, + 0x19, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x03, 0x17, + 0x00, 0x17, 0x00, 0x17, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x16, + 0x00, 0x16, 0x00, 0x16, 0x00, 0x0E, 0x00, 0x0E, 0x01, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x17, + 0x00, 0x17, 0x00, 0x17, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFB, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x06, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, 0x0D, 0x00, + 0x0D, 0x00, 0x0D, 0xBF, 0xFA, 0x03, 0x00, 0x03, 0x00, 0x03, 0x07, 0x0D, 0x00, 0x0D, 0x00, 0x0D, + 0xBF, 0xF9, 0x03, 0xCF, 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0xD8, + 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0xDA, 0x88, 0x70, 0xDA, 0x88, + 0x5E, 0xCF, 0x04, 0x69, 0x6E, 0x74, 0x3F, 0xD8, 0x04, 0x69, 0x6E, 0x74, 0x3F, 0xCF, 0x10, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, 0xD8, + 0x10, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, + 0x6D, 0xCF, 0x10, 0x2A, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x65, + 0x72, 0x73, 0x2A, 0xDA, 0x87, 0xBB, 0xCF, 0x0B, 0x2A, 0x64, 0x6F, 0x63, 0x2D, 0x77, 0x69, 0x64, + 0x74, 0x68, 0x2A, 0xDA, 0x81, 0xEA, 0xCF, 0x0C, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, + 0x2D, 0x69, 0x6E, 0x74, 0xD8, 0x0C, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x69, + 0x6E, 0x74, 0xCF, 0x07, 0x69, 0x66, 0x2D, 0x77, 0x69, 0x74, 0x68, 0xD7, 0x00, 0xCD, 0x00, 0xDC, + 0x00, 0x00, 0x0B, 0x03, 0x02, 0x03, 0x03, 0x1A, 0x00, 0x07, 0xCE, 0x07, 0x69, 0x66, 0x2D, 0x77, + 0x69, 0x74, 0x68, 0xDA, 0x18, 0xDA, 0x82, 0xF2, 0xDA, 0x82, 0xF3, 0xDA, 0x80, 0x86, 0x00, 0x1A, + 0x01, 0xDA, 0x88, 0xAA, 0x00, 0x1A, 0x02, 0xCF, 0x06, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x01, + 0x1A, 0x04, 0xDA, 0x82, 0xF6, 0x03, 0x1A, 0x05, 0xDA, 0x82, 0xF7, 0x05, 0x1A, 0x06, 0xDA, 0x82, + 0xF8, 0x06, 0x1A, 0x00, 0xDA, 0x8C, 0xAD, 0x08, 0x0D, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x3D, 0x03, 0x00, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x3D, 0x03, 0x00, 0x01, 0x1B, + 0x05, 0x03, 0x00, 0x3D, 0x03, 0x00, 0x02, 0x1B, 0x06, 0x03, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x32, + 0x04, 0x05, 0x00, 0x46, 0x03, 0x00, 0x00, 0x1E, 0x06, 0x03, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x32, 0x07, 0x04, 0x00, 0x45, 0x07, 0x00, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x45, 0x08, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x2C, + 0x0A, 0x01, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x33, 0x08, 0x03, 0x09, 0x31, + 0x02, 0x00, 0x00, 0x45, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x81, 0x81, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x05, 0x03, 0x00, 0x03, 0x01, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x14, 0x00, 0x14, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xD8, 0x09, 0x6F, 0x73, + 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, + 0x6F, 0x73, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0xCF, 0x03, 0x63, + 0x6D, 0x70, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, 0x1F, 0x02, 0x02, 0x02, 0x02, 0x00, 0x02, 0xCE, + 0x03, 0x63, 0x6D, 0x70, 0x27, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x03, 0x67, 0x65, + 0x74, 0xDA, 0x88, 0xB1, 0xCF, 0x06, 0x63, 0x61, 0x74, 0x73, 0x65, 0x71, 0xD7, 0x00, 0xCD, 0x00, + 0xDD, 0x00, 0x00, 0x09, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x16, 0x00, 0x04, 0xCE, + 0x06, 0x63, 0x61, 0x74, 0x73, 0x65, 0x71, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x52, 0xDA, 0x58, 0xDA, + 0x80, 0xE3, 0xDA, 0x86, 0xAE, 0x00, 0x16, 0x00, 0xDA, 0x86, 0xAF, 0x00, 0x16, 0x01, 0xDA, 0x81, + 0x74, 0x00, 0x16, 0x02, 0xDA, 0x8C, 0xBA, 0x02, 0x16, 0x04, 0xDA, 0x86, 0xB0, 0x2C, 0x04, 0x00, + 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x40, 0x05, 0x00, 0x00, 0x2C, 0x07, 0x01, + 0x00, 0x33, 0x07, 0x04, 0x05, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x31, 0x07, 0x00, + 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, 0x08, 0x04, + 0x05, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x33, 0x08, 0x00, 0x07, 0x45, 0x05, 0x00, + 0x00, 0x2C, 0x08, 0x02, 0x00, 0x33, 0x08, 0x06, 0x05, 0x31, 0x04, 0x00, 0x00, 0x45, 0x07, 0x00, + 0x00, 0x03, 0x07, 0x00, 0x00, 0x82, 0x6A, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0xCF, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, 0x65, + 0xDA, 0x87, 0x5F, 0xDA, 0x80, 0x98, 0xDA, 0x80, 0x95, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x65, 0x72, 0x66, 0x63, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x72, 0x66, 0x63, 0xCF, + 0x06, 0x64, 0x65, 0x66, 0x64, 0x79, 0x6E, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x0A, 0x01, + 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x0B, 0x33, 0x00, 0x08, 0xCE, 0x06, 0x64, 0x65, 0x66, 0x64, + 0x79, 0x6E, 0xDA, 0x18, 0xDA, 0x80, 0x95, 0xCE, 0x16, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x6D, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0xDA, + 0x82, 0x72, 0xDA, 0x82, 0x87, 0xCE, 0x32, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6D, 0x75, 0x73, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6C, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x27, 0x2A, 0x27, 0x20, 0x63, + 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0xD0, 0x0D, 0x64, 0x65, 0x66, 0x64, 0x79, + 0x6E, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0xDA, 0x80, 0xFB, 0xDA, 0x88, 0x0B, 0xD8, 0x07, + 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0xDA, 0x52, 0xDA, 0x81, 0xC9, 0x00, 0x33, 0x00, 0xCF, + 0x05, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x00, 0x33, 0x01, 0xDA, 0x81, 0xBF, 0x00, 0x33, 0x02, 0xDA, + 0x8C, 0xC0, 0x03, 0x08, 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x4C, 0x0A, 0x19, + 0x04, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x4E, 0x19, 0x1E, 0x04, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x4D, 0x22, 0x33, 0x04, 0xDA, 0x87, 0x07, 0x2B, 0x33, 0x05, 0xCF, + 0x02, 0x6B, 0x77, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, + 0x04, 0x03, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x01, + 0x03, 0x00, 0x00, 0x3F, 0x04, 0x00, 0x00, 0x22, 0x05, 0x04, 0x02, 0x1B, 0x04, 0x05, 0x00, 0x1E, + 0x05, 0x0D, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x07, 0x02, 0x00, 0x35, 0x06, 0x07, 0x00, 0x31, + 0x00, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2B, 0x09, 0x2A, 0x00, 0x25, + 0x08, 0x09, 0x06, 0x1E, 0x08, 0x02, 0x00, 0x25, 0x08, 0x06, 0x07, 0x1B, 0x03, 0x08, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x1C, + 0x03, 0x00, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x01, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x05, 0x00, 0x31, + 0x03, 0x00, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2B, + 0x05, 0x01, 0x00, 0x2B, 0x06, 0xFE, 0xFF, 0x33, 0x00, 0x05, 0x06, 0x2C, 0x06, 0x07, 0x00, 0x35, + 0x05, 0x06, 0x00, 0x32, 0x04, 0x05, 0x00, 0x2C, 0x07, 0x08, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, + 0x05, 0x06, 0x00, 0x2C, 0x08, 0x09, 0x00, 0x2C, 0x09, 0x0A, 0x00, 0x33, 0x08, 0x00, 0x09, 0x34, + 0x01, 0x00, 0x00, 0x31, 0x05, 0x00, 0x00, 0x45, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x84, + 0xC1, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x01, 0x13, 0x00, 0x10, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x39, + 0x00, 0x39, 0x00, 0x39, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x01, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x04, 0x77, 0x69, 0x74, 0x68, 0xD7, 0x00, 0xCD, 0x00, + 0xDD, 0x00, 0x00, 0x09, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x18, 0x00, 0x06, 0xCE, + 0x04, 0x77, 0x69, 0x74, 0x68, 0xDA, 0x18, 0xDA, 0x52, 0xDA, 0x82, 0xF2, 0xDA, 0x82, 0xF3, 0xDA, + 0x58, 0x00, 0x18, 0x01, 0xDA, 0x81, 0x74, 0x01, 0x18, 0x03, 0xDA, 0x82, 0xF6, 0x03, 0x18, 0x04, + 0xDA, 0x82, 0xF7, 0x05, 0x18, 0x05, 0xDA, 0x82, 0xF8, 0x06, 0x18, 0x00, 0xDA, 0x8C, 0xCC, 0x09, + 0x0E, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x3D, 0x02, 0x00, 0x00, 0x1B, + 0x03, 0x02, 0x00, 0x3D, 0x02, 0x00, 0x01, 0x1B, 0x04, 0x02, 0x00, 0x3D, 0x02, 0x00, 0x02, 0x1B, + 0x05, 0x02, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x2C, 0x06, 0x00, 0x00, 0x33, 0x06, 0x03, 0x04, 0x45, + 0x02, 0x00, 0x00, 0x1E, 0x05, 0x03, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, + 0x06, 0x01, 0x00, 0x32, 0x06, 0x03, 0x00, 0x45, 0x06, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x34, + 0x01, 0x00, 0x00, 0x2C, 0x08, 0x02, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, + 0x08, 0x02, 0x07, 0x45, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x81, 0x70, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x06, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x02, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x14, 0x00, 0x14, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0C, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x72, 0x61, 0x77, 0x67, 0x65, 0x74, 0xD8, 0x0C, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2F, 0x72, 0x61, 0x77, 0x67, 0x65, 0x74, 0xDA, 0x8A, 0x85, 0xDA, 0x8A, 0x82, 0xDA, + 0x80, 0xA2, 0xDA, 0x80, 0xA0, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x68, + 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x68, 0xCF, 0x12, 0x66, 0x66, 0x69, + 0x2F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xD8, + 0x12, 0x66, 0x66, 0x69, 0x2F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2D, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0xCF, 0x08, 0x6D, 0x61, 0x63, 0x6C, 0x69, 0x6E, 0x74, 0x66, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x0F, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x08, 0x33, 0x00, 0x0B, + 0xCE, 0x08, 0x6D, 0x61, 0x63, 0x6C, 0x69, 0x6E, 0x74, 0x66, 0xDA, 0x18, 0xDA, 0x83, 0x63, 0xDA, + 0x80, 0xFB, 0xDA, 0x81, 0x06, 0xDA, 0x82, 0x92, 0xDA, 0x81, 0x00, 0xDA, 0x88, 0x5C, 0xDA, 0x54, + 0xDA, 0x80, 0xA8, 0x00, 0x33, 0x00, 0xDA, 0x85, 0x88, 0x00, 0x33, 0x01, 0xDA, 0x81, 0x41, 0x00, + 0x33, 0x02, 0xDA, 0x80, 0xE8, 0x00, 0x33, 0x03, 0xDA, 0x8C, 0xD6, 0x04, 0x33, 0x05, 0xDA, 0x85, + 0xE0, 0x0A, 0x32, 0x07, 0xDA, 0x81, 0x8B, 0x16, 0x32, 0x09, 0xDA, 0x85, 0xF9, 0x18, 0x32, 0x0A, + 0xDA, 0x82, 0x11, 0x1F, 0x32, 0x08, 0xDA, 0x85, 0xF9, 0x26, 0x32, 0x0B, 0xDA, 0x82, 0x11, 0x2B, + 0x32, 0x0C, 0xDA, 0x85, 0xB8, 0x2C, 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, + 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x1E, 0x05, 0x2D, 0x00, 0x2C, 0x06, 0x02, + 0x00, 0x31, 0x06, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, + 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x03, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1E, 0x08, 0x06, + 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0A, 0x04, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x06, 0x09, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x3D, 0x08, 0x06, 0x00, 0x1B, 0x09, 0x08, + 0x00, 0x3D, 0x08, 0x06, 0x01, 0x1B, 0x0A, 0x08, 0x00, 0x2B, 0x0B, 0xFF, 0xFF, 0x25, 0x08, 0x0B, + 0x09, 0x1E, 0x08, 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x09, + 0x00, 0x1B, 0x08, 0x06, 0x00, 0x2B, 0x0C, 0xFF, 0xFF, 0x25, 0x0B, 0x0C, 0x0A, 0x1E, 0x0B, 0x03, + 0x00, 0x28, 0x06, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x0A, 0x00, 0x1B, 0x0B, 0x06, + 0x00, 0x31, 0x01, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x35, 0x06, 0x0C, + 0x00, 0x1B, 0x0C, 0x06, 0x00, 0x33, 0x00, 0x08, 0x0B, 0x31, 0x0C, 0x00, 0x00, 0x45, 0x06, 0x00, + 0x00, 0x32, 0x05, 0x06, 0x00, 0x2C, 0x0E, 0x07, 0x00, 0x35, 0x0D, 0x0E, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x87, 0xFA, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, 0x01, 0x03, 0x01, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x10, + 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x05, 0x01, 0x14, 0x00, 0x14, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, + 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0xBF, 0xF5, 0x01, 0xCF, 0x0A, 0x6D, 0x61, 0x6B, 0x65, 0x2D, + 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, + 0x02, 0x04, 0x00, 0x02, 0xCE, 0x0A, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, + 0xDA, 0x18, 0xD3, 0x00, 0xDA, 0x83, 0x69, 0x00, 0x04, 0x00, 0xDA, 0x85, 0x87, 0x00, 0x04, 0x01, + 0xDA, 0x8C, 0xD9, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x36, + 0x02, 0x00, 0x00, 0x8A, 0xC5, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x05, 0x6F, 0x73, + 0x2F, 0x72, 0x6D, 0xD8, 0x05, 0x6F, 0x73, 0x2F, 0x72, 0x6D, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x6C, 0x63, 0x6D, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x63, 0x6D, 0xCF, 0x06, + 0x6D, 0x61, 0x70, 0x63, 0x61, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x17, 0x02, 0x02, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x80, 0xA9, 0x00, 0x2A, 0xCE, 0x06, 0x6D, 0x61, 0x70, 0x63, + 0x61, 0x74, 0xDA, 0x18, 0xDA, 0x80, 0xE3, 0xDA, 0x80, 0xA9, 0x00, 0x80, 0xA9, 0x00, 0xDA, 0x80, + 0xAA, 0x00, 0x80, 0xA9, 0x01, 0xDA, 0x1F, 0x00, 0x80, 0xA9, 0x02, 0xDA, 0x80, 0xAB, 0x00, 0x80, + 0xA9, 0x03, 0xDA, 0x8C, 0xE1, 0x01, 0x80, 0xA9, 0x05, 0xDA, 0x80, 0xAD, 0x03, 0x80, 0xA8, 0x07, + 0xDA, 0x80, 0xAE, 0x03, 0x80, 0xA8, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x51, + 0x05, 0x13, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x53, 0x08, 0x13, 0x09, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x52, 0x0B, 0x13, 0x0A, 0xDA, 0x1E, 0x17, 0x2C, 0x0A, + 0xDA, 0x80, 0xB2, 0x18, 0x2C, 0x09, 0xDA, 0x80, 0xB3, 0x18, 0x2C, 0x01, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x55, 0x1B, 0x2C, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x54, 0x1E, 0x2C, 0x0D, 0xDA, 0x1E, 0x30, 0x4E, 0x0B, 0xDA, 0x80, 0xB2, 0x32, 0x4E, 0x0C, 0xDA, + 0x80, 0xB6, 0x33, 0x4E, 0x0A, 0xDA, 0x80, 0xB3, 0x34, 0x4E, 0x0D, 0xDA, 0x80, 0xB7, 0x34, 0x4E, + 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x57, 0x37, 0x4E, 0x0F, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x56, 0x3A, 0x4E, 0x10, 0xDA, 0x1E, 0x52, 0x7A, 0x0C, 0xDA, 0x80, + 0xB2, 0x54, 0x7A, 0x0D, 0xDA, 0x80, 0xB6, 0x56, 0x7A, 0x0E, 0xDA, 0x80, 0xBA, 0x57, 0x7A, 0x0B, + 0xDA, 0x80, 0xB3, 0x58, 0x7A, 0x0F, 0xDA, 0x80, 0xB7, 0x59, 0x7A, 0x10, 0xDA, 0x80, 0xBB, 0x59, + 0x7A, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x59, 0x5C, 0x7A, 0x12, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x58, 0x5F, 0x7A, 0x13, 0xDA, 0x1E, 0x7E, 0x80, 0xA8, 0x0C, + 0xDA, 0x80, 0xBE, 0x80, 0x82, 0x80, 0xA8, 0x0D, 0xDA, 0x80, 0xBF, 0x80, 0x83, 0x80, 0xA8, 0x0B, + 0xDA, 0x80, 0xC0, 0x80, 0x83, 0x80, 0xA8, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x80, 0x86, 0x80, 0xA8, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5A, 0x80, + 0x89, 0x80, 0xA8, 0x10, 0xDA, 0x1E, 0x80, 0x8A, 0x80, 0x9E, 0x0E, 0xDA, 0x80, 0xC3, 0x80, 0x8A, + 0x80, 0x9E, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x80, 0x8E, 0x80, 0x9C, + 0x13, 0xDA, 0x80, 0xC5, 0x80, 0x90, 0x80, 0x9C, 0x14, 0xDA, 0x80, 0xC6, 0x80, 0x92, 0x80, 0x9C, + 0x15, 0xDA, 0x80, 0xC7, 0x40, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3F, 0x06, 0x02, 0x00, + 0x1B, 0x07, 0x06, 0x00, 0x26, 0x06, 0x07, 0x00, 0x1E, 0x06, 0x0F, 0x00, 0x28, 0x09, 0x00, 0x00, + 0x49, 0x08, 0x01, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x1F, 0x09, 0x0A, 0x00, 0x3A, 0x08, 0x01, 0x09, + 0x1B, 0x0A, 0x08, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x08, 0x00, 0x00, 0x32, 0x05, 0x08, 0x00, + 0x2C, 0x0C, 0x00, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x49, 0x09, 0x01, 0x09, 0x1C, 0xF7, 0xFF, 0xFF, + 0x1C, 0x95, 0x00, 0x00, 0x26, 0x08, 0x07, 0x01, 0x1E, 0x08, 0x18, 0x00, 0x3D, 0x09, 0x02, 0x00, + 0x1B, 0x0A, 0x09, 0x00, 0x28, 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x49, 0x0B, 0x01, 0x0C, + 0x1B, 0x0C, 0x0B, 0x00, 0x1F, 0x0C, 0x10, 0x00, 0x3A, 0x0B, 0x01, 0x0C, 0x1B, 0x0D, 0x0B, 0x00, + 0x49, 0x09, 0x0A, 0x09, 0x28, 0x0E, 0x00, 0x00, 0x25, 0x0B, 0x0E, 0x09, 0x1E, 0x0B, 0x02, 0x00, + 0x1C, 0x09, 0x00, 0x00, 0x3A, 0x0B, 0x0A, 0x09, 0x32, 0x0D, 0x0B, 0x00, 0x35, 0x0E, 0x00, 0x00, + 0x32, 0x05, 0x0E, 0x00, 0x2C, 0x0F, 0x00, 0x00, 0x35, 0x0B, 0x0F, 0x00, 0x49, 0x0C, 0x01, 0x0C, + 0x1C, 0xF1, 0xFF, 0xFF, 0x1C, 0x7C, 0x00, 0x00, 0x26, 0x09, 0x07, 0x02, 0x1E, 0x09, 0x21, 0x00, + 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, 0x0C, 0x0A, 0x00, + 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0E, 0x01, 0x0F, + 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x16, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, 0x10, 0x0E, 0x00, + 0x49, 0x0A, 0x0B, 0x0A, 0x28, 0x11, 0x00, 0x00, 0x25, 0x0E, 0x11, 0x0A, 0x1E, 0x0E, 0x02, 0x00, + 0x1C, 0x0F, 0x00, 0x00, 0x49, 0x0D, 0x0C, 0x0D, 0x28, 0x11, 0x00, 0x00, 0x25, 0x0E, 0x11, 0x0D, + 0x1E, 0x0E, 0x02, 0x00, 0x1C, 0x0A, 0x00, 0x00, 0x3A, 0x0E, 0x0B, 0x0A, 0x3A, 0x11, 0x0C, 0x0D, + 0x33, 0x10, 0x0E, 0x11, 0x35, 0x12, 0x00, 0x00, 0x32, 0x05, 0x12, 0x00, 0x2C, 0x11, 0x00, 0x00, + 0x35, 0x0E, 0x11, 0x00, 0x49, 0x0F, 0x01, 0x0F, 0x1C, 0xEB, 0xFF, 0xFF, 0x1C, 0x5A, 0x00, 0x00, + 0x26, 0x0A, 0x07, 0x03, 0x1E, 0x0A, 0x2B, 0x00, 0x3D, 0x0B, 0x02, 0x00, 0x1B, 0x0C, 0x0B, 0x00, + 0x3D, 0x0B, 0x02, 0x01, 0x1B, 0x0D, 0x0B, 0x00, 0x3D, 0x0B, 0x02, 0x02, 0x1B, 0x0E, 0x0B, 0x00, + 0x28, 0x0B, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x28, 0x12, 0x00, 0x00, + 0x49, 0x11, 0x01, 0x12, 0x1B, 0x12, 0x11, 0x00, 0x1F, 0x12, 0x1D, 0x00, 0x3A, 0x11, 0x01, 0x12, + 0x1B, 0x13, 0x11, 0x00, 0x49, 0x0B, 0x0C, 0x0B, 0x28, 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x0B, + 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x16, 0x00, 0x00, 0x49, 0x0F, 0x0D, 0x0F, 0x28, 0x14, 0x00, 0x00, + 0x25, 0x11, 0x14, 0x0F, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x49, 0x10, 0x0E, 0x10, + 0x28, 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x10, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x0C, 0x00, 0x00, + 0x3A, 0x11, 0x0C, 0x0B, 0x3A, 0x14, 0x0D, 0x0F, 0x3A, 0x15, 0x0E, 0x10, 0x33, 0x13, 0x11, 0x14, + 0x31, 0x15, 0x00, 0x00, 0x35, 0x16, 0x00, 0x00, 0x32, 0x05, 0x16, 0x00, 0x2C, 0x14, 0x00, 0x00, + 0x35, 0x11, 0x14, 0x00, 0x49, 0x12, 0x01, 0x12, 0x1C, 0xE4, 0xFF, 0xFF, 0x1C, 0x2E, 0x00, 0x00, + 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x0C, 0x0B, 0x00, + 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0D, 0x01, 0x00, 0x35, 0x0B, 0x0D, 0x00, 0x1B, 0x0D, 0x0B, 0x00, + 0x2A, 0x0B, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0E, 0x01, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, + 0x1F, 0x0F, 0x21, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, 0x10, 0x0E, 0x00, 0x2B, 0x0E, 0x00, 0x00, + 0x23, 0x11, 0x0E, 0x07, 0x1E, 0x11, 0x12, 0x00, 0x3A, 0x12, 0x0C, 0x0E, 0x1B, 0x13, 0x12, 0x00, + 0x3A, 0x12, 0x02, 0x0E, 0x1B, 0x14, 0x12, 0x00, 0x49, 0x12, 0x14, 0x13, 0x1B, 0x15, 0x12, 0x00, + 0x28, 0x16, 0x00, 0x00, 0x25, 0x12, 0x16, 0x15, 0x1E, 0x12, 0x04, 0x00, 0x29, 0x0B, 0x00, 0x00, + 0x1C, 0x07, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0C, 0x0E, 0x15, 0x3A, 0x16, 0x14, 0x15, + 0x3C, 0x0D, 0x0E, 0x16, 0x05, 0x0E, 0x0E, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, 0x0B, 0x02, 0x00, + 0x1C, 0x09, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x34, 0x0D, 0x00, 0x00, 0x35, 0x0E, 0x00, 0x00, + 0x32, 0x05, 0x0E, 0x00, 0x2C, 0x12, 0x00, 0x00, 0x35, 0x11, 0x12, 0x00, 0x49, 0x0F, 0x01, 0x0F, + 0x1C, 0xE0, 0xFF, 0xFF, 0x03, 0x05, 0x00, 0x00, 0x83, 0xF3, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFB, 0x01, 0xDA, 0x88, 0x11, 0xDA, + 0x88, 0x2C, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x30, 0xDA, 0x85, + 0x63, 0xCF, 0x05, 0x65, 0x61, 0x63, 0x68, 0x6B, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x05, + 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x04, 0xCE, 0x05, 0x65, 0x61, 0x63, + 0x68, 0x6B, 0xDA, 0x18, 0xDA, 0x8A, 0x41, 0xDA, 0x8A, 0x3D, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, + 0x05, 0x01, 0xDA, 0x24, 0x00, 0x05, 0x02, 0xDA, 0x81, 0x74, 0x00, 0x05, 0x03, 0xDA, 0x8C, 0xF1, + 0x2C, 0x04, 0x00, 0x00, 0x33, 0x00, 0x01, 0x04, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, + 0x36, 0x04, 0x00, 0x00, 0x81, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, + 0x04, 0x6E, 0x65, 0x78, 0x74, 0xDA, 0x8A, 0x3F, 0xCF, 0x08, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, + 0x6C, 0x6C, 0xDA, 0x88, 0x10, 0xCF, 0x03, 0x61, 0x73, 0x6D, 0xD8, 0x03, 0x61, 0x73, 0x6D, 0xCF, + 0x05, 0x65, 0x61, 0x63, 0x68, 0x70, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x05, 0x02, 0x02, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x04, 0xCE, 0x05, 0x65, 0x61, 0x63, 0x68, 0x70, + 0xDA, 0x18, 0xDA, 0x8A, 0x42, 0xDA, 0x8A, 0x3D, 0x00, 0x05, 0x00, 0xDA, 0x1E, 0x00, 0x05, 0x01, + 0xDA, 0x24, 0x00, 0x05, 0x02, 0xDA, 0x81, 0x74, 0x00, 0x05, 0x03, 0xDA, 0x8C, 0xF8, 0x2C, 0x04, + 0x00, 0x00, 0x33, 0x00, 0x01, 0x04, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, + 0x00, 0x00, 0x82, 0x04, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x04, 0x6F, + 0x6E, 0x65, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x01, 0x06, + 0x00, 0x02, 0xCE, 0x04, 0x6F, 0x6E, 0x65, 0x3F, 0xDA, 0x18, 0xDA, 0x84, 0x58, 0x00, 0x06, 0x00, + 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, 0x8C, 0xFB, 0x2B, 0x02, 0x01, 0x00, 0x32, 0x00, 0x02, 0x00, + 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x26, 0x03, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, + 0x83, 0x37, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2C, 0x00, 0x2C, 0xCF, 0x06, 0x65, + 0x76, 0x65, 0x72, 0x79, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, 0x01, + 0x00, 0x0E, 0x00, 0x06, 0xCE, 0x06, 0x65, 0x76, 0x65, 0x72, 0x79, 0x3F, 0xDA, 0x18, 0x00, 0x0E, + 0x00, 0xDA, 0x1F, 0x00, 0x0E, 0x01, 0xDA, 0x8C, 0xFE, 0x00, 0x0E, 0x02, 0xDA, 0x80, 0xAD, 0x00, + 0x0D, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x66, 0x03, 0x0D, 0x04, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x06, 0x0D, 0x05, 0xDA, 0x1E, 0x29, 0x02, 0x00, 0x00, + 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x00, 0x04, 0x1B, 0x04, 0x03, 0x00, 0x1F, 0x04, 0x09, 0x00, + 0x3A, 0x03, 0x00, 0x04, 0x1B, 0x05, 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x1C, 0x04, 0x00, 0x00, 0x1B, 0x02, 0x05, 0x00, 0x49, 0x04, 0x00, 0x04, 0x1C, 0xF8, 0xFF, 0xFF, + 0x03, 0x02, 0x00, 0x00, 0x85, 0xAE, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, + 0xBF, 0xFB, 0x01, 0xCF, 0x07, 0x78, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0xD8, 0x07, 0x78, 0x70, + 0x72, 0x69, 0x6E, 0x74, 0x66, 0xCF, 0x05, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x88, 0x0B, 0xCF, + 0x0D, 0x2A, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x70, 0x61, 0x74, 0x68, 0x2A, 0xD0, 0x0B, + 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x70, 0x61, 0x74, 0x68, 0xDA, 0x8B, 0x0B, 0xDA, 0x88, + 0x37, 0xCF, 0x07, 0x69, 0x6E, 0x74, 0x2F, 0x75, 0x36, 0x34, 0xD8, 0x07, 0x69, 0x6E, 0x74, 0x2F, + 0x75, 0x36, 0x34, 0xCF, 0x10, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x63, 0x68, 0x65, 0x63, + 0x6B, 0x2D, 0x73, 0x65, 0x74, 0xD8, 0x10, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x63, 0x68, + 0x65, 0x63, 0x6B, 0x2D, 0x73, 0x65, 0x74, 0xDA, 0x8B, 0xB0, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x16, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x12, 0x66, 0x00, 0x0D, 0xCE, 0x05, 0x76, + 0x61, 0x72, 0x66, 0x6E, 0xDA, 0x18, 0xDA, 0x82, 0xFE, 0xDA, 0x82, 0x87, 0xDA, 0x80, 0xE0, 0xDA, + 0x88, 0xF7, 0xDA, 0x85, 0xA7, 0xDA, 0x08, 0xCE, 0x11, 0x69, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64, + 0x20, 0x6D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0xDA, 0x81, 0x12, 0xDA, 0x51, 0xDA, + 0x80, 0x9F, 0xDA, 0x80, 0xFB, 0xDA, 0x61, 0xDA, 0x83, 0xA4, 0xDA, 0x52, 0xDA, 0x81, 0x07, 0xD7, + 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x03, 0x03, 0x03, 0x02, 0x21, 0x00, 0x0D, 0xCE, 0x06, + 0x70, 0x75, 0x74, 0x2D, 0x69, 0x6E, 0xDA, 0x18, 0xDA, 0x8B, 0x5D, 0xDA, 0x80, 0xF5, 0x00, 0x21, + 0x00, 0xDA, 0x24, 0x00, 0x21, 0x01, 0xDA, 0x87, 0x37, 0x00, 0x21, 0x02, 0xDA, 0x5A, 0x00, 0x21, + 0x03, 0xCF, 0x06, 0x70, 0x75, 0x74, 0x2D, 0x69, 0x6E, 0x00, 0x21, 0x04, 0xDA, 0x82, 0x70, 0x03, + 0x21, 0x05, 0xDA, 0x8B, 0x5E, 0x08, 0x1B, 0x07, 0xDA, 0x80, 0xC3, 0x08, 0x1B, 0x05, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x73, 0x0C, 0x1B, 0x0A, 0xDA, 0x22, 0x0E, 0x1B, 0x0B, 0xDA, + 0x5A, 0x14, 0x17, 0x0D, 0xDA, 0x8A, 0x88, 0x1C, 0x21, 0x08, 0xDA, 0x8B, 0x60, 0x1E, 0x21, 0x0A, + 0xDA, 0x8B, 0x61, 0x1B, 0x04, 0x00, 0x00, 0x3F, 0x05, 0x01, 0x00, 0x07, 0x06, 0x05, 0x01, 0x1B, + 0x05, 0x06, 0x00, 0x24, 0x07, 0x05, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x01, + 0x08, 0x00, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x23, 0x08, 0x07, 0x05, 0x1E, 0x08, 0x11, 0x00, 0x3B, + 0x09, 0x01, 0x07, 0x1B, 0x0A, 0x09, 0x00, 0x3B, 0x09, 0x04, 0x0A, 0x1B, 0x0B, 0x09, 0x00, 0x28, + 0x0C, 0x00, 0x00, 0x25, 0x09, 0x0C, 0x0B, 0x1E, 0x09, 0x07, 0x00, 0x2C, 0x0D, 0x01, 0x00, 0x35, + 0x0C, 0x0D, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x3C, 0x04, 0x0A, 0x0D, 0x1B, 0x04, 0x0D, 0x00, 0x1C, + 0x02, 0x00, 0x00, 0x1B, 0x04, 0x0B, 0x00, 0x05, 0x07, 0x07, 0x01, 0x1C, 0xEF, 0xFF, 0xFF, 0x3B, + 0x07, 0x01, 0x05, 0x1B, 0x08, 0x07, 0x00, 0x3B, 0x09, 0x04, 0x08, 0x1B, 0x0A, 0x09, 0x00, 0x3C, + 0x04, 0x08, 0x02, 0x03, 0x00, 0x00, 0x00, 0x86, 0x15, 0x03, 0x01, 0x11, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x07, 0x00, 0x03, 0x00, 0x13, 0x00, 0x13, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0C, + 0x00, 0x05, 0x01, 0x0C, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x12, 0x00, 0x12, + 0x00, 0x07, 0x01, 0x09, 0x01, 0x09, 0xBF, 0xFD, 0x05, 0x04, 0x07, 0xBF, 0xF9, 0x03, 0x00, 0x03, + 0x08, 0x11, 0x00, 0x03, 0x01, 0x11, 0x00, 0x03, 0x01, 0x03, 0xBF, 0xEE, 0x01, 0xDA, 0x85, 0x79, + 0xDA, 0x81, 0x73, 0x00, 0x66, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x66, 0x01, 0xDA, 0x81, 0x74, 0x00, + 0x66, 0x02, 0xDA, 0x8B, 0xB0, 0x04, 0x66, 0x04, 0xCF, 0x09, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x08, 0x66, 0x06, 0xCF, 0x05, 0x66, 0x62, 0x6F, 0x64, 0x79, 0x0E, 0x66, 0x08, + 0xDA, 0x83, 0x06, 0x10, 0x66, 0x0A, 0xCF, 0x08, 0x6D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x10, 0x2C, 0x08, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x69, 0x13, 0x2C, 0x0C, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x34, 0x68, 0x16, 0x2C, 0x0D, 0xDA, 0x81, 0x0D, 0x2E, 0x66, + 0x0C, 0xDA, 0x6B, 0x31, 0x66, 0x0D, 0xCF, 0x09, 0x6F, 0x6C, 0x64, 0x2D, 0x65, 0x6E, 0x74, 0x72, + 0x79, 0x34, 0x66, 0x0E, 0xDA, 0x80, 0xAA, 0x31, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, + 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, + 0x06, 0x01, 0x00, 0x35, 0x05, 0x06, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x2B, 0x07, 0x02, 0x00, 0x2B, + 0x08, 0xFE, 0xFF, 0x33, 0x04, 0x07, 0x08, 0x2C, 0x08, 0x02, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, + 0x08, 0x07, 0x00, 0x44, 0x09, 0x00, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x49, + 0x0B, 0x08, 0x0C, 0x1B, 0x0C, 0x0B, 0x00, 0x1F, 0x0C, 0x18, 0x00, 0x3A, 0x0B, 0x08, 0x0C, 0x1B, + 0x0D, 0x0B, 0x00, 0x31, 0x0D, 0x00, 0x00, 0x2C, 0x0E, 0x03, 0x00, 0x35, 0x0B, 0x0E, 0x00, 0x1E, + 0x0B, 0x04, 0x00, 0x29, 0x0E, 0x00, 0x00, 0x3C, 0x0A, 0x0D, 0x0E, 0x1C, 0x0D, 0x00, 0x00, 0x31, + 0x0D, 0x00, 0x00, 0x2C, 0x0F, 0x04, 0x00, 0x35, 0x0E, 0x0F, 0x00, 0x1E, 0x0E, 0x04, 0x00, 0x2C, + 0x0F, 0x05, 0x00, 0x3C, 0x0A, 0x0F, 0x0D, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x0F, 0x06, 0x00, 0x32, + 0x0F, 0x0D, 0x00, 0x2C, 0x10, 0x07, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x01, 0x0F, 0x00, 0x00, 0x49, + 0x0C, 0x08, 0x0C, 0x1C, 0xE9, 0xFF, 0xFF, 0x2C, 0x0C, 0x08, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, + 0x0C, 0x0B, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x35, 0x0B, 0x0D, 0x00, 0x1B, 0x0D, 0x0B, 0x00, 0x2C, + 0x0E, 0x08, 0x00, 0x35, 0x0B, 0x0E, 0x00, 0x1B, 0x0E, 0x0B, 0x00, 0x2C, 0x0F, 0x09, 0x00, 0x32, + 0x0F, 0x00, 0x00, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x10, 0x0A, 0x00, 0x32, 0x10, 0x0B, 0x00, 0x45, + 0x0F, 0x00, 0x00, 0x32, 0x0D, 0x0F, 0x00, 0x46, 0x0B, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x31, + 0x10, 0x00, 0x00, 0x40, 0x0F, 0x00, 0x00, 0x2C, 0x11, 0x0B, 0x00, 0x32, 0x11, 0x0F, 0x00, 0x44, + 0x10, 0x00, 0x00, 0x2C, 0x11, 0x0C, 0x00, 0x33, 0x11, 0x0D, 0x10, 0x45, 0x0F, 0x00, 0x00, 0x2C, + 0x11, 0x0D, 0x00, 0x33, 0x11, 0x0C, 0x0F, 0x45, 0x10, 0x00, 0x00, 0x2C, 0x11, 0x09, 0x00, 0x32, + 0x11, 0x00, 0x00, 0x45, 0x0F, 0x00, 0x00, 0x2C, 0x12, 0x0E, 0x00, 0x33, 0x12, 0x0F, 0x0C, 0x45, + 0x11, 0x00, 0x00, 0x2C, 0x12, 0x0D, 0x00, 0x33, 0x12, 0x0E, 0x06, 0x45, 0x0F, 0x00, 0x00, 0x2C, + 0x13, 0x0B, 0x00, 0x2B, 0x14, 0x00, 0x00, 0x32, 0x13, 0x14, 0x00, 0x46, 0x12, 0x00, 0x00, 0x2C, + 0x14, 0x0F, 0x00, 0x33, 0x14, 0x0C, 0x12, 0x31, 0x0E, 0x00, 0x00, 0x45, 0x13, 0x00, 0x00, 0x2C, + 0x14, 0x09, 0x00, 0x32, 0x14, 0x0A, 0x00, 0x45, 0x12, 0x00, 0x00, 0x2C, 0x15, 0x10, 0x00, 0x33, + 0x15, 0x0C, 0x12, 0x45, 0x14, 0x00, 0x00, 0x2C, 0x15, 0x11, 0x00, 0x33, 0x15, 0x0B, 0x10, 0x33, + 0x11, 0x0F, 0x13, 0x32, 0x14, 0x0E, 0x00, 0x45, 0x12, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0x88, + 0xD5, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x03, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x01, 0x03, + 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x07, + 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x01, 0x14, 0x00, 0x14, 0xBF, 0xFF, 0x05, 0x02, 0x07, + 0x00, 0x07, 0x00, 0x07, 0xBF, 0xFE, 0x05, 0x02, 0x13, 0x00, 0x13, 0xBF, 0xFE, 0x05, 0x03, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0xBF, 0xFC, 0x03, 0x00, 0x03, 0x05, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0xCF, 0x09, 0x2A, 0x74, 0x61, 0x73, 0x6B, 0x2D, 0x69, 0x64, 0x2A, 0xD0, 0x07, 0x74, 0x61, + 0x73, 0x6B, 0x2D, 0x69, 0x64, 0xCF, 0x08, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0xD8, + 0x08, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0xCF, 0x07, 0x6B, 0x65, 0x79, 0x77, 0x6F, + 0x72, 0x64, 0xDA, 0x8C, 0xC6, 0xCF, 0x0E, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x74, 0x73, 0x6F, + 0x63, 0x6B, 0x6F, 0x70, 0x74, 0xD8, 0x0E, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x74, 0x73, 0x6F, + 0x63, 0x6B, 0x6F, 0x70, 0x74, 0xDA, 0x84, 0x5B, 0xDA, 0x84, 0x58, 0xCF, 0x07, 0x6F, 0x73, 0x2F, + 0x64, 0x61, 0x74, 0x65, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0xCF, 0x0A, 0x69, + 0x6E, 0x74, 0x65, 0x72, 0x6C, 0x65, 0x61, 0x76, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, + 0x03, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x02, 0xCE, 0x0A, 0x69, 0x6E, + 0x74, 0x65, 0x72, 0x6C, 0x65, 0x61, 0x76, 0x65, 0xDA, 0x18, 0xDA, 0x80, 0xE7, 0xDA, 0x8C, 0xE2, + 0x00, 0x05, 0x00, 0xCF, 0x04, 0x63, 0x6F, 0x6C, 0x73, 0x00, 0x05, 0x01, 0xDA, 0x8D, 0x22, 0x2C, + 0x02, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x36, + 0x02, 0x00, 0x00, 0x86, 0x93, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x0D, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xD8, 0x0D, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xCF, 0x06, 0x73, 0x79, + 0x6D, 0x62, 0x6F, 0x6C, 0xDA, 0x87, 0x01, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x65, + 0x69, 0x6C, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x65, 0x69, 0x6C, 0xDA, 0x87, 0xAB, + 0xDA, 0x87, 0xA8, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x70, 0xD8, + 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x70, 0xCF, 0x10, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD8, 0x10, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xCF, + 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD8, 0x0D, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xCF, 0x0F, 0x6D, + 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, 0x64, 0x69, 0x63, 0x74, 0xDA, 0x8C, + 0xDC, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x77, 0x68, 0x69, 0x63, 0x68, 0xD8, 0x08, 0x6F, 0x73, 0x2F, + 0x77, 0x68, 0x69, 0x63, 0x68, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, 0x6E, + 0x63, 0x61, 0x74, 0xDA, 0x80, 0xE3, 0xDA, 0x88, 0x13, 0xD7, 0x01, 0xCD, 0x03, 0xFF, 0x00, 0x00, + 0x0E, 0x01, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x07, 0x29, 0x01, 0x01, 0x09, 0xCE, 0x0B, 0x66, + 0x66, 0x69, 0x2F, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0xDA, 0x18, 0xDA, 0x88, 0x0D, 0xDA, + 0x88, 0x0E, 0xDA, 0x83, 0x4E, 0xD0, 0x0B, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2D, 0x70, 0x61, + 0x74, 0x68, 0xDA, 0x88, 0x0F, 0xDA, 0x87, 0x72, 0xDA, 0x81, 0x07, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x88, 0x11, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x88, 0x12, 0x00, 0x29, 0x00, 0xCF, 0x0B, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x02, 0x29, 0x05, 0xDA, 0x88, 0x1C, 0x05, + 0x29, 0x06, 0xCF, 0x0B, 0x6D, 0x61, 0x70, 0x2D, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x06, + 0x29, 0x01, 0xDA, 0x88, 0x13, 0x0B, 0x29, 0x07, 0xDA, 0x8D, 0x39, 0x13, 0x29, 0x09, 0xDA, 0x88, + 0x1F, 0x1A, 0x29, 0x0B, 0xCF, 0x08, 0x6C, 0x61, 0x7A, 0x79, 0x2D, 0x6C, 0x69, 0x62, 0x2C, 0x05, + 0x00, 0x00, 0x3A, 0x04, 0x01, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x3A, 0x04, + 0x01, 0x06, 0x1B, 0x06, 0x04, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x20, 0x06, 0x03, 0x00, 0x2D, 0x04, + 0x00, 0x02, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x04, 0x06, 0x00, 0x1B, 0x07, 0x04, 0x00, 0x1E, 0x05, + 0x03, 0x00, 0x28, 0x08, 0x00, 0x00, 0x1C, 0x05, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x0A, + 0x02, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x08, 0x09, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x1E, 0x05, + 0x05, 0x00, 0x30, 0x0B, 0x00, 0x00, 0x35, 0x0C, 0x0B, 0x00, 0x1B, 0x0A, 0x0C, 0x00, 0x1C, 0x02, + 0x00, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x2C, 0x0D, + 0x03, 0x00, 0x33, 0x0C, 0x05, 0x0D, 0x2C, 0x0C, 0x04, 0x00, 0x33, 0x00, 0x0C, 0x0B, 0x2C, 0x0C, + 0x01, 0x00, 0x2C, 0x0D, 0x05, 0x00, 0x33, 0x0C, 0x07, 0x0D, 0x31, 0x09, 0x00, 0x00, 0x44, 0x0C, + 0x00, 0x00, 0x2D, 0x0D, 0x00, 0x00, 0x32, 0x0D, 0x0C, 0x00, 0x2C, 0x0D, 0x06, 0x00, 0x36, 0x0D, + 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x02, 0xF6, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, + 0x01, 0x08, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8D, 0x38, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x88, 0x1C, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x39, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x88, 0x13, + 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x39, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x88, 0x1F, 0x00, 0x04, + 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x01, 0x04, 0x01, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x28, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, 0x30, 0x02, + 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x00, 0x01, 0x0D, 0x02, 0x08, 0xDA, 0x18, 0xDA, 0x83, 0x4E, 0xBF, 0xFF, 0x01, 0x00, 0xDA, 0x8D, + 0x38, 0xBF, 0xFF, 0x01, 0x05, 0xDA, 0x88, 0x1C, 0xBF, 0xFF, 0x01, 0x06, 0xDA, 0x8D, 0x39, 0xBF, + 0xFF, 0x01, 0x01, 0xDA, 0x88, 0x13, 0xBF, 0xFF, 0x01, 0x07, 0xDA, 0x8D, 0x39, 0xBF, 0xFF, 0x01, + 0x09, 0xDA, 0x88, 0x1F, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x8D, 0x3B, 0xBF, 0xFF, 0x00, 0x01, 0xDA, + 0x8D, 0x3C, 0x2D, 0x00, 0x00, 0x01, 0x1E, 0x00, 0x03, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x01, 0x2D, 0x00, 0x01, 0x00, 0x31, 0x00, + 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x35, 0x00, 0x01, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2D, 0x00, + 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0x8F, 0x08, 0x1C, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23, + 0x00, 0x1C, 0x00, 0x1C, 0x8F, 0x08, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x03, 0x00, 0x00, + 0x00, 0x8F, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x04, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x13, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x05, 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00, 0xDB, 0x01, 0xCF, 0x08, 0x63, 0x6C, 0x69, 0x2D, + 0x6D, 0x61, 0x69, 0x6E, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x27, 0x01, 0x01, 0x01, 0x45, + 0x81, 0x3F, 0x00, 0x19, 0x20, 0xCE, 0x08, 0x63, 0x6C, 0x69, 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0xDA, + 0x18, 0xDA, 0x81, 0xCB, 0xDA, 0x81, 0x07, 0xCE, 0x0A, 0x4A, 0x41, 0x4E, 0x45, 0x54, 0x5F, 0x50, + 0x41, 0x54, 0x48, 0xDA, 0x8C, 0xB3, 0xDA, 0x86, 0xE1, 0xCE, 0x0D, 0x4A, 0x41, 0x4E, 0x45, 0x54, + 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0xDA, 0x8D, 0x07, 0xCE, 0x08, 0x4E, 0x4F, 0x5F, + 0x43, 0x4F, 0x4C, 0x4F, 0x52, 0xDA, 0x82, 0x30, 0xDA, 0x8B, 0x72, 0xDA, 0x8A, 0xD4, 0xDA, 0x82, + 0x34, 0xCE, 0x01, 0x64, 0xCE, 0x01, 0x65, 0xCE, 0x01, 0x68, 0xCE, 0x01, 0x69, 0xCE, 0x01, 0x6B, + 0xCE, 0x01, 0x6C, 0xCE, 0x01, 0x6D, 0xDA, 0x81, 0x53, 0xCE, 0x01, 0x6E, 0xCE, 0x01, 0x70, 0xCE, + 0x01, 0x71, 0xCE, 0x01, 0x72, 0xCE, 0x01, 0x73, 0xCE, 0x01, 0x76, 0xCE, 0x01, 0x77, 0xCE, 0x01, + 0x78, 0xCE, 0x01, 0x45, 0xCE, 0x01, 0x4E, 0xCE, 0x01, 0x52, 0xDA, 0x82, 0x03, 0xDA, 0x81, 0x9D, + 0xDA, 0x84, 0xBB, 0xDA, 0x87, 0xBF, 0xDA, 0x86, 0x07, 0xDA, 0x86, 0x08, 0xDA, 0x85, 0x8D, 0xDA, + 0x82, 0xCE, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x10, 0x03, 0x03, 0x03, 0x0B, 0x33, 0x00, + 0x01, 0x0A, 0xCE, 0x08, 0x72, 0x75, 0x6E, 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0xDA, 0x18, 0xCF, 0x04, + 0x6D, 0x61, 0x69, 0x6E, 0xDA, 0x06, 0xDA, 0x61, 0xDA, 0x85, 0x8D, 0xDA, 0x85, 0xC8, 0xD0, 0x01, + 0x79, 0xDA, 0x81, 0x6B, 0xDA, 0x85, 0xF7, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, 0xDA, 0x85, 0x85, + 0x00, 0x33, 0x00, 0xDA, 0x85, 0x87, 0x00, 0x33, 0x01, 0xCF, 0x07, 0x73, 0x75, 0x62, 0x61, 0x72, + 0x67, 0x73, 0x00, 0x33, 0x02, 0xDA, 0x87, 0x03, 0x00, 0x33, 0x03, 0xCF, 0x08, 0x72, 0x75, 0x6E, + 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0x02, 0x33, 0x05, 0xDA, 0x6B, 0x06, 0x0F, 0x07, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x72, 0x17, 0x31, 0x09, 0xDA, 0x85, 0xD6, 0x19, 0x31, 0x0A, 0xCF, + 0x09, 0x77, 0x72, 0x61, 0x70, 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0x1D, 0x31, 0x0B, 0xDA, 0x80, 0xAA, + 0x1E, 0x31, 0x08, 0xDA, 0x80, 0xAD, 0x2C, 0x05, 0x00, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x1B, 0x05, + 0x04, 0x00, 0x1E, 0x04, 0x2F, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x3B, 0x06, 0x05, 0x07, 0x1B, 0x07, + 0x06, 0x00, 0x1E, 0x07, 0x03, 0x00, 0x1B, 0x06, 0x07, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x2C, 0x09, + 0x02, 0x00, 0x3B, 0x08, 0x05, 0x09, 0x2B, 0x0A, 0x00, 0x00, 0x3A, 0x09, 0x08, 0x0A, 0x1B, 0x06, + 0x09, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x1E, 0x06, 0x21, 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x3B, 0x09, + 0x00, 0x0A, 0x1E, 0x09, 0x03, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x08, + 0x05, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x30, 0x08, 0x00, 0x00, 0x1B, 0x0A, 0x08, 0x00, 0x33, 0x0A, + 0x09, 0x00, 0x2C, 0x0B, 0x06, 0x00, 0x35, 0x08, 0x0B, 0x00, 0x1B, 0x0B, 0x08, 0x00, 0x28, 0x08, + 0x00, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x07, 0x00, 0x35, 0x0C, 0x0D, 0x00, 0x1E, 0x0C, + 0x0E, 0x00, 0x37, 0x08, 0x0B, 0x08, 0x31, 0x0B, 0x00, 0x00, 0x2C, 0x0E, 0x08, 0x00, 0x35, 0x0D, + 0x0E, 0x00, 0x2C, 0x0F, 0x09, 0x00, 0x4A, 0x0E, 0x0F, 0x0D, 0x1E, 0x0E, 0x06, 0x00, 0x31, 0x00, + 0x00, 0x00, 0x2C, 0x0F, 0x0A, 0x00, 0x35, 0x0D, 0x0F, 0x00, 0x32, 0x0B, 0x08, 0x00, 0x35, 0x0F, + 0x0D, 0x00, 0x1C, 0xF0, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x02, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x04, 0x01, 0x03, 0xCE, 0x09, 0x77, 0x72, 0x61, 0x70, 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0xDA, 0x18, + 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x5B, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x57, 0x00, 0x04, + 0x00, 0xDA, 0x8D, 0x5C, 0x2D, 0x01, 0x00, 0x01, 0x34, 0x01, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x07, + 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0x83, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x8F, + 0x7F, 0x14, 0x00, 0x14, 0x00, 0x03, 0x00, 0x03, 0x01, 0x17, 0x00, 0x17, 0x00, 0x13, 0x00, 0x13, + 0x00, 0x13, 0x00, 0x13, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x13, 0xBF, 0xFF, + 0x03, 0x00, 0x03, 0x02, 0x14, 0x00, 0x14, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x05, 0x01, 0x05, 0x00, 0x05, 0x02, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x05, 0x01, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x10, 0x01, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, + 0x0D, 0x00, 0x0D, 0x00, 0x07, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x09, 0x00, 0x09, 0xBF, + 0xFD, 0x05, 0x00, 0x05, 0xBF, 0xF9, 0x03, 0x00, 0x03, 0x82, 0x00, 0x00, 0x00, 0xDA, 0x84, 0x96, + 0xDA, 0x85, 0xCA, 0xDA, 0x85, 0x95, 0xDA, 0x8B, 0x92, 0xDA, 0x8B, 0xC2, 0xDA, 0x8B, 0xE0, 0xDA, + 0x84, 0xBA, 0xD0, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6E, 0xDA, 0x8D, 0x33, 0xD8, 0x07, 0x6F, 0x73, + 0x2F, 0x61, 0x72, 0x63, 0x68, 0xDA, 0x8A, 0xEA, 0xCE, 0x06, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, + 0xDA, 0x89, 0x81, 0xDA, 0x84, 0x47, 0xDA, 0x82, 0x5A, 0xDA, 0x82, 0xDE, 0xCE, 0x13, 0x20, 0x2D, + 0x20, 0x27, 0x28, 0x64, 0x6F, 0x63, 0x29, 0x27, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x68, 0x65, 0x6C, + 0x70, 0xDA, 0x83, 0xBD, 0xDA, 0x84, 0x0F, 0xDA, 0x80, 0xFB, 0xDA, 0x82, 0x04, 0xDA, 0x8A, 0x82, + 0xDA, 0x85, 0xF3, 0xCE, 0x05, 0x25, 0x2E, 0x32, 0x30, 0x51, 0xCE, 0x05, 0x25, 0x2E, 0x32, 0x30, + 0x71, 0xDA, 0x84, 0x0C, 0xDA, 0x85, 0x22, 0xDA, 0x81, 0xEB, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, + 0x00, 0x0D, 0x05, 0x00, 0x05, 0x0A, 0x25, 0x00, 0x01, 0x09, 0xCE, 0x04, 0x72, 0x65, 0x70, 0x6C, + 0xDA, 0x18, 0xDA, 0x84, 0x96, 0xDA, 0x85, 0x85, 0xDA, 0x85, 0x98, 0xDA, 0x85, 0x93, 0xDA, 0x85, + 0x9C, 0xDA, 0x85, 0x94, 0xDA, 0x84, 0xBA, 0xD0, 0x04, 0x72, 0x65, 0x70, 0x6C, 0xDA, 0x85, 0x95, + 0xDA, 0x85, 0x96, 0x00, 0x25, 0x00, 0xDA, 0x85, 0xD8, 0x00, 0x25, 0x01, 0xCF, 0x08, 0x6F, 0x6E, + 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x00, 0x25, 0x02, 0xDA, 0x85, 0x87, 0x00, 0x25, 0x03, 0xDA, + 0x85, 0xD9, 0x00, 0x25, 0x04, 0xDA, 0x85, 0xD4, 0x00, 0x25, 0x05, 0xCF, 0x04, 0x72, 0x65, 0x70, + 0x6C, 0x06, 0x25, 0x07, 0xDA, 0x85, 0x87, 0x0C, 0x25, 0x09, 0xDA, 0x85, 0xD8, 0x0C, 0x16, 0x01, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x20, 0x02, 0x05, 0x00, 0x2C, 0x08, 0x00, + 0x00, 0x35, 0x07, 0x08, 0x00, 0x1B, 0x06, 0x07, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x06, 0x02, + 0x00, 0x1B, 0x07, 0x06, 0x00, 0x20, 0x00, 0x04, 0x00, 0x30, 0x09, 0x00, 0x00, 0x1B, 0x08, 0x09, + 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x08, 0x00, 0x00, 0x1B, 0x09, 0x08, 0x00, 0x1E, 0x01, 0x03, + 0x00, 0x1B, 0x0A, 0x01, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x2B, 0x0B, 0x01, 0x00, 0x29, 0x0C, 0x00, + 0x00, 0x33, 0x07, 0x0B, 0x0C, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, 0x0A, 0x0B, + 0x00, 0x2C, 0x0B, 0x02, 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x33, 0x0B, 0x04, 0x0C, 0x2C, 0x0B, 0x04, + 0x00, 0x33, 0x09, 0x0B, 0x03, 0x2C, 0x0B, 0x05, 0x00, 0x2C, 0x0C, 0x06, 0x00, 0x33, 0x0B, 0x0A, + 0x0C, 0x2C, 0x0B, 0x07, 0x00, 0x2C, 0x0C, 0x08, 0x00, 0x33, 0x0B, 0x0C, 0x07, 0x43, 0x0A, 0x00, + 0x00, 0x31, 0x0A, 0x00, 0x00, 0x2C, 0x0B, 0x09, 0x00, 0x36, 0x0B, 0x00, 0x00, 0xCD, 0x00, 0xD4, + 0x00, 0x00, 0x06, 0x02, 0x02, 0x02, 0x08, 0x15, 0x01, 0x09, 0xDA, 0x18, 0xDA, 0x85, 0xC4, 0xDA, + 0x86, 0x25, 0xDA, 0x86, 0x26, 0xCE, 0x05, 0x72, 0x65, 0x70, 0x6C, 0x3A, 0xDA, 0x85, 0xA3, 0xDA, + 0x85, 0x49, 0xDA, 0x81, 0x12, 0xDA, 0x85, 0xF3, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x85, 0xD8, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x67, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, + 0x03, 0xDA, 0x85, 0xD9, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x85, 0xD4, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x8D, 0x68, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x85, 0x87, 0x00, 0x15, 0x00, 0xDA, 0x82, 0x26, 0x00, + 0x15, 0x01, 0xDA, 0x6D, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, + 0x2B, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x35, 0x03, 0x02, 0x00, 0x2C, 0x02, 0x01, 0x00, + 0x32, 0x01, 0x02, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x02, 0x04, 0x00, 0x2C, 0x04, 0x03, 0x00, + 0x2C, 0x05, 0x04, 0x00, 0x33, 0x04, 0x03, 0x05, 0x2C, 0x04, 0x05, 0x00, 0x32, 0x02, 0x04, 0x00, + 0x2C, 0x05, 0x06, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2D, 0x02, 0x00, 0x07, 0x33, 0x04, 0x00, 0x02, + 0x2C, 0x02, 0x07, 0x00, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8E, 0x79, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x02, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xBF, + 0xFC, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFF, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x8E, 0x73, 0x03, 0x00, 0x10, 0x00, 0x10, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x01, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x0B, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, + 0x29, 0x00, 0x29, 0x00, 0x1C, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x81, 0x3F, 0x00, 0xDA, 0x80, 0xE8, 0x00, + 0x81, 0x3F, 0x01, 0xDA, 0x8D, 0x3D, 0x04, 0x81, 0x3F, 0x03, 0xCF, 0x0B, 0x73, 0x68, 0x6F, 0x75, + 0x6C, 0x64, 0x2D, 0x72, 0x65, 0x70, 0x6C, 0x05, 0x81, 0x3F, 0x04, 0xCF, 0x07, 0x6E, 0x6F, 0x2D, + 0x66, 0x69, 0x6C, 0x65, 0x06, 0x81, 0x3F, 0x05, 0xCF, 0x05, 0x71, 0x75, 0x69, 0x65, 0x74, 0x07, + 0x81, 0x3F, 0x06, 0xCF, 0x09, 0x72, 0x61, 0x77, 0x2D, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x08, 0x81, + 0x3F, 0x07, 0xCF, 0x0A, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x6F, 0x70, 0x74, 0x73, 0x09, 0x81, + 0x3F, 0x08, 0xCF, 0x0D, 0x65, 0x78, 0x69, 0x74, 0x2D, 0x6F, 0x6E, 0x2D, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x0A, 0x81, 0x3F, 0x09, 0xDA, 0x82, 0x08, 0x0B, 0x81, 0x3F, 0x0A, 0xCF, 0x0A, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x2D, 0x66, 0x6C, 0x61, 0x67, 0x0C, 0x81, 0x3F, 0x0B, 0xCF, 0x0C, 0x63, 0x6F, + 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x6F, 0x6E, 0x6C, 0x79, 0x0D, 0x81, 0x3F, 0x0C, 0xCF, 0x0A, + 0x77, 0x61, 0x72, 0x6E, 0x2D, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x0E, 0x81, 0x3F, 0x0D, 0xCF, 0x0B, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2D, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x0F, 0x81, 0x3F, 0x0E, 0xCF, + 0x0C, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x14, 0x1A, 0x10, + 0xCF, 0x02, 0x6A, 0x70, 0x1E, 0x24, 0x10, 0xCF, 0x08, 0x6A, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, + 0x65, 0x2B, 0x33, 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x73, 0x34, 0x81, 0x3F, + 0x10, 0xCF, 0x0E, 0x67, 0x65, 0x74, 0x2D, 0x6C, 0x69, 0x6E, 0x74, 0x2D, 0x6C, 0x65, 0x76, 0x65, + 0x6C, 0x6C, 0x81, 0x3F, 0x12, 0xCF, 0x08, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x73, 0x6E, + 0x81, 0x3F, 0x14, 0xCF, 0x09, 0x64, 0x6F, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x6F, 0x81, + 0x3F, 0x15, 0xDA, 0x80, 0xC3, 0x71, 0x81, 0x3F, 0x17, 0xCF, 0x07, 0x6C, 0x65, 0x6E, 0x61, 0x72, + 0x67, 0x73, 0x75, 0x80, 0xCC, 0x1A, 0xDA, 0x87, 0x03, 0x76, 0x80, 0x82, 0x1B, 0xCF, 0x07, 0x5F, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x75, 0x80, 0x8E, 0x80, 0xCB, 0x1C, 0xDA, 0x8D, 0x59, 0x80, 0x97, + 0x80, 0xA8, 0x1B, 0xDA, 0x85, 0x87, 0x80, 0xAB, 0x80, 0xCA, 0x1D, 0xDA, 0x85, 0x87, 0x80, 0xCC, + 0x80, 0xD1, 0x18, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, 0x76, 0x80, 0xF6, 0x81, 0x3E, + 0x1B, 0xCF, 0x08, 0x67, 0x65, 0x74, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x80, 0xFE, 0x81, 0x0C, 0x1D, + 0xCF, 0x0D, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x81, + 0x05, 0x81, 0x0C, 0x1F, 0xCF, 0x07, 0x6E, 0x65, 0x77, 0x2D, 0x65, 0x6E, 0x76, 0x81, 0x19, 0x81, + 0x3E, 0x1E, 0xCF, 0x08, 0x67, 0x65, 0x74, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x2C, 0x02, 0x00, 0x00, + 0x32, 0x02, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2A, 0x03, 0x00, 0x00, + 0x29, 0x04, 0x00, 0x00, 0x2A, 0x05, 0x00, 0x00, 0x2A, 0x06, 0x00, 0x00, 0x29, 0x07, 0x00, 0x00, + 0x29, 0x08, 0x00, 0x00, 0x29, 0x09, 0x00, 0x00, 0x2A, 0x0A, 0x00, 0x00, 0x2A, 0x0B, 0x00, 0x00, + 0x28, 0x0C, 0x00, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x2A, 0x0E, 0x00, 0x00, 0x2C, 0x0F, 0x02, 0x00, + 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x03, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x1B, 0x10, 0x0F, 0x00, + 0x1E, 0x0F, 0x05, 0x00, 0x2C, 0x11, 0x04, 0x00, 0x32, 0x11, 0x10, 0x00, 0x2C, 0x12, 0x01, 0x00, + 0x35, 0x11, 0x12, 0x00, 0x2C, 0x0F, 0x05, 0x00, 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x03, 0x00, + 0x35, 0x0F, 0x10, 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x1E, 0x0F, 0x05, 0x00, 0x2C, 0x11, 0x06, 0x00, + 0x32, 0x11, 0x10, 0x00, 0x2C, 0x12, 0x01, 0x00, 0x35, 0x11, 0x12, 0x00, 0x2C, 0x0F, 0x07, 0x00, + 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x03, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x31, 0x0F, 0x00, 0x00, + 0x2C, 0x11, 0x08, 0x00, 0x35, 0x10, 0x11, 0x00, 0x1B, 0x0F, 0x10, 0x00, 0x1E, 0x10, 0x06, 0x00, + 0x2C, 0x11, 0x09, 0x00, 0x31, 0x11, 0x00, 0x00, 0x2C, 0x11, 0x0A, 0x00, 0x35, 0x09, 0x11, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x09, 0x0F, 0x00, 0x30, 0x0F, 0x00, 0x00, 0x1B, 0x10, 0x0F, 0x00, + 0x30, 0x11, 0x01, 0x00, 0x30, 0x12, 0x02, 0x00, 0x30, 0x13, 0x03, 0x00, 0x30, 0x14, 0x04, 0x00, + 0x30, 0x15, 0x05, 0x00, 0x30, 0x16, 0x06, 0x00, 0x30, 0x17, 0x07, 0x00, 0x30, 0x18, 0x08, 0x00, + 0x30, 0x19, 0x09, 0x00, 0x30, 0x1A, 0x0A, 0x00, 0x30, 0x1B, 0x0B, 0x00, 0x30, 0x1C, 0x0C, 0x00, + 0x30, 0x1D, 0x0D, 0x00, 0x30, 0x1E, 0x0E, 0x00, 0x30, 0x1F, 0x0F, 0x00, 0x30, 0x20, 0x10, 0x00, + 0x30, 0x21, 0x11, 0x00, 0x30, 0x22, 0x12, 0x00, 0x30, 0x23, 0x13, 0x00, 0x30, 0x24, 0x14, 0x00, + 0x2C, 0x25, 0x0B, 0x00, 0x2C, 0x26, 0x0C, 0x00, 0x33, 0x25, 0x11, 0x26, 0x2C, 0x25, 0x0D, 0x00, + 0x33, 0x12, 0x25, 0x13, 0x2C, 0x25, 0x0E, 0x00, 0x2C, 0x26, 0x0F, 0x00, 0x33, 0x25, 0x14, 0x26, + 0x2C, 0x25, 0x10, 0x00, 0x33, 0x15, 0x25, 0x16, 0x2C, 0x25, 0x11, 0x00, 0x2C, 0x26, 0x12, 0x00, + 0x33, 0x25, 0x17, 0x26, 0x2C, 0x25, 0x13, 0x00, 0x33, 0x18, 0x25, 0x19, 0x2C, 0x25, 0x14, 0x00, + 0x2C, 0x26, 0x15, 0x00, 0x33, 0x25, 0x1A, 0x26, 0x2C, 0x25, 0x16, 0x00, 0x33, 0x1B, 0x25, 0x1C, + 0x2C, 0x25, 0x17, 0x00, 0x2C, 0x26, 0x18, 0x00, 0x33, 0x25, 0x1D, 0x26, 0x2C, 0x25, 0x19, 0x00, + 0x33, 0x1E, 0x25, 0x1F, 0x2C, 0x25, 0x1A, 0x00, 0x2C, 0x26, 0x1B, 0x00, 0x33, 0x25, 0x20, 0x26, + 0x2C, 0x25, 0x1C, 0x00, 0x33, 0x21, 0x25, 0x22, 0x2C, 0x25, 0x1D, 0x00, 0x2C, 0x26, 0x1E, 0x00, + 0x33, 0x25, 0x23, 0x26, 0x31, 0x24, 0x00, 0x00, 0x43, 0x11, 0x00, 0x00, 0x1B, 0x12, 0x11, 0x00, + 0x30, 0x13, 0x15, 0x00, 0x1B, 0x14, 0x13, 0x00, 0x2B, 0x15, 0x00, 0x00, 0x3F, 0x16, 0x00, 0x00, + 0x1B, 0x17, 0x16, 0x00, 0x23, 0x18, 0x15, 0x17, 0x1E, 0x18, 0x59, 0x00, 0x3A, 0x19, 0x00, 0x15, + 0x1B, 0x1A, 0x19, 0x00, 0x1B, 0x1B, 0x07, 0x00, 0x1E, 0x07, 0x0A, 0x00, 0x2B, 0x1C, 0x00, 0x00, + 0x2B, 0x1D, 0x01, 0x00, 0x33, 0x1A, 0x1C, 0x1D, 0x2C, 0x1D, 0x1F, 0x00, 0x35, 0x1C, 0x1D, 0x00, + 0x2C, 0x1E, 0x13, 0x00, 0x25, 0x1D, 0x1E, 0x1C, 0x1B, 0x19, 0x1D, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x1B, 0x19, 0x1B, 0x00, 0x1E, 0x19, 0x09, 0x00, 0x2B, 0x1B, 0x01, 0x00, 0x32, 0x1A, 0x1B, 0x00, + 0x2C, 0x1C, 0x1F, 0x00, 0x35, 0x1B, 0x1C, 0x00, 0x32, 0x1B, 0x15, 0x00, 0x35, 0x1C, 0x14, 0x00, + 0x06, 0x15, 0x15, 0x1C, 0x1C, 0x41, 0x00, 0x00, 0x32, 0x00, 0x15, 0x00, 0x2C, 0x1C, 0x20, 0x00, + 0x35, 0x1B, 0x1C, 0x00, 0x1B, 0x1C, 0x1B, 0x00, 0x2A, 0x04, 0x00, 0x00, 0x1E, 0x0E, 0x19, 0x00, + 0x31, 0x1A, 0x00, 0x00, 0x2C, 0x1D, 0x21, 0x00, 0x35, 0x1B, 0x1D, 0x00, 0x31, 0x1B, 0x00, 0x00, + 0x2C, 0x1E, 0x22, 0x00, 0x35, 0x1D, 0x1E, 0x00, 0x1B, 0x1B, 0x1D, 0x00, 0x2C, 0x1D, 0x00, 0x00, + 0x3C, 0x1B, 0x1D, 0x1C, 0x2C, 0x1D, 0x23, 0x00, 0x3C, 0x1B, 0x1D, 0x0D, 0x2C, 0x1D, 0x24, 0x00, + 0x3C, 0x1B, 0x1D, 0x0C, 0x1E, 0x0A, 0x07, 0x00, 0x2C, 0x1D, 0x25, 0x00, 0x29, 0x1E, 0x00, 0x00, + 0x3C, 0x1B, 0x1D, 0x1E, 0x2C, 0x1D, 0x26, 0x00, 0x29, 0x1E, 0x00, 0x00, 0x3C, 0x1B, 0x1D, 0x1E, + 0x33, 0x1B, 0x1C, 0x1A, 0x2C, 0x1E, 0x27, 0x00, 0x35, 0x1D, 0x1E, 0x00, 0x1C, 0x22, 0x00, 0x00, + 0x2C, 0x1D, 0x28, 0x00, 0x35, 0x1B, 0x1D, 0x00, 0x1B, 0x1D, 0x1B, 0x00, 0x2C, 0x1B, 0x00, 0x00, + 0x3C, 0x1D, 0x1B, 0x1C, 0x2C, 0x1B, 0x23, 0x00, 0x3C, 0x1D, 0x1B, 0x0D, 0x2C, 0x1B, 0x24, 0x00, + 0x3C, 0x1D, 0x1B, 0x0C, 0x1E, 0x0A, 0x07, 0x00, 0x2C, 0x1B, 0x25, 0x00, 0x29, 0x1E, 0x00, 0x00, + 0x3C, 0x1D, 0x1B, 0x1E, 0x2C, 0x1B, 0x26, 0x00, 0x29, 0x1E, 0x00, 0x00, 0x3C, 0x1D, 0x1B, 0x1E, + 0x1E, 0x0B, 0x08, 0x00, 0x2C, 0x1B, 0x29, 0x00, 0x33, 0x1A, 0x1B, 0x08, 0x2C, 0x1B, 0x2A, 0x00, + 0x32, 0x1B, 0x1D, 0x00, 0x2C, 0x1E, 0x2B, 0x00, 0x35, 0x1B, 0x1E, 0x00, 0x1C, 0x0A, 0x00, 0x00, + 0x2C, 0x1B, 0x29, 0x00, 0x33, 0x1A, 0x1B, 0x08, 0x2C, 0x1B, 0x2A, 0x00, 0x32, 0x1B, 0x1D, 0x00, + 0x2C, 0x1E, 0x2C, 0x00, 0x35, 0x1B, 0x1E, 0x00, 0x33, 0x1D, 0x1C, 0x1A, 0x2C, 0x1E, 0x27, 0x00, + 0x35, 0x1B, 0x1E, 0x00, 0x1B, 0x15, 0x17, 0x00, 0x1C, 0xA7, 0xFF, 0xFF, 0x1B, 0x18, 0x03, 0x00, + 0x1E, 0x18, 0x03, 0x00, 0x1B, 0x19, 0x18, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x19, 0x04, 0x00, + 0x1E, 0x19, 0x6D, 0x00, 0x1E, 0x0B, 0x09, 0x00, 0x2C, 0x18, 0x2D, 0x00, 0x2C, 0x1A, 0x2E, 0x00, + 0x2C, 0x1B, 0x2F, 0x00, 0x33, 0x18, 0x1A, 0x1B, 0x2C, 0x18, 0x29, 0x00, 0x32, 0x18, 0x08, 0x00, + 0x2C, 0x18, 0x2B, 0x00, 0x36, 0x18, 0x00, 0x00, 0x1E, 0x05, 0x02, 0x00, 0x1C, 0x15, 0x00, 0x00, + 0x2C, 0x1A, 0x30, 0x00, 0x35, 0x18, 0x1A, 0x00, 0x2C, 0x1B, 0x31, 0x00, 0x35, 0x1A, 0x1B, 0x00, + 0x2C, 0x1C, 0x32, 0x00, 0x35, 0x1B, 0x1C, 0x00, 0x2C, 0x1C, 0x33, 0x00, 0x2C, 0x1D, 0x34, 0x00, + 0x2C, 0x1E, 0x13, 0x00, 0x33, 0x1C, 0x1D, 0x1E, 0x2C, 0x1C, 0x35, 0x00, 0x2C, 0x1D, 0x36, 0x00, + 0x33, 0x1C, 0x1D, 0x18, 0x2C, 0x1C, 0x37, 0x00, 0x2C, 0x1D, 0x37, 0x00, 0x33, 0x1C, 0x1A, 0x1D, + 0x2C, 0x1C, 0x38, 0x00, 0x32, 0x1B, 0x1C, 0x00, 0x2C, 0x1D, 0x39, 0x00, 0x35, 0x1C, 0x1D, 0x00, + 0x2C, 0x1A, 0x3A, 0x00, 0x35, 0x18, 0x1A, 0x00, 0x30, 0x18, 0x16, 0x00, 0x1B, 0x1A, 0x18, 0x00, + 0x30, 0x18, 0x17, 0x00, 0x1B, 0x1B, 0x18, 0x00, 0x2C, 0x1C, 0x28, 0x00, 0x35, 0x18, 0x1C, 0x00, + 0x1B, 0x1C, 0x18, 0x00, 0x2C, 0x18, 0x06, 0x00, 0x31, 0x18, 0x00, 0x00, 0x2C, 0x1D, 0x3B, 0x00, + 0x35, 0x18, 0x1D, 0x00, 0x1B, 0x1D, 0x18, 0x00, 0x1E, 0x18, 0x0D, 0x00, 0x2C, 0x1E, 0x29, 0x00, + 0x29, 0x1F, 0x00, 0x00, 0x33, 0x1D, 0x1E, 0x1F, 0x2C, 0x1F, 0x2C, 0x00, 0x35, 0x1E, 0x1F, 0x00, + 0x1B, 0x1F, 0x1E, 0x00, 0x2C, 0x1E, 0x3C, 0x00, 0x33, 0x1C, 0x1F, 0x1E, 0x2A, 0x1E, 0x00, 0x00, + 0x31, 0x1E, 0x00, 0x00, 0x2C, 0x20, 0x3D, 0x00, 0x35, 0x1E, 0x20, 0x00, 0x1E, 0x0A, 0x07, 0x00, + 0x2C, 0x18, 0x25, 0x00, 0x29, 0x1D, 0x00, 0x00, 0x3C, 0x1C, 0x18, 0x1D, 0x2C, 0x18, 0x26, 0x00, + 0x29, 0x1D, 0x00, 0x00, 0x3C, 0x1C, 0x18, 0x1D, 0x1E, 0x06, 0x03, 0x00, 0x1B, 0x18, 0x1B, 0x00, + 0x1C, 0x02, 0x00, 0x00, 0x2C, 0x18, 0x3E, 0x00, 0x1B, 0x1D, 0x18, 0x00, 0x30, 0x18, 0x18, 0x00, + 0x1B, 0x1E, 0x18, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x2C, 0x18, 0x3F, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x2C, 0x18, 0x40, 0x00, 0x2C, 0x1F, 0x41, 0x00, 0x32, 0x1F, 0x18, 0x00, 0x2C, 0x20, 0x01, 0x00, + 0x35, 0x1F, 0x20, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x29, 0x18, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x28, 0x18, 0x00, 0x00, 0x2C, 0x1F, 0x42, 0x00, 0x32, 0x1F, 0x18, 0x00, 0x2C, 0x20, 0x01, 0x00, + 0x35, 0x1F, 0x20, 0x00, 0x1E, 0x09, 0x03, 0x00, 0x29, 0x18, 0x00, 0x00, 0x1C, 0x02, 0x00, 0x00, + 0x28, 0x18, 0x00, 0x00, 0x2C, 0x1F, 0x43, 0x00, 0x32, 0x1F, 0x18, 0x00, 0x2C, 0x20, 0x01, 0x00, + 0x35, 0x1F, 0x20, 0x00, 0x2C, 0x18, 0x23, 0x00, 0x32, 0x18, 0x0D, 0x00, 0x2C, 0x1F, 0x01, 0x00, + 0x35, 0x18, 0x1F, 0x00, 0x2C, 0x18, 0x24, 0x00, 0x32, 0x18, 0x0D, 0x00, 0x2C, 0x1F, 0x01, 0x00, + 0x35, 0x18, 0x1F, 0x00, 0x28, 0x18, 0x00, 0x00, 0x33, 0x1E, 0x18, 0x1C, 0x2C, 0x18, 0x44, 0x00, + 0x36, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x01, + 0x01, 0x02, 0x0D, 0x01, 0x15, 0xCE, 0x0E, 0x67, 0x65, 0x74, 0x2D, 0x6C, 0x69, 0x6E, 0x74, 0x2D, + 0x6C, 0x65, 0x76, 0x65, 0x6C, 0xDA, 0x18, 0xDA, 0x87, 0x13, 0xDA, 0x8C, 0xC6, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, + 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, + 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, + 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, + 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, + 0x0F, 0xDA, 0x8D, 0x78, 0x00, 0x0D, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x0D, 0x01, 0xDA, 0x8D, 0x79, + 0x03, 0x0D, 0x02, 0xDA, 0x1E, 0x07, 0x0D, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x74, 0x05, 0x02, 0x00, 0x01, 0x2D, 0x04, 0x00, 0x00, 0x3A, 0x03, 0x04, 0x02, 0x1B, 0x02, 0x03, + 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, + 0x00, 0x1E, 0x05, 0x02, 0x00, 0x03, 0x05, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x36, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xB4, 0x15, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x05, + 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x19, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, + 0x15, 0x01, 0x16, 0xCE, 0x08, 0x63, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0xDA, 0x18, 0xDA, + 0x8B, 0xC2, 0xDA, 0x8C, 0xDA, 0xDA, 0x86, 0x96, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, + 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, + 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, + 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, + 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, + 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x00, 0x15, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x15, 0x01, 0xCF, + 0x08, 0x63, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x03, 0x15, 0x02, 0xDA, 0x84, 0xC3, 0x07, + 0x15, 0x05, 0xDA, 0x85, 0x91, 0x05, 0x02, 0x00, 0x01, 0x2D, 0x04, 0x00, 0x00, 0x3A, 0x03, 0x04, + 0x02, 0x1B, 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x1B, 0x05, 0x04, 0x00, 0x05, 0x06, 0x00, 0x02, 0x2D, 0x08, 0x00, 0x00, 0x3A, 0x07, 0x08, + 0x06, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x06, 0x08, 0x00, 0x32, 0x07, 0x06, + 0x00, 0x2C, 0x09, 0x02, 0x00, 0x35, 0x08, 0x09, 0x00, 0x2A, 0x06, 0x00, 0x00, 0x2F, 0x06, 0x00, + 0x04, 0x2B, 0x06, 0x03, 0x00, 0x03, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xE0, 0x1F, 0x00, 0x16, + 0x00, 0x16, 0x00, 0x0C, 0x01, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x0C, 0x01, 0x1B, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x0C, + 0x00, 0x0C, 0xBF, 0xFC, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, + 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, + 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, + 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, + 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, + 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, + 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, + 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x0A, + 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xF7, 0x12, 0x00, 0x12, 0x00, + 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, + 0x01, 0x0A, 0x01, 0x14, 0xCE, 0x08, 0x65, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0xDA, 0x18, + 0xDA, 0x84, 0x33, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, + 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, + 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, + 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, + 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, + 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, + 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x79, 0x00, 0x0A, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x0A, 0x01, 0xCF, 0x08, 0x65, 0x2D, 0x73, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x2A, 0x02, 0x00, 0x00, 0x2F, 0x02, 0x00, 0x04, 0x05, 0x02, 0x00, 0x01, + 0x2D, 0x04, 0x00, 0x00, 0x3A, 0x03, 0x04, 0x02, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x00, 0x00, + 0x35, 0x02, 0x04, 0x00, 0x2B, 0x03, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xEB, + 0x0C, 0x00, 0x0C, 0x01, 0x22, 0x00, 0x19, 0x00, 0x19, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, + 0xFE, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD0, 0x00, 0x00, 0x04, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x08, 0x14, 0x00, 0xDA, 0x18, 0xDA, 0x8B, 0x2D, 0xCE, 0x05, 0x6A, 0x61, 0x6E, 0x65, 0x74, + 0xDA, 0x80, 0xFB, 0xCE, 0x07, 0x75, 0x73, 0x61, 0x67, 0x65, 0x3A, 0x20, 0xCE, 0x19, 0x20, 0x5B, + 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x5D, 0x20, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, + 0x61, 0x72, 0x67, 0x73, 0x2E, 0x2E, 0x2E, 0xDA, 0x83, 0xBD, 0xCE, 0x84, 0x02, 0x4F, 0x70, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x3A, 0x0A, 0x20, 0x20, 0x2D, 0x68, 0x20, 0x3A, + 0x20, 0x53, 0x68, 0x6F, 0x77, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x68, 0x65, 0x6C, 0x70, 0x0A, + 0x20, 0x20, 0x2D, 0x76, 0x20, 0x3A, 0x20, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, + 0x20, 0x20, 0x2D, 0x73, 0x20, 0x3A, 0x20, 0x55, 0x73, 0x65, 0x20, 0x72, 0x61, 0x77, 0x20, 0x73, + 0x74, 0x64, 0x69, 0x6E, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, + 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x69, 0x74, 0x79, 0x0A, 0x20, 0x20, 0x2D, 0x65, 0x20, + 0x63, 0x6F, 0x64, 0x65, 0x20, 0x3A, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, + 0x0A, 0x20, 0x20, 0x2D, 0x45, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x2E, 0x2E, 0x20, 0x3A, 0x20, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x2D, 0x66, 0x6E, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x0A, 0x20, 0x20, + 0x2D, 0x64, 0x20, 0x3A, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, + 0x45, 0x50, 0x4C, 0x0A, 0x20, 0x20, 0x2D, 0x72, 0x20, 0x3A, 0x20, 0x45, 0x6E, 0x74, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x45, 0x50, 0x4C, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x73, 0x0A, 0x20, 0x20, 0x2D, 0x52, 0x20, 0x3A, 0x20, 0x44, 0x69, 0x73, 0x61, 0x62, + 0x6C, 0x65, 0x73, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x72, 0x6F, 0x66, + 0x69, 0x6C, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x4A, + 0x41, 0x4E, 0x45, 0x54, 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0x20, 0x69, 0x73, 0x20, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x0A, 0x20, 0x20, 0x2D, 0x70, 0x20, 0x3A, 0x20, 0x4B, + 0x65, 0x65, 0x70, 0x20, 0x6F, 0x6E, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, + 0x6F, 0x70, 0x2D, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x28, + 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6E, 0x74, 0x29, 0x0A, 0x20, 0x20, 0x2D, 0x71, + 0x20, 0x3A, 0x20, 0x48, 0x69, 0x64, 0x65, 0x20, 0x6C, 0x6F, 0x67, 0x6F, 0x20, 0x28, 0x71, 0x75, + 0x69, 0x65, 0x74, 0x29, 0x0A, 0x20, 0x20, 0x2D, 0x6B, 0x20, 0x3A, 0x20, 0x43, 0x6F, 0x6D, 0x70, + 0x69, 0x6C, 0x65, 0x20, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x73, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x28, + 0x66, 0x6C, 0x79, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x29, 0x0A, 0x20, 0x20, 0x2D, 0x6D, 0x20, 0x73, + 0x79, 0x73, 0x70, 0x61, 0x74, 0x68, 0x20, 0x3A, 0x20, 0x53, 0x65, 0x74, 0x20, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6D, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6C, 0x6F, 0x61, + 0x64, 0x69, 0x6E, 0x67, 0x20, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0x20, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x73, 0x0A, 0x20, 0x20, 0x2D, 0x63, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x3A, 0x20, 0x43, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, + 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, + 0x64, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6D, 0x61, 0x67, 0x65, + 0x0A, 0x20, 0x20, 0x2D, 0x69, 0x20, 0x3A, 0x20, 0x4C, 0x6F, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x6C, + 0x65, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x0A, 0x20, 0x20, 0x2D, 0x6E, 0x20, 0x3A, 0x20, + 0x44, 0x69, 0x73, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x41, 0x4E, 0x53, 0x49, 0x20, 0x63, 0x6F, 0x6C, + 0x6F, 0x72, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x52, 0x45, 0x50, 0x4C, 0x0A, 0x20, 0x20, 0x2D, 0x4E, 0x20, 0x3A, 0x20, 0x45, 0x6E, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x41, 0x4E, 0x53, 0x49, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x20, 0x6F, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x45, 0x50, + 0x4C, 0x0A, 0x20, 0x20, 0x2D, 0x6C, 0x20, 0x6C, 0x69, 0x62, 0x20, 0x3A, 0x20, 0x55, 0x73, 0x65, + 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x0A, 0x20, 0x20, 0x2D, 0x77, 0x20, + 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x3A, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6C, 0x65, 0x76, + 0x65, 0x6C, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x22, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x22, 0x0A, 0x20, 0x20, 0x2D, 0x78, 0x20, 0x6C, 0x65, + 0x76, 0x65, 0x6C, 0x20, 0x3A, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x69, + 0x6E, 0x74, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x2D, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x22, 0x6E, 0x6F, 0x6E, + 0x65, 0x22, 0x0A, 0x20, 0x20, 0x2D, 0x2D, 0x20, 0x3A, 0x20, 0x53, 0x74, 0x6F, 0x70, 0x20, 0x68, + 0x61, 0x6E, 0x64, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0xDA, + 0x8A, 0x74, 0x2C, 0x00, 0x00, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, + 0x02, 0x00, 0x35, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x03, 0x00, 0x2C, 0x02, 0x04, 0x00, 0x33, 0x01, + 0x00, 0x02, 0x2C, 0x02, 0x05, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2C, 0x00, 0x06, 0x00, 0x31, 0x00, + 0x00, 0x00, 0x2C, 0x02, 0x05, 0x00, 0x35, 0x00, 0x02, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x31, 0x02, + 0x00, 0x00, 0x2C, 0x03, 0x07, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2B, 0x03, 0x01, 0x00, 0x03, 0x03, + 0x00, 0x00, 0x8F, 0xBA, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x18, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xE6, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, + 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, + 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, + 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, + 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, + 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, + 0x00, 0x2F, 0x00, 0x00, 0x0E, 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, + 0xDA, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, + 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, + 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, + 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, + 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, + 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, + 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, + 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, + 0x0B, 0x2A, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x08, 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, + 0x00, 0xBF, 0xFF, 0x8F, 0xDB, 0x12, 0x00, 0x12, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x0A, 0x00, 0x0A, + 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x0D, 0x01, + 0x14, 0xCE, 0x08, 0x6C, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0xDA, 0x18, 0xDA, 0x8A, 0x80, + 0xDA, 0x82, 0x04, 0xDA, 0x85, 0xCA, 0xDA, 0x8A, 0x79, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, + 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, + 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, + 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, + 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x00, 0x0D, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x0D, 0x01, + 0xCF, 0x08, 0x6C, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x05, 0x02, 0x00, 0x01, 0x2D, 0x04, + 0x00, 0x00, 0x3A, 0x03, 0x04, 0x02, 0x2C, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x33, 0x03, + 0x02, 0x04, 0x2C, 0x02, 0x02, 0x00, 0x2D, 0x04, 0x00, 0x08, 0x32, 0x02, 0x04, 0x00, 0x2C, 0x04, + 0x03, 0x00, 0x35, 0x02, 0x04, 0x00, 0x2B, 0x03, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, 0xBF, 0xFF, + 0x8F, 0xE7, 0x1E, 0x00, 0x15, 0x00, 0x15, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0xBF, 0xFF, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, + 0x00, 0x04, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x09, 0x01, 0x13, 0xDA, 0x18, 0xDA, + 0x86, 0xE1, 0xDA, 0x81, 0x07, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, + 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, + 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, + 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, + 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, + 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x79, 0x00, 0x09, 0x00, 0xDA, 0x80, 0xC3, 0x05, 0x01, 0x00, 0x01, 0x2D, 0x03, 0x00, + 0x00, 0x3A, 0x02, 0x03, 0x01, 0x2C, 0x01, 0x00, 0x00, 0x32, 0x01, 0x02, 0x00, 0x2C, 0x03, 0x01, + 0x00, 0x35, 0x01, 0x03, 0x00, 0x2B, 0x02, 0x02, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8F, + 0xDE, 0x2F, 0x00, 0x26, 0x00, 0x26, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x0A, + 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, + 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, + 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, + 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, + 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, + 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x79, 0x2A, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x07, 0x2B, 0x00, 0x01, 0x00, 0x03, + 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xE5, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, + 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, + 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, + 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, + 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, + 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, + 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, + 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x2A, + 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x09, 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, + 0xFF, 0x8F, 0xDC, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, + 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, + 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, + 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, + 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, + 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, + 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, + 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, + 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x2A, 0x00, 0x00, 0x00, 0x2F, + 0x00, 0x00, 0x08, 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xD8, 0x12, + 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, + 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, + 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, + 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, + 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, + 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, + 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, + 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, + 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x05, 0x2B, + 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xD9, 0x12, 0x00, 0x12, 0x00, 0x0A, + 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, + 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, + 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, + 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, + 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, + 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, + 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, + 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, + 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x03, 0x2B, 0x00, 0x01, 0x00, 0x03, + 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xD7, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, + 0xD4, 0x00, 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x01, 0x12, 0xDA, + 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, + 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, + 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, + 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, + 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, + 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, + 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x06, 0x29, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x03, 0x2B, + 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xD6, 0x12, 0x00, 0x12, 0x00, 0x27, + 0x00, 0x27, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD0, 0x00, 0x00, 0x03, 0x00, 0x00, 0xCD, 0x7F, + 0xFF, 0xFF, 0xFF, 0x05, 0x0C, 0x00, 0xDA, 0x18, 0xDA, 0x89, 0x81, 0xDA, 0x81, 0x53, 0xDA, 0x84, + 0x47, 0xDA, 0x83, 0xBD, 0xDA, 0x8A, 0x74, 0x2C, 0x00, 0x00, 0x00, 0x2C, 0x01, 0x01, 0x00, 0x2C, + 0x02, 0x02, 0x00, 0x33, 0x00, 0x01, 0x02, 0x2C, 0x01, 0x03, 0x00, 0x35, 0x00, 0x01, 0x00, 0x2B, + 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2C, 0x02, 0x04, 0x00, 0x35, 0x01, 0x02, 0x00, 0x2B, + 0x02, 0x01, 0x00, 0x03, 0x02, 0x00, 0x00, 0x8F, 0xD5, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x0A, 0x00, 0x0A, + 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x01, + 0x13, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, + 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, + 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, + 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, + 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, + 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, + 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, + 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x79, 0x00, 0x06, 0x00, 0xDA, 0x80, 0xC3, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x10, 0x35, + 0x01, 0x02, 0x00, 0x2F, 0x01, 0x00, 0x0C, 0x2B, 0x02, 0x02, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, + 0xFF, 0x8F, 0xF8, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, + 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x01, 0x13, 0xDA, + 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, + 0xFF, 0x00, 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, + 0x05, 0xDA, 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, + 0x8D, 0x6F, 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, + 0xBF, 0xFF, 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, + 0x00, 0x0C, 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, + 0xDA, 0x8D, 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, + 0x77, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x00, + 0x06, 0x00, 0xDA, 0x80, 0xC3, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x10, 0x35, 0x01, 0x02, + 0x00, 0x2F, 0x01, 0x00, 0x0D, 0x2B, 0x02, 0x02, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8F, + 0xF9, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x0B, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x08, 0x24, 0x01, 0x17, 0xCE, 0x08, 0x45, + 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0xDA, 0x18, 0xDA, 0x81, 0x9D, 0xDA, 0x8B, 0xED, 0xDA, + 0x86, 0xFB, 0xCF, 0x0C, 0x45, 0x2D, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0xDA, 0x81, 0x35, 0xDA, 0x87, 0x9E, 0xDA, 0x81, 0x72, 0xDA, 0x86, 0x01, 0xBF, 0xFF, 0x00, 0x00, + 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8D, + 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, 0x8D, 0x6D, 0xBF, + 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, 0xBF, 0xFF, 0x00, + 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, 0x00, 0x0A, 0xDA, + 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, 0x8D, 0x73, + 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, 0x75, 0xBF, 0xFF, + 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, 0xFF, 0x00, 0x0F, + 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x00, 0x24, 0x00, 0xDA, 0x80, 0xC3, + 0x00, 0x24, 0x01, 0xCF, 0x08, 0x45, 0x2D, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x07, 0x24, 0x02, + 0xDA, 0x8D, 0x59, 0x12, 0x24, 0x04, 0xDA, 0x85, 0x66, 0x16, 0x24, 0x07, 0xDA, 0x8B, 0xBD, 0x2A, + 0x02, 0x00, 0x00, 0x2F, 0x02, 0x00, 0x04, 0x05, 0x02, 0x00, 0x02, 0x2D, 0x03, 0x00, 0x00, 0x32, + 0x03, 0x02, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x05, + 0x04, 0x00, 0x01, 0x2D, 0x06, 0x00, 0x00, 0x3A, 0x05, 0x06, 0x04, 0x31, 0x05, 0x00, 0x00, 0x2C, + 0x06, 0x01, 0x00, 0x35, 0x04, 0x06, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x2C, 0x07, 0x03, 0x00, 0x33, + 0x06, 0x04, 0x07, 0x45, 0x05, 0x00, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x31, 0x04, 0x00, 0x00, 0x2C, + 0x07, 0x04, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, + 0x09, 0x05, 0x00, 0x35, 0x08, 0x09, 0x00, 0x1E, 0x08, 0x05, 0x00, 0x35, 0x09, 0x07, 0x00, 0x34, + 0x02, 0x00, 0x00, 0x35, 0x0A, 0x09, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x3B, + 0x09, 0x07, 0x0A, 0x01, 0x09, 0x00, 0x00, 0x2C, 0x08, 0x07, 0x00, 0x03, 0x08, 0x00, 0x00, 0xBF, + 0xFF, 0x8F, 0xEF, 0x0C, 0x00, 0x0C, 0x01, 0x2B, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x0C, 0x01, 0x31, 0x00, 0x28, 0x00, 0x28, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x0C, 0x01, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x0C, + 0x01, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x0C, 0x01, 0x0F, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFF, + 0x0C, 0x02, 0x15, 0x00, 0x15, 0x00, 0x0E, 0xBF, 0xF9, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD4, 0x00, + 0x00, 0x01, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x01, 0x12, 0xDA, 0x18, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, + 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, + 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, + 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, + 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0x29, 0x00, 0x00, + 0x00, 0x2F, 0x00, 0x00, 0x09, 0x2B, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x8F, + 0xDD, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xD0, 0x00, 0x00, 0x02, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x07, 0x00, 0xDA, 0x18, 0xDA, 0x8D, 0x07, 0xDA, 0x81, 0x07, + 0x2C, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x01, 0x01, 0x00, + 0x35, 0x00, 0x01, 0x00, 0x2B, 0x01, 0x01, 0x00, 0x03, 0x01, 0x00, 0x00, 0x8F, 0xFA, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x0A, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x08, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x0E, 0x01, 0x17, 0xCE, 0x09, 0x64, 0x6F, + 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0xDA, 0x18, 0xCE, 0x0E, 0x75, 0x6E, 0x6B, 0x6E, 0x6F, + 0x77, 0x6E, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x20, 0x2D, 0xDA, 0x83, 0xBD, 0xDA, 0x8D, 0x45, 0xBF, + 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8D, 0x3D, 0xBF, 0xFF, 0x00, + 0x03, 0xDA, 0x8D, 0x6B, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8D, 0x6C, 0xBF, 0xFF, 0x00, 0x05, 0xDA, + 0x8D, 0x6D, 0xBF, 0xFF, 0x00, 0x06, 0xDA, 0x8D, 0x6E, 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x8D, 0x6F, + 0xBF, 0xFF, 0x00, 0x08, 0xDA, 0x8D, 0x70, 0xBF, 0xFF, 0x00, 0x09, 0xDA, 0x82, 0x08, 0xBF, 0xFF, + 0x00, 0x0A, 0xDA, 0x8D, 0x71, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8D, 0x72, 0xBF, 0xFF, 0x00, 0x0C, + 0xDA, 0x8D, 0x73, 0xBF, 0xFF, 0x00, 0x0D, 0xDA, 0x8D, 0x74, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x8D, + 0x75, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x76, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x77, 0xBF, + 0xFF, 0x00, 0x0F, 0xDA, 0x8D, 0x78, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x8D, 0x79, 0xBF, 0xFF, 0x00, + 0x12, 0xDA, 0x8D, 0x7A, 0x00, 0x0E, 0x00, 0xDA, 0x81, 0x9E, 0x00, 0x0E, 0x01, 0xDA, 0x80, 0xC3, + 0x00, 0x0E, 0x02, 0xDA, 0x8D, 0x7B, 0x02, 0x0E, 0x04, 0xDA, 0x81, 0x0B, 0x2D, 0x04, 0x00, 0x12, + 0x3A, 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x1E, 0x04, 0x03, 0x00, 0x31, 0x01, 0x00, 0x00, + 0x36, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x32, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, + 0x35, 0x05, 0x06, 0x00, 0x2D, 0x06, 0x00, 0x12, 0x2C, 0x07, 0x02, 0x00, 0x3A, 0x05, 0x06, 0x07, + 0x36, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xFD, 0x0C, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x05, 0x00, + 0x0B, 0x00, 0x0B, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x31, 0x00, 0x31, 0x00, + 0x31, 0x00, 0x30, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x07, 0x10, 0x00, 0x03, + 0xCE, 0x09, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0xDA, 0x18, 0xDA, 0x83, 0xE6, + 0xDA, 0x86, 0x25, 0xDA, 0x89, 0x7C, 0xDA, 0x8D, 0x6A, 0xDA, 0x85, 0xA3, 0xDA, 0x85, 0x49, 0xDA, + 0x81, 0x12, 0x00, 0x10, 0x00, 0xDA, 0x6D, 0x00, 0x10, 0x01, 0xCF, 0x09, 0x67, 0x65, 0x74, 0x70, + 0x72, 0x6F, 0x6D, 0x70, 0x74, 0x04, 0x10, 0x04, 0xDA, 0x82, 0x66, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x3D, 0x03, 0x02, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, + 0x03, 0x01, 0x00, 0x32, 0x00, 0x03, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x35, 0x03, 0x05, 0x00, 0x2C, + 0x05, 0x03, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x33, 0x05, 0x04, 0x06, 0x2C, 0x05, 0x05, 0x00, 0x32, + 0x03, 0x05, 0x00, 0x2C, 0x05, 0x06, 0x00, 0x36, 0x05, 0x00, 0x00, 0x90, 0x2B, 0x17, 0x00, 0x17, + 0x00, 0x17, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xCD, 0x00, 0xDC, 0x00, + 0x00, 0x08, 0x03, 0x03, 0x03, 0x06, 0x0D, 0x00, 0x04, 0xCE, 0x08, 0x67, 0x65, 0x74, 0x73, 0x74, + 0x64, 0x69, 0x6E, 0xDA, 0x18, 0xDA, 0x8B, 0x72, 0xDA, 0x86, 0x9A, 0xDA, 0x8C, 0x0E, 0xDA, 0x8B, + 0xE0, 0xDA, 0x86, 0x0A, 0xDA, 0x84, 0xC1, 0x00, 0x0D, 0x00, 0xDA, 0x84, 0x79, 0x00, 0x0D, 0x01, + 0xDA, 0x82, 0x26, 0x00, 0x0D, 0x02, 0xDA, 0x85, 0x58, 0x00, 0x0D, 0x03, 0xDA, 0x8D, 0x7F, 0x2C, + 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, 0x05, 0x00, 0x2C, + 0x05, 0x00, 0x00, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x35, 0x05, 0x06, 0x00, 0x2C, + 0x06, 0x03, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x33, 0x06, 0x07, 0x01, 0x2C, 0x06, 0x05, 0x00, 0x36, + 0x06, 0x00, 0x00, 0x90, 0x2E, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x00, 0x07, 0x01, 0x09, 0xCE, 0x08, 0x67, 0x65, 0x74, + 0x63, 0x68, 0x75, 0x6E, 0x6B, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x1A, 0xDA, 0x8D, 0x95, 0xBF, 0xFF, + 0x00, 0x1B, 0xDA, 0x8D, 0x7F, 0xBF, 0xFF, 0x00, 0x1C, 0xDA, 0x85, 0x87, 0xBF, 0xFF, 0x00, 0x1D, + 0xDA, 0x8D, 0x80, 0xBF, 0xFF, 0x00, 0x1F, 0xDA, 0x8D, 0x81, 0xBF, 0xFF, 0x00, 0x1D, 0xCF, 0x06, + 0x67, 0x65, 0x74, 0x74, 0x65, 0x72, 0x00, 0x07, 0x00, 0xDA, 0x82, 0x26, 0x00, 0x07, 0x01, 0xDA, + 0x6D, 0x00, 0x07, 0x02, 0xDA, 0x8D, 0x82, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x1A, 0x35, + 0x03, 0x04, 0x00, 0x2D, 0x04, 0x00, 0x1C, 0x33, 0x03, 0x00, 0x04, 0x2D, 0x04, 0x00, 0x1D, 0x36, + 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x90, 0x3A, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x8F, 0x9D, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x03, 0x01, + 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x01, + 0x03, 0x01, 0x03, 0x01, 0x03, 0x02, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, + 0x15, 0x00, 0x03, 0x00, 0x03, 0x00, 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x35, 0x02, 0x18, 0x00, + 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0xBF, 0xFF, 0x11, 0x00, 0x11, + 0x02, 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0xBF, 0xFE, 0x11, 0x00, 0x11, 0x04, 0x03, 0x00, + 0x03, 0x2D, 0x0A, 0x18, 0x0A, 0xBF, 0xF3, 0x0A, 0xBF, 0xCF, 0x0A, 0x21, 0x0A, 0x01, 0x0A, 0x0B, + 0x0A, 0xBF, 0xF8, 0x0A, 0x07, 0x0A, 0xBF, 0xF7, 0x0A, 0xBF, 0xFC, 0x0A, 0x01, 0x0A, 0xBF, 0xFE, + 0x0A, 0xBF, 0xFF, 0x0A, 0xBF, 0xFF, 0x0A, 0x23, 0x0A, 0x01, 0x0A, 0xBF, 0xF5, 0x0A, 0xBF, 0xEF, + 0x0A, 0x1D, 0x0A, 0xBF, 0xBE, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x44, 0x03, 0x00, 0x03, + 0x05, 0x03, 0x01, 0x10, 0x00, 0x03, 0x01, 0x0A, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x05, 0x01, 0x09, + 0x00, 0x09, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x19, 0x00, 0x19, + 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x07, 0xBF, 0xFF, 0x05, 0x03, 0x16, 0x00, 0x16, 0x00, 0x16, 0x00, + 0x09, 0x01, 0x09, 0x01, 0x09, 0x02, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x16, 0x00, 0x16, 0x00, + 0x16, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, 0x01, + 0x0D, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x0D, 0x00, + 0x0D, 0x00, 0x0D, 0xBF, 0xF7, 0x09, 0x0B, 0x16, 0x00, 0x16, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, + 0x01, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x00, 0x0D, 0x01, 0x0D, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x01, 0x0D, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFF, 0x0D, 0x03, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, + 0x11, 0x00, 0x11, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x01, 0x09, 0xBF, 0xE2, 0x03, 0x20, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x01, 0x05, 0x01, 0x14, 0x00, 0x14, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x02, 0x09, 0x00, 0x09, + 0x01, 0x3D, 0x00, 0x3D, 0x00, 0x4C, 0x00, 0x4C, 0x00, 0x5A, 0x00, 0x5A, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, + 0x03, 0x09, 0x00, 0x09, 0x04, 0x12, 0x00, 0x12, 0x00, 0x09, 0x01, 0x22, 0x00, 0x22, 0x00, 0x22, + 0x00, 0x22, 0x00, 0x09, 0x00, 0x09, 0x01, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, + 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x09, + 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x01, 0x15, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x02, 0x21, 0x00, 0x21, 0x00, 0x21, + 0x00, 0x21, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x1D, 0x00, 0x1D, 0x00, 0x1D, + 0x00, 0x1D, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x1D, 0x00, 0x1D, 0x00, 0x1D, + 0x00, 0x1D, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0xBF, 0xE3, 0x03, 0xF9, 0x7F, 0x05, 0x34, 0x00, 0x00, 0x00, 0x00, 0xCF, 0x0A, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x68, 0x79, 0x70, 0x6F, 0x74, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x68, 0x79, 0x70, 0x6F, 0x74, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x61, 0x74, 0xDA, 0x85, + 0x46, 0xCF, 0x0F, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x61, + 0x6C, 0x6C, 0xD8, 0x0F, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, + 0x61, 0x6C, 0x6C, 0xCF, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0xDA, 0x81, 0x6D, 0xCF, 0x10, + 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x72, 0x6C, 0x6F, 0x63, 0x6B, + 0xD8, 0x10, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x72, 0x6C, 0x6F, + 0x63, 0x6B, 0xDA, 0x84, 0x72, 0xDA, 0x84, 0x70, 0xDA, 0x88, 0x73, 0xDA, 0x88, 0x71, 0xDA, 0x85, + 0x8A, 0xDA, 0x85, 0x85, 0xDA, 0x83, 0x83, 0xDA, 0x83, 0x81, 0xCF, 0x04, 0x6B, 0x65, 0x65, 0x70, + 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x17, 0x02, 0x02, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, + 0x80, 0xB3, 0x00, 0x2F, 0xCE, 0x04, 0x6B, 0x65, 0x65, 0x70, 0xDA, 0x18, 0xDA, 0x80, 0xA8, 0xDA, + 0x80, 0xA9, 0x00, 0x80, 0xB3, 0x00, 0xDA, 0x81, 0xD2, 0x00, 0x80, 0xB3, 0x01, 0xDA, 0x1F, 0x00, + 0x80, 0xB3, 0x02, 0xDA, 0x80, 0xAB, 0x00, 0x80, 0xB3, 0x03, 0xDA, 0x8D, 0xA1, 0x01, 0x80, 0xB3, + 0x05, 0xDA, 0x80, 0xAD, 0x03, 0x80, 0xB2, 0x07, 0xDA, 0x80, 0xAE, 0x03, 0x80, 0xB2, 0x07, 0xCF, + 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x67, 0x05, 0x15, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x69, 0x08, 0x15, 0x09, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x68, + 0x0B, 0x15, 0x0A, 0xDA, 0x1E, 0x0E, 0x13, 0x0B, 0xDA, 0x80, 0xD9, 0x19, 0x30, 0x0A, 0xDA, 0x80, + 0xB2, 0x1A, 0x30, 0x09, 0xDA, 0x80, 0xB3, 0x1A, 0x30, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x6B, 0x1D, 0x30, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x6A, 0x20, + 0x30, 0x0D, 0xDA, 0x1E, 0x29, 0x2E, 0x0B, 0xDA, 0x80, 0xD9, 0x34, 0x54, 0x0B, 0xDA, 0x80, 0xB2, + 0x36, 0x54, 0x0C, 0xDA, 0x80, 0xB6, 0x37, 0x54, 0x0A, 0xDA, 0x80, 0xB3, 0x38, 0x54, 0x0D, 0xDA, + 0x80, 0xB7, 0x38, 0x54, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x6D, 0x3B, 0x54, + 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x6C, 0x3E, 0x54, 0x10, 0xDA, 0x1E, 0x4D, + 0x52, 0x0E, 0xDA, 0x80, 0xD9, 0x58, 0x80, 0x82, 0x0C, 0xDA, 0x80, 0xB2, 0x5A, 0x80, 0x82, 0x0D, + 0xDA, 0x80, 0xB6, 0x5C, 0x80, 0x82, 0x0E, 0xDA, 0x80, 0xBA, 0x5D, 0x80, 0x82, 0x0B, 0xDA, 0x80, + 0xB3, 0x5E, 0x80, 0x82, 0x0F, 0xDA, 0x80, 0xB7, 0x5F, 0x80, 0x82, 0x10, 0xDA, 0x80, 0xBB, 0x5F, + 0x80, 0x82, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x6F, 0x62, 0x80, 0x82, 0x12, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x6E, 0x65, 0x80, 0x82, 0x13, 0xDA, 0x1E, 0x7B, + 0x80, 0x80, 0x11, 0xDA, 0x80, 0xD9, 0x80, 0x86, 0x80, 0xB2, 0x0C, 0xDA, 0x80, 0xBE, 0x80, 0x8A, + 0x80, 0xB2, 0x0D, 0xDA, 0x80, 0xBF, 0x80, 0x8B, 0x80, 0xB2, 0x0B, 0xDA, 0x80, 0xC0, 0x80, 0x8B, + 0x80, 0xB2, 0x01, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x71, 0x80, 0x8E, 0x80, 0xB2, + 0x0F, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x70, 0x80, 0x91, 0x80, 0xB2, 0x10, 0xDA, + 0x1E, 0x80, 0x92, 0x80, 0xA6, 0x0E, 0xDA, 0x80, 0xC3, 0x80, 0x92, 0x80, 0xA6, 0x07, 0xCF, 0x07, + 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x72, 0x80, 0x96, 0x80, 0xA4, 0x13, 0xDA, 0x80, 0xC5, 0x80, + 0x98, 0x80, 0xA4, 0x14, 0xDA, 0x80, 0xC6, 0x80, 0x9A, 0x80, 0xA4, 0x15, 0xDA, 0x80, 0xC7, 0x80, + 0xAB, 0x80, 0xB0, 0x11, 0xDA, 0x80, 0xD9, 0x40, 0x04, 0x00, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x3F, + 0x06, 0x02, 0x00, 0x1B, 0x07, 0x06, 0x00, 0x26, 0x06, 0x07, 0x00, 0x1E, 0x06, 0x11, 0x00, 0x28, + 0x09, 0x00, 0x00, 0x49, 0x08, 0x01, 0x09, 0x1B, 0x09, 0x08, 0x00, 0x1F, 0x09, 0x0C, 0x00, 0x3A, + 0x08, 0x01, 0x09, 0x1B, 0x0A, 0x08, 0x00, 0x31, 0x0A, 0x00, 0x00, 0x35, 0x08, 0x00, 0x00, 0x1B, + 0x0B, 0x08, 0x00, 0x1E, 0x08, 0x04, 0x00, 0x32, 0x05, 0x0B, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x35, + 0x0C, 0x0D, 0x00, 0x49, 0x09, 0x01, 0x09, 0x1C, 0xF5, 0xFF, 0xFF, 0x1C, 0x9D, 0x00, 0x00, 0x26, + 0x08, 0x07, 0x01, 0x1E, 0x08, 0x1A, 0x00, 0x3D, 0x09, 0x02, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x28, + 0x09, 0x00, 0x00, 0x28, 0x0C, 0x00, 0x00, 0x49, 0x0B, 0x01, 0x0C, 0x1B, 0x0C, 0x0B, 0x00, 0x1F, + 0x0C, 0x12, 0x00, 0x3A, 0x0B, 0x01, 0x0C, 0x1B, 0x0D, 0x0B, 0x00, 0x49, 0x09, 0x0A, 0x09, 0x28, + 0x0E, 0x00, 0x00, 0x25, 0x0B, 0x0E, 0x09, 0x1E, 0x0B, 0x02, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x3A, + 0x0B, 0x0A, 0x09, 0x32, 0x0D, 0x0B, 0x00, 0x35, 0x0E, 0x00, 0x00, 0x1B, 0x0B, 0x0E, 0x00, 0x1E, + 0x0E, 0x04, 0x00, 0x32, 0x05, 0x0B, 0x00, 0x2C, 0x10, 0x00, 0x00, 0x35, 0x0F, 0x10, 0x00, 0x49, + 0x0C, 0x01, 0x0C, 0x1C, 0xEF, 0xFF, 0xFF, 0x1C, 0x82, 0x00, 0x00, 0x26, 0x09, 0x07, 0x02, 0x1E, + 0x09, 0x23, 0x00, 0x3D, 0x0A, 0x02, 0x00, 0x1B, 0x0B, 0x0A, 0x00, 0x3D, 0x0A, 0x02, 0x01, 0x1B, + 0x0C, 0x0A, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, + 0x0E, 0x01, 0x0F, 0x1B, 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x18, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, + 0x10, 0x0E, 0x00, 0x49, 0x0A, 0x0B, 0x0A, 0x28, 0x11, 0x00, 0x00, 0x25, 0x0E, 0x11, 0x0A, 0x1E, + 0x0E, 0x02, 0x00, 0x1C, 0x11, 0x00, 0x00, 0x49, 0x0D, 0x0C, 0x0D, 0x28, 0x11, 0x00, 0x00, 0x25, + 0x0E, 0x11, 0x0D, 0x1E, 0x0E, 0x02, 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x3A, 0x0E, 0x0B, 0x0A, 0x3A, + 0x11, 0x0C, 0x0D, 0x33, 0x10, 0x0E, 0x11, 0x35, 0x12, 0x00, 0x00, 0x1B, 0x0E, 0x12, 0x00, 0x1E, + 0x12, 0x04, 0x00, 0x32, 0x05, 0x0E, 0x00, 0x2C, 0x13, 0x00, 0x00, 0x35, 0x11, 0x13, 0x00, 0x49, + 0x0F, 0x01, 0x0F, 0x1C, 0xE9, 0xFF, 0xFF, 0x1C, 0x5E, 0x00, 0x00, 0x26, 0x0A, 0x07, 0x03, 0x1E, + 0x0A, 0x2D, 0x00, 0x3D, 0x0B, 0x02, 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x3D, 0x0B, 0x02, 0x01, 0x1B, + 0x0D, 0x0B, 0x00, 0x3D, 0x0B, 0x02, 0x02, 0x1B, 0x0E, 0x0B, 0x00, 0x28, 0x0B, 0x00, 0x00, 0x28, + 0x0F, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x28, 0x12, 0x00, 0x00, 0x49, 0x11, 0x01, 0x12, 0x1B, + 0x12, 0x11, 0x00, 0x1F, 0x12, 0x1F, 0x00, 0x3A, 0x11, 0x01, 0x12, 0x1B, 0x13, 0x11, 0x00, 0x49, + 0x0B, 0x0C, 0x0B, 0x28, 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x0B, 0x1E, 0x11, 0x02, 0x00, 0x1C, + 0x18, 0x00, 0x00, 0x49, 0x0F, 0x0D, 0x0F, 0x28, 0x14, 0x00, 0x00, 0x25, 0x11, 0x14, 0x0F, 0x1E, + 0x11, 0x02, 0x00, 0x1C, 0x13, 0x00, 0x00, 0x49, 0x10, 0x0E, 0x10, 0x28, 0x14, 0x00, 0x00, 0x25, + 0x11, 0x14, 0x10, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x0E, 0x00, 0x00, 0x3A, 0x11, 0x0C, 0x0B, 0x3A, + 0x14, 0x0D, 0x0F, 0x3A, 0x15, 0x0E, 0x10, 0x33, 0x13, 0x11, 0x14, 0x31, 0x15, 0x00, 0x00, 0x35, + 0x16, 0x00, 0x00, 0x1B, 0x11, 0x16, 0x00, 0x1E, 0x16, 0x04, 0x00, 0x32, 0x05, 0x11, 0x00, 0x2C, + 0x15, 0x00, 0x00, 0x35, 0x14, 0x15, 0x00, 0x49, 0x12, 0x01, 0x12, 0x1C, 0xE2, 0xFF, 0xFF, 0x1C, + 0x30, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0C, 0x01, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x1B, + 0x0C, 0x0B, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x0D, 0x01, 0x00, 0x35, 0x0B, 0x0D, 0x00, 0x1B, + 0x0D, 0x0B, 0x00, 0x2A, 0x0B, 0x00, 0x00, 0x28, 0x0F, 0x00, 0x00, 0x49, 0x0E, 0x01, 0x0F, 0x1B, + 0x0F, 0x0E, 0x00, 0x1F, 0x0F, 0x23, 0x00, 0x3A, 0x0E, 0x01, 0x0F, 0x1B, 0x10, 0x0E, 0x00, 0x2B, + 0x0E, 0x00, 0x00, 0x23, 0x11, 0x0E, 0x07, 0x1E, 0x11, 0x12, 0x00, 0x3A, 0x12, 0x0C, 0x0E, 0x1B, + 0x13, 0x12, 0x00, 0x3A, 0x12, 0x02, 0x0E, 0x1B, 0x14, 0x12, 0x00, 0x49, 0x12, 0x14, 0x13, 0x1B, + 0x15, 0x12, 0x00, 0x28, 0x16, 0x00, 0x00, 0x25, 0x12, 0x16, 0x15, 0x1E, 0x12, 0x04, 0x00, 0x29, + 0x0B, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x3C, 0x0C, 0x0E, 0x15, 0x3A, + 0x16, 0x14, 0x15, 0x3C, 0x0D, 0x0E, 0x16, 0x05, 0x0E, 0x0E, 0x01, 0x1C, 0xEE, 0xFF, 0xFF, 0x1E, + 0x0B, 0x02, 0x00, 0x1C, 0x0B, 0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x34, 0x0D, 0x00, 0x00, 0x35, + 0x0E, 0x00, 0x00, 0x1B, 0x11, 0x0E, 0x00, 0x1E, 0x0E, 0x04, 0x00, 0x32, 0x05, 0x11, 0x00, 0x2C, + 0x13, 0x00, 0x00, 0x35, 0x12, 0x13, 0x00, 0x49, 0x0F, 0x01, 0x0F, 0x1C, 0xDE, 0xFF, 0xFF, 0x03, + 0x05, 0x00, 0x00, 0x84, 0x0F, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xBF, 0xF9, 0x01, 0xCF, 0x07, 0x67, 0x65, 0x74, + 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x85, 0xF3, 0xCF, 0x0F, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, + 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, 0xDA, 0x81, 0x00, 0xCF, 0x12, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xDA, + 0x83, 0x02, 0xCF, 0x12, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x65, 0x78, 0x70, 0x61, 0x6E, + 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, 0xDA, 0x87, 0xA1, 0xCF, 0x06, 0x6F, 0x73, 0x2F, 0x63, 0x77, + 0x64, 0xD8, 0x06, 0x6F, 0x73, 0x2F, 0x63, 0x77, 0x64, 0xDA, 0x8B, 0xBB, 0xDA, 0x8B, 0xC2, 0xCF, + 0x08, 0x6F, 0x73, 0x2F, 0x74, 0x6F, 0x75, 0x63, 0x68, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x74, 0x6F, + 0x75, 0x63, 0x68, 0xDA, 0x8D, 0x68, 0xDA, 0x8D, 0x64, 0xCF, 0x07, 0x66, 0x6F, 0x72, 0x65, 0x76, + 0x65, 0x72, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x05, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, + 0xFF, 0x01, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x66, 0x6F, 0x72, 0x65, 0x76, 0x65, 0x72, 0xDA, 0x18, + 0xDA, 0x80, 0x9E, 0x00, 0x06, 0x00, 0xDA, 0x81, 0x74, 0x00, 0x06, 0x01, 0xDA, 0x8D, 0xB8, 0x2C, + 0x03, 0x00, 0x00, 0x29, 0x04, 0x00, 0x00, 0x32, 0x03, 0x04, 0x00, 0x34, 0x00, 0x00, 0x00, 0x45, + 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x82, 0x0F, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0xCF, 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x3F, 0xDA, 0x83, + 0x76, 0xCF, 0x02, 0x25, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, 0xCE, 0x02, 0x25, 0x3D, 0xDA, 0x18, 0xDA, 0x8C, + 0x22, 0xDA, 0x34, 0x00, 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x35, 0x00, 0x08, 0x02, + 0xDA, 0x8D, 0xBC, 0x2C, 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, + 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, 0x03, 0x45, 0x04, 0x00, 0x00, 0x03, + 0x04, 0x00, 0x00, 0x80, 0x90, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0xCF, 0x0E, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x2D, 0x67, + 0x61, 0x6D, 0x6D, 0x61, 0xD8, 0x0E, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x2D, 0x67, + 0x61, 0x6D, 0x6D, 0x61, 0xCF, 0x04, 0x62, 0x6E, 0x6F, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0x08, 0x00, + 0x13, 0x01, 0x01, 0x01, 0x01, 0x00, 0x02, 0xCE, 0x04, 0x62, 0x6E, 0x6F, 0x74, 0x13, 0x00, 0x00, + 0x00, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, + 0xD8, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x86, 0xAE, 0xD7, 0x00, + 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x04, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x04, 0x00, + 0x03, 0xCE, 0x04, 0x6C, 0x6F, 0x6F, 0x70, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x15, 0x03, 0x03, 0x03, 0x29, 0x80, 0xD5, 0x00, 0x0C, 0xCE, 0x05, 0x6C, 0x6F, 0x6F, 0x70, 0x31, + 0xDA, 0x18, 0xDA, 0x58, 0xDA, 0x88, 0xF7, 0xD0, 0x05, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xDA, 0x80, + 0x9A, 0xDA, 0x57, 0xD0, 0x05, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xD0, 0x03, 0x6C, 0x65, 0x74, 0xDA, + 0x81, 0x73, 0xD0, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0xD0, 0x06, 0x62, 0x65, 0x66, 0x6F, 0x72, + 0x65, 0xD0, 0x06, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xDA, 0x51, 0xDA, 0x80, 0x9C, 0xDA, 0x8A, + 0xE6, 0xDA, 0x81, 0x4D, 0xDA, 0x80, 0x9E, 0xD0, 0x04, 0x77, 0x68, 0x65, 0x6E, 0xDA, 0x82, 0xB0, + 0xD0, 0x06, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0xDA, 0x8A, 0x57, 0xCE, 0x19, 0x75, 0x6E, 0x65, + 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x6D, 0x6F, 0x64, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0xDA, 0x81, 0x12, 0xD0, 0x05, 0x72, 0x61, 0x6E, 0x67, 0x65, + 0xDA, 0x32, 0xDA, 0x88, 0x60, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x14, 0x06, 0x06, 0x06, + 0x04, 0x3B, 0x00, 0x0F, 0xCE, 0x0E, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2D, 0x74, 0x65, 0x6D, 0x70, + 0x6C, 0x61, 0x74, 0x65, 0xDA, 0x18, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x01, + 0x01, 0x03, 0x0B, 0x00, 0x02, 0xCE, 0x0D, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x65, 0x64, 0xDA, 0x18, 0xDA, 0x83, 0x76, 0xCE, 0x1E, 0x65, 0x78, 0x70, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x72, 0x61, + 0x6E, 0x67, 0x65, 0x2C, 0x20, 0x67, 0x6F, 0x74, 0x20, 0xDA, 0x81, 0x12, 0x00, 0x0B, 0x00, 0xDA, + 0x1E, 0x00, 0x0B, 0x01, 0xCF, 0x0D, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x65, 0x64, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, + 0x02, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x32, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x01, 0x03, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x81, + 0xA1, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, 0x03, 0x02, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x05, 0x00, 0x05, 0xDA, 0x8D, 0xD3, 0xD0, 0x04, 0x64, 0x6F, 0x77, 0x6E, 0xDA, + 0x8A, 0x2D, 0x00, 0x3B, 0x00, 0xDA, 0x82, 0xF6, 0x00, 0x3B, 0x01, 0xCF, 0x06, 0x6F, 0x62, 0x6A, + 0x65, 0x63, 0x74, 0x00, 0x3B, 0x02, 0xDA, 0x8A, 0x44, 0x00, 0x3B, 0x03, 0xCF, 0x04, 0x72, 0x65, + 0x73, 0x74, 0x00, 0x3B, 0x04, 0xCF, 0x02, 0x6F, 0x70, 0x00, 0x3B, 0x05, 0xDA, 0x8A, 0x33, 0x00, + 0x3B, 0x06, 0xCF, 0x0E, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, + 0x74, 0x65, 0x04, 0x3B, 0x09, 0xDA, 0x88, 0x66, 0x06, 0x3B, 0x0A, 0xDA, 0x82, 0x6D, 0x08, 0x3B, + 0x0B, 0xDA, 0x82, 0x11, 0x0A, 0x2E, 0x0C, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x0C, 0x21, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x2F, 0x3B, 0x0D, 0xDA, + 0x82, 0x5F, 0x31, 0x3B, 0x0E, 0xDA, 0x8A, 0x31, 0x33, 0x3B, 0x0F, 0xDA, 0x8A, 0x32, 0x31, 0x01, + 0x00, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x35, 0x07, 0x08, 0x00, 0x3D, 0x08, 0x01, 0x00, 0x1B, 0x09, + 0x08, 0x00, 0x3D, 0x08, 0x01, 0x01, 0x1B, 0x0A, 0x08, 0x00, 0x3D, 0x08, 0x01, 0x02, 0x1B, 0x0B, + 0x08, 0x00, 0x3F, 0x08, 0x01, 0x00, 0x1B, 0x0C, 0x08, 0x00, 0x26, 0x0D, 0x0C, 0x01, 0x1E, 0x0D, + 0x17, 0x00, 0x2C, 0x10, 0x01, 0x00, 0x25, 0x0F, 0x02, 0x10, 0x1E, 0x0F, 0x07, 0x00, 0x2B, 0x10, + 0x00, 0x00, 0x2B, 0x11, 0x01, 0x00, 0x33, 0x10, 0x09, 0x11, 0x45, 0x10, 0x00, 0x00, 0x1B, 0x0E, + 0x10, 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x2C, 0x12, 0x02, 0x00, 0x25, 0x11, 0x02, 0x12, 0x1E, 0x11, + 0x07, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x2B, 0x13, 0x01, 0x00, 0x33, 0x09, 0x12, 0x13, 0x45, 0x12, + 0x00, 0x00, 0x1B, 0x10, 0x12, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x1B, 0x0E, + 0x10, 0x00, 0x1B, 0x08, 0x0E, 0x00, 0x1C, 0x0C, 0x00, 0x00, 0x26, 0x0F, 0x0C, 0x02, 0x1E, 0x0F, + 0x06, 0x00, 0x2B, 0x10, 0x01, 0x00, 0x33, 0x09, 0x0A, 0x10, 0x45, 0x10, 0x00, 0x00, 0x1B, 0x0E, + 0x10, 0x00, 0x1C, 0x04, 0x00, 0x00, 0x33, 0x09, 0x0A, 0x0B, 0x45, 0x10, 0x00, 0x00, 0x1B, 0x0E, + 0x10, 0x00, 0x1B, 0x08, 0x0E, 0x00, 0x3D, 0x0C, 0x08, 0x00, 0x1B, 0x0D, 0x0C, 0x00, 0x3D, 0x0C, + 0x08, 0x01, 0x1B, 0x0E, 0x0C, 0x00, 0x3D, 0x0C, 0x08, 0x02, 0x1B, 0x0F, 0x0C, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x45, 0x0C, 0x00, 0x00, 0x33, 0x00, 0x0D, 0x0E, 0x33, 0x0F, 0x05, 0x04, 0x31, 0x0C, + 0x00, 0x00, 0x2C, 0x10, 0x03, 0x00, 0x36, 0x10, 0x00, 0x00, 0x81, 0xA7, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x0B, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x1B, 0x00, 0x1B, 0x00, + 0x1B, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x29, 0x00, + 0x29, 0x00, 0x29, 0x00, 0x29, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFF, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x09, 0x00, 0x09, 0x00, 0x09, 0xBF, 0xFE, 0x05, 0x00, + 0x05, 0x03, 0x07, 0x00, 0x07, 0xBF, 0xFD, 0x05, 0x00, 0x05, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x05, 0x37, 0x00, 0x37, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0xD0, 0x08, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2D, 0x74, 0x6F, 0xDA, + 0x87, 0xFD, 0xDA, 0x8D, 0xDA, 0xDA, 0x81, 0x52, 0xDA, 0x88, 0x64, 0xD0, 0x07, 0x64, 0x6F, 0x77, + 0x6E, 0x2D, 0x74, 0x6F, 0xDA, 0x88, 0xDF, 0xDA, 0x8A, 0x41, 0xDA, 0x8A, 0x3D, 0xDA, 0x8A, 0x42, + 0xD0, 0x02, 0x69, 0x6E, 0xDA, 0x8A, 0x3C, 0xD0, 0x07, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x03, 0x03, 0x03, 0x06, 0x15, 0x00, 0x05, 0xCE, + 0x10, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, + 0x65, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x9C, 0xDA, 0x34, 0xDA, 0x52, 0xDA, 0x80, 0x9E, 0xDA, + 0x58, 0x00, 0x15, 0x00, 0xDA, 0x82, 0xF6, 0x00, 0x15, 0x01, 0xCF, 0x04, 0x65, 0x78, 0x70, 0x72, + 0x00, 0x15, 0x02, 0xDA, 0x81, 0x74, 0x00, 0x15, 0x03, 0xCF, 0x10, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x02, 0x15, 0x05, 0xDA, 0x80, + 0xC3, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1B, 0x05, 0x04, 0x00, 0x2C, 0x06, 0x01, + 0x00, 0x28, 0x07, 0x00, 0x00, 0x33, 0x06, 0x05, 0x07, 0x45, 0x04, 0x00, 0x00, 0x2C, 0x07, 0x02, + 0x00, 0x33, 0x07, 0x05, 0x01, 0x45, 0x06, 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x33, 0x08, 0x00, + 0x05, 0x45, 0x07, 0x00, 0x00, 0x2C, 0x09, 0x04, 0x00, 0x33, 0x09, 0x06, 0x07, 0x31, 0x02, 0x00, + 0x00, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x07, 0x05, 0x00, 0x33, 0x07, 0x04, 0x08, 0x45, 0x06, 0x00, + 0x00, 0x03, 0x06, 0x00, 0x00, 0x81, 0xC2, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0xCE, 0x15, 0x75, 0x6E, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x6F, 0x6F, + 0x70, 0x20, 0x76, 0x65, 0x72, 0x62, 0x20, 0x00, 0x80, 0xD5, 0x00, 0xDA, 0x81, 0x74, 0x00, 0x80, + 0xD5, 0x01, 0xDA, 0x86, 0xAF, 0x00, 0x80, 0xD5, 0x02, 0xDA, 0x80, 0xC3, 0x00, 0x80, 0xD5, 0x03, + 0xCF, 0x05, 0x6C, 0x6F, 0x6F, 0x70, 0x31, 0x0B, 0x80, 0xD5, 0x06, 0xCF, 0x04, 0x76, 0x65, 0x72, + 0x62, 0x0D, 0x80, 0xD5, 0x07, 0xDA, 0x82, 0xF6, 0x15, 0x7C, 0x08, 0xDA, 0x8D, 0xDC, 0x15, 0x7C, + 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x55, 0x68, 0x10, 0xDA, 0x8A, 0xE7, + 0x7E, 0x80, 0xD5, 0x09, 0xDA, 0x8D, 0xDB, 0x80, 0x82, 0x80, 0xD5, 0x04, 0xDA, 0x8D, 0xDC, 0x80, + 0x82, 0x80, 0xD5, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x2E, 0x03, 0x00, + 0x00, 0x3F, 0x04, 0x01, 0x00, 0x48, 0x05, 0x04, 0x02, 0x1E, 0x05, 0x06, 0x00, 0x2C, 0x06, 0x00, + 0x00, 0x31, 0x06, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, + 0x00, 0x05, 0x05, 0x02, 0x01, 0x3A, 0x04, 0x01, 0x05, 0x1B, 0x06, 0x04, 0x00, 0x3A, 0x04, 0x01, + 0x02, 0x1B, 0x07, 0x04, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x08, 0x01, 0x00, 0x35, 0x04, 0x08, + 0x00, 0x1E, 0x04, 0x6B, 0x00, 0x05, 0x08, 0x02, 0x02, 0x33, 0x00, 0x01, 0x08, 0x35, 0x09, 0x03, + 0x00, 0x1B, 0x08, 0x09, 0x00, 0x2C, 0x0A, 0x02, 0x00, 0x25, 0x09, 0x07, 0x0A, 0x1E, 0x09, 0x0D, + 0x00, 0x2C, 0x0B, 0x03, 0x00, 0x31, 0x0B, 0x00, 0x00, 0x45, 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x04, + 0x00, 0x33, 0x0C, 0x06, 0x0A, 0x28, 0x0C, 0x00, 0x00, 0x31, 0x0C, 0x00, 0x00, 0x45, 0x0B, 0x00, + 0x00, 0x2C, 0x0C, 0x00, 0x00, 0x33, 0x0C, 0x0B, 0x08, 0x45, 0x0A, 0x00, 0x00, 0x03, 0x0A, 0x00, + 0x00, 0x2C, 0x0B, 0x05, 0x00, 0x25, 0x0A, 0x07, 0x0B, 0x1E, 0x0A, 0x0D, 0x00, 0x2C, 0x0C, 0x03, + 0x00, 0x31, 0x0C, 0x00, 0x00, 0x45, 0x0B, 0x00, 0x00, 0x2C, 0x0D, 0x04, 0x00, 0x28, 0x0E, 0x00, + 0x00, 0x33, 0x0D, 0x06, 0x0E, 0x31, 0x0B, 0x00, 0x00, 0x45, 0x0C, 0x00, 0x00, 0x2C, 0x0D, 0x00, + 0x00, 0x33, 0x0D, 0x0C, 0x08, 0x45, 0x0B, 0x00, 0x00, 0x03, 0x0B, 0x00, 0x00, 0x2C, 0x0C, 0x06, + 0x00, 0x25, 0x0B, 0x07, 0x0C, 0x1E, 0x0B, 0x08, 0x00, 0x2C, 0x0D, 0x00, 0x00, 0x32, 0x0D, 0x08, + 0x00, 0x45, 0x0C, 0x00, 0x00, 0x2C, 0x0E, 0x07, 0x00, 0x33, 0x0E, 0x06, 0x0C, 0x45, 0x0D, 0x00, + 0x00, 0x03, 0x0D, 0x00, 0x00, 0x2C, 0x0D, 0x08, 0x00, 0x25, 0x0C, 0x07, 0x0D, 0x1E, 0x0C, 0x07, + 0x00, 0x2C, 0x0E, 0x00, 0x00, 0x33, 0x0E, 0x08, 0x06, 0x28, 0x0E, 0x00, 0x00, 0x31, 0x0E, 0x00, + 0x00, 0x45, 0x0D, 0x00, 0x00, 0x03, 0x0D, 0x00, 0x00, 0x2C, 0x0E, 0x09, 0x00, 0x25, 0x0D, 0x07, + 0x0E, 0x1E, 0x0D, 0x07, 0x00, 0x2C, 0x0F, 0x00, 0x00, 0x33, 0x0F, 0x06, 0x08, 0x28, 0x0F, 0x00, + 0x00, 0x31, 0x0F, 0x00, 0x00, 0x45, 0x0E, 0x00, 0x00, 0x03, 0x0E, 0x00, 0x00, 0x2C, 0x0F, 0x0A, + 0x00, 0x25, 0x0E, 0x07, 0x0F, 0x1E, 0x0E, 0x16, 0x00, 0x2C, 0x10, 0x0B, 0x00, 0x35, 0x0F, 0x10, + 0x00, 0x1B, 0x10, 0x0F, 0x00, 0x2C, 0x11, 0x0C, 0x00, 0x33, 0x11, 0x10, 0x06, 0x45, 0x0F, 0x00, + 0x00, 0x2C, 0x12, 0x0D, 0x00, 0x2B, 0x13, 0x00, 0x00, 0x33, 0x12, 0x10, 0x13, 0x45, 0x11, 0x00, + 0x00, 0x2C, 0x13, 0x0E, 0x00, 0x32, 0x13, 0x10, 0x00, 0x45, 0x12, 0x00, 0x00, 0x2C, 0x14, 0x0F, + 0x00, 0x33, 0x14, 0x11, 0x08, 0x31, 0x12, 0x00, 0x00, 0x45, 0x13, 0x00, 0x00, 0x2C, 0x12, 0x00, + 0x00, 0x33, 0x12, 0x0F, 0x13, 0x45, 0x11, 0x00, 0x00, 0x03, 0x11, 0x00, 0x00, 0x2C, 0x10, 0x10, + 0x00, 0x25, 0x0F, 0x07, 0x10, 0x1E, 0x0F, 0x05, 0x00, 0x2C, 0x11, 0x11, 0x00, 0x33, 0x11, 0x06, + 0x08, 0x45, 0x10, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x2C, 0x11, 0x12, 0x00, 0x25, 0x10, 0x07, + 0x11, 0x1E, 0x10, 0x05, 0x00, 0x2C, 0x12, 0x13, 0x00, 0x33, 0x12, 0x06, 0x08, 0x45, 0x11, 0x00, + 0x00, 0x03, 0x11, 0x00, 0x00, 0x2C, 0x11, 0x14, 0x00, 0x32, 0x11, 0x07, 0x00, 0x2C, 0x12, 0x15, + 0x00, 0x35, 0x11, 0x12, 0x00, 0x01, 0x11, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x08, 0x02, + 0x02, 0x3A, 0x04, 0x01, 0x08, 0x1B, 0x09, 0x04, 0x00, 0x05, 0x04, 0x02, 0x03, 0x33, 0x00, 0x01, + 0x04, 0x35, 0x0A, 0x03, 0x00, 0x1B, 0x04, 0x0A, 0x00, 0x2C, 0x0B, 0x16, 0x00, 0x25, 0x0A, 0x06, + 0x0B, 0x1E, 0x0A, 0x08, 0x00, 0x2C, 0x0B, 0x16, 0x00, 0x33, 0x07, 0x09, 0x0B, 0x2C, 0x0B, 0x17, + 0x00, 0x2C, 0x0C, 0x18, 0x00, 0x33, 0x04, 0x0B, 0x0C, 0x2C, 0x0B, 0x19, 0x00, 0x36, 0x0B, 0x00, + 0x00, 0x2C, 0x0C, 0x1A, 0x00, 0x25, 0x0B, 0x06, 0x0C, 0x1E, 0x0B, 0x08, 0x00, 0x2C, 0x0C, 0x16, + 0x00, 0x33, 0x07, 0x09, 0x0C, 0x2C, 0x0C, 0x17, 0x00, 0x2C, 0x0D, 0x1B, 0x00, 0x33, 0x04, 0x0C, + 0x0D, 0x2C, 0x0C, 0x19, 0x00, 0x36, 0x0C, 0x00, 0x00, 0x2C, 0x0D, 0x1C, 0x00, 0x25, 0x0C, 0x06, + 0x0D, 0x1E, 0x0C, 0x08, 0x00, 0x2C, 0x0D, 0x1C, 0x00, 0x33, 0x07, 0x09, 0x0D, 0x2C, 0x0D, 0x1D, + 0x00, 0x2C, 0x0E, 0x1E, 0x00, 0x33, 0x04, 0x0D, 0x0E, 0x2C, 0x0D, 0x19, 0x00, 0x36, 0x0D, 0x00, + 0x00, 0x2C, 0x0E, 0x1F, 0x00, 0x25, 0x0D, 0x06, 0x0E, 0x1E, 0x0D, 0x08, 0x00, 0x2C, 0x0E, 0x1C, + 0x00, 0x33, 0x07, 0x09, 0x0E, 0x2C, 0x0E, 0x1D, 0x00, 0x2C, 0x0F, 0x20, 0x00, 0x33, 0x04, 0x0E, + 0x0F, 0x2C, 0x0E, 0x19, 0x00, 0x36, 0x0E, 0x00, 0x00, 0x2C, 0x0F, 0x21, 0x00, 0x25, 0x0E, 0x06, + 0x0F, 0x1E, 0x0E, 0x08, 0x00, 0x31, 0x04, 0x00, 0x00, 0x45, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x21, + 0x00, 0x33, 0x07, 0x09, 0x10, 0x31, 0x0F, 0x00, 0x00, 0x2C, 0x10, 0x22, 0x00, 0x36, 0x10, 0x00, + 0x00, 0x2C, 0x10, 0x23, 0x00, 0x25, 0x0F, 0x06, 0x10, 0x1E, 0x0F, 0x08, 0x00, 0x31, 0x04, 0x00, + 0x00, 0x45, 0x10, 0x00, 0x00, 0x2C, 0x11, 0x23, 0x00, 0x33, 0x07, 0x09, 0x11, 0x31, 0x10, 0x00, + 0x00, 0x2C, 0x11, 0x22, 0x00, 0x36, 0x11, 0x00, 0x00, 0x2C, 0x11, 0x24, 0x00, 0x25, 0x10, 0x06, + 0x11, 0x1E, 0x10, 0x08, 0x00, 0x31, 0x04, 0x00, 0x00, 0x45, 0x11, 0x00, 0x00, 0x2C, 0x12, 0x25, + 0x00, 0x33, 0x07, 0x09, 0x12, 0x31, 0x11, 0x00, 0x00, 0x2C, 0x12, 0x22, 0x00, 0x36, 0x12, 0x00, + 0x00, 0x2C, 0x12, 0x26, 0x00, 0x25, 0x11, 0x06, 0x12, 0x1E, 0x11, 0x04, 0x00, 0x33, 0x07, 0x09, + 0x04, 0x2C, 0x12, 0x27, 0x00, 0x36, 0x12, 0x00, 0x00, 0x2C, 0x12, 0x28, 0x00, 0x32, 0x12, 0x06, + 0x00, 0x2C, 0x13, 0x15, 0x00, 0x35, 0x12, 0x13, 0x00, 0x01, 0x12, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x81, 0xC9, 0x01, 0x04, 0x0D, 0x00, 0x09, 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, + 0x00, 0x0C, 0x00, 0x0C, 0x03, 0x09, 0xBF, 0xFF, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x04, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x02, 0x23, 0x00, 0x12, 0x00, 0x12, 0x00, 0x07, 0x01, + 0x09, 0x00, 0x09, 0x00, 0x09, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFF, 0x09, + 0x00, 0x09, 0x00, 0x09, 0x02, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFE, 0x09, 0x00, + 0x09, 0x00, 0x09, 0x03, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0xBF, 0xFD, 0x09, 0x00, 0x09, 0x00, 0x09, 0x04, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x12, 0xBF, 0xFC, 0x09, 0x00, 0x09, 0x00, 0x09, 0x05, 0x13, 0x00, 0x13, 0x00, + 0x13, 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0xBF, 0xFB, 0x09, 0x00, 0x09, 0x00, 0x09, 0x06, 0x13, + 0x00, 0x13, 0x00, 0x13, 0x01, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, + 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0xBF, 0xF9, 0x09, 0x00, 0x09, 0x00, 0x09, 0x08, + 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, 0xF8, 0x09, 0x00, 0x09, 0x00, 0x09, 0x09, 0x13, + 0x00, 0x13, 0x00, 0x13, 0x00, 0x13, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x0B, + 0x00, 0x0B, 0x03, 0x09, 0x00, 0x03, 0x00, 0x03, 0x01, 0x1F, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x03, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFF, 0x05, 0x00, 0x05, 0x00, 0x05, 0x02, 0x11, 0x00, 0x11, 0x00, + 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0xBF, 0xFE, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x03, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFD, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x04, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, + 0x10, 0x00, 0x10, 0xBF, 0xFC, 0x05, 0x00, 0x05, 0x00, 0x05, 0x05, 0x31, 0x00, 0x31, 0x00, 0x0D, + 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0xBF, 0xFB, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, + 0x33, 0x00, 0x33, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFA, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x07, 0x2F, 0x00, 0x2F, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0xBF, 0xF9, 0x05, 0x00, 0x05, 0x00, 0x05, 0x08, 0x10, 0x00, 0x10, 0x00, 0x10, 0x01, + 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x00, 0x04, 0x00, 0xDA, 0x86, + 0xAF, 0x00, 0x04, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x04, 0x02, 0xDA, 0x86, 0xAE, 0x2B, 0x03, 0x00, + 0x00, 0x33, 0x01, 0x00, 0x03, 0x2C, 0x03, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0x82, 0x5D, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x04, 0x6D, 0x65, 0x61, 0x6E, 0xD7, 0x00, 0xCD, 0x00, + 0xDC, 0x00, 0x00, 0x08, 0x01, 0x01, 0x01, 0x02, 0x18, 0x00, 0x07, 0xCE, 0x04, 0x6D, 0x65, 0x61, + 0x6E, 0xDA, 0x18, 0xDA, 0x86, 0x85, 0xDA, 0x8A, 0x4D, 0x00, 0x18, 0x00, 0xDA, 0x82, 0x74, 0x00, + 0x18, 0x01, 0xDA, 0x8D, 0xEE, 0x0A, 0x18, 0x03, 0xDA, 0x81, 0x96, 0x0B, 0x18, 0x04, 0xCF, 0x05, + 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x0B, 0x16, 0x00, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x0E, 0x16, 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x11, 0x16, 0x07, + 0xDA, 0x1E, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x1E, 0x02, + 0x07, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, 0x03, 0x04, 0x00, 0x3F, 0x04, + 0x00, 0x00, 0x0C, 0x05, 0x03, 0x04, 0x03, 0x05, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x2B, 0x04, + 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, 0x05, 0x00, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x1F, 0x06, + 0x07, 0x00, 0x3A, 0x05, 0x00, 0x06, 0x1B, 0x07, 0x05, 0x00, 0x06, 0x03, 0x03, 0x07, 0x05, 0x04, + 0x04, 0x01, 0x49, 0x06, 0x00, 0x06, 0x1C, 0xFA, 0xFF, 0xFF, 0x0C, 0x05, 0x03, 0x04, 0x03, 0x05, + 0x00, 0x00, 0x82, 0x8E, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x03, 0x01, 0x08, 0x00, 0x08, 0x00, + 0x08, 0x00, 0x11, 0x00, 0x05, 0x00, 0x05, 0x02, 0x07, 0x00, 0x07, 0x01, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x12, 0x00, 0x1F, 0x00, 0x07, 0x00, 0x07, 0x01, + 0x07, 0x00, 0x07, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0x68, 0xD8, + 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0x68, 0xCF, 0x0B, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0xDA, 0x83, 0x8D, 0xCF, 0x0F, 0x2A, 0x64, 0x65, + 0x66, 0x64, 0x79, 0x6E, 0x2D, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x2A, 0xDA, 0x8C, 0xC5, 0xCF, + 0x07, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x3F, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, + 0x01, 0x01, 0x01, 0x02, 0x06, 0x00, 0x02, 0xCE, 0x07, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x3F, + 0xDA, 0x18, 0xDA, 0x65, 0xDA, 0x81, 0x11, 0x00, 0x06, 0x00, 0xDA, 0x1E, 0x00, 0x06, 0x01, 0xDA, + 0x8D, 0xF8, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x2C, 0x04, + 0x01, 0x00, 0x25, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x69, 0x30, 0x00, 0x30, 0x00, 0x30, + 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0xCF, 0x08, 0x72, 0x6F, 0x6F, 0x74, 0x2D, 0x65, 0x6E, 0x76, + 0xDA, 0x00, 0xDA, 0x8B, 0xBA, 0xD7, 0x00, 0xCD, 0x00, 0xFD, 0x00, 0x00, 0x09, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x05, 0x12, 0x00, 0x01, 0x05, 0xCE, 0x06, 0x69, 0x6D, 0x70, 0x6F, 0x72, + 0x74, 0xDA, 0x18, 0xDA, 0x86, 0x7D, 0xDA, 0x8C, 0xE2, 0xDA, 0x81, 0x12, 0xDA, 0x8A, 0x79, 0xDA, + 0x80, 0xE7, 0x00, 0x12, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x12, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x12, + 0x02, 0xDA, 0x8B, 0xBA, 0x04, 0x12, 0x04, 0xDA, 0x8A, 0x9C, 0x09, 0x12, 0x05, 0xCF, 0x04, 0x61, + 0x72, 0x67, 0x6D, 0x2B, 0x03, 0x02, 0x00, 0x32, 0x03, 0x01, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, + 0x03, 0x04, 0x00, 0x1B, 0x04, 0x03, 0x00, 0x30, 0x05, 0x00, 0x00, 0x32, 0x05, 0x04, 0x00, 0x2C, + 0x07, 0x01, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, 0x05, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2C, + 0x08, 0x02, 0x00, 0x35, 0x07, 0x08, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x32, 0x08, 0x07, 0x00, 0x34, + 0x05, 0x00, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x36, 0x08, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x06, 0x01, 0x01, 0x01, 0x02, 0x10, 0x00, 0x02, 0xDA, 0x18, 0xDA, 0x8A, 0x7F, 0xDA, 0x81, 0x12, + 0x01, 0x10, 0x02, 0xDA, 0x22, 0x03, 0x10, 0x03, 0xDA, 0x5A, 0x3D, 0x01, 0x00, 0x00, 0x1B, 0x02, + 0x01, 0x00, 0x3D, 0x01, 0x00, 0x01, 0x1B, 0x03, 0x01, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x25, 0x01, + 0x02, 0x04, 0x1E, 0x01, 0x06, 0x00, 0x31, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x35, 0x04, + 0x05, 0x00, 0x1B, 0x00, 0x04, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x32, 0x02, + 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x8C, 0x1A, 0x15, 0x00, 0x15, 0x00, + 0x15, 0x00, 0x15, 0x00, 0x28, 0x00, 0x28, 0x00, 0x24, 0x00, 0x32, 0x00, 0x32, 0x00, 0x32, 0x00, + 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0x8C, 0x19, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x15, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x0D, 0x00, 0x03, + 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x63, 0x68, 0x6D, 0x6F, 0x64, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x63, + 0x68, 0x6D, 0x6F, 0x64, 0xDA, 0x8D, 0x11, 0xDA, 0x8D, 0x0F, 0xDA, 0x80, 0xAC, 0xDA, 0x80, 0xA6, + 0xCF, 0x04, 0x61, 0x73, 0x2D, 0x3E, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x07, 0x02, 0x02, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x02, 0x05, 0xCE, 0x04, 0x61, 0x73, 0x2D, 0x3E, + 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x89, 0x43, 0xDA, 0x81, 0x73, 0x00, 0x07, 0x00, 0xDA, 0x1E, 0x00, + 0x07, 0x01, 0xDA, 0x89, 0x46, 0x00, 0x07, 0x02, 0xDA, 0x81, 0x9A, 0x00, 0x07, 0x03, 0xDA, 0x8E, + 0x01, 0x00, 0x07, 0x04, 0xDA, 0x89, 0x47, 0x1B, 0x04, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x49, + 0x05, 0x02, 0x06, 0x1B, 0x06, 0x05, 0x00, 0x30, 0x05, 0x01, 0x00, 0x35, 0x05, 0x05, 0x00, 0x03, + 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x06, 0x01, 0x06, + 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x89, 0x46, 0xBF, + 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x9A, 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8E, 0x01, 0xBF, 0xFF, 0x00, + 0x04, 0xDA, 0x89, 0x47, 0x00, 0x06, 0x00, 0xDA, 0x80, 0xD9, 0x2D, 0x02, 0x00, 0x01, 0x25, 0x01, + 0x00, 0x02, 0x1E, 0x01, 0x03, 0x00, 0x2D, 0x02, 0x00, 0x08, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0xBF, 0xFF, 0x85, 0x76, 0x2A, 0x00, 0x2A, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, + 0x26, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x07, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x03, 0x1C, + 0x01, 0x01, 0x05, 0xDA, 0x89, 0x48, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x89, 0x43, 0xDA, 0x81, 0x73, + 0xBF, 0xFF, 0x00, 0x02, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x57, 0xBF, 0xFF, 0x00, + 0x06, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x56, 0x06, 0x1C, 0x01, 0xDA, 0x81, 0x8B, + 0x09, 0x1C, 0x02, 0xDA, 0x69, 0x0E, 0x1C, 0x00, 0xDA, 0x89, 0x4B, 0x2D, 0x00, 0x00, 0x06, 0x20, + 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x02, 0x2D, 0x02, 0x00, 0x06, 0x3A, + 0x00, 0x01, 0x02, 0x1B, 0x01, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x35, 0x00, 0x02, 0x00, 0x1B, + 0x02, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x32, 0x00, 0x01, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x35, + 0x03, 0x04, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x04, 0x32, 0x02, 0x04, 0x00, 0x46, + 0x03, 0x00, 0x00, 0x2C, 0x05, 0x02, 0x00, 0x33, 0x05, 0x03, 0x00, 0x45, 0x04, 0x00, 0x00, 0x2F, + 0x04, 0x00, 0x04, 0x2D, 0x05, 0x00, 0x02, 0x2D, 0x06, 0x00, 0x06, 0x49, 0x03, 0x05, 0x06, 0x2F, + 0x03, 0x00, 0x06, 0x2E, 0x05, 0x00, 0x00, 0x36, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, + 0x00, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x06, 0x02, 0x08, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, + 0xDA, 0x1E, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x89, 0x46, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x81, 0x9A, + 0xBF, 0xFF, 0x00, 0x03, 0xDA, 0x8E, 0x01, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x89, 0x47, 0xBF, 0xFF, + 0x01, 0x01, 0xDA, 0x81, 0x8B, 0xBF, 0xFF, 0x01, 0x02, 0xDA, 0x69, 0x00, 0x06, 0x00, 0xDA, 0x80, + 0xD9, 0x2D, 0x02, 0x00, 0x01, 0x25, 0x01, 0x00, 0x02, 0x1E, 0x01, 0x03, 0x00, 0x2D, 0x02, 0x01, + 0x02, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x85, 0x76, 0x2A, 0x00, + 0x2A, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0x85, 0x74, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x01, 0x1E, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x05, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0xBF, 0xFD, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x85, 0x73, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0xBF, 0xFA, 0x01, 0x56, 0x01, 0x00, 0x00, 0xCF, 0x03, 0x74, 0x72, 0x79, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x02, 0x02, 0x02, 0x0D, 0x3A, 0x00, 0x07, 0xCE, + 0x03, 0x74, 0x72, 0x79, 0xDA, 0x18, 0xDA, 0x51, 0xDA, 0x80, 0x9B, 0xDA, 0x81, 0x6B, 0xDA, 0x81, + 0x6C, 0xDA, 0x81, 0x6D, 0xDA, 0x81, 0x6F, 0xDA, 0x84, 0x7F, 0xDA, 0x81, 0x72, 0xDA, 0x52, 0xDA, + 0x80, 0xE0, 0xDA, 0x58, 0xDA, 0x57, 0xDA, 0x81, 0x73, 0x00, 0x3A, 0x00, 0xDA, 0x81, 0x74, 0x00, + 0x3A, 0x01, 0xCF, 0x05, 0x63, 0x61, 0x74, 0x63, 0x68, 0x00, 0x3A, 0x02, 0xDA, 0x8E, 0x06, 0x02, + 0x3A, 0x05, 0xDA, 0x59, 0x04, 0x3A, 0x06, 0xDA, 0x84, 0x84, 0x07, 0x3A, 0x04, 0xDA, 0x80, 0xAA, + 0x0A, 0x3A, 0x07, 0xDA, 0x6C, 0x3D, 0x03, 0x01, 0x00, 0x3D, 0x04, 0x03, 0x00, 0x1B, 0x05, 0x04, + 0x00, 0x3D, 0x04, 0x03, 0x01, 0x1B, 0x06, 0x04, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, + 0x00, 0x1B, 0x04, 0x03, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x35, 0x03, 0x07, 0x00, 0x1B, 0x07, 0x03, + 0x00, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x09, 0x01, 0x00, 0x33, 0x09, 0x03, 0x00, 0x45, 0x08, 0x00, + 0x00, 0x2C, 0x09, 0x02, 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x33, 0x09, 0x08, 0x0A, 0x45, 0x03, 0x00, + 0x00, 0x2C, 0x09, 0x04, 0x00, 0x32, 0x09, 0x04, 0x00, 0x45, 0x08, 0x00, 0x00, 0x33, 0x04, 0x03, + 0x07, 0x31, 0x08, 0x00, 0x00, 0x46, 0x09, 0x00, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x32, 0x08, 0x04, + 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x0A, 0x06, 0x00, 0x2C, 0x0B, 0x07, 0x00, 0x33, 0x0A, 0x03, + 0x0B, 0x45, 0x08, 0x00, 0x00, 0x2C, 0x0A, 0x08, 0x00, 0x33, 0x0A, 0x05, 0x07, 0x45, 0x03, 0x00, + 0x00, 0x1E, 0x06, 0x06, 0x00, 0x2C, 0x0C, 0x08, 0x00, 0x33, 0x0C, 0x06, 0x04, 0x45, 0x0B, 0x00, + 0x00, 0x1B, 0x0A, 0x0B, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x2B, 0x0B, 0x01, + 0x00, 0x32, 0x01, 0x0B, 0x00, 0x2C, 0x0C, 0x09, 0x00, 0x35, 0x0B, 0x0C, 0x00, 0x2C, 0x0D, 0x0A, + 0x00, 0x33, 0x0D, 0x03, 0x0A, 0x34, 0x0B, 0x00, 0x00, 0x45, 0x0C, 0x00, 0x00, 0x2C, 0x0A, 0x0B, + 0x00, 0x33, 0x0A, 0x08, 0x0C, 0x31, 0x07, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x0A, 0x0C, + 0x00, 0x33, 0x0A, 0x09, 0x03, 0x45, 0x08, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x80, 0xF4, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0xBF, 0xFF, 0x03, 0x02, + 0x0B, 0x00, 0x0B, 0xBF, 0xFE, 0x03, 0x03, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x03, 0x1D, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x00, 0x1D, + 0x00, 0x1D, 0x00, 0x1D, 0x00, 0x37, 0x00, 0x37, 0x00, 0x37, 0x00, 0x37, 0xBF, 0xFD, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xCF, 0x08, 0x65, 0x76, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xDA, + 0x8B, 0x67, 0xDA, 0x85, 0x62, 0xDA, 0x85, 0x60, 0xCF, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2F, 0x62, 0x69, 0x74, 0xD8, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, + 0xCF, 0x08, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2D, 0x66, 0x6E, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, + 0x00, 0x05, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x0A, 0x00, 0x03, 0xCE, 0x08, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2D, 0x66, 0x6E, 0xDA, 0x18, 0xDA, 0x80, 0x9B, 0xDA, 0x81, 0xAC, 0xDA, + 0x80, 0xE7, 0xDA, 0x81, 0x6B, 0x00, 0x0A, 0x00, 0xCF, 0x05, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x00, + 0x0A, 0x01, 0xDA, 0x81, 0x74, 0x00, 0x0A, 0x02, 0xDA, 0x8E, 0x0D, 0x2C, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x32, 0x03, 0x04, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, + 0x03, 0x04, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x33, 0x04, 0x03, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x36, + 0x04, 0x00, 0x00, 0x82, 0x82, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0xD8, + 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0xCF, 0x0B, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0xDA, 0x87, 0x13, 0xCF, 0x0C, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, + 0x2D, 0x65, 0x6E, 0x76, 0xDA, 0x84, 0xA0, 0xCF, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x6A, 0x69, 0x74, + 0x66, 0x6E, 0xD8, 0x09, 0x66, 0x66, 0x69, 0x2F, 0x6A, 0x69, 0x74, 0x66, 0x6E, 0xDA, 0x8A, 0x89, + 0xDA, 0x8A, 0x79, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x84, + 0xC1, 0xCF, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0xDA, 0x80, 0xA8, + 0xCF, 0x04, 0x63, 0x6F, 0x6D, 0x70, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x18, 0x00, 0x00, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x3A, 0x00, 0x04, 0x03, 0xCE, 0x04, 0x63, 0x6F, 0x6D, 0x70, + 0xDA, 0x18, 0xDA, 0x80, 0xE0, 0x00, 0x3A, 0x00, 0xCF, 0x09, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x00, 0x3A, 0x01, 0xDA, 0x8E, 0x19, 0x02, 0x3A, 0x03, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x67, 0x2E, 0x01, 0x00, 0x00, 0x3F, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, + 0x00, 0x26, 0x02, 0x03, 0x00, 0x1E, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x26, 0x04, 0x03, + 0x01, 0x1E, 0x04, 0x04, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x3A, 0x05, 0x00, 0x06, 0x03, 0x05, 0x00, + 0x00, 0x26, 0x05, 0x03, 0x02, 0x1E, 0x05, 0x07, 0x00, 0x3D, 0x06, 0x00, 0x00, 0x1B, 0x07, 0x06, + 0x00, 0x3D, 0x06, 0x00, 0x01, 0x1B, 0x08, 0x06, 0x00, 0x30, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, + 0x00, 0x26, 0x06, 0x03, 0x03, 0x1E, 0x06, 0x09, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x1B, 0x0A, 0x09, + 0x00, 0x3D, 0x09, 0x00, 0x01, 0x1B, 0x0B, 0x09, 0x00, 0x3D, 0x09, 0x00, 0x02, 0x1B, 0x0C, 0x09, + 0x00, 0x30, 0x09, 0x01, 0x00, 0x03, 0x09, 0x00, 0x00, 0x26, 0x09, 0x03, 0x04, 0x1E, 0x09, 0x0B, + 0x00, 0x3D, 0x0D, 0x00, 0x00, 0x1B, 0x0E, 0x0D, 0x00, 0x3D, 0x0D, 0x00, 0x01, 0x1B, 0x0F, 0x0D, + 0x00, 0x3D, 0x0D, 0x00, 0x02, 0x1B, 0x10, 0x0D, 0x00, 0x3D, 0x0D, 0x00, 0x03, 0x1B, 0x11, 0x0D, + 0x00, 0x30, 0x0D, 0x02, 0x00, 0x03, 0x0D, 0x00, 0x00, 0x3D, 0x0D, 0x00, 0x00, 0x1B, 0x12, 0x0D, + 0x00, 0x3D, 0x0D, 0x00, 0x01, 0x1B, 0x13, 0x0D, 0x00, 0x3D, 0x0D, 0x00, 0x02, 0x1B, 0x14, 0x0D, + 0x00, 0x3D, 0x0D, 0x00, 0x03, 0x1B, 0x15, 0x0D, 0x00, 0x30, 0x0D, 0x03, 0x00, 0x2B, 0x16, 0x04, + 0x00, 0x2B, 0x17, 0xFF, 0xFF, 0x33, 0x00, 0x16, 0x17, 0x2C, 0x17, 0x00, 0x00, 0x35, 0x16, 0x17, + 0x00, 0x31, 0x0D, 0x00, 0x00, 0x34, 0x16, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0xCD, 0x00, 0xD5, + 0x00, 0x00, 0x03, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x01, 0x03, 0xDA, 0x18, + 0xBF, 0xFF, 0x00, 0x07, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x08, 0xCF, 0x01, 0x67, 0x00, 0x06, + 0x00, 0xDA, 0x1E, 0x34, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x08, 0x35, 0x01, 0x02, 0x00, 0x31, + 0x01, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x07, 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x82, 0xC1, 0x2B, + 0x00, 0x2B, 0x00, 0x2B, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0xCD, 0x00, 0xD5, 0x00, 0x00, 0x04, + 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x09, 0x01, 0x04, 0xDA, 0x18, 0xBF, 0xFF, 0x00, + 0x0A, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x0B, 0xDA, 0x8E, 0x1E, 0xBF, 0xFF, 0x00, 0x0C, 0xDA, + 0x81, 0x0B, 0x00, 0x09, 0x00, 0xDA, 0x1E, 0x34, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x0C, 0x35, + 0x01, 0x02, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x0B, 0x35, 0x02, 0x03, 0x00, 0x31, + 0x02, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x0A, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x82, 0xC2, 0x30, + 0x00, 0x30, 0x00, 0x30, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x2A, 0x00, 0x2A, 0x00, 0x2A, + 0xCD, 0x00, 0xD5, 0x00, 0x00, 0x04, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x0C, 0x01, + 0x05, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x0E, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x0F, 0xDA, 0x8E, + 0x1E, 0xBF, 0xFF, 0x00, 0x10, 0xDA, 0x81, 0x0B, 0xBF, 0xFF, 0x00, 0x11, 0xDA, 0x80, 0xC3, 0x00, + 0x0C, 0x00, 0xDA, 0x1E, 0x34, 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x11, 0x35, 0x01, 0x02, 0x00, + 0x31, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x10, 0x35, 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, + 0x2D, 0x03, 0x00, 0x0F, 0x35, 0x01, 0x03, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x0E, + 0x36, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x82, 0xC3, 0x35, 0x00, 0x35, 0x00, 0x35, 0x00, 0x32, 0x00, + 0x32, 0x00, 0x32, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2C, 0x00, 0x2C, 0x00, 0x2C, 0xCD, + 0x00, 0xD4, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01, 0x00, 0x0C, 0x01, 0x05, 0xDA, 0x18, 0xBF, 0xFF, + 0x00, 0x12, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x13, 0xDA, 0x8E, 0x1E, 0xBF, 0xFF, 0x00, 0x14, + 0xDA, 0x81, 0x0B, 0xBF, 0xFF, 0x00, 0x15, 0xDA, 0x80, 0xC3, 0x00, 0x0C, 0x00, 0xDA, 0x1E, 0x31, + 0x00, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x15, 0x35, 0x01, 0x02, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, + 0x03, 0x00, 0x14, 0x35, 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x13, 0x35, + 0x01, 0x03, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x12, 0x36, 0x02, 0x00, 0x00, 0xBF, + 0xFF, 0x82, 0xC5, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x1B, 0x00, 0x18, + 0x00, 0x18, 0x00, 0x18, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x82, 0xBA, 0x01, 0x04, 0x09, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x02, 0x07, 0x00, 0x07, 0x00, + 0x07, 0xBF, 0xFE, 0x03, 0x00, 0x03, 0x03, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1E, + 0x00, 0x1E, 0xBF, 0xFD, 0x03, 0x00, 0x03, 0x04, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x20, 0x00, 0x20, 0xBF, 0xFC, 0x03, 0x00, 0x03, 0x05, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x22, 0x00, 0x22, + 0x01, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, + 0x01, 0x0D, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0xBF, 0xFF, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x80, 0xDD, 0x3F, 0x00, 0xDA, 0x85, 0xC1, 0xDA, 0x85, 0xBC, 0xDA, 0x8B, 0xB2, + 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, + 0x06, 0x00, 0x03, 0xCE, 0x04, 0x76, 0x61, 0x72, 0x2D, 0xDA, 0x18, 0xDA, 0x80, 0x9C, 0xDA, 0x62, + 0x00, 0x06, 0x00, 0xDA, 0x81, 0xBE, 0x00, 0x06, 0x01, 0xDA, 0x81, 0xBF, 0x00, 0x06, 0x02, 0xDA, + 0x8B, 0xB2, 0x2C, 0x04, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x34, 0x01, + 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x4D, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, 0x85, 0xA9, 0xDA, 0x85, 0xA7, 0xCF, 0x06, 0x69, 0x6E, + 0x76, 0x65, 0x72, 0x74, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x01, 0x00, + 0x0C, 0x00, 0x06, 0xCE, 0x06, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x74, 0xDA, 0x18, 0x00, 0x0C, 0x00, + 0xDA, 0x24, 0x00, 0x0C, 0x01, 0xDA, 0x8E, 0x21, 0x01, 0x0C, 0x03, 0xDA, 0x23, 0x01, 0x0B, 0x00, + 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x32, 0x6F, 0x04, 0x0B, 0x05, 0xCF, 0x07, 0x5F, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x6E, 0x06, 0x0B, 0x04, 0xDA, 0x22, 0x44, 0x02, 0x00, 0x00, 0x1B, 0x03, + 0x02, 0x00, 0x28, 0x05, 0x00, 0x00, 0x49, 0x04, 0x00, 0x05, 0x1B, 0x05, 0x04, 0x00, 0x1F, 0x05, + 0x06, 0x00, 0x1B, 0x04, 0x05, 0x00, 0x3A, 0x06, 0x00, 0x04, 0x3C, 0x03, 0x06, 0x04, 0x49, 0x05, + 0x00, 0x05, 0x1C, 0xFB, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x85, 0xDE, 0x03, 0x00, 0x03, 0x01, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x0E, 0x00, 0x05, 0xBF, 0xFF, 0x03, + 0x00, 0x03, 0xBF, 0xF9, 0x01, 0xDA, 0x8B, 0x0E, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, + 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x0C, 0x00, 0x02, 0xCE, 0x0C, 0x65, 0x76, 0x2F, + 0x64, 0x6F, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x18, 0xDA, 0x86, 0x38, 0xDA, 0x80, + 0x9B, 0xCF, 0x0A, 0x5F, 0x64, 0x6F, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0xDA, 0x88, 0x03, + 0x00, 0x0C, 0x00, 0xDA, 0x81, 0x74, 0x00, 0x0C, 0x01, 0xDA, 0x8B, 0x0E, 0x2C, 0x03, 0x00, 0x00, + 0x31, 0x03, 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x2C, 0x05, 0x02, 0x00, + 0x33, 0x04, 0x05, 0x02, 0x34, 0x00, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x04, 0x03, 0x00, + 0x32, 0x04, 0x03, 0x00, 0x45, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x8E, 0x9F, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x05, 0xCF, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x2D, + 0x66, 0x6F, 0x72, 0x6B, 0xD8, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x2D, 0x66, + 0x6F, 0x72, 0x6B, 0xCF, 0x04, 0x63, 0x6F, 0x6E, 0x64, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, + 0x05, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x00, 0x01, 0x03, 0xCE, 0x04, 0x63, + 0x6F, 0x6E, 0x64, 0xDA, 0x18, 0x00, 0x05, 0x00, 0xDA, 0x88, 0x73, 0x00, 0x05, 0x01, 0xDA, 0x8E, + 0x2B, 0x01, 0x05, 0x03, 0xDA, 0x81, 0x27, 0x30, 0x02, 0x00, 0x00, 0x1B, 0x03, 0x02, 0x00, 0x2B, + 0x04, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x0A, 0x01, 0x01, 0x01, 0x02, 0x1A, 0x01, 0x05, 0xDA, 0x81, 0x28, 0xDA, 0x18, 0xDA, 0x57, 0xDA, + 0x80, 0xE7, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x88, 0x73, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x8E, 0x2B, + 0x00, 0x1A, 0x00, 0xDA, 0x80, 0xC3, 0x00, 0x1A, 0x01, 0xDA, 0x81, 0x27, 0x04, 0x1A, 0x02, 0xDA, + 0x8B, 0x4C, 0x2E, 0x01, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x00, 0x3F, 0x02, 0x03, 0x00, 0x08, 0x03, + 0x02, 0x00, 0x1B, 0x02, 0x03, 0x00, 0x26, 0x04, 0x02, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x26, 0x05, 0x02, 0x01, 0x1E, 0x05, 0x04, 0x00, 0x2D, 0x07, 0x00, 0x00, 0x3A, 0x06, + 0x07, 0x00, 0x03, 0x06, 0x00, 0x00, 0x2D, 0x07, 0x00, 0x00, 0x3A, 0x06, 0x07, 0x00, 0x05, 0x07, + 0x00, 0x01, 0x2D, 0x09, 0x00, 0x00, 0x3A, 0x08, 0x09, 0x07, 0x05, 0x07, 0x00, 0x02, 0x31, 0x07, + 0x00, 0x00, 0x35, 0x09, 0x01, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x33, 0x07, 0x06, 0x08, 0x31, 0x09, + 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x36, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x80, 0xC0, 0x03, 0x01, + 0x15, 0x00, 0x15, 0x00, 0x12, 0x00, 0x05, 0x01, 0x09, 0x00, 0x05, 0x00, 0x05, 0x01, 0x0B, 0x00, + 0x07, 0x00, 0x19, 0x00, 0x19, 0x00, 0x19, 0x01, 0x14, 0x00, 0x14, 0x01, 0x1A, 0x00, 0x10, 0x00, + 0x10, 0x01, 0x15, 0x00, 0x10, 0x00, 0x10, 0xBF, 0xFE, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, + 0x00, 0x09, 0x80, 0xC0, 0x03, 0x00, 0x03, 0x07, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, + 0x00, 0xCF, 0x0C, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0xD8, + 0x0C, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0xCF, 0x07, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0xD7, 0x00, 0xCD, 0x02, 0xFF, 0x00, 0x00, 0x06, 0x01, 0x01, + 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x03, 0xCE, 0x07, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x61, 0x6C, 0xDA, 0x18, 0xDA, 0x8A, 0x00, 0x00, 0x08, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x08, + 0x01, 0xDA, 0x81, 0xBF, 0x00, 0x08, 0x02, 0xDA, 0x8E, 0x30, 0x3F, 0x03, 0x01, 0x00, 0x31, 0x03, + 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, 0x00, 0x1E, 0x04, 0x02, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xD5, 0x00, 0x00, 0x02, + 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x01, 0x04, 0xDA, 0x18, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x81, 0xBF, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x8E, 0x30, 0x00, 0x05, 0x00, 0xDA, 0x6C, 0x2D, 0x01, 0x00, 0x01, 0x34, 0x01, 0x00, 0x00, 0x34, + 0x00, 0x00, 0x00, 0x2D, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0x85, 0xA8, 0x0F, + 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x85, 0xA7, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x03, 0x00, 0x03, 0x01, 0x05, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0xCF, 0x08, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x61, 0x62, 0x73, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x62, + 0x73, 0xCF, 0x07, 0x73, 0x6F, 0x72, 0x74, 0x2D, 0x62, 0x79, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, + 0x00, 0x05, 0x02, 0x02, 0x02, 0x01, 0x04, 0x00, 0x01, 0x03, 0xCE, 0x07, 0x73, 0x6F, 0x72, 0x74, + 0x2D, 0x62, 0x79, 0xDA, 0x18, 0xDA, 0x88, 0x5E, 0x00, 0x04, 0x00, 0xDA, 0x80, 0xAA, 0x00, 0x04, + 0x01, 0xDA, 0x1F, 0x00, 0x04, 0x02, 0xDA, 0x8E, 0x35, 0x30, 0x03, 0x00, 0x00, 0x32, 0x01, 0x03, + 0x00, 0x2C, 0x04, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x02, + 0x02, 0x02, 0x00, 0x08, 0x01, 0x05, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, 0x80, 0xAA, 0xBF, + 0xFF, 0x00, 0x01, 0xDA, 0x1F, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8E, 0x35, 0x00, 0x08, 0x00, 0xDA, + 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x80, 0xD9, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x23, + 0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x83, 0x73, 0x1A, 0x00, 0x1A, 0x00, 0x1A, + 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x17, 0x00, 0x17, 0x83, 0x73, 0x0D, 0x00, 0x03, 0x00, + 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xCF, 0x04, 0x62, 0x61, 0x6E, 0x64, 0xD7, 0x00, 0xCD, + 0x00, 0x09, 0x00, 0x0D, 0x06, 0x00, 0x00, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x00, 0x13, 0xCE, 0x04, + 0x62, 0x61, 0x6E, 0x64, 0x3F, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x1E, 0x02, 0x03, 0x00, + 0x2B, 0x03, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x01, 0x1E, 0x02, 0x05, 0x00, + 0x2B, 0x03, 0xFF, 0xFF, 0x3D, 0x04, 0x00, 0x00, 0x10, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, + 0x3D, 0x03, 0x00, 0x00, 0x2B, 0x05, 0x01, 0x00, 0x3A, 0x04, 0x00, 0x05, 0x10, 0x03, 0x03, 0x04, + 0x05, 0x05, 0x05, 0x01, 0x25, 0x02, 0x05, 0x01, 0x1E, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, + 0xCF, 0x09, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2D, 0x62, 0x79, 0xD7, 0x00, 0xCD, 0x02, 0xFE, + 0x00, 0x00, 0x05, 0x02, 0x02, 0x02, 0x01, 0x04, 0x00, 0x01, 0x03, 0xCE, 0x09, 0x73, 0x6F, 0x72, + 0x74, 0x65, 0x64, 0x2D, 0x62, 0x79, 0xDA, 0x18, 0xDA, 0x89, 0x8C, 0x00, 0x04, 0x00, 0xDA, 0x80, + 0xAA, 0x00, 0x04, 0x01, 0xDA, 0x1F, 0x00, 0x04, 0x02, 0xDA, 0x8E, 0x3B, 0x30, 0x03, 0x00, 0x00, + 0x32, 0x01, 0x03, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, + 0x00, 0x05, 0x02, 0x02, 0x02, 0x00, 0x08, 0x01, 0x05, 0xDA, 0x18, 0xBF, 0xFF, 0x00, 0x00, 0xDA, + 0x80, 0xAA, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x1F, 0xBF, 0xFF, 0x00, 0x02, 0xDA, 0x8E, 0x3B, 0x00, + 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x80, 0xD9, 0x31, 0x00, 0x00, 0x00, 0x2D, 0x03, + 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x31, 0x01, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x00, 0x35, 0x03, + 0x04, 0x00, 0x23, 0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0x83, 0x80, 0x1C, 0x00, + 0x1C, 0x00, 0x1C, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x19, 0x00, 0x19, 0x83, 0x80, 0x0F, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2F, 0x70, 0x6F, 0x70, 0x6E, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, + 0x70, 0x6F, 0x70, 0x6E, 0xCF, 0x02, 0x2A, 0x3D, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x06, + 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x00, 0x03, 0xCE, 0x02, 0x2A, 0x3D, 0xDA, + 0x18, 0xDA, 0x8C, 0x27, 0xDA, 0x34, 0x00, 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x35, + 0x00, 0x08, 0x02, 0xDA, 0x8E, 0x40, 0x2C, 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, 0x34, 0x01, + 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x33, 0x05, 0x00, 0x03, 0x45, 0x04, + 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x80, 0x8E, 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0x00, + 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x3A, 0xCF, 0x07, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x32, + 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x02, 0x02, 0x02, 0x00, 0x13, 0x00, 0x05, 0xCE, + 0x07, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x32, 0xDA, 0x18, 0x00, 0x13, 0x00, 0xDA, 0x80, 0xAA, + 0x00, 0x13, 0x01, 0xDA, 0x1F, 0x00, 0x13, 0x02, 0xDA, 0x8E, 0x43, 0x02, 0x13, 0x04, 0xDA, 0x22, + 0x08, 0x13, 0x06, 0xDA, 0x80, 0xAD, 0x28, 0x04, 0x00, 0x00, 0x49, 0x03, 0x01, 0x04, 0x1B, 0x04, + 0x03, 0x00, 0x28, 0x06, 0x00, 0x00, 0x25, 0x05, 0x06, 0x04, 0x1E, 0x05, 0x02, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x3A, 0x05, 0x01, 0x04, 0x1B, 0x06, 0x05, 0x00, 0x49, 0x04, 0x01, 0x04, 0x28, 0x08, + 0x00, 0x00, 0x4A, 0x07, 0x08, 0x04, 0x1E, 0x07, 0x06, 0x00, 0x3A, 0x08, 0x01, 0x04, 0x32, 0x06, + 0x08, 0x00, 0x35, 0x06, 0x00, 0x00, 0x49, 0x04, 0x01, 0x04, 0x1C, 0xF9, 0xFF, 0xFF, 0x03, 0x06, + 0x00, 0x00, 0x83, 0x92, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x07, 0x00, 0x07, 0x00, 0x03, 0x00, + 0x11, 0x01, 0x0C, 0x00, 0x03, 0x01, 0x0A, 0x01, 0x0A, 0x00, 0x0A, 0x00, 0x03, 0x01, 0x15, 0x00, + 0x0E, 0x00, 0x0E, 0x01, 0x0C, 0xBF, 0xFE, 0x03, 0xBF, 0xF8, 0x01, 0xCF, 0x08, 0x67, 0x65, 0x6E, + 0x65, 0x72, 0x61, 0x74, 0x65, 0xD7, 0x00, 0xCD, 0x00, 0xDD, 0x00, 0x00, 0x07, 0x01, 0x01, 0xCD, + 0x7F, 0xFF, 0xFF, 0xFF, 0x06, 0x13, 0x00, 0x03, 0xCE, 0x08, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, + 0x74, 0x65, 0xDA, 0x18, 0xDA, 0x58, 0xDA, 0x8B, 0x42, 0xDA, 0x86, 0xAE, 0xDA, 0x80, 0x9B, 0xDA, + 0x81, 0x6B, 0xDA, 0x81, 0xAD, 0x00, 0x13, 0x00, 0xDA, 0x86, 0xAF, 0x00, 0x13, 0x01, 0xDA, 0x81, + 0x74, 0x00, 0x13, 0x02, 0xDA, 0x8E, 0x46, 0x46, 0x03, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x31, + 0x05, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, 0x2C, 0x06, 0x01, 0x00, 0x32, + 0x06, 0x04, 0x00, 0x45, 0x05, 0x00, 0x00, 0x2C, 0x06, 0x02, 0x00, 0x33, 0x06, 0x00, 0x05, 0x45, + 0x04, 0x00, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x33, 0x06, 0x03, 0x04, 0x45, 0x05, 0x00, 0x00, 0x2C, + 0x04, 0x04, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x33, 0x04, 0x05, 0x06, 0x45, 0x03, 0x00, 0x00, 0x03, + 0x03, 0x00, 0x00, 0x82, 0x78, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x61, + 0x72, 0x63, 0x68, 0xDA, 0x8D, 0x5F, 0xDA, 0x86, 0x86, 0xDA, 0x86, 0x83, 0xCF, 0x0A, 0x61, 0x72, + 0x72, 0x61, 0x79, 0x2F, 0x66, 0x69, 0x6C, 0x6C, 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, + 0x66, 0x69, 0x6C, 0x6C, 0xCF, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x77, 0x65, 0x61, 0x6B, + 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x77, 0x65, 0x61, 0x6B, 0xCF, 0x06, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0xDA, 0x81, 0x12, 0xCF, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, + 0x78, 0x2D, 0x65, 0x78, 0x65, 0x63, 0xD8, 0x0D, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, + 0x2D, 0x65, 0x78, 0x65, 0x63, 0xCF, 0x02, 0x2B, 0x2B, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x05, 0x01, 0x01, 0x01, 0x02, 0x08, 0x00, 0x02, 0xCE, 0x02, 0x2B, 0x2B, 0xDA, 0x18, 0xDA, 0x32, + 0xDA, 0x34, 0x00, 0x08, 0x00, 0xDA, 0x1E, 0x00, 0x08, 0x01, 0xDA, 0x8E, 0x51, 0x2C, 0x03, 0x00, + 0x00, 0x2B, 0x04, 0x01, 0x00, 0x33, 0x03, 0x00, 0x04, 0x45, 0x02, 0x00, 0x00, 0x2C, 0x04, 0x01, + 0x00, 0x33, 0x04, 0x00, 0x02, 0x45, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x80, 0x8A, 0x2F, + 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x2F, 0xDA, 0x8A, + 0xDA, 0x00, 0x04, 0x00, 0xCF, 0x05, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x00, 0x04, 0x01, 0xDA, 0x8C, + 0x5B, 0x2C, 0x02, 0x00, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x02, 0x01, 0x00, 0x36, 0x02, 0x00, + 0x00, 0x8A, 0xCA, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x06, 0x00, 0xDA, 0x84, 0xC3, + 0x00, 0x06, 0x01, 0xCF, 0x0C, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, + 0x72, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x35, 0x02, 0x03, 0x00, 0x31, 0x02, 0x00, + 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8B, 0xD9, 0x32, 0x00, 0x32, 0x00, 0x32, + 0x00, 0x26, 0x00, 0x26, 0x00, 0x26, 0xDA, 0x87, 0x72, 0xD7, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, + 0x04, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x05, 0x00, 0x02, 0xCE, 0x0D, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x84, 0x96, + 0xDA, 0x8B, 0x59, 0x00, 0x05, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x05, 0x01, 0xCF, 0x0D, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x2C, 0x03, 0x00, 0x00, 0x35, + 0x02, 0x03, 0x00, 0x32, 0x00, 0x02, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x36, 0x03, 0x00, 0x00, 0x8B, + 0xCD, 0x35, 0x00, 0x35, 0x00, 0x28, 0x00, 0x28, 0x00, 0x28, 0xDA, 0x87, 0x61, 0xD7, 0x00, 0xCD, + 0x00, 0xDD, 0x00, 0x00, 0x09, 0x01, 0x01, 0xCD, 0x7F, 0xFF, 0xFF, 0xFF, 0x04, 0x14, 0x00, 0x05, + 0xCE, 0x0E, 0x70, 0x72, 0x65, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, + 0xDA, 0x18, 0xDA, 0x86, 0x91, 0xDA, 0x87, 0x5F, 0xDA, 0x80, 0xFB, 0xDA, 0x87, 0x9E, 0x00, 0x14, + 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x14, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x14, 0x02, 0xCF, 0x0E, 0x70, + 0x72, 0x65, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x05, 0x14, 0x04, + 0xCF, 0x02, 0x6D, 0x63, 0x07, 0x14, 0x06, 0xDA, 0x81, 0x0D, 0x2C, 0x03, 0x00, 0x00, 0x2C, 0x04, + 0x01, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, 0x04, + 0x03, 0x00, 0x3A, 0x05, 0x04, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x1E, 0x05, 0x0B, 0x00, 0x31, 0x06, + 0x00, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x07, 0x08, 0x00, 0x1E, 0x07, 0x06, 0x00, 0x31, 0x00, + 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x35, 0x08, 0x06, 0x00, 0x3C, 0x04, 0x00, 0x08, 0x03, 0x08, + 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8B, 0xD4, 0x18, 0x00, 0x18, 0x00, + 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x10, 0x01, 0x1D, 0x00, 0x10, 0x00, 0x10, 0x01, 0x16, 0x00, + 0x16, 0x00, 0x16, 0x00, 0x12, 0x01, 0x23, 0x00, 0x23, 0x00, 0x23, 0x00, 0x14, 0x00, 0x14, 0xBF, + 0xFF, 0x12, 0xBF, 0xFF, 0x10, 0xDA, 0x84, 0xBA, 0xD7, 0x00, 0xCD, 0x02, 0xFE, 0x00, 0x00, 0x0A, + 0x02, 0x02, 0x02, 0x07, 0x1C, 0x00, 0x01, 0x06, 0xCE, 0x0D, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0xDA, 0x18, 0xDA, 0x87, 0xB9, 0xDA, 0x87, 0xBA, 0xDA, + 0x80, 0xFB, 0xDA, 0x81, 0x86, 0xDA, 0x81, 0x6B, 0xDA, 0x81, 0x6F, 0xDA, 0x81, 0x88, 0x00, 0x1C, + 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x1C, 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x1C, 0x02, 0xCF, 0x0D, 0x73, + 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x05, 0x1C, 0x04, 0xCF, + 0x02, 0x6D, 0x6C, 0x0D, 0x1C, 0x05, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x10, + 0x1C, 0x07, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x2C, 0x03, 0x00, 0x00, 0x2C, + 0x04, 0x01, 0x00, 0x32, 0x03, 0x04, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x35, 0x03, 0x04, 0x00, 0x1B, + 0x04, 0x03, 0x00, 0x29, 0x05, 0x00, 0x00, 0x3C, 0x04, 0x00, 0x05, 0x30, 0x05, 0x00, 0x00, 0x2C, + 0x06, 0x03, 0x00, 0x32, 0x05, 0x06, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x35, 0x06, 0x07, 0x00, 0x1B, + 0x05, 0x06, 0x00, 0x28, 0x07, 0x00, 0x00, 0x37, 0x06, 0x05, 0x07, 0x1B, 0x07, 0x06, 0x00, 0x28, + 0x06, 0x00, 0x00, 0x3C, 0x04, 0x00, 0x06, 0x31, 0x05, 0x00, 0x00, 0x2C, 0x08, 0x05, 0x00, 0x35, + 0x06, 0x08, 0x00, 0x2C, 0x09, 0x06, 0x00, 0x25, 0x08, 0x06, 0x09, 0x1E, 0x08, 0x02, 0x00, 0x03, + 0x07, 0x00, 0x00, 0x39, 0x06, 0x07, 0x05, 0x03, 0x06, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x04, 0xDA, 0x18, 0xDA, 0x8B, 0xC2, 0xBF, 0xFF, 0x00, + 0x00, 0xDA, 0x84, 0xC3, 0xBF, 0xFF, 0x00, 0x01, 0xDA, 0x80, 0xE8, 0xBF, 0xFF, 0x00, 0x02, 0xDA, + 0x8E, 0x5F, 0xBF, 0xFF, 0x00, 0x04, 0xDA, 0x8E, 0x60, 0x2D, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, + 0x00, 0x2D, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, + 0x00, 0xBF, 0xFF, 0x8B, 0xD2, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, + 0x8B, 0xCF, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x17, 0x00, 0x0F, 0x01, 0x0F, 0x00, + 0x0F, 0x01, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x16, 0x00, 0x16, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x03, 0x00, 0x00, 0x00, 0xD0, 0x05, 0x66, + 0x72, 0x65, 0x73, 0x68, 0xCE, 0x14, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x64, + 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x6E, 0x63, 0x79, 0x20, 0xCE, 0x09, 0x20, 0x64, 0x65, 0x74, + 0x65, 0x63, 0x74, 0x65, 0x64, 0xDA, 0x81, 0x12, 0xDA, 0x88, 0xF7, 0xCE, 0x0C, 0x6D, 0x6F, 0x64, + 0x75, 0x6C, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0xCE, 0x08, 0x20, 0x75, 0x6E, 0x6B, 0x6E, + 0x6F, 0x77, 0x6E, 0x00, 0x48, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x48, 0x01, 0xDA, 0x80, 0xE8, 0x00, + 0x48, 0x02, 0xDA, 0x8A, 0x8A, 0x00, 0x48, 0x03, 0xCF, 0x09, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x2D, 0x31, 0x04, 0x48, 0x06, 0xDA, 0x87, 0xB4, 0x06, 0x48, 0x07, 0xDA, 0x87, 0xB2, 0x0F, + 0x48, 0x08, 0xDA, 0x8E, 0x5C, 0x15, 0x48, 0x0A, 0xDA, 0x8E, 0x60, 0x1B, 0x48, 0x0C, 0xCF, 0x03, + 0x6D, 0x6C, 0x73, 0x24, 0x48, 0x0E, 0xDA, 0x89, 0xEC, 0x3A, 0x48, 0x11, 0xDA, 0x8A, 0x11, 0x45, + 0x48, 0x12, 0xDA, 0x85, 0x87, 0x31, 0x00, 0x00, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x35, 0x04, 0x05, + 0x00, 0x3D, 0x05, 0x04, 0x00, 0x1B, 0x06, 0x05, 0x00, 0x3D, 0x05, 0x04, 0x01, 0x1B, 0x07, 0x05, + 0x00, 0x1E, 0x06, 0x02, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x2C, 0x05, 0x01, + 0x00, 0x2C, 0x08, 0x02, 0x00, 0x32, 0x05, 0x08, 0x00, 0x2C, 0x08, 0x03, 0x00, 0x35, 0x05, 0x08, + 0x00, 0x1B, 0x08, 0x05, 0x00, 0x2C, 0x09, 0x04, 0x00, 0x2C, 0x0A, 0x05, 0x00, 0x32, 0x09, 0x0A, + 0x00, 0x2C, 0x0A, 0x03, 0x00, 0x35, 0x09, 0x0A, 0x00, 0x1B, 0x0A, 0x09, 0x00, 0x2C, 0x0B, 0x06, + 0x00, 0x2C, 0x0C, 0x07, 0x00, 0x32, 0x0B, 0x0C, 0x00, 0x2C, 0x0C, 0x03, 0x00, 0x35, 0x0B, 0x0C, + 0x00, 0x1B, 0x0C, 0x0B, 0x00, 0x2C, 0x0E, 0x08, 0x00, 0x31, 0x0E, 0x00, 0x00, 0x35, 0x0E, 0x02, + 0x00, 0x1E, 0x0E, 0x03, 0x00, 0x28, 0x0D, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x00, 0x3A, 0x0F, 0x08, + 0x06, 0x1B, 0x0D, 0x0F, 0x00, 0x1B, 0x0E, 0x0D, 0x00, 0x1E, 0x0D, 0x02, 0x00, 0x03, 0x0E, 0x00, + 0x00, 0x31, 0x06, 0x00, 0x00, 0x35, 0x0F, 0x0A, 0x00, 0x1E, 0x0F, 0x08, 0x00, 0x2C, 0x10, 0x09, + 0x00, 0x2C, 0x11, 0x0A, 0x00, 0x33, 0x10, 0x06, 0x11, 0x2C, 0x11, 0x0B, 0x00, 0x35, 0x10, 0x11, + 0x00, 0x01, 0x10, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x07, 0x00, 0x00, 0x2C, 0x12, 0x0C, + 0x00, 0x35, 0x11, 0x12, 0x00, 0x1E, 0x11, 0x05, 0x00, 0x31, 0x07, 0x00, 0x00, 0x35, 0x12, 0x0C, + 0x00, 0x1B, 0x10, 0x12, 0x00, 0x1C, 0x02, 0x00, 0x00, 0x1B, 0x10, 0x07, 0x00, 0x1B, 0x11, 0x10, + 0x00, 0x1E, 0x11, 0x02, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x2C, 0x10, 0x0D, 0x00, 0x2C, 0x12, 0x0E, + 0x00, 0x33, 0x10, 0x07, 0x12, 0x2C, 0x12, 0x0B, 0x00, 0x35, 0x10, 0x12, 0x00, 0x01, 0x10, 0x00, + 0x00, 0x32, 0x06, 0x01, 0x00, 0x35, 0x10, 0x11, 0x00, 0x1B, 0x12, 0x10, 0x00, 0x3C, 0x08, 0x06, + 0x12, 0x03, 0x12, 0x00, 0x00, 0x8B, 0xDD, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x01, 0x03, 0x00, 0x03, 0x00, 0x14, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x03, 0x01, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, 0x00, 0x0B, + 0x00, 0x03, 0x01, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x03, 0x01, 0x1A, + 0x00, 0x1A, 0x00, 0x1A, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x29, 0x00, 0x12, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x02, 0x09, 0x00, 0x09, 0x00, 0x05, 0x01, 0x0E, 0x00, 0x0E, 0x00, 0x0E, + 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x02, 0x19, 0x00, 0x19, 0x00, 0x19, 0x00, 0x15, + 0x00, 0x2D, 0x00, 0x2D, 0x00, 0x15, 0x00, 0x15, 0x00, 0x15, 0x00, 0x09, 0xBF, 0xFF, 0x07, 0x00, + 0x07, 0x02, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x18, 0x01, 0x12, 0x00, + 0x12, 0x00, 0x09, 0x01, 0x09, 0xBF, 0xFC, 0x07, 0x00, 0x06, 0x00, 0xDA, 0x84, 0xC3, 0x00, 0x06, + 0x01, 0xDA, 0x80, 0xE8, 0x00, 0x06, 0x02, 0xDA, 0x87, 0x52, 0x34, 0x01, 0x00, 0x00, 0x2C, 0x04, + 0x00, 0x00, 0x35, 0x03, 0x04, 0x00, 0x33, 0x00, 0x01, 0x03, 0x2C, 0x04, 0x01, 0x00, 0x36, 0x04, + 0x00, 0x00, 0x8B, 0xF2, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xDA, + 0x08, 0xCE, 0x80, 0xB6, 0x28, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x70, 0x61, 0x74, + 0x68, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x2E, + 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x61, 0x6C, 0x6C, + 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x20, 0x69, 0x6E, + 0x0A, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0x60, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x0A, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, + 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xDA, 0x87, 0xC2, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x81, 0x6B, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xC3, 0xDA, + 0x08, 0xCE, 0x47, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6C, 0x6C, 0x20, 0x66, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, + 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, + 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x60, 0x66, 0x60, 0x2E, 0xDA, 0x87, 0xC4, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x80, 0x93, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xBE, 0xDA, + 0x08, 0xCE, 0x82, 0xD5, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2D, 0x73, 0x69, 0x7A, 0x65, 0x29, 0x0A, 0x0A, 0x4F, 0x70, 0x65, 0x6E, + 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x60, 0x70, 0x61, 0x74, 0x68, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x6F, + 0x72, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x69, 0x6E, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, + 0x65, 0x20, 0x74, 0x6F, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x2E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, 0x20, 0x69, 0x73, + 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, + 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x20, 0x66, 0x6C, 0x61, + 0x67, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x63, + 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x65, 0x64, 0x2C, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x6F, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x68, 0x61, 0x6E, + 0x64, 0x6C, 0x65, 0x2E, 0x20, 0x4D, 0x6F, 0x64, 0x65, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x3A, + 0x0A, 0x0A, 0x2A, 0x20, 0x72, 0x20, 0x2D, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x77, 0x20, 0x2D, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, + 0x20, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x61, 0x20, 0x2D, 0x20, 0x61, 0x70, 0x70, 0x65, + 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x0A, 0x0A, + 0x46, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x20, 0x66, 0x6C, 0x61, + 0x67, 0x73, 0x2C, 0x20, 0x30, 0x20, 0x6F, 0x72, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x6C, 0x61, 0x67, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, + 0x6E, 0x64, 0x65, 0x64, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x62, 0x20, 0x2D, 0x20, 0x6F, 0x70, 0x65, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x69, + 0x6E, 0x61, 0x72, 0x79, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x28, 0x72, 0x61, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x65, + 0x29, 0x0A, 0x0A, 0x2A, 0x20, 0x2B, 0x20, 0x2D, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, + 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x69, + 0x6E, 0x67, 0x20, 0x69, 0x74, 0x0A, 0x0A, 0x2A, 0x20, 0x6E, 0x20, 0x2D, 0x20, 0x65, 0x72, 0x72, + 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x63, + 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x65, 0x64, 0x20, + 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x69, 0x6C, 0x0A, 0x0A, 0x53, 0x65, 0x65, 0x20, 0x66, 0x6F, + 0x70, 0x65, 0x6E, 0x20, 0x28, 0x3C, 0x73, 0x74, 0x64, 0x69, 0x6F, 0x2E, 0x68, 0x3E, 0x2C, 0x20, + 0x43, 0x39, 0x39, 0x29, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x66, 0x75, 0x72, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x87, 0xC5, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x87, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xC6, 0xDA, 0x08, + 0xCE, 0x81, 0x39, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, + 0x63, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x73, 0x74, + 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x65, + 0x20, 0x6F, 0x66, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x60, 0x73, 0x75, 0x62, 0x73, 0x74, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x60, 0x73, 0x75, 0x62, 0x73, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, + 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x70, + 0x61, 0x74, 0x74, 0x60, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x6D, + 0x61, 0x74, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6C, 0x20, 0x72, 0x65, 0x70, 0x6C, + 0x61, 0x63, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x75, 0x73, 0x65, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, + 0x69, 0x66, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x75, + 0x6E, 0x64, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x2E, 0xDA, 0x87, 0xC7, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x25, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xC8, + 0xDA, 0x08, 0xCE, 0x65, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3C, 0x3D, 0x20, 0x26, + 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6C, 0x65, 0x6E, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x60, 0x3C, 0x3D, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x69, + 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x6C, 0x79, 0x6D, 0x6F, 0x72, 0x70, 0x68, 0x69, 0x63, 0x20, 0x60, + 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x60, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, + 0x20, 0x6F, 0x66, 0x20, 0x70, 0x72, 0x69, 0x6D, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, + 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x2E, 0xDA, 0x87, 0xCB, 0xD3, 0x04, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xB5, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xCC, 0xDA, 0x08, 0xCE, + 0x43, 0x28, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x73, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x69, 0x66, 0x2D, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x28, 0x64, 0x6F, 0x20, 0x3B, 0x62, 0x6F, 0x64, 0x79, + 0x29, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x87, 0xA0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x6A, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x9E, 0xDA, 0x08, 0xCE, 0x3A, 0x28, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, + 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x28, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x63, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x29, 0x2E, 0xDA, 0x87, 0xCE, 0xD3, 0x04, 0xDA, 0x81, 0xC9, + 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xDE, 0x01, 0xDA, 0x06, 0xDA, 0x86, 0x07, + 0xDA, 0x08, 0xCE, 0x7E, 0x54, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6C, 0x65, 0x76, 0x65, + 0x6C, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x6C, 0x65, + 0x76, 0x65, 0x6C, 0x20, 0x61, 0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x6F, 0x6D, + 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x65, 0x78, + 0x69, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, + 0x65, 0x2E, 0xDA, 0x87, 0xCF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, 0x56, + 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xD0, 0xDA, 0x08, 0xCE, 0x4E, 0x28, 0x6F, 0x73, 0x2F, 0x72, 0x65, + 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x6C, 0x64, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x6E, 0x61, 0x6D, 0x65, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x64, 0x69, 0x73, 0x6B, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x87, 0xD1, 0xD3, 0x02, 0xDA, 0x06, 0xDA, + 0x55, 0xDA, 0x08, 0xCE, 0x4E, 0x28, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x65, 0x29, 0x0A, 0x0A, + 0x54, 0x68, 0x72, 0x6F, 0x77, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, + 0x75, 0x67, 0x68, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2E, 0xDA, 0x87, 0xD2, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, + 0xAB, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xD3, 0xDA, 0x08, 0xCE, 0x52, 0x28, 0x69, 0x66, 0x2D, 0x6E, + 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, 0x6C, 0x73, 0x65, 0x29, 0x0A, 0x0A, 0x53, 0x68, + 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x28, 0x69, 0x66, + 0x20, 0x28, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x29, + 0x20, 0x65, 0x6C, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, + 0xDA, 0x87, 0xD7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x33, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xD8, 0xDA, 0x08, 0xCE, 0x80, 0xB0, 0x28, 0x78, 0x70, 0x72, 0x69, 0x6E, + 0x20, 0x74, 0x6F, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, + 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6C, 0x69, 0x63, + 0x69, 0x74, 0x6C, 0x79, 0x20, 0x28, 0x6E, 0x6F, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x29, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, + 0x6F, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61, + 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, + 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, + 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x60, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x87, 0xD9, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0xE6, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xDA, 0xDA, 0x08, + 0xCE, 0x54, 0x28, 0x6F, 0x73, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, + 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x6C, 0x69, 0x6E, 0x6B, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x6F, 0x6E, 0x20, 0x57, 0x69, 0x6E, + 0x64, 0x6F, 0x77, 0x73, 0x2E, 0x0A, 0xDA, 0x87, 0xDB, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x3A, 0x84, 0x64, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xDC, 0xDA, 0x08, 0xCE, 0x62, 0x28, 0x65, + 0x76, 0x2F, 0x72, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x20, 0x26, 0x20, 0x63, 0x6C, 0x61, 0x75, + 0x73, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, + 0x20, 0x65, 0x76, 0x2F, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x72, 0x79, 0x20, 0x63, 0x6C, 0x61, 0x75, 0x73, 0x65, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x6F, 0x72, 0x64, + 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x66, 0x61, 0x69, 0x72, 0x6E, 0x65, 0x73, 0x73, 0x2E, + 0xDA, 0x87, 0xDD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x0D, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xDE, 0xDA, 0x08, 0xCE, 0x26, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, + 0x6F, 0x73, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6F, 0x73, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, + 0x87, 0xDF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x7A, 0x01, 0xDA, 0x06, + 0xDA, 0x87, 0xE0, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x74, 0x65, 0x6D, + 0x70, 0x29, 0x0A, 0x0A, 0x4F, 0x70, 0x65, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x6E, 0x6F, 0x6E, + 0x79, 0x6D, 0x6F, 0x75, 0x73, 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x72, 0x79, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x6D, + 0x6F, 0x76, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x2E, 0x20, 0x52, + 0x61, 0x69, 0x73, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, + 0x6E, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x87, 0xE1, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x83, 0x09, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xE2, 0xDA, 0x08, + 0xCE, 0x84, 0xA3, 0x28, 0x73, 0x61, 0x6E, 0x64, 0x62, 0x6F, 0x78, 0x20, 0x26, 0x20, 0x66, 0x6F, + 0x72, 0x62, 0x69, 0x64, 0x64, 0x65, 0x6E, 0x2D, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6C, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, + 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x73, 0x65, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x70, + 0x72, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x70, 0x72, 0x65, 0x74, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x75, 0x73, 0x69, 0x6E, + 0x67, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x20, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2E, 0x20, 0x4F, 0x6E, 0x63, 0x65, + 0x20, 0x61, 0x20, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x64, 0x69, + 0x73, 0x61, 0x62, 0x6C, 0x65, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x6F, 0x20, 0x77, 0x61, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x2D, 0x65, 0x6E, + 0x61, 0x62, 0x6C, 0x65, 0x20, 0x69, 0x74, 0x2E, 0x20, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6C, + 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x3A, 0x0A, 0x0A, 0x2A, + 0x20, 0x3A, 0x61, 0x6C, 0x6C, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, + 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x28, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x49, 0x4F, 0x20, + 0x74, 0x6F, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x2C, 0x20, 0x73, 0x74, 0x64, 0x65, 0x72, + 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x29, 0x0A, 0x2A, 0x20, + 0x3A, 0x65, 0x6E, 0x76, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, + 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x0A, + 0x2A, 0x20, 0x3A, 0x66, 0x66, 0x69, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, + 0x77, 0x20, 0x46, 0x46, 0x49, 0x20, 0x28, 0x72, 0x65, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x64, + 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6C, 0x69, 0x6E, 0x67, 0x20, + 0x61, 0x6E, 0x79, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x73, 0x65, 0x29, 0x0A, 0x2A, + 0x20, 0x3A, 0x66, 0x66, 0x69, 0x2D, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x2D, 0x20, 0x64, + 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x46, 0x46, 0x49, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, 0x77, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x66, 0x69, + 0x2D, 0x6A, 0x69, 0x74, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x66, 0x66, 0x69, 0x2F, 0x6A, 0x69, 0x74, + 0x66, 0x6E, 0x60, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x66, 0x69, 0x2D, 0x75, 0x73, 0x65, 0x20, 0x2D, + 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, + 0x61, 0x6E, 0x79, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, 0x73, 0x6C, 0x79, 0x20, 0x62, + 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x46, 0x46, 0x49, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2D, 0x75, 0x6E, + 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x0A, + 0x2A, 0x20, 0x3A, 0x66, 0x73, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, + 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x73, + 0x2D, 0x72, 0x65, 0x61, 0x64, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, + 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6F, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x0A, + 0x2A, 0x20, 0x3A, 0x66, 0x73, 0x2D, 0x74, 0x65, 0x6D, 0x70, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, + 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x72, 0x79, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x0A, 0x2A, + 0x20, 0x3A, 0x66, 0x73, 0x2D, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6D, 0x0A, 0x2A, 0x20, 0x3A, 0x68, 0x72, 0x74, 0x69, 0x6D, 0x65, 0x20, + 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x68, 0x69, 0x67, 0x68, 0x2D, + 0x72, 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x72, + 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x2D, 0x20, 0x64, + 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x64, 0x79, 0x6E, + 0x61, 0x6D, 0x69, 0x63, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x28, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x73, 0x29, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x65, 0x74, 0x20, 0x2D, 0x20, + 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, + 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x65, 0x74, 0x2D, 0x63, + 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, + 0x77, 0x20, 0x6D, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x75, 0x74, 0x62, 0x6F, 0x75, 0x6E, + 0x64, 0x20, 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x65, 0x74, 0x2D, 0x6C, 0x69, 0x73, + 0x74, 0x65, 0x6E, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x62, 0x6F, 0x75, 0x6E, 0x64, + 0x20, 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x61, 0x6E, 0x64, 0x62, 0x6F, 0x78, 0x20, + 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, + 0x6E, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, 0x64, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x20, + 0x72, 0x65, 0x6D, 0x6F, 0x76, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, + 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x75, 0x62, 0x70, + 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x2D, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6C, 0x6C, 0x6F, + 0x77, 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, + 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0xDA, 0x87, 0xE3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x80, 0x82, 0x80, 0xF0, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xE4, 0xDA, 0x08, 0xCE, 0x80, 0x90, + 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x29, 0x0A, 0x0A, + 0x46, 0x69, 0x6C, 0x6C, 0x20, 0x75, 0x70, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2C, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6C, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x30, 0x73, 0x2E, 0x20, 0x44, + 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x27, 0x73, 0x20, 0x6C, 0x65, 0x6E, 0x67, + 0x74, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, + 0xDA, 0x87, 0xE5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x80, 0xC6, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xE6, 0xDA, 0x08, 0xCE, 0x80, 0x85, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, + 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x2C, 0x20, + 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x65, 0x6E, 0x6F, 0x75, 0x67, 0x68, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, 0x6E, 0x67, + 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x63, 0x61, 0x70, + 0x61, 0x63, 0x69, 0x74, 0x79, 0x60, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x30, 0x2E, 0xDA, + 0x81, 0x13, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0x7B, 0x01, 0xDA, 0x06, + 0xDA, 0x81, 0x0F, 0xDA, 0x08, 0xCE, 0x80, 0x99, 0x28, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, + 0x74, 0x3D, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x6E, + 0x6F, 0x74, 0x3D, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2C, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, + 0x29, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, + 0x0A, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x20, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x4D, 0x75, 0x63, 0x68, 0x20, 0x73, 0x6C, + 0x6F, 0x77, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x60, 0x6E, 0x6F, 0x74, 0x3D, 0x60, + 0x2E, 0xCF, 0x0E, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x69, 0x6E, 0x74, 0x33, 0x32, 0x2D, 0x6D, 0x69, + 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x9C, 0x01, 0xDA, 0x06, + 0xCD, 0x80, 0x00, 0x00, 0x00, 0xDA, 0x08, 0xCE, 0x47, 0x54, 0x68, 0x65, 0x20, 0x6D, 0x69, 0x6E, + 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, 0x20, + 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x33, 0x32, 0x20, 0x62, 0x69, + 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0xDA, 0x87, 0xE7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x80, 0xF5, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xE8, 0xDA, 0x08, 0xCE, 0x6E, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, + 0x65, 0x65, 0x64, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x73, 0x65, 0x65, 0x64, 0x29, 0x0A, + 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x65, 0x64, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x2E, 0x20, 0x60, + 0x73, 0x65, 0x65, 0x64, 0x60, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x87, 0xE9, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x84, 0x5D, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xEA, 0xDA, 0x08, 0xCE, 0x44, 0x28, + 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, + 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, + 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x28, 0x63, 0x6F, 0x6D, 0x70, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 0x29, 0x20, 0x69, 0x6E, 0x64, + 0x29, 0x60, 0x2E, 0xDA, 0x87, 0xF6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, + 0x2F, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xF7, 0xDA, 0x08, 0xCE, 0x65, 0x28, 0x63, 0x6F, 0x6D, 0x70, + 0x61, 0x72, 0x65, 0x3E, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x71, 0x75, + 0x69, 0x76, 0x61, 0x6C, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x3E, 0x3D, 0x60, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x6C, 0x79, 0x6D, 0x6F, + 0x72, 0x70, 0x68, 0x69, 0x63, 0x20, 0x60, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x60, 0x20, + 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x72, 0x69, 0x6D, 0x69, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x2E, + 0xDA, 0x87, 0xFA, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x83, 0x35, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xFB, 0xDA, 0x08, 0xCE, 0x18, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, + 0x6E, 0x64, 0x61, 0x72, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x66, 0x69, 0x6C, 0x65, + 0x2E, 0xDA, 0x87, 0xFC, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x87, 0xFD, 0xDA, 0x08, 0xCE, 0x45, 0x28, + 0x3C, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, + 0x64, 0x65, 0x73, 0x63, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, + 0x65, 0x61, 0x6E, 0x2E, 0xDA, 0x87, 0xFF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, + 0x8C, 0x2F, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x00, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x65, 0x76, 0x2F, + 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x72, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x72, 0x77, + 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x41, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x20, + 0x72, 0x65, 0x61, 0x64, 0x2D, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x2E, + 0xDA, 0x88, 0x01, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0xC9, 0x01, 0xDA, + 0x06, 0xDA, 0x87, 0xBC, 0xDA, 0x08, 0xCE, 0x80, 0x8B, 0x41, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x20, 0x6F, 0x66, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x65, 0x74, 0x68, + 0x6F, 0x64, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x6F, 0x61, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x0A, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x74, 0x73, 0x20, 0x60, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x69, 0x6D, + 0x70, 0x6F, 0x72, 0x74, 0x60, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x6D, 0x61, 0x6E, 0x79, 0x20, + 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6B, 0x69, 0x6E, 0x64, 0x73, 0x0A, + 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x73, 0x20, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x73, 0x2E, 0xDA, 0x88, 0x02, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, + 0x8B, 0x38, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x03, 0xDA, 0x08, 0xCE, 0x82, 0xFA, 0x28, 0x65, 0x76, + 0x2F, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x6D, 0x61, 0x69, 0x6E, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x73, 0x75, + 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x60, + 0x6D, 0x61, 0x69, 0x6E, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x6F, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, + 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2C, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x6C, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, + 0x20, 0x60, 0x6D, 0x61, 0x69, 0x6E, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x65, 0x69, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x6F, + 0x72, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x73, 0x20, 0x30, 0x20, 0x6F, 0x72, 0x20, 0x31, + 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x20, 0x55, 0x6E, 0x6C, 0x69, + 0x6B, 0x65, 0x20, 0x60, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0x60, 0x2C, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, + 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6D, + 0x70, 0x6C, 0x65, 0x74, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x79, 0x6F, 0x75, 0x20, 0x77, 0x61, + 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x77, 0x61, 0x69, + 0x74, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, + 0x74, 0x2C, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x3A, 0x6E, 0x60, + 0x20, 0x66, 0x6C, 0x61, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6C, 0x79, 0x2E, + 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x41, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, + 0x6C, 0x65, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x6E, + 0x60, 0x20, 0x2D, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, + 0x69, 0x61, 0x74, 0x65, 0x6C, 0x79, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x74, 0x60, 0x20, 0x2D, 0x20, + 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6B, 0x2D, 0x69, 0x64, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0x20, 0x74, 0x6F, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6B, 0x2D, 0x69, 0x64, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x20, + 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x2E, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x61, 0x60, 0x20, + 0x2D, 0x20, 0x64, 0x6F, 0x6E, 0x27, 0x74, 0x20, 0x63, 0x6F, 0x70, 0x79, 0x20, 0x61, 0x62, 0x73, + 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x20, 0x74, + 0x6F, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x28, 0x70, 0x65, + 0x72, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6D, 0x69, + 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x29, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x63, 0x60, 0x20, 0x2D, + 0x20, 0x64, 0x6F, 0x6E, 0x27, 0x74, 0x20, 0x63, 0x6F, 0x70, 0x79, 0x20, 0x63, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x20, 0x74, + 0x6F, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x28, 0x70, 0x65, + 0x72, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6D, 0x69, + 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x29, 0xDA, 0x88, 0x04, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, + 0x05, 0xDA, 0x08, 0xCE, 0x80, 0xD1, 0x28, 0x64, 0x69, 0x76, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6C, + 0x6F, 0x6F, 0x72, 0x65, 0x64, 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6F, + 0x66, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, + 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x31, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x72, 0x6F, 0x63, 0x61, 0x6C, 0x20, 0x6F, + 0x66, 0x20, 0x78, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x73, 0x20, 0x72, 0x65, 0x70, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x6C, 0x79, 0x20, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0xDA, 0x88, 0x07, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0x94, 0x82, 0x92, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xF7, 0xDA, 0x08, 0xCE, 0x4E, + 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x61, 0x6E, 0x2D, 0x72, 0x65, 0x73, 0x75, 0x6D, + 0x65, 0x3F, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x6E, 0x6E, + 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x64, 0x2E, 0xDA, 0x85, + 0xD3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0xBE, 0x01, 0xDA, 0x06, 0xDA, + 0x85, 0x96, 0xDA, 0x08, 0xCE, 0x85, 0x6A, 0x28, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x78, 0x74, 0x20, 0x6F, 0x70, 0x74, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x61, + 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x65, + 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, + 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x0A, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x63, 0x61, + 0x70, 0x73, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x28, 0x69, 0x6E, 0x20, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x3A, 0x65, 0x78, 0x69, + 0x74, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, + 0x65, 0x6E, 0x74, 0x29, 0x60, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, + 0x65, 0x74, 0x65, 0x2E, 0x0A, 0x60, 0x6F, 0x70, 0x74, 0x73, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x73, 0x20, + 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x73, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, + 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, + 0x61, 0x63, 0x6B, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0x0A, 0x0A, + 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x6F, 0x6E, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, + 0x6B, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x61, 0x69, 0x6C, 0x73, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x62, 0x61, 0x64, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x0A, 0x0A, 0x20, 0x20, 0x2A, + 0x20, 0x60, 0x3A, 0x65, 0x6E, 0x76, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, + 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x74, 0x20, 0x2D, 0x20, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, + 0x60, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x65, 0x74, + 0x74, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x28, 0x75, 0x73, 0x65, 0x20, + 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6E, 0x6F, 0x6E, + 0x2D, 0x70, 0x61, 0x74, 0x68, 0x73, 0x29, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x69, 0x73, 0x20, 0x3A, 0x3C, 0x61, 0x6E, 0x6F, 0x6E, 0x79, + 0x6D, 0x6F, 0x75, 0x73, 0x3E, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x6F, 0x6E, 0x2D, + 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x60, 0x20, 0x2D, + 0x2D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, 0x6B, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, + 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x61, 0x69, 0x6C, + 0x73, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x62, + 0x61, 0x64, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, + 0x60, 0x3A, 0x6F, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x77, 0x61, 0x72, + 0x6E, 0x69, 0x6E, 0x67, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, + 0x6B, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, + 0x65, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x6F, 0x72, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, 0x6B, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x75, 0x6E, 0x6B, 0x73, 0x2E, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x28, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x74, 0x68, + 0x75, 0x6E, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x65, + 0x6E, 0x76, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, + 0x3A, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x63, + 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, 0x6B, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2E, + 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2D, 0x66, 0x6C, + 0x61, 0x67, 0x73, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x77, 0x68, 0x61, 0x74, 0x20, 0x66, 0x6C, 0x61, + 0x67, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x72, 0x61, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x2E, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x3A, 0x69, 0x61, 0x2E, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x65, 0x78, + 0x70, 0x61, 0x6E, 0x64, 0x65, 0x72, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x6F, + 0x6E, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x74, 0x6F, 0x70, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x2E, + 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x60, 0x20, + 0x2D, 0x2D, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x63, 0x75, 0x73, + 0x74, 0x6F, 0x6D, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x61, 0x6D, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x61, 0x73, + 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x27, 0x73, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x62, 0x75, 0x69, + 0x6C, 0x74, 0x2D, 0x69, 0x6E, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0x0A, 0x0A, 0x20, + 0x20, 0x2A, 0x20, 0x60, 0x3A, 0x72, 0x65, 0x61, 0x64, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x6F, 0x70, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x6F, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x2C, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x6C, 0x69, 0x6B, + 0x65, 0x20, 0x60, 0x28, 0x72, 0x65, 0x61, 0x64, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x29, 0x60, 0x2E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x4F, 0x76, 0x65, 0x72, 0x72, + 0x69, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, + 0x2E, 0xDA, 0x88, 0x08, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8F, 0x10, 0x03, + 0xDA, 0x06, 0xDA, 0x88, 0x09, 0xDA, 0x08, 0xCE, 0x62, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x64, 0x65, + 0x66, 0x62, 0x69, 0x6E, 0x64, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x72, 0x65, 0x74, 0x2D, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x6E, + 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x69, + 0x65, 0x6E, 0x74, 0x20, 0x6D, 0x61, 0x6E, 0x6E, 0x65, 0x72, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x88, + 0x2F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x82, 0x64, 0x01, 0xDA, 0x06, 0xDA, + 0x88, 0x30, 0xDA, 0x08, 0xCE, 0x81, 0xCF, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x68, 0x75, 0x74, + 0x64, 0x6F, 0x77, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x29, 0x0A, 0x0A, 0x53, 0x74, 0x6F, 0x70, 0x20, 0x63, 0x6F, 0x6D, + 0x6D, 0x75, 0x6E, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x67, + 0x72, 0x61, 0x63, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x6D, 0x61, 0x6E, 0x6E, 0x65, 0x72, 0x2C, 0x20, + 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x6F, 0x74, 0x68, 0x20, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x6A, 0x75, 0x73, + 0x74, 0x20, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, + 0x6D, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, 0x20, 0x70, 0x61, + 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x73, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x75, 0x6E, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x6F, 0x70, 0x20, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0x20, 0x0A, 0x0A, 0x2A, 0x20, + 0x60, 0x3A, 0x77, 0x72, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6C, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x62, 0x6F, 0x74, 0x68, 0x20, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6E, + 0x65, 0x77, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x72, 0x69, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6F, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0x0A, 0x2A, 0x20, 0x60, 0x3A, + 0x72, 0x60, 0x20, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0x0A, 0x2A, 0x20, + 0x60, 0x3A, 0x77, 0x60, 0x20, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, 0x73, + 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0xDA, 0x88, 0x31, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x80, 0xA7, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x32, 0xDA, 0x08, 0xCE, 0x2D, 0x28, 0x63, + 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x26, 0x29, 0x0A, 0x0A, 0x49, 0x67, 0x6E, 0x6F, 0x72, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x37, 0xCB, 0xCF, 0x11, + 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x6F, 0x6E, 0x66, 0x69, 0x67, 0x2D, 0x62, 0x69, 0x74, + 0x73, 0xD3, 0x02, 0xDA, 0x06, 0x01, 0xDA, 0x08, 0xCE, 0x7E, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6C, + 0x61, 0x67, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x6F, 0x6E, 0x66, 0x69, 0x67, + 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x6A, 0x61, + 0x6E, 0x65, 0x74, 0x63, 0x6F, 0x6E, 0x66, 0x2E, 0x68, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, + 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6C, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, + 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0xDA, 0x88, 0x34, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x82, 0x6D, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x35, 0xDA, 0x08, 0xCE, 0x7D, + 0x28, 0x74, 0x61, 0x62, 0x73, 0x65, 0x71, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, 0x6B, 0x65, 0x79, + 0x2D, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x26, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2D, 0x62, 0x6F, + 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, + 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x63, 0x63, 0x75, + 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x0A, 0x53, 0x65, 0x65, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x37, 0xCB, + 0xDA, 0x88, 0x3B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, 0x77, 0x80, 0xF5, 0x01, + 0xDA, 0x06, 0xDA, 0x84, 0xDA, 0xDA, 0x08, 0xCE, 0x80, 0xD3, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x66, 0x75, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x70, 0x63, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, + 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, + 0x6E, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x70, 0x63, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x6F, 0x66, + 0x66, 0x73, 0x65, 0x74, 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x66, 0x75, 0x6E, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x66, 0x66, + 0x73, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x6F, 0x6F, 0x20, 0x6C, 0x61, 0x72, 0x67, 0x65, + 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2E, 0xDA, 0x88, 0x3C, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x52, 0x01, 0xDA, 0x06, 0xDA, + 0x87, 0x9B, 0xDA, 0x08, 0xCE, 0x42, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x68, 0x61, + 0x73, 0x2D, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x3F, 0x20, 0x73, 0x66, 0x78, 0x20, 0x73, 0x74, + 0x72, 0x29, 0x0A, 0x0A, 0x54, 0x65, 0x73, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x65, 0x6E, 0x64, 0x73, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x60, 0x73, 0x66, 0x78, 0x60, 0x2E, 0xDA, 0x88, 0x3D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x85, 0x92, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x3E, 0xDA, 0x08, 0xCE, 0x80, + 0x90, 0x28, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x76, 0x61, 0x72, 0x73, 0x20, 0x76, 0x61, 0x72, 0x73, + 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x65, 0x61, 0x63, 0x68, 0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x76, 0x61, 0x72, + 0x73, 0x60, 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6F, 0x72, 0x61, 0x72, 0x69, 0x6C, 0x79, 0x20, 0x62, + 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x74, 0x6F, 0x0A, 0x60, 0x6C, 0x65, 0x74, 0x60, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x72, + 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x88, 0x55, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x84, 0x66, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x56, 0xDA, 0x08, 0xCE, 0x80, 0xCE, 0x28, 0x74, 0x61, + 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, + 0x64, 0x29, 0x0A, 0x0A, 0x47, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x2C, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x6F, 0x6E, 0x6C, 0x79, + 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x2C, + 0x20, 0x6F, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x0A, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, + 0x62, 0x6F, 0x72, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x61, + 0x69, 0x6C, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x72, 0x65, + 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0xDA, 0x88, 0x58, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x87, 0x1B, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x59, 0xDA, + 0x08, 0xCE, 0x85, 0x18, 0x28, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x78, 0x20, 0x26, 0x20, 0x63, + 0x61, 0x73, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x6D, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x4D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, + 0x6E, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x78, 0x60, + 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x74, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x2E, 0x0A, 0x45, 0x61, + 0x63, 0x68, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, + 0x74, 0x65, 0x72, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x67, + 0x61, 0x69, 0x6E, 0x73, 0x74, 0x2C, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x74, 0x6F, 0x0A, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6F, 0x20, + 0x69, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x2E, 0x20, 0x20, 0x4C, 0x65, 0x67, 0x61, 0x6C, 0x20, + 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x3A, 0x0A, 0x0A, 0x2A, + 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x2D, 0x2D, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, + 0x74, 0x65, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, + 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, + 0x20, 0x61, 0x6E, 0x79, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x20, 0x60, 0x78, 0x60, 0x27, 0x73, 0x0A, 0x20, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, + 0x0A, 0x0A, 0x2A, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x72, 0x61, + 0x63, 0x6B, 0x65, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x2D, 0x2D, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, + 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, 0x74, + 0x63, 0x68, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x69, 0x66, 0x0A, 0x20, 0x20, 0x61, 0x6C, 0x6C, + 0x20, 0x6F, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, + 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x72, 0x72, 0x65, + 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x78, 0x60, 0x2E, 0x0A, 0x20, 0x20, 0x55, 0x73, 0x65, 0x20, + 0x60, 0x26, 0x20, 0x72, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x6F, 0x72, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x65, 0x64, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x72, + 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, + 0x74, 0x6F, 0x20, 0x60, 0x72, 0x65, 0x73, 0x74, 0x60, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x2D, 0x2D, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x69, 0x66, + 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x6D, 0x61, 0x74, 0x63, + 0x68, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0A, 0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x72, + 0x72, 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x78, 0x60, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x20, 0x2D, 0x2D, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, + 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x20, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, + 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x74, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, + 0x75, 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x5F, 0x60, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, + 0x6C, 0x20, 0x2D, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x61, 0x6C, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x60, 0x5F, 0x60, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2C, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x77, 0x69, 0x6C, 0x64, 0x63, 0x61, 0x72, + 0x64, 0x0A, 0x20, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, + 0x74, 0x63, 0x68, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x0A, 0x0A, 0x57, 0x68, 0x69, 0x6C, 0x65, + 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, + 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x61, 0x72, 0x69, 0x6C, + 0x79, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x60, + 0x28, 0x40, 0x20, 0x3C, 0x73, 0x79, 0x6D, 0x3E, 0x29, 0x60, 0x2C, 0x0A, 0x77, 0x68, 0x65, 0x72, + 0x65, 0x20, 0x3C, 0x73, 0x79, 0x6D, 0x3E, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x73, + 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x74, 0x74, 0x65, + 0x6D, 0x70, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x60, 0x78, 0x60, + 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x74, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x0A, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x60, 0x3C, 0x73, 0x79, 0x6D, 0x3E, 0x60, 0x2C, 0x20, 0x72, 0x61, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x74, + 0x2E, 0x0A, 0x0A, 0x41, 0x6E, 0x79, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x78, 0x60, + 0x2E, 0x0A, 0x51, 0x75, 0x6F, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x27, 0x60, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x74, 0x72, 0x65, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x74, + 0x63, 0x68, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x74, 0x2E, 0x0A, 0xDA, 0x37, 0xCB, 0xDA, + 0x81, 0x1E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0xBC, 0x01, 0xDA, 0x06, + 0xDA, 0x80, 0x91, 0xDA, 0x08, 0xCE, 0x81, 0x61, 0x28, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x20, 0x78, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6F, 0x6E, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x29, 0x0A, 0x0A, 0x45, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x6C, 0x79, 0x2E, 0x0A, 0x60, 0x6F, 0x6E, + 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, + 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, + 0x6B, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x65, 0x76, 0x65, 0x72, 0x20, 0x61, + 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x69, 0x63, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x0A, 0x69, 0x73, 0x20, 0x65, 0x6E, 0x63, 0x6F, + 0x75, 0x6E, 0x74, 0x65, 0x72, 0x65, 0x64, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6C, + 0x6C, 0x6F, 0x77, 0x73, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x65, + 0x61, 0x73, 0x69, 0x6C, 0x79, 0x20, 0x73, 0x65, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x69, 0x72, 0x0A, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x62, + 0x79, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x6D, 0x61, 0x63, 0x65, 0x78, + 0x60, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x69, 0x74, 0x73, 0x65, 0x6C, 0x66, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x0A, + 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x60, 0x6F, 0x6E, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x60, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, + 0x65, 0x64, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0xDA, 0x84, 0x9A, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x58, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x96, 0xDA, 0x08, 0xCE, + 0x80, 0xB8, 0x28, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x0A, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x68, 0x65, 0x72, 0x69, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2C, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x6E, 0x65, 0x77, 0x0A, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x6F, 0x6C, 0x6C, 0x75, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, + 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x88, 0xDC, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0xDE, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0xDD, 0xDA, 0x08, + 0xCE, 0x80, 0xEC, 0x28, 0x65, 0x76, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6D, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, + 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, 0x0A, 0x57, 0x72, 0x69, 0x74, 0x65, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2C, 0x20, + 0x73, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, + 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x63, 0x6F, 0x6D, + 0x70, 0x6C, 0x65, 0x74, 0x65, 0x73, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, + 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, + 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0xDA, + 0x88, 0xDE, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0xDF, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x3E, 0x3D, + 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, + 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x61, 0x73, + 0x63, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, + 0x2E, 0xDA, 0x88, 0xE1, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0x7B, 0x01, + 0xDA, 0x06, 0xDA, 0x88, 0xE2, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x64, 0x6F, 0x63, 0x2A, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, + 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, + 0x72, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x64, 0x6F, 0x63, 0x60, 0x2E, 0xDA, 0x89, 0x1F, 0xD3, + 0x02, 0xDA, 0x06, 0xDA, 0x89, 0x20, 0xDA, 0x08, 0xCE, 0x59, 0x28, 0x62, 0x6F, 0x72, 0x20, 0x26, + 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x69, 0x74, 0x2D, 0x77, 0x69, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x66, + 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x78, + 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x78, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, 0x20, + 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, + 0x65, 0x72, 0x2E, 0xDA, 0x89, 0x22, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, + 0xEA, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x23, 0xDA, 0x08, 0xCE, 0x6B, 0x28, 0x74, 0x72, 0x61, 0x63, + 0x65, 0x76, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, + 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x74, 0x6F, 0x20, 0x78, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x30, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x80, 0xBB, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x31, 0xDA, 0x08, + 0xCE, 0x80, 0xB8, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x72, 0x6E, 0x67, 0x20, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, + 0x75, 0x66, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x6E, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, + 0x6D, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x75, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x6D, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2E, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, + 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, + 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x89, 0x32, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0xD0, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xF5, 0xDA, + 0x08, 0xCE, 0x80, 0xD1, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x26, 0x20, 0x6B, 0x76, 0x73, + 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x76, 0x61, + 0x72, 0x69, 0x61, 0x64, 0x69, 0x63, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, + 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x2E, 0x20, 0x6B, 0x76, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6E, 0x63, 0x65, 0x20, 0x6B, 0x31, 0x2C, 0x20, 0x76, 0x31, 0x2C, 0x20, 0x6B, 0x32, 0x2C, 0x20, + 0x76, 0x32, 0x2C, 0x20, 0x6B, 0x33, 0x2C, 0x20, 0x76, 0x33, 0x2C, 0x20, 0x2E, 0x2E, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x6B, 0x76, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x64, + 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x6E, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x89, 0x33, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x64, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x34, 0xDA, 0x08, 0xCE, 0x24, 0x28, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, + 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, + 0xDA, 0x89, 0x37, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x1E, 0x01, 0xDA, + 0x06, 0xDA, 0x89, 0x38, 0xDA, 0x08, 0xCE, 0x80, 0xDC, 0x28, 0x2D, 0x3E, 0x3E, 0x20, 0x78, 0x20, + 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x49, 0x6E, 0x73, 0x65, 0x72, + 0x74, 0x73, 0x20, 0x78, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, + 0x6D, 0x73, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x6D, 0x61, 0x6E, 0x6E, 0x65, 0x72, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x6F, 0x20, 0x6F, 0x6E, 0x2E, 0x20, 0x55, 0x73, 0x65, + 0x66, 0x75, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6E, 0x67, 0x20, 0x70, 0x69, 0x70, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x3A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0x57, 0x84, 0xFC, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x3B, 0xDA, 0x08, 0xCE, + 0x80, 0xD1, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0x20, + 0x70, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, + 0x65, 0x70, 0x20, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x64, 0x65, + 0x6E, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, + 0x70, 0x75, 0x74, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0x64, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x63, + 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, + 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x67, 0x6F, 0x6F, 0x64, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x69, 0x66, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, + 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2E, 0xDA, 0x89, 0x3C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, + 0xA4, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x3D, 0xDA, 0x08, 0xCE, 0x80, 0x89, 0x28, 0x65, 0x76, 0x2F, + 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, + 0x29, 0x0A, 0x0A, 0x43, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x20, 0x61, 0x20, 0x73, 0x75, 0x73, 0x70, + 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2E, 0x20, 0x44, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x63, 0x61, 0x6E, 0x63, + 0x65, 0x6C, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, + 0x65, 0x64, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, + 0x74, 0x65, 0x6C, 0x79, 0x2E, 0xCF, 0x0C, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x69, 0x6E, 0x74, 0x2D, + 0x6D, 0x69, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0xA0, 0x01, + 0xDA, 0x06, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC3, 0xDA, 0x08, 0xCE, 0x3F, 0x54, + 0x68, 0x65, 0x20, 0x6D, 0x69, 0x6E, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x69, + 0x67, 0x75, 0x6F, 0x75, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x20, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x20, 0x28, 0x32, 0x5E, 0x35, 0x33, 0x29, 0xDA, 0x21, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0x30, 0x01, 0xDA, 0x06, 0xDA, 0x1C, + 0xDA, 0x08, 0xCE, 0x80, 0xBB, 0x28, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2D, 0x6F, 0x66, 0x20, 0x78, + 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x29, 0x0A, + 0x0A, 0x46, 0x69, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x6B, 0x65, 0x79, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x20, 0x69, 0x6E, + 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x2C, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x2E, + 0x0A, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x20, 0x61, + 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x64, 0x66, 0x6C, + 0x74, 0x60, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, + 0xDA, 0x89, 0x3E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x5F, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0x3F, 0xDA, 0x08, 0xCE, 0x80, 0xA4, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2F, 0x77, 0x65, 0x61, 0x6B, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x63, 0x61, 0x70, + 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6B, 0x65, 0x79, 0x73, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x65, 0x61, 0x6B, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, + 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2F, 0x6E, 0x65, 0x77, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x89, + 0x40, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x7A, 0x01, 0xDA, 0x06, 0xDA, + 0x89, 0x41, 0xDA, 0x08, 0xCE, 0x80, 0xE0, 0x28, 0x61, 0x73, 0x3F, 0x2D, 0x3E, 0x20, 0x78, 0x20, + 0x61, 0x73, 0x20, 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x72, + 0x65, 0x61, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x2C, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x61, + 0x73, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x60, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x0A, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x66, 0x6F, 0x72, + 0x6D, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, + 0x6D, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, + 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x0A, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6D, 0x65, + 0x64, 0x69, 0x61, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x6E, 0x69, 0x6C, 0x3B, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x6C, 0x61, 0x73, 0x74, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x4C, 0xD3, 0x04, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xB4, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x4D, 0xDA, 0x08, + 0xCE, 0x77, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x66, 0x20, 0x63, 0x6E, 0x64, 0x20, 0x74, 0x72, + 0x75, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, + 0x65, 0x63, 0x6B, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x60, 0x63, 0x6E, 0x64, 0x60, 0x20, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, + 0x6C, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x2D, 0x2D, 0x20, 0x69, 0x66, 0x20, 0x74, 0x72, + 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x60, 0x74, + 0x72, 0x75, 0x60, 0x2C, 0x20, 0x65, 0x6C, 0x73, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, + 0x65, 0x20, 0x60, 0x66, 0x61, 0x6C, 0x73, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x51, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xBB, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x52, + 0xDA, 0x08, 0xCE, 0x7B, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6E, + 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, + 0x63, 0x6E, 0x64, 0x60, 0x20, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, + 0x74, 0x69, 0x6D, 0x65, 0x20, 0x2D, 0x2D, 0x20, 0x69, 0x66, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, + 0x79, 0x2C, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x60, 0x28, 0x75, 0x70, 0x73, + 0x63, 0x6F, 0x70, 0x65, 0x20, 0x3B, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x60, 0x2C, 0x20, 0x65, 0x6C, + 0x73, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, + 0x37, 0xCB, 0xDA, 0x89, 0x54, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, + 0xC4, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x55, 0xDA, 0x08, 0xCE, 0x52, 0x28, 0x6B, 0x65, 0x79, 0x77, + 0x6F, 0x72, 0x64, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x29, 0x0A, + 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, + 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2E, 0xDA, 0x89, 0x56, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x81, 0x37, 0x01, 0xDA, 0x06, 0xDA, + 0x84, 0xC2, 0xDA, 0x08, 0xCE, 0x80, 0xAC, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, + 0x73, 0x65, 0x20, 0x66, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x61, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, + 0x61, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x6F, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x2E, 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x79, 0x6F, 0x75, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x64, 0x6F, 0x6E, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x69, + 0x74, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x20, 0x72, + 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6C, 0x65, 0x61, 0x6B, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x6C, 0x65, 0x74, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, + 0x73, 0x73, 0x65, 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x2E, 0xDA, 0x89, 0x57, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, + 0x95, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x58, 0xDA, 0x08, 0xCE, 0x80, 0xF7, 0x28, 0x6F, 0x73, 0x2F, + 0x6D, 0x6B, 0x64, 0x69, 0x72, 0x20, 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, + 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x69, 0x66, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x69, + 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x77, 0x61, 0x73, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x61, 0x6C, + 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, + 0x73, 0x65, 0x2E, 0xDA, 0x89, 0x59, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, + 0x2B, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x5A, 0xDA, 0x08, 0xCE, 0x81, 0x2A, 0x28, 0x2D, 0x3F, 0x3E, + 0x20, 0x78, 0x20, 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, + 0x72, 0x74, 0x20, 0x63, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, + 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x49, 0x6E, 0x73, 0x65, + 0x72, 0x74, 0x73, 0x20, 0x78, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x6F, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x0A, 0x69, 0x6E, 0x20, 0x60, + 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x6E, 0x73, 0x65, + 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x0A, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x6D, 0x61, 0x6E, + 0x6E, 0x65, 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x6F, 0x20, 0x6F, 0x6E, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x70, 0x69, 0x70, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x0A, 0x69, 0x66, 0x20, + 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6D, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x0A, 0x55, 0x73, + 0x65, 0x66, 0x75, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x69, 0x6E, 0x67, 0x20, 0x70, 0x69, 0x70, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x6F, 0x66, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x5C, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0x38, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xBA, 0xDA, 0x08, 0xCE, + 0x5A, 0x41, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, + 0x67, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, 0x6C, 0x6F, 0x61, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, + 0x76, 0x65, 0x6E, 0x74, 0x0A, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x64, 0x65, + 0x70, 0x65, 0x6E, 0x64, 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0x2E, 0xDA, 0x89, 0x5D, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x2B, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x5E, 0xDA, + 0x08, 0xCE, 0x69, 0x28, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x73, 0x20, 0x73, 0x79, + 0x6D, 0x73, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x69, 0x6E, + 0x20, 0x60, 0x73, 0x79, 0x6D, 0x73, 0x60, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x61, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x75, 0x6E, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, + 0x89, 0x61, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xDD, 0x01, 0xDA, 0x06, + 0xDA, 0x89, 0x62, 0xDA, 0x08, 0xCE, 0x80, 0xC5, 0x28, 0x65, 0x78, 0x74, 0x72, 0x65, 0x6D, 0x65, + 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x73, 0x74, 0x20, 0x65, + 0x78, 0x74, 0x72, 0x65, 0x6D, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x61, 0x72, 0x67, 0x73, 0x60, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x6F, 0x72, + 0x64, 0x65, 0x72, 0x60, 0x2E, 0x0A, 0x60, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x60, 0x20, 0x73, 0x68, + 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x74, 0x72, 0x75, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x28, 0x61, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6F, 0x6E, 0x29, 0x2E, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x60, 0x61, 0x72, + 0x67, 0x73, 0x60, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2E, 0xDA, 0x89, 0x65, + 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xAF, 0x01, 0xDA, 0x06, 0xDA, 0x89, + 0x66, 0xDA, 0x08, 0xCE, 0x5D, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x78, + 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x73, 0x20, 0x78, 0x20, 0x61, 0x74, 0x20, 0x63, 0x6F, + 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, + 0x74, 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, + 0x74, 0x6F, 0x70, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x75, 0x6E, 0x71, 0x75, 0x6F, 0x74, + 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x68, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0xB7, 0xDA, + 0x08, 0xCE, 0x80, 0xB1, 0x28, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x64, 0x73, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x6E, + 0x67, 0x74, 0x68, 0x20, 0x6F, 0x72, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, + 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x20, 0x69, 0x6E, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x20, 0x74, 0x69, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, + 0x20, 0x46, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x6B, + 0x65, 0x79, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x89, 0x69, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x29, 0x82, 0x4B, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x6A, 0xDA, 0x08, 0xCE, 0x80, 0xBF, 0x28, 0x68, + 0x61, 0x73, 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, + 0x20, 0x61, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x79, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, + 0x68, 0x65, 0x61, 0x70, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6C, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, + 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x89, 0x6B, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x0E, 0x01, 0xDA, 0x06, 0xDA, + 0x89, 0x6C, 0xDA, 0x08, 0xCE, 0x32, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x68, 0x79, 0x70, 0x65, 0x72, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x63, 0x6F, 0x73, 0x69, + 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x89, 0x6D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0x57, 0x84, 0x15, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x39, 0xDA, 0x08, 0xCE, + 0x80, 0xFF, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2C, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x4F, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x41, 0x6C, 0x73, 0x6F, 0x20, 0x66, 0x6C, 0x75, 0x73, 0x68, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x71, + 0x75, 0x65, 0x75, 0x65, 0x2C, 0x20, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x73, 0x75, 0x72, 0x65, + 0x20, 0x74, 0x6F, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, + 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x65, + 0x75, 0x65, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, + 0x67, 0x20, 0x60, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x60, + 0x2E, 0xDA, 0x89, 0x6E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, 0x77, 0x81, 0xA2, + 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xCE, 0xDA, 0x08, 0xCE, 0x80, 0xF9, 0x28, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x2F, 0x73, 0x74, 0x65, 0x70, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, + 0x6C, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, + 0x6E, 0x65, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x6C, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, + 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x75, 0x6D, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x62, 0x65, 0x20, 0x6E, 0x69, + 0x6C, 0x2C, 0x20, 0x61, 0x73, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, + 0x73, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x73, 0x2E, 0xDA, 0x89, 0x6F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x88, 0xAF, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x70, 0xDA, 0x08, 0xCE, 0x80, 0xBE, 0x28, 0x74, 0x68, + 0x61, 0x77, 0x20, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x61, 0x77, 0x20, 0x61, 0x6E, 0x20, + 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x28, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x74, 0x20, + 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x29, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x6F, 0x20, + 0x61, 0x20, 0x64, 0x65, 0x65, 0x70, 0x20, 0x63, 0x6F, 0x70, 0x79, 0x2C, 0x20, 0x6D, 0x61, 0x6B, + 0x69, 0x6E, 0x67, 0x0A, 0x63, 0x68, 0x69, 0x6C, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x43, 0x6C, + 0x6F, 0x73, 0x75, 0x72, 0x65, 0x73, 0x2C, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x0A, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, + 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x61, 0x77, 0x65, + 0x64, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0xDA, 0x89, 0x75, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x23, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x76, + 0xDA, 0x08, 0xCE, 0x2E, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x72, 0x66, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x2E, 0xDA, 0x85, 0x7D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x2D, + 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x79, 0xDA, 0x08, 0xCE, 0x80, 0xBF, 0x28, 0x6D, 0x65, 0x72, 0x67, + 0x65, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x61, 0x62, 0x20, 0x26, 0x20, 0x63, 0x6F, 0x6C, + 0x6C, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x65, 0x72, 0x67, 0x65, 0x73, 0x20, 0x6D, 0x75, 0x6C, 0x74, + 0x69, 0x70, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2F, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, + 0x74, 0x61, 0x62, 0x60, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x61, + 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, 0x65, 0x0A, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x63, 0x6F, 0x6C, 0x6C, 0x73, 0x60, 0x2C, 0x20, 0x74, + 0x68, 0x65, 0x6E, 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x70, 0x72, 0x65, + 0x76, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x60, 0x74, 0x61, 0x62, 0x60, 0x2E, 0xDA, 0x89, 0x77, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x82, 0x19, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x78, 0xDA, + 0x08, 0xCE, 0x81, 0x30, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, + 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x60, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x2E, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x68, 0x61, + 0x6C, 0x66, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x2C, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, + 0x20, 0x65, 0x6E, 0x64, 0x29, 0x2E, 0x20, 0x49, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x73, 0x20, 0x63, + 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x2C, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, + 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x42, + 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, 0x20, 0x60, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x65, 0x6E, 0x64, + 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x89, 0x79, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, + 0x77, 0x80, 0xDD, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x7A, 0xDA, 0x08, 0xCE, 0x81, 0x0C, 0x28, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, + 0x73, 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x69, + 0x6E, 0x20, 0x60, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x60, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, + 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, + 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x63, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, + 0x6C, 0x65, 0x0A, 0x0A, 0x09, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, + 0x6B, 0x20, 0x22, 0x63, 0x6F, 0x72, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x22, 0x20, 0x31, + 0x30, 0x20, 0x34, 0x29, 0x0A, 0x0A, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x65, 0x74, 0x20, 0x61, + 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x61, 0x74, 0x20, 0x6C, + 0x69, 0x6E, 0x65, 0x20, 0x31, 0x30, 0x2C, 0x20, 0x34, 0x74, 0x68, 0x20, 0x63, 0x6F, 0x6C, 0x75, + 0x6D, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x63, + 0x6F, 0x72, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2E, 0xDA, 0x89, 0x7B, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x57, 0x84, 0xDC, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x7C, 0xDA, + 0x08, 0xCE, 0x82, 0x9B, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6B, 0x65, + 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, + 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, + 0x73, 0x73, 0x65, 0x64, 0x2C, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x62, 0x6F, 0x75, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x6F, 0x77, 0x65, 0x64, + 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x72, 0x65, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, + 0x65, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0x73, 0x20, 0x2D, 0x20, 0x45, 0x61, 0x63, 0x68, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6D, + 0x70, 0x6C, 0x65, 0x2C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x27, 0x28, 0x5B, 0x22, + 0x27, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x69, 0x64, + 0x64, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, + 0x73, 0x20, 0x69, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x68, + 0x65, 0x73, 0x65, 0x73, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x75, 0x67, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x20, 0x52, + 0x45, 0x50, 0x4C, 0x20, 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, + 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x20, 0x2D, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x20, 0x27, 0x66, + 0x72, 0x61, 0x6D, 0x65, 0x27, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2E, 0x20, 0x46, 0x72, 0x61, 0x6D, 0x65, + 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x62, 0x6F, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70, + 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x20, 0x61, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2D, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x63, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, + 0x67, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x6E, 0x01, 0xDA, 0x06, 0xDA, 0x63, + 0xDA, 0x08, 0xCE, 0x23, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x89, 0x7D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0xF9, 0x81, 0x1B, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x7E, 0xDA, 0x08, 0xCE, 0x81, + 0x33, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, 0x61, + 0x72, 0x72, 0x20, 0x61, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x73, + 0x65, 0x72, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x69, 0x6E, 0x74, + 0x6F, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x60, 0x61, 0x72, 0x72, 0x60, 0x20, 0x61, 0x74, + 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x61, 0x74, 0x60, 0x2E, 0x20, 0x60, 0x61, 0x74, + 0x60, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, 0x20, 0x30, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x41, 0x20, + 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x60, 0x61, 0x74, 0x60, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x6E, 0x73, 0x65, + 0x72, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x74, 0x20, 0x2D, 0x31, 0x20, 0x61, 0x70, 0x70, 0x65, + 0x6E, 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, + 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x89, 0x7F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, + 0x77, 0x80, 0xFF, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xEF, 0xDA, 0x08, 0xCE, 0x47, 0x28, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x66, 0x75, 0x6E, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x70, 0x63, 0x29, 0x0A, 0x0A, 0x55, 0x6E, 0x73, 0x65, 0x74, + 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, + 0x65, 0x61, 0x6B, 0x2E, 0xDA, 0x89, 0x80, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x89, 0x81, 0xDA, 0x08, + 0xCE, 0x30, 0x54, 0x68, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x6E, + 0x69, 0x6E, 0x67, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, + 0x6D, 0x2E, 0xDA, 0x89, 0x82, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x11, 0x73, 0x72, + 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0x63, 0x80, + 0xE1, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x83, 0xDA, 0x08, 0xCE, 0x56, 0x28, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, + 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, + 0x64, 0x6F, 0x65, 0x73, 0x6E, 0x27, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6F, 0x6E, 0x65, + 0x2E, 0xDA, 0x85, 0xFF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x75, 0x01, 0xDA, + 0x06, 0xDA, 0x85, 0xFD, 0xDA, 0x08, 0xCE, 0x22, 0x28, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x3F, 0x20, + 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2E, 0xDA, 0x89, 0x45, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x63, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x43, 0xDA, 0x08, + 0xCE, 0x66, 0x28, 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 0x20, 0x66, 0x20, 0x66, 0x6F, + 0x72, 0x6D, 0x29, 0x0A, 0x0A, 0x44, 0x6F, 0x20, 0x61, 0x20, 0x70, 0x6F, 0x73, 0x74, 0x2D, 0x6F, + 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x72, 0x61, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6C, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x60, 0x28, 0x66, 0x20, + 0x78, 0x29, 0x60, 0x0A, 0x6F, 0x6E, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x76, 0x69, 0x73, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x89, 0x84, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8D, 0x97, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x85, 0xDA, 0x08, 0xCE, 0x81, + 0x60, 0x28, 0x64, 0x6F, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x29, 0x0A, + 0x0A, 0x53, 0x68, 0x6F, 0x77, 0x73, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, + 0x65, 0x6E, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x73, 0x68, 0x6F, 0x77, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x73, 0x74, 0x20, 0x6F, 0x66, + 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x73, 0x2E, 0x0A, 0x49, 0x66, 0x20, 0x60, 0x73, 0x79, 0x6D, 0x60, 0x20, 0x69, 0x73, + 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x6C, 0x6F, 0x6F, 0x6B, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x73, 0x79, 0x6D, 0x60, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0x6F, 0x72, 0x20, + 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, + 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x68, 0x6F, 0x77, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6C, + 0x65, 0x78, 0x69, 0x63, 0x61, 0x6C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, + 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, + 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x0A, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x69, 0x6E, + 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x28, 0x61, + 0x6C, 0x6C, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, + 0x20, 0x62, 0x65, 0x20, 0x73, 0x68, 0x6F, 0x77, 0x6E, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x29, + 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x85, 0xBA, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x89, 0x9B, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xA0, 0xDA, 0x08, 0xCE, 0x52, 0x28, 0x62, 0x61, 0x64, + 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x6D, 0x73, 0x67, 0x20, 0x6D, 0x61, 0x63, + 0x72, 0x6F, 0x66, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, + 0x69, 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, + 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x89, + 0x87, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x8F, 0x61, 0x80, 0xEC, 0x01, 0xDA, 0x06, + 0xDA, 0x89, 0x73, 0xDA, 0x08, 0xCE, 0x80, 0xA8, 0x28, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, + 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x2D, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x20, 0x73, 0x74, + 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x20, 0x62, 0x79, 0x20, 0x6D, 0x65, 0x72, 0x67, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, + 0xDA, 0x89, 0x88, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x3B, 0x01, 0xDA, 0x06, + 0xDA, 0x89, 0x89, 0xDA, 0x08, 0xCE, 0x4A, 0x28, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, + 0x2D, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, 0x0A, 0x0A, + 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, + 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, + 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x89, 0x8B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x83, 0x75, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x8C, 0xDA, 0x08, 0xCE, 0x80, 0xB3, 0x28, 0x73, 0x6F, + 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x65, + 0x66, 0x6F, 0x72, 0x65, 0x3F, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, + 0x79, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x6C, 0x64, 0x20, 0x6F, 0x6E, 0x65, + 0x2E, 0x0A, 0x49, 0x66, 0x20, 0x61, 0x20, 0x60, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x3F, 0x60, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x2C, 0x20, 0x73, 0x6F, 0x72, 0x74, 0x73, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, + 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x2C, 0x0A, 0x6F, 0x74, 0x68, + 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x60, 0x3C, 0x60, 0x2E, + 0xDA, 0x88, 0xF4, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8C, 0x35, 0x01, 0xDA, + 0x06, 0xDA, 0x88, 0xE6, 0xDA, 0x08, 0xCE, 0x80, 0xC8, 0x28, 0x61, 0x6C, 0x6C, 0x2D, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x20, + 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x20, + 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, + 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, + 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x0A, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x27, 0x73, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x60, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x73, 0x68, 0x6F, 0x77, 0x20, 0x69, 0x6E, 0x68, 0x65, 0x72, 0x69, 0x74, 0x65, 0x64, 0x20, + 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x0A, 0x28, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x70, + 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x29, + 0x2E, 0xDA, 0x89, 0x8E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0xA6, 0x01, + 0xDA, 0x06, 0xDA, 0x87, 0xEF, 0xDA, 0x08, 0xCE, 0x31, 0x28, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x61, 0x72, 0x79, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, + 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0xDA, 0x81, 0x0A, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x09, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x08, 0xDA, 0x08, + 0xCE, 0x80, 0xB5, 0x28, 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x21, + 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x29, 0x0A, 0x0A, + 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x6B, 0x65, 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, + 0x78, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x66, 0x20, 0x60, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, + 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x65, 0x72, 0x63, 0x65, 0x64, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0x0A, 0x55, 0x73, 0x65, 0x66, + 0x75, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x20, 0x73, + 0x79, 0x6E, 0x74, 0x61, 0x63, 0x74, 0x69, 0x63, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x72, 0x61, 0x6E, 0x73, 0x66, + 0x6F, 0x72, 0x6D, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x73, 0x74, 0x20, 0x69, 0x6E, + 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x2E, 0xDA, 0x89, 0x8F, 0xD3, 0x04, 0xDA, 0x81, 0xC9, + 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD6, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x8D, + 0xDA, 0x08, 0xCE, 0x58, 0x45, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x20, 0x62, 0x75, + 0x69, 0x6C, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, + 0x6F, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x66, 0x65, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x69, 0x6E, + 0x67, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x2E, 0xDA, 0x88, 0xFB, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8C, 0x3C, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0xF5, + 0xDA, 0x08, 0xCE, 0x80, 0xC7, 0x28, 0x61, 0x6C, 0x6C, 0x2D, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, + 0x63, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x6C, 0x6F, 0x63, 0x61, + 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x64, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, + 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x0A, 0x66, 0x69, 0x62, 0x65, 0x72, 0x27, 0x73, 0x20, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x60, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, + 0x79, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x73, 0x68, 0x6F, 0x77, + 0x20, 0x69, 0x6E, 0x68, 0x65, 0x72, 0x69, 0x74, 0x65, 0x64, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x73, 0x0A, 0x28, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x29, 0x2E, 0xDA, 0x89, 0x90, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x3F, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0xFC, + 0xDA, 0x08, 0xCE, 0x80, 0xC9, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x78, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x68, 0x75, + 0x6D, 0x61, 0x6E, 0x2D, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x60, 0x2E, + 0x20, 0x46, 0x6F, 0x72, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x2C, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x70, + 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6E, + 0x74, 0x69, 0x74, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x62, 0x65, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x65, 0x64, 0x2E, 0xDA, 0x89, + 0x91, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x26, 0x01, 0xDA, 0x06, 0xDA, + 0x89, 0x92, 0xDA, 0x08, 0xCE, 0x80, 0x8A, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6C, 0x74, 0x20, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x70, 0x65, 0x67, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x67, + 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x73, + 0x65, 0x76, 0x65, 0x72, 0x61, 0x6C, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x6F, 0x6E, 0x20, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x0A, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6F, 0x75, + 0x6C, 0x64, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x74, 0x20, 0x65, 0x61, 0x73, 0x69, 0x65, + 0x72, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, + 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x78, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, + 0x2E, 0xDA, 0x89, 0xD8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x40, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0xD9, 0xDA, 0x08, 0xCE, 0x81, 0x16, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x61, + 0x63, 0x63, 0x65, 0x70, 0x74, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x6F, 0x75, + 0x6C, 0x64, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, + 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x69, + 0x6E, 0x20, 0x61, 0x20, 0x64, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, 0x69, + 0x6E, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x64, 0x75, 0x70, 0x6C, 0x65, 0x78, 0x20, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6D, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2E, + 0xDA, 0x89, 0xDA, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x81, 0x55, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0xDB, 0xDA, 0x08, 0xCE, 0x69, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, + 0x74, 0x72, 0x69, 0x6D, 0x20, 0x61, 0x72, 0x72, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, + 0x69, 0x74, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x74, 0x6F, 0x20, 0x69, 0x74, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x65, 0x6E, 0x67, 0x74, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x2E, 0xDA, 0x89, 0xDC, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, + 0x68, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0xEA, 0xDA, 0x08, 0xCE, 0x80, 0x85, 0x28, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x20, 0x74, 0x61, 0x62, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, + 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x68, + 0x61, 0x73, 0x20, 0x6E, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x2C, + 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, + 0x2E, 0xDA, 0x89, 0xDD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8D, 0x9F, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0xDE, 0xDA, 0x08, 0xCE, 0x80, 0xAA, 0x28, 0x64, 0x6F, 0x63, 0x2D, 0x6F, + 0x66, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x73, 0x20, 0x61, + 0x6C, 0x6C, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x64, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, + 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x73, + 0x20, 0x6F, 0x75, 0x74, 0x20, 0x69, 0x74, 0x73, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x0A, 0x54, 0x68, 0x69, 0x73, 0x20, 0x64, 0x6F, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x62, 0x79, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x62, + 0x79, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x81, 0x04, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x84, 0xFA, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xFD, 0xDA, 0x08, 0xCE, 0x81, 0x0E, 0x28, 0x6B, 0x65, + 0x65, 0x70, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, + 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x62, + 0x65, 0x66, 0x6F, 0x72, 0x65, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x60, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x60, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x60, 0x20, 0x75, 0x6E, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2E, 0x20, 0x55, + 0x73, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x20, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x63, 0x74, 0x69, 0x63, 0x20, 0x69, 0x6E, 0x66, 0x6F, + 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x72, 0x61, + 0x6E, 0x73, 0x66, 0x6F, 0x72, 0x6D, 0x69, 0x6E, 0x67, 0x0A, 0x61, 0x6E, 0x20, 0x61, 0x73, 0x74, + 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x2E, 0xDA, 0x89, 0xED, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x9B, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0xEE, + 0xDA, 0x08, 0xCE, 0x5D, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, + 0x20, 0x74, 0x61, 0x62, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x6B, 0x65, 0x79, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, 0x74, 0x61, 0x62, 0x60, + 0x2E, 0xDA, 0x89, 0xEF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0x6B, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0xF0, 0xDA, 0x08, 0xCE, 0x80, 0xE8, 0x28, 0x6F, 0x73, 0x2F, 0x6C, 0x69, + 0x6E, 0x6B, 0x20, 0x6F, 0x6C, 0x64, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6E, 0x65, 0x77, 0x70, 0x61, + 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x29, + 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x6B, 0x20, + 0x61, 0x74, 0x20, 0x6E, 0x65, 0x77, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6F, 0x6C, 0x64, 0x70, 0x61, 0x74, + 0x68, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, + 0x6C, 0x2E, 0x20, 0x49, 0x66, 0x66, 0x20, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x2E, 0x20, 0x49, 0x66, 0x66, + 0x20, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, + 0x65, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x2C, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x68, 0x61, + 0x72, 0x64, 0x20, 0x6C, 0x69, 0x6E, 0x6B, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x6F, 0x6E, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, + 0x73, 0x2E, 0xDA, 0x89, 0xF1, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0x83, + 0x01, 0xDA, 0x06, 0xDA, 0x89, 0xF2, 0xDA, 0x08, 0xCE, 0x5A, 0x28, 0x65, 0x76, 0x2F, 0x73, 0x6C, + 0x65, 0x65, 0x70, 0x20, 0x73, 0x65, 0x63, 0x29, 0x0A, 0x0A, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6E, + 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x73, 0x65, 0x63, 0x20, 0x73, 0x65, 0x63, 0x6F, + 0x6E, 0x64, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x62, 0x6C, 0x6F, 0x63, + 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x2E, 0xDA, 0x89, 0xF3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, + 0x85, 0xE3, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0xF4, 0xDA, 0x08, 0xCE, 0x49, 0x28, 0x66, 0x66, 0x69, + 0x2F, 0x66, 0x72, 0x65, 0x65, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x29, 0x0A, 0x0A, + 0x46, 0x72, 0x65, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x61, 0x6C, 0x6C, 0x6F, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x66, 0x66, 0x69, 0x2F, + 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x89, 0xF5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0x57, 0x81, 0x12, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0xF6, 0xDA, 0x08, 0xCE, 0x34, 0x28, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x79, 0x70, 0x65, 0x72, 0x62, + 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x61, 0x72, 0x63, 0x73, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x2E, 0xDA, 0x85, 0xC6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x64, + 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xC2, 0xDA, 0x08, 0xCE, 0x37, 0x28, 0x62, 0x61, 0x64, 0x2D, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x20, 0x70, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x44, + 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, + 0x2E, 0xDA, 0x89, 0xF7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x03, 0x01, + 0xDA, 0x06, 0xDA, 0x51, 0xDA, 0x08, 0xCE, 0x80, 0xD1, 0x28, 0x67, 0x65, 0x6E, 0x73, 0x79, 0x6D, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x75, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x20, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x75, 0x6E, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x6D, 0x65, 0x61, 0x6E, 0x73, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x69, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, + 0x6E, 0x79, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x20, 0x64, 0x75, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x73, + 0x6F, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x67, 0x65, + 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x61, 0x75, 0x74, 0x6F, 0x6D, 0x61, 0x74, 0x69, 0x63, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x2E, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x69, 0x6E, 0x66, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x98, + 0x01, 0xDA, 0x06, 0xDA, 0x86, 0x01, 0xDA, 0x08, 0xCE, 0x29, 0x54, 0x68, 0x65, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6E, 0x66, 0x69, 0x6E, + 0x69, 0x74, 0x79, 0xDA, 0x89, 0xF8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, + 0x6B, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x01, 0xDA, 0x08, 0xCE, 0x80, 0xB6, 0x28, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x62, 0x79, 0x20, 0x63, + 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, 0x6E, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x73, + 0x60, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, + 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, + 0x2C, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x60, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2E, 0xDA, 0x89, 0xF9, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x5B, 0x01, + 0xDA, 0x06, 0xDA, 0x89, 0xFA, 0xDA, 0x08, 0xCE, 0x37, 0x28, 0x76, 0x61, 0x72, 0x67, 0x6C, 0x6F, + 0x62, 0x61, 0x6C, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x29, 0x0A, 0x0A, + 0x44, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x20, 0x61, 0x20, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0x20, 0x76, 0x61, 0x72, 0x2E, + 0xDA, 0x89, 0xFD, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x84, 0xD4, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0xFE, 0xDA, 0x08, 0xCE, 0x26, 0x57, 0x68, 0x65, 0x72, + 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, + 0x6F, 0x2E, 0xDA, 0x89, 0xFF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x34, + 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x00, 0xDA, 0x08, 0xCE, 0x1E, 0x28, 0x7A, 0x65, 0x72, 0x6F, 0x3F, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, + 0x69, 0x73, 0x20, 0x7A, 0x65, 0x72, 0x6F, 0x2E, 0xDA, 0x8A, 0x02, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0x94, 0x81, 0xFA, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x6B, 0xDA, 0x08, 0xCE, + 0x84, 0x81, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x65, + 0x6E, 0x76, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x2E, + 0x20, 0x43, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, + 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x60, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x73, 0x6B, 0x60, 0x20, + 0x74, 0x6F, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x63, 0x68, 0x69, 0x6C, 0x64, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, 0x65, 0x6E, 0x76, 0x60, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, + 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, 0x68, 0x61, 0x72, + 0x61, 0x63, 0x74, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x65, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x64, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, + 0x74, 0x6F, 0x20, 0x60, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0x60, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x73, + 0x65, 0x20, 0x22, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x22, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, + 0x69, 0x6E, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x62, 0x65, 0x69, 0x6E, + 0x67, 0x20, 0x73, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, + 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x73, 0x69, + 0x67, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x3A, 0x79, 0x2E, 0x20, 0x46, 0x6F, 0x72, + 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x2C, 0x0A, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x28, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x6D, 0x79, 0x66, 0x75, 0x6E, 0x20, + 0x3A, 0x65, 0x31, 0x32, 0x33, 0x29, 0x0A, 0x0A, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x31, 0x2C, + 0x20, 0x32, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x33, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x6C, + 0x6C, 0x6F, 0x77, 0x73, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x20, 0x2D, 0x20, 0x62, 0x6C, + 0x6F, 0x63, 0x6B, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, + 0x2A, 0x20, 0x3A, 0x64, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x65, 0x20, + 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x74, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, + 0x63, 0x6B, 0x20, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x73, + 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x3A, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x2B, 0x20, + 0x75, 0x73, 0x65, 0x72, 0x5B, 0x30, 0x2D, 0x34, 0x5D, 0x0A, 0x2A, 0x20, 0x3A, 0x75, 0x20, 0x2D, + 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x73, 0x0A, 0x2A, 0x20, 0x3A, 0x79, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, + 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x2A, + 0x20, 0x3A, 0x77, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x61, 0x77, 0x61, 0x69, + 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x28, 0x75, 0x73, 0x65, 0x72, 0x39, + 0x29, 0x0A, 0x2A, 0x20, 0x3A, 0x72, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, + 0x20, 0x28, 0x75, 0x73, 0x65, 0x72, 0x38, 0x29, 0x0A, 0x2A, 0x20, 0x3A, 0x30, 0x2D, 0x39, 0x20, + 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x63, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x0A, 0x0A, + 0x54, 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x61, 0x72, 0x67, 0x75, + 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x74, 0x61, + 0x6B, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x66, + 0x6C, 0x61, 0x67, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6D, 0x75, 0x74, + 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x65, 0x78, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, + 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, + 0x74, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x66, 0x6C, 0x61, 0x67, + 0x20, 0x74, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x6E, 0x63, + 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x69, 0x20, 0x2D, 0x20, 0x69, 0x6E, 0x68, 0x65, 0x72, + 0x69, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x0A, 0x2A, 0x20, 0x3A, 0x70, 0x20, 0x2D, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x27, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, + 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0xDA, 0x83, 0x90, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, + 0x21, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x8E, 0xDA, 0x08, 0xCE, 0x80, 0x81, 0x28, 0x66, 0x69, 0x6E, + 0x64, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x64, 0x66, 0x6C, 0x74, 0x29, 0x0A, 0x0A, 0x46, 0x69, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, + 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x60, 0x64, 0x66, 0x6C, 0x74, 0x60, 0x20, + 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, 0x8A, 0x03, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x1D, 0x01, 0xDA, 0x06, 0xDA, + 0x8A, 0x04, 0xDA, 0x08, 0xCE, 0x2A, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x62, 0x72, 0x74, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x75, 0x62, 0x65, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, + 0xDA, 0x8A, 0x05, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0xDE, 0x01, + 0xDA, 0x06, 0xDA, 0x8A, 0x06, 0xDA, 0x08, 0xCE, 0x73, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x61, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x63, 0x6F, 0x70, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x20, 0x61, 0x74, 0x20, 0x69, 0x6E, + 0x64, 0x65, 0x78, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x60, 0x2E, 0xDA, 0x8A, 0x07, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, 0x77, 0x81, 0x74, 0x01, 0xDA, 0x06, 0xDA, 0x84, + 0xAF, 0xDA, 0x08, 0xCE, 0x83, 0x4C, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, + 0x63, 0x6B, 0x20, 0x66, 0x69, 0x62, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x69, 0x6E, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x62, 0x6F, 0x75, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2E, + 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, + 0x73, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x62, + 0x6F, 0x75, 0x74, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, + 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x6F, 0x70, 0x2D, 0x6D, 0x6F, 0x73, 0x74, 0x2C, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, + 0x72, 0x61, 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, + 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, + 0x74, 0x74, 0x6F, 0x6D, 0x2D, 0x6D, 0x6F, 0x73, 0x74, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, + 0x66, 0x72, 0x61, 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, + 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x73, 0x74, + 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, + 0x6E, 0x73, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x20, 0x2D, 0x20, 0x74, 0x72, 0x75, + 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, + 0x72, 0x61, 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x76, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x63, 0x6F, 0x6C, 0x75, 0x6D, + 0x6E, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x2D, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, + 0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x73, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x2D, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x75, 0x6D, 0x61, 0x6E, 0x2D, 0x66, + 0x72, 0x69, 0x65, 0x6E, 0x64, 0x6C, 0x79, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x70, 0x63, 0x20, 0x2D, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6E, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x63, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x67, 0x72, 0x61, 0x6D, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2D, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, + 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, + 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x20, 0x2D, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, + 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x65, + 0x61, 0x63, 0x68, 0x20, 0x73, 0x6C, 0x6F, 0x74, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x74, 0x61, 0x69, + 0x6C, 0x20, 0x2D, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x74, 0x61, 0x69, 0x6C, 0x20, 0x63, 0x61, + 0x6C, 0x6C, 0xDA, 0x8A, 0x08, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xEA, + 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x09, 0xDA, 0x08, 0xCE, 0x81, 0x71, 0x28, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x2F, 0x61, 0x64, 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x73, 0x20, 0x65, 0x78, 0x74, + 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x41, 0x64, 0x64, 0x20, 0x70, 0x61, + 0x74, 0x68, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, + 0x61, 0x74, 0x68, 0x73, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, + 0x6E, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6C, 0x69, + 0x6B, 0x65, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2C, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x69, 0x6E, 0x67, + 0x0A, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, + 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x79, 0x73, 0x70, 0x61, 0x74, 0x68, 0x20, 0x69, 0x6D, + 0x70, 0x6F, 0x72, 0x74, 0x73, 0x2E, 0x20, 0x60, 0x65, 0x78, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6E, 0x73, 0x69, + 0x6F, 0x6E, 0x0A, 0x74, 0x6F, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x2C, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x6F, 0x74, 0x2E, 0x20, 0x60, 0x6C, 0x6F, 0x61, 0x64, 0x65, + 0x72, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, + 0x64, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x6C, 0x6F, 0x61, 0x64, + 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x6C, 0x6F, + 0x61, 0x64, 0x65, 0x72, 0x73, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x60, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0x60, 0x2E, 0xDA, 0x8A, 0x1C, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xBC, 0x01, 0xDA, 0x06, 0xDA, 0x8A, + 0x1D, 0xDA, 0x08, 0xCE, 0x50, 0x28, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2F, 0x73, 0x6C, 0x69, + 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x2C, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x79, + 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0xDA, 0x8A, 0x1E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0xA3, 0x81, 0xF0, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x4B, 0xDA, 0x08, 0xCE, 0x7A, 0x28, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x65, 0x70, 0x29, 0x0A, 0x0A, 0x4A, 0x6F, 0x69, 0x6E, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, + 0x79, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x60, 0x73, 0x65, 0x70, 0x60, 0x2E, 0xDA, 0x8A, 0x1F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x84, 0xA7, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x20, 0xDA, 0x08, 0xCE, 0x7F, + 0x28, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0x20, 0x26, 0x20, 0x66, 0x75, 0x6E, 0x73, 0x29, 0x0A, 0x0A, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6A, 0x75, 0x78, 0x74, + 0x61, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x2C, 0x0A, 0x60, 0x28, 0x28, 0x6A, 0x75, 0x78, 0x74, 0x2A, + 0x20, 0x61, 0x20, 0x62, 0x20, 0x63, 0x29, 0x20, 0x78, 0x29, 0x60, 0x20, 0x65, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x5B, 0x28, 0x61, 0x20, 0x78, 0x29, + 0x20, 0x28, 0x62, 0x20, 0x78, 0x29, 0x20, 0x28, 0x63, 0x20, 0x78, 0x29, 0x5D, 0x60, 0x2E, 0xDA, + 0x8A, 0x24, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x20, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0x25, 0xDA, 0x08, 0xCE, 0x41, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x72, + 0x75, 0x6E, 0x63, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x62, 0x65, 0x74, 0x77, + 0x65, 0x65, 0x6E, 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x30, 0x20, 0x6E, 0x65, 0x61, 0x72, + 0x65, 0x73, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x78, 0x2E, 0xDA, 0x8A, 0x26, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xCC, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x5B, 0xDA, 0x08, + 0xCE, 0x55, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x63, 0x6F, 0x70, 0x69, 0x65, 0x73, 0x20, 0x6F, + 0x66, 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x73, 0x60, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, + 0x65, 0x6E, 0x61, 0x74, 0x65, 0x64, 0x2E, 0xDA, 0x8A, 0x27, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x65, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x28, 0xDA, 0x08, 0xCE, 0x22, 0x28, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, + 0xDA, 0x8A, 0x2A, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0xF7, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0x2B, 0xDA, 0x08, 0xCE, 0x4F, 0x28, 0x66, 0x6F, 0x72, 0x20, 0x69, 0x20, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, 0x74, 0x6F, 0x70, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, + 0x29, 0x0A, 0x0A, 0x44, 0x6F, 0x20, 0x61, 0x20, 0x43, 0x2D, 0x73, 0x74, 0x79, 0x6C, 0x65, 0x20, + 0x66, 0x6F, 0x72, 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x73, 0x69, 0x64, + 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x82, 0x75, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xF3, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x72, 0xDA, 0x08, + 0xCE, 0x41, 0x28, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x47, 0x65, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, + 0x78, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x2E, 0xDA, 0x82, 0xC8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, + 0x56, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0xBC, 0xDA, 0x08, 0xCE, 0x80, 0xAB, 0x28, 0x77, 0x61, 0x6C, + 0x6B, 0x20, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x29, 0x0A, 0x0A, 0x49, 0x74, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x73, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x70, + 0x70, 0x6C, 0x79, 0x20, 0x60, 0x66, 0x60, 0x0A, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x6D, 0x2E, + 0x20, 0x43, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6C, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x73, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x0A, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2C, + 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2C, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, + 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2C, 0x0A, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0xDA, 0x8A, 0x39, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x82, 0x11, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x3A, 0xDA, 0x08, 0xCE, 0x3E, 0x28, + 0x65, 0x61, 0x63, 0x68, 0x20, 0x78, 0x20, 0x64, 0x73, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, + 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x64, 0x73, 0x60, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, + 0xDA, 0x8A, 0x47, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xC7, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0x48, 0xDA, 0x08, 0xCE, 0x49, 0x28, 0x68, 0x61, 0x73, 0x2D, 0x6B, 0x65, 0x79, + 0x3F, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x60, 0x6B, 0x65, 0x79, 0x60, + 0x2E, 0xDA, 0x8A, 0x4A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x94, 0x82, 0x70, + 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x4B, 0xDA, 0x08, 0xCE, 0x81, 0x08, 0x28, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x66, 0x69, 0x62, 0x29, 0x0A, + 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, + 0x6D, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x69, 0x6E, 0x20, + 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x6C, 0x6C, + 0x6F, 0x77, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2E, 0x20, 0x57, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x27, 0x73, 0x20, 0x73, + 0x74, 0x61, 0x63, 0x6B, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x6F, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x75, 0x70, 0x20, 0x66, 0x72, 0x6F, 0x6E, 0x74, 0x2C, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6D, 0x6F, 0x72, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6D, 0x6F, 0x75, + 0x6E, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, + 0x77, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x2D, 0x6F, 0x76, 0x65, 0x72, 0x66, 0x6C, + 0x6F, 0x77, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x65, 0x64, 0x65, + 0x64, 0x2E, 0x20, 0xDA, 0x8A, 0x4C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, + 0x84, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x4D, 0xDA, 0x08, 0xCE, 0x3B, 0x28, 0x73, 0x75, 0x6D, 0x20, + 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, + 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x30, 0x2E, 0xDA, 0x8A, 0x51, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x86, 0x9D, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x52, 0xDA, 0x08, 0xCE, 0x80, 0x87, 0x28, + 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x74, + 0x6F, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x28, 0x74, 0x72, 0x65, + 0x65, 0x29, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x70, 0x70, 0x65, + 0x6E, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x70, 0x74, 0x68, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x61, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6C, 0x20, 0x6F, 0x66, + 0x0A, 0x60, 0x78, 0x73, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x60, + 0x69, 0x6E, 0x74, 0x6F, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, + 0x69, 0x6E, 0x74, 0x6F, 0x60, 0x2E, 0xDA, 0x8A, 0x57, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x80, 0xB5, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x58, 0xDA, 0x08, 0xCE, 0x49, 0x28, 0x75, + 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, + 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x28, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x28, 0x6E, + 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x29, 0x20, 0x3B, 0x62, + 0x6F, 0x64, 0x79, 0x29, 0x60, 0x2E, 0x20, 0xDA, 0x37, 0xCB, 0xDA, 0x8A, 0x5A, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x94, 0x82, 0x66, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x5B, 0xDA, + 0x08, 0xCE, 0x70, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x72, 0x6F, 0x6F, 0x74, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6E, 0x74, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x6C, 0x64, 0x65, 0x73, 0x74, 0x20, 0x61, 0x6E, + 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x65, + 0x6E, 0x74, 0x2E, 0xDA, 0x8A, 0x5C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, + 0x84, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x5D, 0xDA, 0x08, 0xCE, 0x6B, 0x28, 0x6F, 0x73, 0x2F, 0x70, + 0x65, 0x72, 0x6D, 0x2D, 0x69, 0x6E, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x0A, 0x0A, + 0x50, 0x61, 0x72, 0x73, 0x65, 0x20, 0x61, 0x20, 0x39, 0x2D, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, + 0x74, 0x65, 0x72, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x63, 0x68, 0x6D, 0x6F, 0x64, 0x2E, 0xDA, 0x8A, 0x5E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x8A, 0xA5, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xC1, 0xDA, 0x08, 0xCE, 0x80, 0xB4, 0x41, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x63, + 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x60, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x75, + 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, + 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x0A, + 0x62, 0x79, 0x20, 0x60, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x60, 0x2C, + 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x60, 0x28, 0x6C, 0x6F, 0x61, + 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, + 0x28, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, 0x64, 0x69, 0x63, 0x74, + 0x29, 0x60, 0x2E, 0xDA, 0x8A, 0x5F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, + 0x81, 0x16, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x60, 0xDA, 0x08, 0xCE, 0x2A, 0x28, 0x6D, 0x61, 0x74, + 0x68, 0x2F, 0x65, 0x78, 0x70, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6F, 0x77, 0x65, 0x72, + 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8A, 0x61, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x83, 0x6D, 0x87, 0x51, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x62, 0xDA, 0x08, 0xCE, 0x81, 0x56, + 0x28, 0x70, 0x65, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x70, 0x65, 0x67, + 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, + 0x52, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6D, 0x61, + 0x74, 0x63, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x70, 0x65, 0x67, 0x60, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x74, 0x65, 0x78, 0x74, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x73, 0x75, 0x62, + 0x73, 0x74, 0x60, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x70, 0x65, 0x67, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6E, 0x65, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x64, 0x6F, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x73, 0x75, 0x62, 0x73, 0x74, + 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, + 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x74, 0x63, + 0x68, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, + 0x65, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, + 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x70, 0x75, 0x74, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8A, 0x63, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x29, 0x82, 0x0B, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x64, 0xDA, 0x08, 0xCE, 0x50, 0x28, 0x67, + 0x63, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x67, + 0x61, 0x72, 0x62, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x2E, 0x20, 0x59, 0x6F, 0x75, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x70, 0x72, + 0x6F, 0x62, 0x61, 0x62, 0x6C, 0x79, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x6D, 0x61, 0x6E, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x2E, 0xDA, 0x8A, + 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x7B, 0x01, 0xDA, 0x06, + 0xDA, 0x84, 0x0E, 0xDA, 0x08, 0xCE, 0x7F, 0x28, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x20, 0x66, + 0x6D, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x73, + 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x28, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x66, 0x6D, 0x74, + 0x20, 0x3B, 0x78, 0x73, 0x29, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, + 0x3A, 0x6F, 0x75, 0x74, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x29, 0x60, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, + 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x2E, 0xDA, 0x83, 0xAC, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x80, 0x82, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0xA9, 0xDA, 0x08, 0xCE, 0x4E, 0x28, 0x69, + 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, 0x65, 0x6E, 0x74, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, + 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6C, 0x66, 0x20, 0x77, 0x68, + 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0xDA, 0x8A, 0x66, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x80, 0xEA, 0x01, 0xDA, 0x06, 0xDA, 0x8A, + 0x67, 0xDA, 0x08, 0xCE, 0x4D, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x61, 0x6E, 0x64, 0x6F, + 0x6D, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6E, + 0x69, 0x66, 0x6F, 0x72, 0x6D, 0x6C, 0x79, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x31, 0x2E, 0xDA, 0x8A, 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x54, 0x01, + 0xDA, 0x06, 0xDA, 0x8A, 0x69, 0xDA, 0x08, 0xCE, 0x38, 0x28, 0x64, 0x65, 0x66, 0x67, 0x6C, 0x6F, + 0x62, 0x61, 0x6C, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, + 0x0A, 0x44, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0x20, 0x64, 0x65, 0x66, + 0x2E, 0xDA, 0x8A, 0x6B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x9B, 0x01, + 0xDA, 0x06, 0xDA, 0x8A, 0x6C, 0xDA, 0x08, 0xCE, 0x81, 0x32, 0x28, 0x61, 0x63, 0x63, 0x75, 0x6D, + 0x75, 0x6C, 0x61, 0x74, 0x65, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x20, 0x69, 0x6E, 0x64, + 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x72, + 0x65, 0x64, 0x75, 0x63, 0x65, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x63, 0x63, 0x75, + 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6D, 0x65, 0x64, + 0x69, 0x61, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x73, 0x20, 0x77, 0x68, 0x61, 0x74, + 0x20, 0x77, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x60, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x60, 0x2E, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x60, 0x69, + 0x6E, 0x69, 0x74, 0x60, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x61, 0x64, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x20, 0x28, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x0A, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x6F, 0x66, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x73, 0x20, + 0x60, 0x69, 0x6E, 0x64, 0x60, 0x29, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x81, 0x73, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xDD, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x70, + 0xDA, 0x08, 0xCE, 0x80, 0xAE, 0x28, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, + 0x67, 0x73, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x62, + 0x69, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x79, + 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x70, 0x61, 0x69, 0x72, + 0x20, 0x69, 0x6E, 0x20, 0x60, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x60, 0x20, 0x69, + 0x73, 0x0A, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x66, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x64, 0x65, 0x66, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x60, 0x6C, 0x65, 0x74, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x0A, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x82, 0x94, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x6F, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x92, 0xDA, 0x08, 0xCE, 0x22, 0x28, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, + 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xDA, + 0x8A, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x80, 0xEB, 0x01, 0xDA, 0x06, + 0xDA, 0x8A, 0x74, 0xDA, 0x08, 0xCE, 0x80, 0xC9, 0x28, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x78, 0x20, 0x66, 0x6F, 0x72, 0x63, 0x65, 0x29, 0x0A, 0x0A, + 0x45, 0x78, 0x69, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, 0x64, + 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x78, 0x2E, 0x20, 0x49, 0x66, + 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x63, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, + 0x75, 0x74, 0x68, 0x79, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x69, + 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6C, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, + 0x6B, 0x69, 0x70, 0x20, 0x63, 0x6C, 0x65, 0x61, 0x6E, 0x75, 0x70, 0x20, 0x63, 0x6F, 0x64, 0x65, + 0x2E, 0xDA, 0x88, 0x42, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x38, 0x01, + 0xDA, 0x06, 0xDA, 0x88, 0x40, 0xDA, 0x08, 0xCE, 0x1E, 0x28, 0x65, 0x76, 0x65, 0x6E, 0x3F, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, + 0x73, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x2E, 0xDA, 0x8A, 0x75, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8C, 0x1D, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x76, 0xDA, 0x08, 0xCE, 0x80, 0x94, + 0x28, 0x75, 0x73, 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x29, 0x0A, + 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x69, 0x6D, 0x70, + 0x6F, 0x72, 0x74, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, + 0x65, 0x64, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x0A, 0x69, 0x64, 0x65, 0x6E, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, + 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, + 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x73, + 0x68, 0x6F, 0x74, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8A, 0x90, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0xA3, 0x82, 0x32, 0x01, 0xDA, 0x06, 0xDA, 0x54, 0xDA, 0x08, 0xCE, 0x85, 0x4B, + 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x26, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x29, 0x0A, + 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x43, 0x27, 0x73, 0x20, + 0x60, 0x73, 0x6E, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x4A, + 0x61, 0x6E, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2E, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, + 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x75, 0x70, 0x70, 0x65, 0x72, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, + 0x75, 0x70, 0x70, 0x65, 0x72, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x3A, 0x0A, 0x2D, 0x20, 0x60, 0x63, 0x60, 0x3A, 0x20, 0x41, 0x53, 0x43, 0x49, 0x49, 0x20, + 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x64, 0x60, + 0x2C, 0x20, 0x60, 0x69, 0x60, 0x3A, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, + 0x65, 0x63, 0x69, 0x6D, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x2D, + 0x20, 0x60, 0x78, 0x60, 0x2C, 0x20, 0x60, 0x58, 0x60, 0x3A, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, + 0x65, 0x72, 0x2C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x20, 0x68, 0x65, 0x78, 0x61, 0x64, 0x65, 0x63, 0x69, 0x6D, 0x61, 0x6C, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x6F, 0x60, 0x3A, 0x20, 0x69, 0x6E, + 0x74, 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x63, 0x74, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x66, 0x60, 0x2C, 0x20, 0x60, 0x46, 0x60, 0x3A, + 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, 0x63, 0x69, 0x6D, 0x61, 0x6C, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x65, 0x60, 0x2C, 0x20, 0x60, 0x45, + 0x60, 0x3A, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x69, 0x6E, + 0x74, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, + 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x63, 0x69, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x20, 0x6E, 0x6F, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x67, + 0x60, 0x2C, 0x20, 0x60, 0x47, 0x60, 0x3A, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x74, 0x73, 0x20, + 0x73, 0x68, 0x6F, 0x72, 0x74, 0x65, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0x0A, 0x2D, + 0x20, 0x60, 0x61, 0x60, 0x2C, 0x20, 0x60, 0x41, 0x60, 0x3A, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x2C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, + 0x20, 0x68, 0x65, 0x78, 0x61, 0x64, 0x65, 0x63, 0x69, 0x6D, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x73, 0x60, 0x3A, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2C, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, + 0x68, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x74, 0x60, 0x3A, 0x20, 0x65, 0x6D, 0x69, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, + 0x69, 0x76, 0x65, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x0A, 0x2D, 0x20, 0x60, 0x76, + 0x60, 0x3A, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x28, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x78, 0x29, 0x0A, 0x2D, 0x20, 0x60, 0x56, + 0x60, 0x3A, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x28, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x78, 0x29, 0x0A, 0x2D, 0x20, 0x60, 0x6A, 0x60, 0x3A, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x6A, 0x64, 0x6E, 0x20, 0x28, + 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6E, 0x6F, 0x74, 0x61, 0x74, + 0x69, 0x6F, 0x6E, 0x29, 0x2E, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, + 0x77, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x22, 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, 0x2D, + 0x70, 0x72, 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x67, 0x22, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x70, 0x65, 0x72, 0x2D, 0x63, 0x61, 0x73, 0x65, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x61, 0x6E, 0x74, 0x73, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x65, 0x64, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, + 0x65, 0x63, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x74, 0x6F, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x6E, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67, 0x20, + 0x64, 0x65, 0x70, 0x74, 0x68, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x2E, 0x0A, + 0x2D, 0x20, 0x60, 0x70, 0x60, 0x2C, 0x20, 0x60, 0x50, 0x60, 0x3A, 0x20, 0x70, 0x72, 0x65, 0x74, + 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x2C, 0x20, 0x74, 0x72, 0x75, 0x6E, 0x63, + 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, + 0x72, 0x79, 0x0A, 0x2D, 0x20, 0x60, 0x6D, 0x60, 0x2C, 0x20, 0x60, 0x4D, 0x60, 0x3A, 0x20, 0x70, + 0x72, 0x65, 0x74, 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x6F, 0x75, 0x74, 0x20, 0x74, 0x72, 0x75, 0x6E, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x2E, + 0x0A, 0x2D, 0x20, 0x60, 0x71, 0x60, 0x2C, 0x20, 0x60, 0x51, 0x60, 0x3A, 0x20, 0x70, 0x72, 0x65, + 0x74, 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x2C, 0x20, 0x74, 0x72, 0x75, 0x6E, 0x63, 0x61, 0x74, 0x69, + 0x6E, 0x67, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x2E, + 0x0A, 0x2D, 0x20, 0x60, 0x6E, 0x60, 0x2C, 0x20, 0x60, 0x4E, 0x60, 0x3A, 0x20, 0x70, 0x72, 0x65, + 0x74, 0x74, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x74, + 0x72, 0x75, 0x6E, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x0A, 0xDA, 0x8A, 0x91, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x80, 0xD0, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x7B, + 0xDA, 0x08, 0xCE, 0x80, 0x90, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, + 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x60, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x60, + 0x20, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x62, 0x79, + 0x74, 0x65, 0x60, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, + 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x30, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8A, 0x92, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x87, 0x04, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x0C, 0xDA, 0x08, 0xCE, + 0x26, 0x46, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x70, 0x70, 0x60, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xDA, 0x84, 0xC4, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x86, 0xF1, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xBB, 0xDA, 0x08, 0xCE, 0x51, 0x28, + 0x73, 0x6C, 0x75, 0x72, 0x70, 0x20, 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, + 0x64, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x61, 0x6D, 0x65, + 0x20, 0x60, 0x70, 0x61, 0x74, 0x68, 0x60, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6E, + 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, + 0xDA, 0x8A, 0x93, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xE3, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0x94, 0xDA, 0x08, 0xCE, 0x4D, 0x28, 0x7A, 0x69, 0x70, 0x63, 0x6F, 0x6C, 0x6C, + 0x20, 0x6B, 0x73, 0x20, 0x76, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x77, + 0x6F, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2F, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x2E, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0x99, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x86, 0xB5, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x9A, 0xDA, 0x08, 0xCE, 0x80, 0x8C, 0x28, 0x66, + 0x72, 0x6F, 0x6D, 0x2D, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x70, 0x73, 0x29, 0x0A, 0x0A, 0x54, + 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x70, 0x61, 0x69, 0x72, 0x2E, 0x20, 0x49, 0x74, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6F, + 0x66, 0x0A, 0x60, 0x70, 0x61, 0x69, 0x72, 0x73, 0x60, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0x9F, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x8E, 0x03, 0xDA, 0x06, 0xDA, 0x8A, 0xA0, 0xDA, 0x08, + 0xCE, 0x6A, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x66, 0x20, 0x26, 0x20, 0x61, + 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x61, 0x6C, 0x6C, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x73, 0x79, 0x6E, 0x63, 0x68, 0x72, 0x6F, 0x6E, 0x6F, + 0x75, 0x73, 0x6C, 0x79, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x8A, 0xA4, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x94, 0x81, 0xD6, 0x01, 0xDA, 0x06, 0xDA, 0x86, + 0x1C, 0xDA, 0x08, 0xCE, 0x71, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x65, + 0x6E, 0x76, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x29, 0x0A, + 0x0A, 0x53, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x6F, 0x20, + 0x6E, 0x69, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x89, 0x9B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x29, 0x81, 0xB1, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xA5, 0xDA, 0x08, 0xCE, 0x80, 0xDD, 0x28, + 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, + 0x20, 0x65, 0x6E, 0x64, 0x29, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, + 0x65, 0x6E, 0x20, 0x73, 0x74, 0x65, 0x70, 0x2E, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x5B, 0x30, 0x2C, 0x20, + 0x65, 0x6E, 0x64, 0x29, 0x2E, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x61, + 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x2C, 0x20, 0x65, 0x6E, 0x64, 0x29, 0x2E, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x72, + 0x65, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, + 0x6E, 0x67, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, + 0x6C, 0x20, 0x73, 0x74, 0x65, 0x70, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x2E, 0xDA, 0x8A, 0xA6, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x92, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xA7, + 0xDA, 0x08, 0xCE, 0x80, 0xD6, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x6E, 0x64, 0x2D, 0x74, + 0x6F, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x64, 0x65, 0x73, 0x74, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, + 0x0A, 0x0A, 0x57, 0x72, 0x69, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x67, + 0x72, 0x61, 0x6D, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x64, 0x65, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, + 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, + 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, + 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0xDA, 0x8A, 0xA8, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x36, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xA9, 0xDA, + 0x08, 0xCE, 0x80, 0xC0, 0x28, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x20, 0x26, 0x20, 0x63, 0x6F, 0x6C, + 0x6C, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x65, 0x72, 0x67, 0x65, 0x73, 0x20, 0x6D, 0x75, 0x6C, 0x74, + 0x69, 0x70, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2F, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, + 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, 0x65, 0x0A, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x63, 0x6F, 0x6C, 0x6C, 0x73, 0x60, 0x2C, + 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x73, 0x2E, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0xB0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, + 0x89, 0x20, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xB1, 0xDA, 0x08, 0xCE, 0x38, 0x28, 0x6F, 0x73, 0x2F, + 0x75, 0x6D, 0x61, 0x73, 0x6B, 0x20, 0x6D, 0x61, 0x73, 0x6B, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, + 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x75, 0x6D, 0x61, 0x73, 0x6B, 0x2C, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x6C, 0x64, 0x20, 0x75, 0x6D, + 0x61, 0x73, 0x6B, 0x2E, 0xDA, 0x8A, 0xB2, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8C, 0x46, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0xEB, 0xDA, 0x08, 0xCE, 0x43, + 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x74, + 0x6F, 0x20, 0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x69, 0x7A, 0x65, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, + 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x65, 0x64, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x64, 0x6F, 0x63, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0x60, 0x2E, 0xDA, 0x8A, 0xB3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xCE, 0x0E, 0x73, + 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x61, 0x73, 0x6D, 0x2E, 0x63, 0x84, 0x36, 0x01, + 0xDA, 0x06, 0xDA, 0x84, 0xB2, 0xDA, 0x08, 0xCE, 0x84, 0xC5, 0x28, 0x64, 0x69, 0x73, 0x61, 0x73, + 0x6D, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x66, 0x69, 0x65, 0x6C, + 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x73, 0x73, 0x65, + 0x6D, 0x62, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x75, 0x6C, 0x64, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, + 0x6C, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x20, 0x6D, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x63, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x6F, 0x6E, 0x20, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x62, 0x61, 0x64, 0x6C, 0x79, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6C, + 0x64, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6F, 0x6E, 0x6C, + 0x79, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x70, 0x61, + 0x72, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x2E, 0x20, 0x50, 0x6F, 0x73, + 0x73, 0x69, 0x62, 0x6C, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6C, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, + 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x2D, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x61, 0x72, + 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x69, 0x6E, 0x2D, + 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x2D, 0x20, 0x6D, 0x69, 0x6E, 0x69, 0x6D, 0x75, 0x6D, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, + 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x2E, + 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x61, 0x78, 0x2D, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x2D, 0x20, + 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x76, 0x61, 0x72, 0x61, + 0x72, 0x67, 0x20, 0x2D, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, + 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x0A, 0x2A, + 0x20, 0x3A, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x2D, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, + 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2D, 0x20, 0x6E, 0x61, 0x6D, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x61, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, + 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x2D, + 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x6C, 0x6F, 0x74, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, + 0x2D, 0x20, 0x68, 0x6F, 0x77, 0x20, 0x6D, 0x61, 0x6E, 0x79, 0x20, 0x76, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6C, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x6F, 0x72, + 0x20, 0x73, 0x6C, 0x6F, 0x74, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x75, 0x73, 0x65, 0x73, 0x2E, 0x20, 0x43, 0x6F, 0x72, 0x72, + 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, + 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x79, 0x6D, 0x62, + 0x6F, 0x6C, 0x6D, 0x61, 0x70, 0x20, 0x2D, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x79, 0x6D, 0x62, + 0x6F, 0x6C, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x73, 0x6C, + 0x6F, 0x74, 0x73, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, + 0x73, 0x20, 0x2D, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, + 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6E, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x6D, 0x61, 0x70, 0x20, 0x2D, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, + 0x6F, 0x66, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6F, 0x64, 0x65, + 0x20, 0x69, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, + 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x2D, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x6E, 0x61, 0x6C, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x65, 0x6E, 0x63, 0x6C, 0x6F, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x73, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x64, 0x65, 0x66, 0x73, 0x20, 0x2D, 0x20, + 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x64, + 0x65, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6D, 0x61, + 0x79, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x69, 0x61, 0x74, 0x65, 0x2E, 0x0A, 0xDA, + 0x8A, 0xB4, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x82, 0x5D, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0xB5, 0xDA, 0x08, 0xCE, 0x80, 0xAD, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2F, 0x74, 0x72, 0x69, 0x6D, 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, + 0x65, 0x74, 0x29, 0x0A, 0x0A, 0x54, 0x72, 0x69, 0x6D, 0x20, 0x6C, 0x65, 0x61, 0x64, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x77, + 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, + 0x60, 0x73, 0x65, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, + 0x64, 0x2C, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x6C, 0x79, + 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, + 0x73, 0x65, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x2E, 0xDA, 0x8A, 0xB6, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x22, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xB7, 0xDA, 0x08, + 0xCE, 0x80, 0x91, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6D, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74, 0x20, + 0x62, 0x61, 0x73, 0x65, 0x20, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x69, 0x6E, 0x67, + 0x20, 0x50, 0x45, 0x47, 0x73, 0x2E, 0x20, 0x41, 0x6E, 0x79, 0x20, 0x75, 0x6E, 0x64, 0x65, 0x66, + 0x69, 0x6E, 0x65, 0x64, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x0A, 0x66, 0x6F, + 0x75, 0x6E, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x69, + 0x6E, 0x67, 0x20, 0x61, 0x20, 0x70, 0x65, 0x67, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x28, 0x69, 0x66, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x64, 0x29, 0x2E, 0xDA, 0x8A, 0xB8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x85, 0xB3, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xB9, 0xDA, 0x08, 0xCE, 0x80, 0x89, 0x28, 0x61, 0x6E, + 0x79, 0x3F, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, + 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x61, + 0x6C, 0x73, 0x65, 0x79, 0x2C, 0x0A, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, + 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x8A, 0xBD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x87, 0x0E, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xBE, 0xDA, 0x08, 0xCE, 0x3F, 0x28, 0x66, + 0x69, 0x6C, 0x65, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x74, 0x6F, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x69, 0x6E, + 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0xC1, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x26, 0x01, 0xDA, 0x06, 0xDA, 0x8A, + 0xC2, 0xDA, 0x08, 0xCE, 0x70, 0x28, 0x67, 0x63, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, + 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, + 0x66, 0x20, 0x67, 0x61, 0x72, 0x62, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x8A, 0xC3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x83, 0x57, 0x83, 0xED, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xC4, 0xDA, 0x08, 0xCE, 0x60, 0x28, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x62, 0x79, 0x74, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x72, 0x20, 0x62, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x70, 0x75, 0x74, 0x20, 0x61, 0x20, 0x73, 0x69, + 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x60, 0x62, 0x60, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0xDA, 0x8A, + 0xC5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x81, 0x6C, 0x01, 0xDA, 0x06, + 0xDA, 0x85, 0xFC, 0xDA, 0x08, 0xCE, 0x80, 0x80, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, + 0x6C, 0x65, 0x61, 0x72, 0x20, 0x61, 0x72, 0x72, 0x29, 0x0A, 0x0A, 0x45, 0x6D, 0x70, 0x74, 0x69, + 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x73, 0x65, 0x74, + 0x74, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, + 0x74, 0x6F, 0x20, 0x30, 0x20, 0x62, 0x75, 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, + 0x74, 0x20, 0x66, 0x72, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, + 0x6E, 0x67, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x80, 0x8E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x83, 0x39, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x5B, 0xDA, 0x08, 0xCE, 0x1C, + 0x28, 0x6F, 0x64, 0x64, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x64, 0x64, 0x2E, 0xDA, 0x81, 0x95, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x82, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x92, + 0xDA, 0x08, 0xCE, 0x81, 0xC7, 0x28, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x20, 0x66, 0x20, 0x69, + 0x6E, 0x69, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x64, 0x75, 0x63, 0x65, + 0x2C, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x6B, 0x6E, 0x6F, 0x77, 0x20, 0x61, 0x73, 0x20, 0x66, + 0x6F, 0x6C, 0x64, 0x2D, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x6D, 0x61, 0x6E, 0x79, + 0x20, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x2C, 0x20, 0x74, 0x72, 0x61, 0x6E, + 0x73, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x0A, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, + 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x29, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, + 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x62, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6C, + 0x79, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x66, 0x60, 0x20, 0x74, 0x6F, 0x0A, 0x65, 0x61, 0x63, 0x68, + 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x6F, 0x72, 0x64, 0x65, + 0x72, 0x2E, 0x20, 0x60, 0x66, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x32, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x60, 0x28, 0x66, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x20, 0x65, + 0x6C, 0x29, 0x60, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0A, 0x60, 0x61, 0x63, 0x63, 0x75, + 0x6D, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, + 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x65, 0x6C, 0x60, + 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, + 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x2E, 0x0A, 0x60, 0x66, + 0x60, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x60, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x60, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, + 0x74, 0x6F, 0x20, 0x60, 0x66, 0x60, 0x2E, 0x20, 0x60, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x60, + 0x0A, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6E, 0x61, 0x6C, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x66, 0x60, 0x2E, 0xDA, 0x8A, 0xC6, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0xA1, 0x03, 0xDA, 0x06, 0xDA, 0x8A, 0xC7, + 0xDA, 0x08, 0xCE, 0x6A, 0x28, 0x65, 0x76, 0x2F, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x2D, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, + 0x6E, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x20, 0x4C, 0x69, 0x6B, + 0x65, 0x20, 0x60, 0x65, 0x76, 0x2F, 0x64, 0x6F, 0x2D, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x60, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, + 0x6C, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6C, 0x79, 0x2E, 0xDA, 0x37, + 0xCB, 0xDA, 0x8A, 0xCB, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x81, 0x91, 0x01, + 0xDA, 0x06, 0xDA, 0x8A, 0xCC, 0xDA, 0x08, 0xCE, 0x82, 0x1C, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x70, 0x6F, 0x72, 0x74, + 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, + 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x6F, 0x6B, 0x20, 0x75, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, + 0x6E, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x6E, 0x61, 0x6D, 0x65, 0x2C, 0x20, 0x70, 0x6F, 0x72, 0x74, + 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x65, 0x6E, 0x64, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x67, 0x72, 0x61, 0x6D, 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, + 0x6E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, + 0x65, 0x73, 0x74, 0x61, 0x62, 0x6C, 0x69, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x63, + 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x4F, 0x6E, 0x20, 0x50, 0x6F, + 0x73, 0x69, 0x78, 0x20, 0x70, 0x6C, 0x61, 0x74, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x2C, 0x20, 0x79, + 0x6F, 0x75, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x75, 0x73, 0x65, 0x20, 0x3A, 0x75, 0x6E, 0x69, 0x78, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6E, + 0x6E, 0x65, 0x63, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x75, 0x6E, 0x69, 0x78, 0x20, 0x64, + 0x6F, 0x6D, 0x61, 0x69, 0x6E, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2C, 0x20, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6F, 0x72, + 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x4F, 0x6E, 0x20, 0x4C, + 0x69, 0x6E, 0x75, 0x78, 0x2C, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x75, + 0x6E, 0x69, 0x78, 0x20, 0x64, 0x6F, 0x6D, 0x61, 0x69, 0x6E, 0x20, 0x73, 0x6F, 0x63, 0x6B, 0x65, + 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x6C, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, + 0x27, 0x40, 0x27, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6E, + 0x20, 0x70, 0x6F, 0x72, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x6D, 0x75, 0x6C, 0x74, 0x69, + 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, + 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x6E, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x2E, 0xDA, 0x8A, 0xCD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x81, 0x6B, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xCE, 0xDA, 0x08, 0xCE, 0x31, 0x28, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x70, 0x72, 0x6F, 0x6D, 0x70, 0x74, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x2E, 0xCF, + 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x2D, 0x69, 0x6E, 0x66, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x57, 0x81, 0x9A, 0x01, 0xDA, 0x06, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xF0, 0xFF, 0xDA, 0x08, 0xCE, 0x29, 0x54, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, + 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6E, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x79, 0xDA, + 0x82, 0xF5, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x36, 0x01, 0xDA, 0x06, + 0xDA, 0x82, 0xF3, 0xDA, 0x08, 0xCE, 0x80, 0x96, 0x28, 0x64, 0x65, 0x66, 0x65, 0x72, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, + 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x60, 0x20, 0x75, 0x6E, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, + 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x60, 0x62, + 0x6F, 0x64, 0x79, 0x60, 0x2C, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x73, 0x20, 0x61, 0x6E, + 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0x0A, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x6C, 0x73, + 0x6F, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x60, 0x20, 0x69, 0x66, 0x20, + 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x30, 0x2D, + 0x34, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x2E, 0xDA, 0x37, + 0xCB, 0xDA, 0x8A, 0xD1, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x84, 0xD3, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xD2, 0xDA, 0x08, 0xCE, 0x2D, 0x57, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, + 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6F, 0x2E, 0xDA, 0x8A, 0xD3, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, 0x66, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xD4, 0xDA, 0x08, + 0xCE, 0x7C, 0x28, 0x6F, 0x73, 0x2F, 0x69, 0x73, 0x61, 0x74, 0x74, 0x79, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x60, 0x66, 0x69, 0x6C, 0x65, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x61, 0x6C, 0x2E, 0x20, 0x49, + 0x66, 0x20, 0x60, 0x66, 0x69, 0x6C, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, + 0x61, 0x6E, 0x64, 0x61, 0x72, 0x64, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2E, 0xDA, 0x8A, + 0xD5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x63, 0x01, 0xDA, 0x06, 0xDA, 0x8A, + 0xD6, 0xDA, 0x08, 0xCE, 0x1C, 0x28, 0x6E, 0x61, 0x6E, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, + 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x61, 0x4E, + 0x2E, 0xDA, 0x8A, 0xD8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x07, 0x01, + 0xDA, 0x06, 0xDA, 0x80, 0xFB, 0xDA, 0x08, 0xCE, 0x66, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x6B, 0x65, + 0x79, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x29, 0x0A, + 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x28, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x29, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, + 0x8A, 0xD9, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x67, 0x86, 0x7E, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0xDA, 0xDA, 0x08, 0xCE, 0x80, 0xBE, 0x28, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, + 0x68, 0x61, 0x6C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x29, 0x0A, 0x0A, 0x55, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, + 0x61, 0x6C, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x6F, 0x70, 0x74, + 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x61, 0x6C, 0x69, 0x61, 0x73, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x64, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, + 0x68, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8A, 0xDB, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xE1, 0x01, 0xDA, 0x06, 0xDA, 0x86, 0x08, 0xDA, + 0x08, 0xCE, 0x80, 0x8F, 0x54, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6C, 0x65, 0x76, + 0x65, 0x6C, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x77, 0x61, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, + 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x69, 0x6E, + 0x74, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x61, 0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x62, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x62, 0x75, 0x74, 0x20, 0x63, + 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, 0x20, 0x61, 0x73, 0x20, 0x6E, 0x6F, 0x72, 0x6D, + 0x61, 0x6C, 0x2E, 0xDA, 0x8A, 0xDC, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, + 0x74, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xDD, 0xDA, 0x08, 0xCE, 0x2E, 0x28, 0x61, 0x62, 0x73, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, + 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0xDA, 0x80, 0xE4, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xF8, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x87, 0xDA, 0x08, 0xCE, + 0x3F, 0x28, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, + 0xDA, 0x89, 0x29, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x36, 0x01, 0xDA, + 0x06, 0xDA, 0x89, 0x27, 0xDA, 0x08, 0xCE, 0x24, 0x28, 0x6E, 0x65, 0x67, 0x3F, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, + 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x30, 0x2E, 0xDA, 0x8A, 0xDE, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x16, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xDF, + 0xDA, 0x08, 0xCE, 0x80, 0xD3, 0x28, 0x67, 0x63, 0x73, 0x65, 0x74, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x76, 0x61, 0x6C, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x53, + 0x65, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, + 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x67, 0x61, 0x72, 0x62, 0x61, 0x67, 0x65, + 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x4C, 0x6F, 0x77, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x72, 0x76, 0x61, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x73, 0x6C, 0x6F, + 0x77, 0x65, 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6C, 0x65, 0x73, 0x73, + 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x48, 0x69, 0x67, 0x68, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x66, 0x61, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x2E, 0xDA, 0x8A, 0xE0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0xDB, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xE1, 0xDA, 0x08, 0xCE, + 0x81, 0x56, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x65, 0x6E, 0x73, 0x75, 0x72, 0x65, 0x20, + 0x61, 0x72, 0x72, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x67, 0x72, 0x6F, + 0x77, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x45, 0x6E, 0x73, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x62, 0x61, + 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x69, 0x73, 0x20, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x20, 0x65, 0x6E, 0x6F, 0x75, 0x67, 0x68, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x60, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x60, 0x20, 0x69, + 0x74, 0x65, 0x6D, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, + 0x6E, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x67, 0x72, 0x6F, 0x77, 0x74, 0x68, + 0x2E, 0x20, 0x60, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x60, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x60, 0x67, 0x72, 0x6F, 0x77, 0x74, 0x68, 0x60, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, + 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x65, + 0x6E, 0x6F, 0x75, 0x67, 0x68, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, + 0x6F, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, + 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x6D, + 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, + 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x73, 0x6F, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6E, 0x6F, 0x75, 0x67, + 0x68, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2E, 0xDA, 0x8A, 0xE2, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0x94, 0x81, 0xCB, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x95, 0xDA, 0x08, 0xCE, + 0x60, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x69, 0x73, 0x20, 0x73, 0x65, 0x74, 0x20, 0x79, 0x65, 0x74, + 0x2E, 0xDA, 0x8A, 0xE3, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x06, 0x01, + 0xDA, 0x06, 0xDA, 0x8A, 0xE4, 0xDA, 0x08, 0xCE, 0x6D, 0x28, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, + 0x20, 0x6E, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x2C, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x30, 0x20, 0x74, 0x69, + 0x6D, 0x65, 0x73, 0x2E, 0x20, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x6F, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x88, 0xFA, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x68, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0xF7, 0xDA, 0x08, 0xCE, 0x26, + 0x28, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, + 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, + 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2E, 0xDA, 0x83, 0x8C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x6C, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x8A, 0xDA, 0x08, 0xCE, 0x1F, 0x28, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, + 0x66, 0x20, 0x78, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0xE8, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x8F, 0x61, 0x81, 0x0D, 0x01, 0xDA, 0x06, 0xDA, 0x83, + 0x84, 0xDA, 0x08, 0xCE, 0x80, 0xA5, 0x28, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, 0x74, 0x6F, + 0x2D, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x73, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x72, + 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, + 0x72, 0x74, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, + 0x73, 0x69, 0x76, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2C, 0x20, 0x61, 0x6C, + 0x73, 0x6F, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x27, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x27, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x2E, 0xDA, 0x8A, 0xE9, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x80, 0xD6, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xEA, 0xDA, + 0x08, 0xCE, 0x79, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x72, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, + 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, + 0x6C, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, + 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, + 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x67, 0x63, 0x63, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, + 0x63, 0x6C, 0x61, 0x6E, 0x67, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x73, 0x76, 0x63, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x75, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x0A, 0x0A, 0xDA, 0x8A, 0xEB, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x62, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xEC, + 0xDA, 0x08, 0xCE, 0x80, 0xC1, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x6E, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, + 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x74, 0x2F, 0x72, 0x65, 0x61, 0x64, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x77, 0x61, 0x69, 0x74, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x6F, 0x20, 0x61, 0x72, 0x72, 0x69, 0x76, 0x65, 0x20, 0x72, 0x61, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x65, 0x61, 0x72, + 0x6C, 0x79, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, + 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, 0x69, 0x6E, + 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x8A, 0xED, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x86, 0x77, 0x81, 0x95, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xEE, 0xDA, 0x08, 0xCE, 0x80, 0xCF, + 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x61, 0x72, 0x67, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x6C, 0x79, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x27, + 0x73, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, + 0x2E, 0x20, 0x4E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x6C, 0x79, 0x2C, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, + 0x20, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, + 0x70, 0x75, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, + 0x8A, 0xEF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x87, 0x01, 0xDA, + 0x06, 0xDA, 0x85, 0x41, 0xDA, 0x08, 0xCE, 0x80, 0x80, 0x28, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0x66, 0x20, 0x66, 0x6D, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x69, + 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x60, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, + 0x66, 0x6D, 0x74, 0x20, 0x3B, 0x78, 0x73, 0x29, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x64, + 0x79, 0x6E, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x20, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x29, 0x60, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, + 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x2E, 0xDA, 0x8A, 0xF0, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0x93, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xF1, 0xDA, 0x08, 0xCE, + 0x81, 0xE3, 0x28, 0x65, 0x76, 0x2F, 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x73, + 0x65, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x6F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, + 0x20, 0x74, 0x6F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x53, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6C, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x61, + 0x6E, 0x63, 0x65, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x74, 0x6F, 0x63, 0x61, 0x6E, 0x63, + 0x65, 0x6C, 0x60, 0x20, 0x74, 0x61, 0x73, 0x6B, 0x20, 0x61, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x60, 0x65, 0x76, 0x2F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x60, 0x2E, 0x20, 0x41, 0x66, + 0x74, 0x65, 0x72, 0x20, 0x60, 0x73, 0x65, 0x63, 0x60, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, + 0x73, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, + 0x70, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6D, 0x70, 0x74, 0x20, 0x63, + 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, + 0x74, 0x6F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x60, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x60, 0x74, 0x6F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x60, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x60, + 0x73, 0x65, 0x63, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, + 0x20, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x70, 0x61, 0x72, 0x74, + 0x2E, 0x20, 0x60, 0x74, 0x6F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x60, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2F, 0x72, 0x6F, 0x6F, 0x74, 0x29, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x66, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2C, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6B, 0x20, 0x28, 0x72, 0x6F, 0x6F, 0x74, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x2E, 0x20, 0x60, 0x74, 0x6F, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x60, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x29, 0x60, 0x2C, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x66, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x2C, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x74, + 0x6F, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x60, 0x20, 0x69, 0x6D, 0x6D, 0x65, 0x64, 0x69, 0x61, + 0x74, 0x65, 0x6C, 0x79, 0x2E, 0xDA, 0x8A, 0xF2, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x80, 0xA1, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xF3, 0xDA, 0x08, 0xCE, 0x74, 0x28, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x20, 0x76, 0x61, 0x6C, 0x29, 0x0A, 0x0A, + 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, + 0x0A, 0x45, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x64, 0x65, + 0x66, 0x20, 0x73, 0x79, 0x6D, 0x20, 0x28, 0x69, 0x66, 0x20, 0x28, 0x3D, 0x20, 0x6E, 0x69, 0x6C, + 0x20, 0x73, 0x79, 0x6D, 0x29, 0x20, 0x76, 0x61, 0x6C, 0x20, 0x73, 0x79, 0x6D, 0x29, 0x29, 0x60, + 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x86, 0xE1, 0xCE, 0x14, 0x2F, 0x75, 0x73, 0x72, 0x2F, 0x6C, 0x6F, + 0x63, 0x61, 0x6C, 0x2F, 0x6C, 0x69, 0x62, 0x2F, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x8A, 0xF6, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0x33, 0x01, 0xDA, 0x06, 0xDA, 0x4A, + 0xDA, 0x08, 0xCE, 0x80, 0xC7, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, + 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x68, 0x61, 0x6E, + 0x64, 0x6C, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x6F, 0x75, + 0x73, 0x6C, 0x79, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x63, + 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x42, 0x6C, 0x6F, 0x63, + 0x6B, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, 0x2C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0xDA, 0x8A, 0xF7, 0xD3, + 0x02, 0xDA, 0x06, 0xDA, 0x8A, 0xF8, 0xDA, 0x08, 0xCE, 0x80, 0x92, 0x28, 0x62, 0x72, 0x73, 0x68, + 0x69, 0x66, 0x74, 0x20, 0x78, 0x20, 0x26, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x73, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x20, 0x62, 0x69, 0x74, 0x20, 0x73, 0x68, 0x69, 0x66, + 0x74, 0x65, 0x64, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x73, 0x2E, 0x20, 0x78, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, 0xDA, 0x8A, 0xFA, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x81, 0x4F, 0x01, 0xDA, 0x06, 0xDA, + 0x8A, 0xFB, 0xDA, 0x08, 0xCE, 0x81, 0xCF, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x65, + 0x6B, 0x20, 0x66, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x20, + 0x6E, 0x29, 0x0A, 0x0A, 0x4A, 0x75, 0x6D, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x60, 0x66, 0x60, 0x2E, + 0x20, 0x60, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x60, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x75, + 0x72, 0x20, 0x2D, 0x20, 0x6A, 0x75, 0x6D, 0x70, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x73, 0x65, 0x74, 0x20, 0x2D, 0x20, 0x6A, 0x75, 0x6D, 0x70, 0x20, 0x72, 0x65, + 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, + 0x67, 0x69, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x65, 0x6E, 0x64, 0x20, 0x2D, 0x20, 0x6A, 0x75, + 0x6D, 0x70, 0x20, 0x72, 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x0A, 0x0A, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, 0x20, + 0x60, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x3A, 0x63, 0x75, 0x72, + 0x2E, 0x20, 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x61, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x6D, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, + 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x65, 0x65, 0x6B, 0x20, + 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x60, 0x6E, 0x60, + 0x20, 0x6D, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x6C, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, + 0x6C, 0x61, 0x72, 0x67, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x6D, + 0x6F, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x34, 0x47, 0x42, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x68, + 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x2E, 0xDA, 0x8A, 0xFC, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x83, 0x20, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0xFD, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x63, + 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3C, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x45, + 0x71, 0x75, 0x69, 0x76, 0x61, 0x6C, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x3C, 0x60, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x6C, 0x79, 0x6D, + 0x6F, 0x72, 0x70, 0x68, 0x69, 0x63, 0x20, 0x60, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x60, + 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x72, 0x69, 0x6D, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, + 0x2E, 0xDA, 0x8B, 0x00, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x1B, 0x01, + 0xDA, 0x06, 0xDA, 0x8B, 0x01, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, + 0x65, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x71, 0x75, 0x69, 0x76, 0x61, + 0x6C, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x3D, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x6C, 0x79, 0x6D, 0x6F, 0x72, 0x70, 0x68, 0x69, + 0x63, 0x20, 0x60, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x60, 0x20, 0x69, 0x6E, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x72, 0x69, 0x6D, 0x69, 0x74, 0x69, 0x76, 0x65, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x2E, 0xDA, 0x8B, 0x04, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x2A, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x05, + 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x3E, 0x20, 0x26, 0x20, + 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6C, 0x65, 0x6E, 0x74, 0x20, + 0x6F, 0x66, 0x20, 0x60, 0x3E, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, + 0x20, 0x70, 0x6F, 0x6C, 0x79, 0x6D, 0x6F, 0x72, 0x70, 0x68, 0x69, 0x63, 0x20, 0x60, 0x63, 0x6F, + 0x6D, 0x70, 0x61, 0x72, 0x65, 0x60, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, + 0x66, 0x20, 0x70, 0x72, 0x69, 0x6D, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, + 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x2E, 0xDA, 0x8B, 0x08, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8E, 0xC8, 0x03, 0xDA, 0x06, 0xDA, 0x8B, 0x09, 0xDA, 0x08, 0xCE, 0x80, 0x92, + 0x28, 0x65, 0x76, 0x2F, 0x67, 0x61, 0x74, 0x68, 0x65, 0x72, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, + 0x69, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, + 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x6A, 0x6F, 0x69, 0x6E, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x63, + 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x61, 0x74, 0x68, 0x65, 0x72, 0x65, 0x64, 0x20, 0x72, 0x65, + 0x73, 0x75, 0x6C, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x84, 0x41, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8A, 0x75, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x3D, 0xDA, 0x08, 0xCE, 0x7C, 0x28, 0x65, 0x76, + 0x61, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x63, + 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x0A, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, + 0x65, 0x65, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x75, 0x73, 0x65, 0x20, 0x60, 0x72, 0x75, 0x6E, 0x2D, + 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x60, 0x2E, 0xDA, 0x8B, 0x2A, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x80, 0xE2, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x2B, 0xDA, 0x08, + 0xCE, 0x80, 0x96, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x20, 0x62, 0x79, 0x74, 0x65, 0x2D, 0x76, 0x61, 0x6C, + 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x62, 0x75, + 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, + 0x72, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x41, + 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, + 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x65, 0x72, 0x63, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x31, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x20, 0x30, 0x2D, 0x32, 0x35, 0x35, 0x2E, 0xDA, 0x8B, 0x2C, 0xD3, 0x04, 0xDA, 0x81, + 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8F, 0x8E, 0x01, 0xDA, 0x06, 0xDA, 0x8B, + 0x2D, 0xDA, 0x08, 0xCE, 0x80, 0x8E, 0x4E, 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x72, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, + 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0x20, 0x43, 0x6F, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6F, 0x6E, + 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x61, 0x72, 0x67, 0x76, 0x5B, 0x30, 0x5D, 0x60, 0x20, + 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x74, 0x6F, 0x0A, 0x20, + 0x20, 0x60, 0x69, 0x6E, 0x74, 0x20, 0x6D, 0x61, 0x69, 0x6E, 0x28, 0x69, 0x6E, 0x74, 0x20, 0x61, + 0x72, 0x67, 0x63, 0x2C, 0x20, 0x63, 0x68, 0x61, 0x72, 0x20, 0x2A, 0x2A, 0x61, 0x72, 0x67, 0x76, + 0x29, 0x3B, 0x60, 0x2E, 0xDA, 0x8B, 0x2E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, + 0x87, 0xB4, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x2F, 0xDA, 0x08, 0xCE, 0x5A, 0x28, 0x6F, 0x73, 0x2F, + 0x63, 0x64, 0x20, 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, + 0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x6F, 0x6E, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x2C, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x66, 0x61, + 0x69, 0x6C, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x8B, 0x30, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x83, 0xF9, 0x81, 0x3A, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x88, 0xDA, 0x08, 0xCE, 0x80, 0xEF, + 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x72, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x61, 0x72, + 0x72, 0x20, 0x61, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x61, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x60, 0x61, 0x74, 0x60, 0x20, 0x69, + 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x60, 0x61, 0x72, 0x72, 0x60, 0x2E, 0x20, 0x60, + 0x61, 0x74, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x66, 0x72, + 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x6E, + 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6E, + 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x2C, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x69, 0x73, 0x20, 0x31, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, + 0x88, 0x81, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xC9, 0x01, 0xDA, 0x06, + 0xDA, 0x88, 0x79, 0xDA, 0x08, 0xCE, 0x80, 0x9F, 0x28, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, + 0x20, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, + 0x65, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x61, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, + 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2E, 0xDA, 0x8B, 0x31, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0x94, 0x82, 0x79, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x32, 0xDA, 0x08, 0xCE, 0x80, + 0x8E, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x78, 0x73, 0x74, + 0x61, 0x63, 0x6B, 0x20, 0x66, 0x69, 0x62, 0x20, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, + 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, + 0x6D, 0x75, 0x6D, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x69, + 0x6E, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, + 0x6D, 0x75, 0x6D, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x38, 0x31, 0x39, 0x32, 0x2E, 0xDA, + 0x8B, 0x33, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, 0xE5, 0x01, 0xDA, 0x06, + 0xDA, 0x8B, 0x34, 0xDA, 0x08, 0xCE, 0x81, 0x3A, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x72, 0x66, + 0x74, 0x69, 0x6D, 0x65, 0x20, 0x66, 0x6D, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, + 0x6D, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x46, 0x6F, 0x72, 0x6D, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x6F, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x69, 0x6D, + 0x65, 0x20, 0x69, 0x66, 0x20, 0x60, 0x74, 0x69, 0x6D, 0x65, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x69, + 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, + 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x72, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x49, 0x53, 0x4F, 0x20, 0x43, 0x38, 0x39, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x66, 0x74, 0x69, 0x6D, 0x65, 0x28, 0x29, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x55, 0x54, 0x43, 0x20, 0x75, 0x6E, 0x6C, + 0x65, 0x73, 0x73, 0x20, 0x60, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x69, 0x6E, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, + 0x63, 0x61, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x7A, 0x6F, 0x6E, + 0x65, 0x2E, 0xDA, 0x8B, 0x35, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8C, 0x38, + 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x36, 0xDA, 0x08, 0xCE, 0x45, 0x28, 0x65, 0x76, 0x2F, 0x61, 0x63, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x2D, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x72, 0x77, 0x6C, 0x6F, + 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x41, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x61, 0x20, 0x77, + 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x72, + 0x65, 0x61, 0x64, 0x2D, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x2E, 0xDA, + 0x8B, 0x37, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x72, 0x01, 0xDA, 0x06, 0xDA, + 0x8B, 0x38, 0xDA, 0x08, 0xCE, 0x1E, 0x28, 0x74, 0x72, 0x75, 0x65, 0x3F, 0x20, 0x78, 0x29, 0x0A, + 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x2E, 0xDA, 0x8B, 0x3A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x86, 0x95, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x3B, 0xDA, 0x08, 0xCE, 0x43, 0x28, 0x64, 0x69, 0x73, + 0x74, 0x69, 0x6E, 0x63, 0x74, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x64, 0x65, 0x64, 0x75, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x78, 0x73, 0x60, 0x2E, 0xDA, + 0x8B, 0x40, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0xDD, 0x01, 0xDA, 0x06, + 0xDA, 0x8B, 0x41, 0xDA, 0x08, 0xCE, 0x5E, 0x28, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0x20, 0x57, 0x69, 0x6C, + 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, + 0x60, 0x78, 0x60, 0x20, 0x68, 0x61, 0x73, 0x20, 0x6E, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, + 0x74, 0x79, 0x70, 0x65, 0x2E, 0xDA, 0x8B, 0x42, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8B, 0x43, 0xDA, + 0x08, 0xCE, 0x80, 0xE3, 0x28, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x59, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x73, 0x2C, 0x20, 0x69, 0x74, 0x73, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x61, 0x6E, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x73, 0x20, 0x69, + 0x74, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x79, 0x69, 0x65, 0x6C, + 0x64, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x2E, 0xDA, 0x8B, 0x45, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x17, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x46, 0xDA, 0x08, 0xCE, 0x40, + 0x28, 0x70, 0x72, 0x69, 0x6E, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x60, 0x2C, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x64, 0x64, 0x20, 0x74, + 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x2E, + 0xDA, 0x8B, 0x47, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xC9, 0x01, 0xDA, + 0x06, 0xDA, 0x8B, 0x48, 0xDA, 0x08, 0xCE, 0x80, 0xBB, 0x28, 0x63, 0x61, 0x73, 0x65, 0x20, 0x64, + 0x69, 0x73, 0x70, 0x61, 0x74, 0x63, 0x68, 0x20, 0x26, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x29, + 0x0A, 0x0A, 0x53, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, + 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x69, 0x73, 0x70, 0x61, 0x74, 0x63, 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x2E, 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x60, 0x70, 0x61, 0x69, 0x72, 0x73, 0x60, 0x0A, 0x68, + 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x64, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x6F, 0x66, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x2E, 0x0A, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x69, 0x73, + 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8B, 0x4D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xCE, 0x13, 0x73, 0x72, 0x63, 0x2F, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x69, 0x6E, 0x74, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x2E, 0x63, 0x80, 0xD0, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x4E, 0xDA, 0x08, + 0xCE, 0x73, 0x28, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, + 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x2F, 0x75, 0x36, 0x34, 0x20, 0x6F, 0x72, 0x20, 0x69, + 0x6E, 0x74, 0x2F, 0x73, 0x36, 0x34, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x46, 0x61, 0x69, 0x6C, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F, + 0x66, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x69, + 0x6E, 0x74, 0x33, 0x32, 0x2E, 0xDA, 0x8B, 0x4F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x80, 0x82, 0x82, 0x60, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x50, 0xDA, 0x08, 0xCE, 0x81, 0x1F, 0x28, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x6C, 0x69, 0x74, 0x20, 0x64, 0x65, 0x73, 0x74, + 0x20, 0x73, 0x72, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x65, 0x73, 0x74, 0x2D, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, 0x72, 0x63, 0x2D, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, + 0x72, 0x63, 0x2D, 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, + 0x60, 0x73, 0x72, 0x63, 0x60, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x60, 0x64, 0x65, 0x73, 0x74, + 0x60, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, + 0x79, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x77, 0x68, 0x69, + 0x63, 0x68, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x73, 0x72, 0x63, 0x60, + 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x70, 0x79, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x64, 0x65, 0x73, + 0x74, 0x60, 0x2E, 0x20, 0x49, 0x6E, 0x64, 0x69, 0x63, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x62, 0x65, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x6F, + 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x66, 0x72, + 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x73, + 0x72, 0x63, 0x60, 0x20, 0x6F, 0x72, 0x20, 0x60, 0x64, 0x65, 0x73, 0x74, 0x60, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x64, 0x65, 0x73, 0x74, 0x60, 0x2E, 0xDA, 0x8B, + 0x51, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x0C, 0x01, 0xDA, 0x06, + 0xDA, 0x8B, 0x52, 0xDA, 0x08, 0xCE, 0x2B, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, + 0x6E, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x72, 0x63, 0x74, 0x61, 0x6E, 0x67, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x2E, 0xDA, 0x88, 0x7E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xBC, + 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x7C, 0xDA, 0x08, 0xCE, 0x63, 0x28, 0x72, 0x65, 0x76, 0x65, 0x72, + 0x73, 0x65, 0x21, 0x20, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x69, 0x74, 0x0A, 0x6D, 0x75, 0x74, 0x61, 0x74, 0x65, 0x64, 0x2E, 0xDA, 0x8B, 0x53, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x8A, 0x4E, 0x01, 0xDA, 0x06, 0xDA, 0x8B, + 0x54, 0xDA, 0x08, 0xCE, 0x80, 0xC5, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x69, 0x70, 0x65, 0x29, 0x0A, + 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, + 0x6C, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, + 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x74, 0x77, + 0x6F, 0x2D, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, + 0x64, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0xDA, 0x48, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x3D, 0x01, 0xDA, 0x06, 0xDA, 0x65, 0xDA, 0x08, 0xCE, + 0x81, 0x02, 0x28, 0x74, 0x79, 0x70, 0x65, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x60, 0x78, 0x60, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, + 0x2E, 0x20, 0x60, 0x78, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x69, 0x6C, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x62, 0x6F, 0x6F, + 0x6C, 0x65, 0x61, 0x6E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, + 0x20, 0x3A, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6B, 0x65, + 0x79, 0x77, 0x6F, 0x72, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x69, 0x62, 0x65, 0x72, 0x0A, 0x0A, 0x6F, 0x72, 0x20, 0x61, + 0x6E, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x2E, 0xDA, 0x8B, 0x55, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, + 0x82, 0x8D, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x14, 0xDA, 0x08, 0xCE, 0x69, 0x28, 0x6E, 0x61, 0x74, + 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, + 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6C, 0x79, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, + 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x33, 0x32, + 0x20, 0x62, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x74, 0x77, 0x6F, 0x27, + 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x2E, 0xDA, 0x8B, 0x56, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x04, 0x89, 0xAC, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x57, 0xDA, 0x08, 0xCE, 0x83, 0xA6, 0x28, 0x6F, + 0x73, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x66, 0x72, + 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x50, 0x4F, 0x53, 0x49, 0x58, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, + 0x2E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6F, 0x73, 0x2F, + 0x63, 0x68, 0x6D, 0x6F, 0x64, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6F, 0x6E, 0x6C, 0x79, + 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x66, + 0x6C, 0x61, 0x67, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x38, 0x72, 0x36, 0x36, 0x36, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x6F, 0x77, 0x65, 0x64, + 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, + 0x6C, 0x6C, 0x6F, 0x77, 0x73, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x72, 0x20, 0x2D, + 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x0A, 0x20, 0x20, 0x2A, 0x20, + 0x3A, 0x77, 0x20, 0x2D, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x0A, + 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x63, 0x20, 0x2D, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x28, 0x4F, 0x5C, 0x5F, 0x43, + 0x52, 0x45, 0x41, 0x54, 0x45, 0x29, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x65, 0x20, 0x2D, 0x20, + 0x66, 0x61, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, + 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x20, 0x28, 0x4F, 0x5C, 0x5F, 0x45, 0x58, 0x43, 0x4C, + 0x29, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x74, 0x20, 0x2D, 0x20, 0x73, 0x68, 0x6F, 0x72, 0x74, + 0x65, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x30, 0x20, + 0x28, 0x4F, 0x5C, 0x5F, 0x54, 0x52, 0x55, 0x4E, 0x43, 0x29, 0x0A, 0x0A, 0x50, 0x6F, 0x73, 0x69, + 0x78, 0x2D, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x3A, 0x0A, 0x0A, 0x20, + 0x20, 0x2A, 0x20, 0x3A, 0x61, 0x20, 0x2D, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x28, 0x4F, 0x5C, 0x5F, 0x41, 0x50, 0x50, + 0x45, 0x4E, 0x44, 0x29, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x78, 0x20, 0x2D, 0x20, 0x4F, 0x5C, + 0x5F, 0x53, 0x59, 0x4E, 0x43, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x43, 0x20, 0x2D, 0x20, 0x4F, + 0x5C, 0x5F, 0x4E, 0x4F, 0x43, 0x54, 0x54, 0x59, 0x0A, 0x0A, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, + 0x73, 0x2D, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x3A, 0x0A, 0x0A, 0x20, + 0x20, 0x2A, 0x20, 0x3A, 0x52, 0x20, 0x2D, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x73, 0x20, 0x28, 0x46, 0x49, 0x4C, 0x45, 0x5C, 0x5F, 0x53, 0x48, 0x41, 0x52, 0x45, + 0x5C, 0x5F, 0x52, 0x45, 0x41, 0x44, 0x29, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x57, 0x20, 0x2D, + 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x73, 0x20, 0x28, 0x46, + 0x49, 0x4C, 0x45, 0x5C, 0x5F, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5C, 0x5F, 0x57, 0x52, 0x49, 0x54, + 0x45, 0x29, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x44, 0x20, 0x2D, 0x20, 0x73, 0x68, 0x61, 0x72, + 0x65, 0x20, 0x64, 0x65, 0x6C, 0x65, 0x74, 0x65, 0x73, 0x20, 0x28, 0x46, 0x49, 0x4C, 0x45, 0x5C, + 0x5F, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5C, 0x5F, 0x44, 0x45, 0x4C, 0x45, 0x54, 0x45, 0x29, 0x0A, + 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x48, 0x20, 0x2D, 0x20, 0x46, 0x49, 0x4C, 0x45, 0x5C, 0x5F, 0x41, + 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x5C, 0x5F, 0x48, 0x49, 0x44, 0x44, 0x45, 0x4E, + 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x4F, 0x20, 0x2D, 0x20, 0x46, 0x49, 0x4C, 0x45, 0x5C, 0x5F, + 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x5C, 0x5F, 0x52, 0x45, 0x41, 0x44, 0x4F, + 0x4E, 0x4C, 0x59, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x46, 0x20, 0x2D, 0x20, 0x46, 0x49, 0x4C, + 0x45, 0x5C, 0x5F, 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x5C, 0x5F, 0x4F, 0x46, + 0x46, 0x4C, 0x49, 0x4E, 0x45, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x54, 0x20, 0x2D, 0x20, 0x46, + 0x49, 0x4C, 0x45, 0x5C, 0x5F, 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x5C, 0x5F, + 0x54, 0x45, 0x4D, 0x50, 0x4F, 0x52, 0x41, 0x52, 0x59, 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x64, + 0x20, 0x2D, 0x20, 0x46, 0x49, 0x4C, 0x45, 0x5C, 0x5F, 0x46, 0x4C, 0x41, 0x47, 0x5C, 0x5F, 0x44, + 0x45, 0x4C, 0x45, 0x54, 0x45, 0x5C, 0x5F, 0x4F, 0x4E, 0x5C, 0x5F, 0x43, 0x4C, 0x4F, 0x53, 0x45, + 0x0A, 0x20, 0x20, 0x2A, 0x20, 0x3A, 0x62, 0x20, 0x2D, 0x20, 0x46, 0x49, 0x4C, 0x45, 0x5C, 0x5F, + 0x46, 0x4C, 0x41, 0x47, 0x5C, 0x5F, 0x4E, 0x4F, 0x5C, 0x5F, 0x42, 0x55, 0x46, 0x46, 0x45, 0x52, + 0x49, 0x4E, 0x47, 0x0A, 0xDA, 0x8B, 0x58, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, + 0x81, 0x26, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x59, 0xDA, 0x08, 0xCE, 0x81, 0x28, 0x28, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, + 0x6E, 0x76, 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x61, 0x64, 0x20, 0x61, 0x20, 0x6E, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x72, + 0x65, 0x6C, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x2C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, + 0x61, 0x20, 0x2E, 0x73, 0x6F, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x55, 0x6E, + 0x69, 0x78, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x61, 0x20, 0x2E, 0x64, 0x6C, 0x6C, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x57, + 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, + 0x6E, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x66, 0x72, + 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0x5A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x85, 0xFA, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x5B, 0xDA, 0x08, 0xCE, 0x81, 0x1B, 0x28, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x2D, 0x69, 0x6E, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x73, 0x20, 0x66, + 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, 0x2E, 0x20, 0x4C, 0x6F, 0x6F, 0x6B, 0x73, 0x20, + 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x60, 0x64, 0x73, 0x60, 0x20, 0x76, 0x69, 0x61, 0x20, 0x61, 0x20, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x6B, 0x65, 0x79, 0x73, + 0x2C, 0x0A, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x66, 0x60, 0x20, 0x61, 0x70, + 0x70, 0x6C, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x2E, 0x0A, 0x4D, 0x69, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2C, + 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x8B, 0x62, 0xD3, 0x04, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x40, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x63, 0xDA, 0x08, 0xCE, 0x49, + 0x28, 0x64, 0x65, 0x66, 0x6E, 0x2D, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, + 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8B, 0x0C, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x8C, 0x03, 0xDA, 0x06, 0xDA, 0x8B, 0x65, + 0xDA, 0x08, 0xCE, 0x29, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, 0x0A, 0x0A, 0x41, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x60, 0x65, 0x76, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x60, 0x2E, 0xDA, 0x8B, 0x69, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0xA7, 0x01, 0xDA, 0x06, 0xDA, 0x8B, + 0x6A, 0xDA, 0x08, 0xCE, 0x80, 0xDC, 0x28, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, + 0x65, 0x32, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x32, + 0x2D, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, + 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x61, 0x63, 0x63, 0x75, 0x6D, 0x75, 0x6C, 0x61, 0x74, 0x65, + 0x60, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x69, + 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x0A, 0x54, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, + 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x64, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x20, 0x61, 0x73, 0x20, 0x69, 0x73, 0x2C, 0x20, 0x73, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x62, 0x65, 0x20, 0x60, 0x28, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x69, 0x6E, 0x64, 0x29, + 0x60, 0x2E, 0xDA, 0x8B, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0xCD, + 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x6D, 0xDA, 0x08, 0xCE, 0x81, 0x32, 0x28, 0x6D, 0x65, 0x6D, 0x63, + 0x6D, 0x70, 0x20, 0x61, 0x20, 0x62, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, 0x65, 0x6E, 0x20, + 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x2D, 0x61, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x2D, + 0x62, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x60, 0x61, 0x60, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x62, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x20, 0x30, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x20, 0x63, 0x6F, + 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, + 0x69, 0x73, 0x20, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x62, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x62, 0x2E, 0x20, 0x4F, + 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x61, + 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x66, 0x73, + 0x65, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x20, 0x73, + 0x6C, 0x69, 0x63, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x2E, 0xDA, 0x8B, 0x6E, + 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x4F, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x6F, + 0xDA, 0x08, 0xCE, 0x56, 0x28, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x74, 0x6F, 0x20, 0x69, 0x74, 0x73, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x20, 0x69, + 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x2E, 0x20, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, + 0x60, 0x28, 0x73, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x28, 0x6E, 0x6F, 0x74, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8B, 0x71, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x83, 0x31, 0x01, 0xDA, 0x06, 0xDA, + 0x8B, 0x72, 0xDA, 0x08, 0xCE, 0x19, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6E, 0x64, 0x61, + 0x72, 0x64, 0x20, 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xDA, + 0x8B, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x8D, 0x01, 0xDA, + 0x06, 0xDA, 0x85, 0x4D, 0xDA, 0x08, 0xCE, 0x3F, 0x28, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x66, 0x20, + 0x66, 0x6D, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, + 0x60, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x6E, 0x6F, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6E, + 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x2E, 0xDA, 0x8B, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x62, 0x81, 0xA4, 0x01, 0xDA, 0x06, 0xDA, 0x89, 0x72, 0xDA, 0x08, 0xCE, 0x6C, + 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x2D, 0x66, 0x6C, 0x61, + 0x74, 0x74, 0x65, 0x6E, 0x20, 0x74, 0x61, 0x62, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x6D, 0x65, 0x72, 0x67, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6C, 0x6C, 0x20, + 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0x75, 0xD3, + 0x02, 0xDA, 0x06, 0xDA, 0x8B, 0x76, 0xDA, 0x08, 0xCE, 0x80, 0xAD, 0x28, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x72, 0x6F, 0x77, + 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x75, + 0x67, 0x68, 0x74, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x69, 0x6E, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, + 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x79, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x2E, 0xDA, 0x8B, 0x78, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0xBC, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x79, 0xDA, 0x08, 0xCE, 0x81, + 0xC8, 0x28, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, + 0x20, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x74, + 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x75, 0x70, + 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x61, 0x73, 0x79, 0x6E, 0x63, 0x68, + 0x72, 0x6F, 0x6E, 0x6F, 0x75, 0x73, 0x6C, 0x79, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x77, + 0x6F, 0x72, 0x64, 0x20, 0x60, 0x3A, 0x61, 0x6C, 0x6C, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x6C, 0x79, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x74, + 0x6F, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x74, + 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, + 0x73, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x6F, + 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, + 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x77, 0x61, 0x73, 0x20, 0x73, 0x75, 0x63, + 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6C, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, + 0x66, 0x20, 0x65, 0x6E, 0x64, 0x2D, 0x6F, 0x66, 0x2D, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, + 0x72, 0x65, 0x61, 0x63, 0x68, 0x65, 0x64, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x61, + 0x69, 0x73, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x62, 0x6C, 0x65, + 0x6D, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x4F, 0x20, 0x6F, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x8B, 0x7A, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0xB9, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x7B, 0xDA, 0x08, 0xCE, + 0x47, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x68, 0x65, 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, + 0x0A, 0x50, 0x61, 0x73, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x20, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x6C, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6D, 0x20, 0x73, 0x68, 0x65, 0x6C, 0x6C, 0x2E, 0xDA, 0x8B, 0x7C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x73, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x7D, 0xDA, 0x08, 0xCE, 0x20, 0x28, + 0x66, 0x61, 0x6C, 0x73, 0x65, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x2E, 0xDA, + 0x8B, 0x7F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xEC, 0x01, 0xDA, + 0x06, 0xDA, 0x8B, 0x80, 0xDA, 0x08, 0xCE, 0x80, 0x96, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x26, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x2D, 0x76, 0x61, 0x6C, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, + 0x72, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x73, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x65, 0x72, 0x63, 0x65, + 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x31, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x30, 0x2D, 0x32, 0x35, 0x35, 0x2E, 0xDA, + 0x8B, 0x81, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0xE9, 0x01, 0xDA, 0x06, + 0xDA, 0x8B, 0x82, 0xDA, 0x08, 0xCE, 0x80, 0xBE, 0x28, 0x64, 0x65, 0x6C, 0x61, 0x79, 0x20, 0x26, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x4C, 0x61, 0x7A, 0x69, 0x6C, 0x79, 0x20, + 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x6F, 0x66, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x73, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, + 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x20, 0x62, 0x6F, + 0x64, 0x79, 0x20, 0x6F, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x6E, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x69, 0x7A, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x73, 0x75, 0x6C, 0x74, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8B, 0x86, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0x1D, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xC6, 0xDA, 0x08, + 0xCE, 0x5C, 0x28, 0x65, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, + 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x60, + 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, + 0x20, 0x3A, 0x65, 0x72, 0x72, 0x20, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x29, 0x60, 0x20, 0x69, + 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, + 0x3A, 0x6F, 0x75, 0x74, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x29, 0x60, 0x2E, 0xDA, 0x8B, + 0x87, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x82, 0x53, 0x01, 0xDA, 0x06, + 0xDA, 0x8B, 0x88, 0xDA, 0x08, 0xCE, 0x67, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, + 0x69, 0x74, 0x2D, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, 0x0A, 0x0A, 0x54, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x69, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, + 0x69, 0x6E, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8B, + 0x89, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x81, 0x89, 0xDA, 0x08, 0xCE, 0x81, 0xD0, 0x28, 0x70, 0x72, + 0x6F, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0x20, 0x78, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, + 0x0A, 0x0A, 0x50, 0x72, 0x6F, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x78, 0x60, 0x2E, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x6E, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x61, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, + 0x20, 0x66, 0x72, 0x61, 0x6D, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, + 0x69, 0x6E, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x64, 0x2C, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6D, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, 0x60, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6F, 0x20, 0x72, 0x65, 0x2D, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x6C, 0x6F, 0x73, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, + 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2E, 0xDA, 0x8B, 0x8A, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x10, 0x01, 0xDA, 0x06, 0xDA, + 0x8B, 0x8B, 0xDA, 0x08, 0xCE, 0x24, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8B, 0x8C, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x81, 0x00, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x8D, 0xDA, + 0x08, 0xCE, 0x7E, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x74, 0x72, 0x69, 0x6D, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x61, 0x63, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, + 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x2E, 0xDA, 0x8B, 0x8E, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8B, 0x8F, 0xDA, 0x08, 0xCE, 0x80, 0xF4, + 0x28, 0x62, 0x72, 0x75, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x78, 0x20, 0x26, 0x20, 0x73, 0x68, + 0x69, 0x66, 0x74, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x20, 0x62, 0x69, + 0x74, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x65, 0x64, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, + 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, + 0x74, 0x73, 0x2E, 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, + 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, + 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x64, 0x2C, 0x20, 0x73, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, + 0x69, 0x76, 0x65, 0x20, 0x73, 0x68, 0x69, 0x66, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, + 0x20, 0x61, 0x6C, 0x77, 0x61, 0x79, 0x73, 0x20, 0x62, 0x65, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x74, + 0x69, 0x76, 0x65, 0x2E, 0xDA, 0x8B, 0x91, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x8F, 0x63, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x92, 0xDA, 0x08, 0xCE, 0x81, 0x3D, 0x28, 0x66, 0x6C, + 0x79, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x6B, 0x65, 0x79, + 0x73, 0x20, 0x6B, 0x77, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x72, 0x75, 0x6E, 0x6E, 0x69, + 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x46, 0x6F, 0x75, + 0x6E, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, + 0x65, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x64, + 0x65, 0x72, 0x72, 0x0A, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x2E, 0x20, 0x4D, 0x61, 0x63, 0x72, 0x6F, 0x73, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x68, 0x6F, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2C, + 0x20, 0x73, 0x6F, 0x0A, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x70, 0x6F, 0x73, 0x73, 0x69, + 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x64, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x60, 0x2E, 0x20, 0x60, + 0x70, 0x61, 0x74, 0x68, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, + 0x65, 0x0A, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x73, + 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x8B, 0xD5, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x82, 0x6A, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xD6, 0xDA, + 0x08, 0xCE, 0x80, 0xA1, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, 0x6D, + 0x6C, 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x65, 0x74, 0x29, 0x0A, + 0x0A, 0x54, 0x72, 0x69, 0x6D, 0x20, 0x6C, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x68, + 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x60, + 0x73, 0x65, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x2C, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, + 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x73, + 0x65, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x2E, 0xDA, 0x8B, 0xD7, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD7, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xCA, 0xDA, 0x08, 0xCE, + 0x6A, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x73, 0x65, 0x74, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, + 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, + 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, + 0x70, 0x6C, 0x65, 0x74, 0x65, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x72, + 0x65, 0x70, 0x6C, 0x20, 0x28, 0x6F, 0x72, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x29, 0x2C, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0xD8, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x82, 0x74, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xD9, + 0xDA, 0x08, 0xCE, 0x80, 0xA2, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x74, 0x72, 0x69, + 0x6D, 0x72, 0x20, 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x65, 0x74, 0x29, + 0x0A, 0x0A, 0x54, 0x72, 0x69, 0x6D, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, + 0x77, 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x60, 0x73, 0x65, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x2C, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x6C, + 0x79, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x73, 0x65, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x77, 0x68, 0x69, 0x74, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2E, 0xDA, 0x84, 0x20, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x29, 0x81, 0x17, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x07, 0xDA, 0x08, 0xCE, 0x39, 0x28, + 0x73, 0x65, 0x74, 0x64, 0x79, 0x6E, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x61, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x8B, 0xDA, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0xEB, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x9D, 0xDA, 0x08, 0xCE, + 0x81, 0x88, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x61, + 0x72, 0x72, 0x74, 0x75, 0x70, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x20, 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, + 0x6C, 0x69, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, + 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x60, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x60, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x68, 0x61, 0x6C, 0x66, 0x20, + 0x6F, 0x70, 0x65, 0x6E, 0x2C, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, 0x20, 0x65, 0x6E, + 0x64, 0x29, 0x2E, 0x20, 0x49, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x2C, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x64, + 0x65, 0x78, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, + 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, 0x20, 0x60, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x65, + 0x6E, 0x64, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, + 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, + 0x4E, 0x6F, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x6E, 0x20, + 0x61, 0x73, 0x20, 0x28, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, 0x20, 0x65, 0x6E, 0x64, 0x5D, 0x20, + 0x74, 0x6F, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x20, + 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x72, + 0x61, 0x6E, 0x67, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x8B, 0xDB, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8A, 0x99, 0x01, 0xDA, 0x06, 0xDA, 0x44, 0xDA, 0x08, 0xCE, + 0x81, 0xD5, 0x28, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2D, 0x6F, + 0x72, 0x2D, 0x66, 0x75, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x20, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x29, 0x0A, 0x0A, 0x50, 0x75, + 0x74, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x62, + 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x64, 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, + 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x77, 0x72, + 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x60, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x2E, 0x20, 0x4F, 0x70, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x61, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x69, 0x6C, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x20, 0x60, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x60, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x2E, + 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x65, 0x76, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x79, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, + 0x64, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x76, 0x65, 0x6E, + 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x70, 0x75, 0x73, 0x68, 0x65, 0x64, + 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, + 0x6F, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x68, 0x65, 0x72, 0x69, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x75, 0x70, 0x65, + 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x2E, 0xDA, 0x8B, 0xDC, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x81, 0x57, 0x81, 0x21, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xDD, 0xDA, 0x08, 0xCE, 0x31, + 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x67, 0x65, 0x72, 0x20, 0x6E, 0x65, 0x61, 0x72, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x78, + 0x2E, 0xDA, 0x8B, 0xDE, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, 0xB3, + 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x0F, 0xDA, 0x08, 0xCE, 0x49, 0x28, 0x66, 0x6C, 0x75, 0x73, 0x68, + 0x29, 0x0A, 0x0A, 0x46, 0x6C, 0x75, 0x73, 0x68, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, + 0x6F, 0x75, 0x74, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x29, 0x60, 0x20, 0x69, 0x66, 0x20, + 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x6F, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x68, 0x69, + 0x6E, 0x67, 0x2E, 0xDA, 0x8B, 0xDF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, + 0x83, 0x39, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xE0, 0xDA, 0x08, 0xCE, 0x18, 0x54, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x6E, 0x64, 0x61, 0x72, 0x64, 0x20, 0x69, 0x6E, 0x70, 0x75, 0x74, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0xE1, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xD4, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xB9, 0xDA, 0x08, 0xDA, 0x86, + 0x92, 0xDA, 0x8B, 0xE2, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0xA2, + 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x5D, 0xDA, 0x08, 0xCE, 0x81, 0x90, 0x28, 0x73, 0x74, 0x72, 0x69, + 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0x20, 0x70, + 0x61, 0x74, 0x74, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, + 0x52, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x73, 0x74, + 0x61, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x73, 0x75, 0x62, 0x73, 0x74, 0x60, 0x20, 0x69, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, + 0x2E, 0x20, 0x4F, 0x76, 0x65, 0x72, 0x6C, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x61, + 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, + 0x69, 0x6E, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x20, 0x73, 0x70, 0x61, 0x6E, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x64, 0x2E, + 0x20, 0x49, 0x66, 0x20, 0x60, 0x73, 0x75, 0x62, 0x73, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x6F, 0x6E, 0x63, 0x65, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6C, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, + 0x63, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x75, + 0x73, 0x65, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, + 0x66, 0x20, 0x60, 0x70, 0x61, 0x74, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x75, 0x6E, + 0x64, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x2E, 0xDA, 0x8B, 0xE3, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x81, 0xC6, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xE4, 0xDA, + 0x08, 0xCE, 0x6E, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x26, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x61, 0x73, + 0x73, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x6E, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, + 0x20, 0xDA, 0x8B, 0xE5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x31, + 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xE6, 0xDA, 0x08, 0xCE, 0x48, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, + 0x61, 0x74, 0x61, 0x6E, 0x32, 0x20, 0x79, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x63, 0x74, 0x61, 0x6E, 0x67, 0x65, + 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x79, 0x2F, 0x78, 0x2E, 0x20, 0x57, 0x6F, 0x72, 0x6B, 0x73, + 0x20, 0x65, 0x76, 0x65, 0x6E, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, + 0x30, 0x2E, 0xDA, 0x8A, 0xB7, 0xDA, 0x89, 0x92, 0xDA, 0x8B, 0xE7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x91, 0x0C, 0x80, 0xF5, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xE8, 0xDA, 0x08, 0xCE, + 0x81, 0xAC, 0x28, 0x69, 0x6E, 0x74, 0x2F, 0x74, 0x6F, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x69, 0x61, + 0x6E, 0x6E, 0x65, 0x73, 0x73, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x57, + 0x72, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x6E, 0x20, 0x60, 0x69, 0x6E, 0x74, 0x2F, 0x73, 0x36, 0x34, 0x60, 0x20, 0x6F, + 0x72, 0x20, 0x60, 0x69, 0x6E, 0x74, 0x2F, 0x75, 0x36, 0x34, 0x60, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x60, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x60, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, + 0x72, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, + 0x78, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x74, + 0x6F, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x74, 0x6F, 0x2C, 0x20, 0x69, 0x66, 0x20, 0x75, + 0x6E, 0x73, 0x65, 0x74, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, + 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x0A, + 0x54, 0x68, 0x65, 0x20, 0x60, 0x65, 0x6E, 0x64, 0x69, 0x61, 0x6E, 0x6E, 0x65, 0x73, 0x73, 0x60, + 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6F, 0x72, + 0x64, 0x65, 0x72, 0x3A, 0x0A, 0x2D, 0x20, 0x60, 0x6E, 0x69, 0x6C, 0x60, 0x20, 0x28, 0x75, 0x6E, + 0x73, 0x65, 0x74, 0x29, 0x3A, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x0A, 0x2D, 0x20, 0x60, 0x3A, 0x6C, 0x65, 0x60, 0x3A, + 0x20, 0x6C, 0x69, 0x74, 0x74, 0x6C, 0x65, 0x2D, 0x65, 0x6E, 0x64, 0x69, 0x61, 0x6E, 0x2C, 0x20, + 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6E, + 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x0A, 0x2D, 0x20, 0x60, + 0x3A, 0x62, 0x65, 0x60, 0x3A, 0x20, 0x62, 0x69, 0x67, 0x2D, 0x65, 0x6E, 0x64, 0x69, 0x61, 0x6E, + 0x2C, 0x20, 0x6D, 0x6F, 0x73, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x6E, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x0A, 0xDA, 0x8A, + 0x7D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0xAF, 0x01, 0xDA, 0x06, 0xDA, + 0x8A, 0x7B, 0xDA, 0x08, 0xCE, 0x80, 0xA2, 0x28, 0x63, 0x75, 0x72, 0x65, 0x6E, 0x76, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, + 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x53, 0x61, 0x6D, 0x65, 0x20, + 0x61, 0x73, 0x20, 0x60, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, + 0x76, 0x20, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x29, 0x29, 0x60, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x6E, 0x60, 0x0A, 0x69, 0x73, 0x20, 0x70, + 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x67, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6E, 0x74, 0x68, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0xE9, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xDB, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x5C, 0xDA, 0x08, 0xCE, + 0x82, 0x09, 0x54, 0x68, 0x65, 0x20, 0x6C, 0x69, 0x73, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, + 0x74, 0x68, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x60, 0x2E, 0x0A, 0x45, 0x61, 0x63, + 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, + 0x77, 0x6F, 0x2D, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, + 0x2C, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x74, 0x68, 0x0A, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x3A, 0x73, 0x6F, + 0x75, 0x72, 0x63, 0x65, 0x2C, 0x20, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x20, 0x6F, + 0x72, 0x20, 0x3A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x68, 0x6F, 0x77, 0x0A, 0x60, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x60, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2E, 0x0A, 0x0A, 0x41, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x0A, 0x63, 0x6F, 0x6E, 0x74, + 0x61, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x69, 0x6E, 0x67, 0x20, + 0x61, 0x20, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x70, 0x72, + 0x65, 0x76, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, + 0x69, 0x6E, 0x64, 0x60, 0x0A, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x65, + 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x74, 0x65, 0x72, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x6E, 0x27, 0x74, 0x20, 0x6D, 0x61, 0x74, + 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x70, 0x75, 0x74, 0x0A, 0x70, 0x61, 0x74, + 0x68, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, + 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x0A, 0x69, 0x73, 0x20, 0x6F, 0x66, + 0x74, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6E, + 0x73, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x69, 0x6E, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6F, 0x64, 0x2E, 0xDA, 0x8B, 0xEA, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8C, 0x53, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xEB, 0xDA, + 0x08, 0xCE, 0x57, 0x28, 0x65, 0x76, 0x2F, 0x61, 0x6C, 0x6C, 0x2D, 0x74, 0x61, 0x73, 0x6B, 0x73, + 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x62, 0x65, + 0x69, 0x6E, 0x67, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, 0x72, 0x2E, 0xDA, 0x8B, 0xEC, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0x7E, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xED, 0xDA, 0x08, + 0xCE, 0x80, 0x88, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, + 0x50, 0x61, 0x72, 0x73, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x63, + 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x78, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x2C, 0x20, + 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x70, 0x6C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x68, 0x61, + 0x6E, 0x64, 0x6C, 0x69, 0x6E, 0x67, 0x2C, 0x0A, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x61, 0x70, 0x69, 0x2E, 0xDA, 0x8B, 0xF0, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0xF1, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xF1, 0xDA, + 0x08, 0xCE, 0x80, 0x9C, 0x28, 0x66, 0x6F, 0x72, 0x76, 0x20, 0x69, 0x20, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x20, 0x73, 0x74, 0x6F, 0x70, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, + 0x44, 0x6F, 0x20, 0x61, 0x20, 0x43, 0x2D, 0x73, 0x74, 0x79, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, + 0x2D, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65, 0x20, 0x65, + 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, + 0x69, 0x60, 0x0A, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2C, 0x20, 0x75, + 0x6E, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x60, 0x66, 0x6F, + 0x72, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x84, 0x3C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, + 0x8D, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x35, 0xDA, 0x08, 0xCE, 0x80, 0x8E, 0x28, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x50, 0x61, 0x72, + 0x73, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x63, 0x6F, + 0x6D, 0x70, 0x6C, 0x65, 0x78, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x73, + 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, + 0x6C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x68, 0x61, 0x6E, + 0x64, 0x6C, 0x69, 0x6E, 0x67, 0x2C, 0x0A, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x61, 0x70, 0x69, 0x2E, 0xDA, 0x8B, 0xF3, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x80, 0xFA, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xF4, 0xDA, + 0x08, 0xCE, 0x80, 0xBE, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, + 0x69, 0x2D, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, + 0x6E, 0x67, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0x63, 0x61, + 0x73, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x6D, 0x73, 0x65, 0x6C, 0x76, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x41, 0x53, 0x43, 0x49, + 0x49, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x61, 0x20, 0x76, + 0x65, 0x72, 0x79, 0x20, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, + 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2C, 0x20, 0x6D, 0x65, 0x61, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6E, + 0x6F, 0x20, 0x75, 0x6E, 0x69, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, 0x72, + 0x74, 0x2E, 0xDA, 0x8B, 0xF5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x36, 0x01, 0xDA, 0x06, 0xDA, 0x82, 0x30, 0xDA, 0x08, 0xCE, 0x2A, 0x28, 0x6E, 0x6F, 0x74, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8B, 0xF6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x04, 0x85, 0xCD, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xF7, 0xDA, 0x08, 0xCE, 0x35, 0x28, 0x6F, 0x73, + 0x2F, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, + 0x20, 0x63, 0x6F, 0x70, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4F, 0x53, 0x20, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0xDA, 0x8B, 0xF8, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x84, 0x4F, + 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xF9, 0xDA, 0x08, 0xCE, 0x4B, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x6F, + 0x75, 0x6E, 0x74, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, + 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x6C, 0x79, 0x20, + 0x77, 0x61, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x6E, 0x65, 0x6C, 0x2E, 0xDA, 0x87, 0xAE, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8B, 0x1A, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x59, 0xDA, 0x08, 0xCE, 0x81, 0x01, 0x28, 0x6D, + 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x74, 0x68, 0x29, + 0x0A, 0x0A, 0x54, 0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, + 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, + 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0x60, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x28, 0x66, 0x75, 0x6C, 0x6C, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x6B, 0x69, 0x6E, 0x64, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6B, 0x69, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2C, 0x20, 0x3A, 0x6E, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x2C, 0x0A, 0x6F, 0x72, 0x20, 0x3A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, + 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6E, 0x69, + 0x6C, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0A, 0x61, 0x6E, + 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2E, 0xDA, + 0x8B, 0xFA, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x80, 0xF0, 0x01, 0xDA, + 0x06, 0xDA, 0x86, 0x9A, 0xDA, 0x08, 0xCE, 0x64, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x20, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x57, 0x72, + 0x69, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, + 0x27, 0x62, 0x79, 0x74, 0x65, 0x73, 0x27, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2C, 0x20, + 0x6F, 0x72, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xDA, 0x8B, 0xFB, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0xCC, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xFC, + 0xDA, 0x08, 0xCE, 0x80, 0x85, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, + 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x29, 0x0A, 0x0A, 0x46, 0x72, 0x65, 0x65, 0x20, 0x61, 0x20, + 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x2E, 0x20, 0x44, + 0x65, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x6F, 0x69, + 0x6E, 0x74, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x75, 0x6E, 0x64, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x64, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6F, 0x72, 0x20, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x20, 0x66, 0x72, 0x65, 0x65, 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8B, 0xFD, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x82, 0xE7, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xFE, 0xDA, 0x08, + 0xCE, 0x82, 0x2C, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x6B, 0x69, 0x6C, 0x6C, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x77, 0x61, 0x69, 0x74, 0x20, + 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x4B, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x20, + 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x79, 0x20, 0x73, 0x65, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x53, 0x49, 0x47, 0x4B, 0x49, 0x4C, 0x4C, 0x20, 0x74, 0x6F, + 0x20, 0x69, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x20, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6D, 0x73, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6C, 0x6F, 0x73, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, + 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, + 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, + 0x69, 0x74, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, + 0x68, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x2C, 0x20, 0x6F, 0x73, + 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x6B, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0x20, 0x41, 0x66, 0x74, 0x65, + 0x72, 0x20, 0x73, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, + 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x2C, 0x20, 0x69, 0x66, 0x20, 0x60, 0x77, 0x61, + 0x69, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x77, 0x61, 0x69, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x69, 0x6E, 0x69, + 0x73, 0x68, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x62, 0x79, 0x20, 0x63, + 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, + 0x61, 0x69, 0x74, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x60, 0x70, 0x72, 0x6F, 0x63, 0x60, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2C, 0x20, 0x73, 0x65, 0x6E, 0x64, 0x20, 0x69, 0x74, 0x20, + 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2E, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, + 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x61, 0x6D, + 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x43, + 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x69, 0x6E, 0x20, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0x63, 0x61, 0x73, 0x65, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x20, + 0x60, 0x53, 0x49, 0x47, 0x60, 0x20, 0x73, 0x74, 0x72, 0x69, 0x70, 0x70, 0x65, 0x64, 0x2E, 0x20, + 0x53, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x67, 0x6E, 0x6F, + 0x72, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x2E, 0xDA, + 0x8B, 0xFF, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x63, 0x01, 0xDA, 0x06, + 0xDA, 0x8C, 0x00, 0xDA, 0x08, 0xCE, 0x7B, 0x28, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0x20, 0x6E, 0x61, + 0x6D, 0x65, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, + 0x61, 0x20, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6C, 0x65, 0x78, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, + 0x73, 0x63, 0x6F, 0x70, 0x65, 0x64, 0x2E, 0x20, 0x60, 0x6E, 0x61, 0x6D, 0x65, 0x60, 0x20, 0x73, + 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, + 0x6C, 0x0A, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x62, + 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x62, 0x65, + 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0x03, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x3A, 0x8B, 0x6A, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x04, 0xDA, 0x08, 0xCE, 0x81, 0x2D, 0x28, 0x65, + 0x76, 0x2F, 0x67, 0x69, 0x76, 0x65, 0x2D, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, + 0x72, 0x20, 0x74, 0x61, 0x67, 0x20, 0x26, 0x20, 0x70, 0x61, 0x79, 0x6C, 0x6F, 0x61, 0x64, 0x29, + 0x0A, 0x0A, 0x53, 0x65, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, + 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, + 0x65, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6F, + 0x6E, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, + 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x65, 0x64, + 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x6D, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x61, 0x67, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, + 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x74, 0x61, 0x67, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, + 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x69, + 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x8C, 0x05, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x15, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x06, + 0xDA, 0x08, 0xCE, 0x37, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x68, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x68, 0x79, 0x70, 0x65, 0x72, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x61, 0x72, 0x63, 0x74, 0x61, + 0x6E, 0x67, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x87, 0xA4, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0xF7, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xA2, 0xDA, + 0x08, 0xCE, 0x80, 0x8A, 0x28, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x20, 0x70, 0x72, 0x65, 0x64, + 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x47, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x70, + 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2C, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x6F, + 0x6E, 0x6C, 0x79, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x0A, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x60, 0x28, + 0x70, 0x72, 0x65, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x29, 0x60, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x8B, + 0x0F, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0xA6, 0x03, 0xDA, 0x06, 0xDA, + 0x8C, 0x07, 0xDA, 0x08, 0xCE, 0x81, 0x69, 0x28, 0x65, 0x76, 0x2F, 0x77, 0x69, 0x74, 0x68, 0x2D, + 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x73, 0x65, 0x63, 0x20, 0x26, 0x20, 0x62, + 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, + 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x2C, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6C, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, + 0x74, 0x6F, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6B, 0x20, 0x28, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x20, + 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x27, 0x73, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x0A, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, + 0x27, 0x73, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x62, 0x79, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6D, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x74, 0x2E, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x65, 0x76, + 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x72, + 0x79, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x60, 0x62, + 0x6F, 0x64, 0x79, 0x60, 0x27, 0x73, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x0A, 0x68, 0x61, 0x73, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x64, 0x20, 0x61, + 0x66, 0x74, 0x65, 0x72, 0x20, 0x61, 0x74, 0x20, 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x60, 0x73, + 0x65, 0x63, 0x60, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2E, 0x0A, 0x0A, 0x60, 0x73, + 0x65, 0x63, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x20, + 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x70, 0x61, 0x72, 0x74, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x86, 0x35, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, + 0x8F, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xE7, 0xDA, 0x08, 0xCE, 0x50, 0x28, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x20, 0x26, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x69, 0x74, + 0x65, 0x6D, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xDA, 0x8C, 0x0A, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x71, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x0B, 0xDA, 0x08, + 0xCE, 0x22, 0x28, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, + 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, + 0x74, 0x68, 0x79, 0x2E, 0xDA, 0x8C, 0x0D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, + 0xC3, 0x81, 0x11, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x0E, 0xDA, 0x08, 0xCE, 0x80, 0x90, 0x28, 0x66, + 0x69, 0x6C, 0x65, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0x20, 0x66, 0x29, 0x0A, 0x0A, 0x46, 0x6C, + 0x75, 0x73, 0x68, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x6D, 0x6F, + 0x73, 0x74, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6E, 0x63, 0x79, 0x20, 0x72, 0x65, 0x61, + 0x73, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x2E, 0xDA, 0x8C, + 0x0F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0xFB, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0x10, 0xDA, 0x08, 0xCE, 0x33, 0x28, 0x65, 0x76, 0x2F, 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, + 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x6C, 0x6F, + 0x63, 0x6B, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x2E, 0xDA, 0x89, 0x98, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0x73, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x11, 0xDA, 0x08, 0xCE, + 0x80, 0x95, 0x28, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, + 0x20, 0x26, 0x20, 0x69, 0x6E, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x60, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, + 0x69, 0x74, 0x65, 0x6D, 0x29, 0x60, 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, + 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, + 0x20, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x2E, 0x0A, + 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x75, + 0x74, 0x68, 0x79, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x65, 0x6E, 0x63, 0x6F, 0x75, + 0x6E, 0x74, 0x65, 0x72, 0x65, 0x64, 0x2E, 0xDA, 0x8C, 0x1F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x83, 0x94, 0x82, 0x9A, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x9E, 0xDA, 0x08, 0xCE, 0x51, + 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6C, 0x61, 0x73, 0x74, 0x2D, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x65, + 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, + 0x2E, 0xDA, 0x8C, 0x20, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x72, + 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x98, 0xDA, 0x08, 0xCE, 0x5B, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x2F, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x20, 0x74, 0x61, 0x62, 0x20, 0x70, 0x72, + 0x6F, 0x74, 0x6F, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, + 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, + 0x74, 0x61, 0x62, 0x60, 0x2E, 0xDA, 0x8C, 0x21, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8C, 0x22, 0xDA, + 0x08, 0xCE, 0x5A, 0x28, 0x25, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x64, + 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x64, 0x69, 0x76, 0x69, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x78, 0x73, 0x20, 0x62, 0x79, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x72, 0x65, 0x6D, + 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x8C, 0x23, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xEB, 0x01, 0xDA, 0x06, 0xDA, 0x8C, + 0x24, 0xDA, 0x08, 0xCE, 0x44, 0x28, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, + 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0xDA, 0x8C, 0x26, 0xD3, 0x02, 0xDA, 0x06, + 0xDA, 0x8C, 0x27, 0xDA, 0x08, 0xCE, 0x4F, 0x28, 0x2A, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x64, 0x75, 0x63, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, + 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x31, 0x2E, 0xDA, 0x8C, 0x28, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x32, 0xDA, + 0x08, 0xCE, 0x68, 0x28, 0x2B, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, + 0x61, 0x6C, 0x6C, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x78, 0x73, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x72, + 0x65, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, 0x20, 0x6F, 0x6E, 0x6C, 0x79, + 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, + 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x30, 0x2E, 0xDA, 0x8C, 0x29, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, 0x51, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x2A, 0xDA, + 0x08, 0xCE, 0x59, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0x20, 0x6E, 0x29, 0x0A, + 0x0A, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x67, 0x72, 0x61, 0x6D, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x73, 0x65, 0x63, + 0x6F, 0x6E, 0x64, 0x73, 0x2E, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, + 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x8C, 0x2B, 0xD3, + 0x02, 0xDA, 0x06, 0xDA, 0x81, 0x52, 0xDA, 0x08, 0xCE, 0x80, 0xDB, 0x28, 0x2D, 0x20, 0x26, 0x20, + 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, + 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, + 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x30, 0x2E, 0x20, 0x49, 0x66, + 0x20, 0x78, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x2E, + 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, 0x20, 0x6D, 0x69, 0x6E, 0x75, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0xDA, 0x8C, 0x2C, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x82, 0xDD, + 0xDA, 0x08, 0xCE, 0x80, 0xC7, 0x28, 0x2F, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x6F, 0x74, 0x69, + 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x31, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x78, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, + 0x6F, 0x6E, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x2C, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x72, 0x6F, + 0x63, 0x61, 0x6C, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, + 0x69, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x73, + 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x6C, 0x79, 0x20, 0x64, 0x69, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6D, 0x61, 0x69, + 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0xDA, 0x8C, 0x2D, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x6D, 0x86, 0xC1, 0x01, 0xDA, 0x06, 0xDA, 0x8C, + 0x2E, 0xDA, 0x08, 0xCE, 0x81, 0x01, 0x28, 0x70, 0x65, 0x67, 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, + 0x6C, 0x65, 0x20, 0x70, 0x65, 0x67, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x70, 0x65, 0x67, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x6E, + 0x74, 0x6F, 0x20, 0x61, 0x20, 0x3C, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x70, 0x65, 0x67, 0x3E, 0x2E, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x70, 0x65, 0x65, 0x64, + 0x20, 0x75, 0x70, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x70, 0x65, 0x67, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, + 0x6C, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x61, + 0x6C, 0x73, 0x6F, 0x20, 0x75, 0x73, 0x65, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x70, + 0x65, 0x67, 0x2D, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x29, 0x60, 0x20, 0x74, 0x6F, 0x20, + 0x73, 0x75, 0x70, 0x70, 0x6C, 0x69, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, + 0x72, 0x61, 0x6D, 0x6D, 0x61, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, + 0x67, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, + 0x75, 0x6E, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x20, 0x70, 0x65, 0x67, 0x20, 0x6B, 0x65, + 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x2E, 0xDA, 0x8C, 0x2F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x29, 0x82, 0xAD, 0x01, 0xDA, 0x06, 0xDA, 0x86, 0x85, 0xDA, 0x08, 0xCE, 0x3F, 0x28, + 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x2C, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x2C, 0x20, + 0x6F, 0x72, 0x20, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x72, 0x79, 0x2E, 0xDA, 0x8B, + 0xA0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0x6A, 0x01, 0xDA, 0x06, 0xDA, + 0x8B, 0x9E, 0xDA, 0x08, 0xCE, 0x80, 0xAF, 0x28, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x64, + 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x20, 0x69, 0x6E, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x60, 0x28, + 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x29, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, + 0x69, 0x74, 0x65, 0x6D, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x2E, 0x0A, 0x4F, + 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x61, 0x6C, 0x73, + 0x65, 0x79, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x65, 0x6E, 0x63, 0x6F, 0x75, 0x6E, + 0x74, 0x65, 0x72, 0x65, 0x64, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x69, 0x73, 0x20, + 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2E, 0xDA, 0x8C, 0x30, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0x60, + 0xDA, 0x08, 0xCE, 0x3F, 0x28, 0x3C, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, + 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x73, 0x63, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, + 0x61, 0x6E, 0x2E, 0xDA, 0x81, 0x87, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x84, 0x7F, 0xDA, 0x08, 0xCE, + 0x41, 0x28, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x78, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, + 0x6E, 0x2E, 0xDA, 0x8A, 0xE6, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0x64, 0xDA, 0x08, 0xCE, 0x40, + 0x28, 0x3E, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, + 0x69, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, + 0xDA, 0x8C, 0x31, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0xB4, 0x01, 0xDA, + 0x06, 0xDA, 0x8A, 0xD0, 0xDA, 0x08, 0xCE, 0x30, 0x28, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, + 0x77, 0x68, 0x61, 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x61, 0x69, 0x73, 0x65, 0x20, 0x61, + 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x61, 0x79, + 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x78, 0x2E, 0x20, 0xDA, 0x8C, 0x32, 0xD3, 0x04, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x81, 0x5C, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x33, 0xDA, 0x08, 0xCE, 0x50, + 0x28, 0x63, 0x68, 0x72, 0x20, 0x63, 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, + 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x6C, 0x65, 0x6E, + 0x67, 0x74, 0x68, 0x20, 0x31, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x74, 0x73, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x20, 0x28, 0x61, 0x73, 0x63, 0x69, 0x69, 0x29, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0x37, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8A, 0xD3, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x5B, 0xDA, 0x08, 0xDA, 0x86, 0x92, + 0xDA, 0x8C, 0x38, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, 0x77, 0x81, 0x0C, 0x01, + 0xDA, 0x06, 0xDA, 0x8C, 0x39, 0xDA, 0x08, 0xCE, 0x81, 0x2E, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x62, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x63, 0x68, 0x69, 0x6C, 0x64, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6C, 0x20, 0x77, + 0x68, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x61, 0x6E, 0x20, 0x61, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x55, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x73, 0x65, 0x65, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x2E, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, + 0x64, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x6D, 0x6F, 0x73, 0x74, 0x6C, 0x79, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x69, 0x6E, 0x67, 0x20, 0x70, + 0x75, 0x72, 0x70, 0x6F, 0x73, 0x65, 0x73, 0x2E, 0xDA, 0x8C, 0x3A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x86, 0xA7, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x3B, 0xDA, 0x08, 0xCE, 0x70, + 0x28, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x61, + 0x6B, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x28, 0x74, 0x72, 0x65, 0x65, 0x29, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x65, 0x70, 0x74, 0x68, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x61, 0x76, 0x65, + 0x72, 0x73, 0x61, 0x6C, 0x20, 0x6F, 0x66, 0x0A, 0x69, 0x74, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, + 0xDA, 0x8C, 0x3D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0xA5, 0x01, 0xDA, + 0x06, 0xDA, 0x8C, 0x3E, 0xDA, 0x08, 0xCE, 0x4C, 0x28, 0x6F, 0x73, 0x2F, 0x72, 0x6D, 0x64, 0x69, + 0x72, 0x20, 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x6C, 0x65, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x65, 0x64, 0x2E, 0xDA, 0x8C, 0x3F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, + 0x67, 0x86, 0x59, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x40, 0xDA, 0x08, 0xCE, 0x80, 0xC0, 0x28, 0x65, + 0x6E, 0x76, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x65, 0x6E, 0x76, 0x29, 0x0A, 0x0A, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x77, 0x61, 0x72, + 0x64, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, + 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, + 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x54, 0x6F, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x6F, 0x20, 0x73, 0x77, 0x61, 0x70, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8C, + 0x41, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x8F, 0x61, 0x80, 0xD2, 0x01, 0xDA, 0x06, + 0xDA, 0x8C, 0x42, 0xDA, 0x08, 0xCE, 0x7F, 0x28, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2F, 0x77, + 0x69, 0x74, 0x68, 0x2D, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x20, + 0x26, 0x20, 0x6B, 0x76, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2C, 0x20, 0x61, 0x73, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x20, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6F, 0x72, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x61, 0x73, + 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x2E, 0xDA, 0x8C, 0x43, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x3A, 0x84, 0x44, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x44, 0xDA, 0x08, 0xCE, 0x5C, 0x28, 0x65, + 0x76, 0x2F, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, + 0x65, 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x61, 0x20, 0x63, + 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x6F, 0x72, + 0x65, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x69, 0x6E, + 0x67, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2E, 0xDA, 0x8C, 0x45, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x68, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x46, 0xDA, 0x08, + 0xCE, 0x5C, 0x28, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0x20, 0x69, + 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, + 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, + 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x8C, + 0x4B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x4D, 0x01, 0xDA, 0x06, + 0xDA, 0x8C, 0x4C, 0xDA, 0x08, 0xCE, 0x80, 0x88, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x77, + 0x65, 0x61, 0x6B, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, + 0x74, 0x79, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x77, 0x65, + 0x61, 0x6B, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, + 0xDA, 0x8C, 0x4D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x81, 0xBF, 0x01, 0xDA, + 0x06, 0xDA, 0x8C, 0x4E, 0xDA, 0x08, 0xCE, 0x81, 0xBE, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x63, 0x6F, + 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x20, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x70, 0x6F, 0x72, 0x74, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x68, 0x6F, + 0x73, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x70, 0x6F, 0x72, 0x74, 0x29, 0x0A, 0x0A, 0x4F, 0x70, + 0x65, 0x6E, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x75, 0x6E, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x64, 0x75, 0x70, 0x6C, 0x65, 0x78, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x75, 0x6E, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, + 0x72, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x61, 0x20, + 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2C, + 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x3A, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, + 0x6F, 0x72, 0x20, 0x3A, 0x64, 0x61, 0x74, 0x61, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x3A, 0x73, 0x74, + 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x42, 0x69, 0x6E, 0x64, 0x68, 0x6F, 0x73, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x20, 0x66, + 0x72, 0x6F, 0x6D, 0x20, 0x77, 0x68, 0x61, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x75, 0x74, + 0x67, 0x6F, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x2C, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6C, 0x74, 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4F, + 0x53, 0x27, 0x73, 0x20, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x2E, 0x20, 0xDA, 0x8C, 0x4F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x3A, 0x8C, 0x10, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x50, 0xDA, 0x08, 0xCE, 0x4E, 0x28, + 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x6C, 0x6F, 0x63, 0x6B, 0x20, + 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x20, 0x61, + 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x20, 0x6D, 0x61, + 0x79, 0x20, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x69, 0x74, 0x2E, 0xDA, 0x83, 0x7F, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x74, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x7D, + 0xDA, 0x08, 0xCE, 0x1C, 0x28, 0x6E, 0x69, 0x6C, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, + 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0xDA, 0x8C, 0x51, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x5D, 0x6F, 0x01, 0xDA, + 0x06, 0xDA, 0x81, 0x01, 0xDA, 0x08, 0xCE, 0x73, 0x28, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, + 0x65, 0x74, 0x6D, 0x61, 0x70, 0x20, 0x74, 0x75, 0x70, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, + 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, 0x20, 0x6D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0x20, 0x6C, + 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x69, + 0x6E, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, + 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x2E, 0xDA, 0x8C, 0x52, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0x6C, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x53, 0xDA, + 0x08, 0xCE, 0x80, 0xF6, 0x28, 0x71, 0x75, 0x69, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x54, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, + 0x65, 0x78, 0x69, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x75, + 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x6C, 0x77, 0x61, 0x79, 0x73, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, + 0x0A, 0x57, 0x6F, 0x72, 0x6B, 0x73, 0x20, 0x62, 0x79, 0x20, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x65, 0x78, 0x69, 0x74, 0x20, 0x64, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x2E, 0x20, 0x50, 0x61, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x6E, + 0x6F, 0x6E, 0x2D, 0x6E, 0x69, 0x6C, 0x20, 0x60, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x60, 0x20, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6F, 0x75, 0x74, 0x65, 0x72, 0x0A, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, + 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x8C, 0x55, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0xFE, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x56, 0xDA, 0x08, + 0xCE, 0x38, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0x20, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x53, 0x65, + 0x74, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x8C, 0x57, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xEF, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x58, 0xDA, 0x08, + 0xCE, 0x44, 0x28, 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, + 0x65, 0x72, 0x69, 0x63, 0x20, 0x6D, 0x69, 0x6E, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x65, 0x71, + 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0xDA, 0x8C, 0x5A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x83, 0x57, 0x84, 0x27, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x3B, 0xDA, 0x08, 0xCE, 0x81, 0x28, + 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x77, 0x72, 0x61, 0x70, + 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x71, 0x75, 0x65, 0x75, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, + 0x65, 0x78, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2E, 0x20, 0x57, 0x69, + 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, + 0x20, 0x6E, 0x6F, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x65, + 0x75, 0x65, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x64, 0x65, 0x71, 0x75, 0x65, 0x75, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, + 0x65, 0x78, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x77, + 0x72, 0x61, 0x70, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x20, 0x31, 0x2D, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x77, 0x72, 0x61, 0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6C, 0x74, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x70, + 0x75, 0x72, 0x70, 0x6F, 0x73, 0x65, 0x73, 0x2E, 0xDA, 0x8C, 0x5B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xC7, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xBF, 0xDA, 0x08, 0xCE, 0x52, + 0x28, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x69, 0x6D, 0x61, 0x67, + 0x65, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, + 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6D, 0x61, + 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, + 0x74, 0x2E, 0xDA, 0x88, 0x5D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x07, + 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x5C, 0xDA, 0x08, 0xCE, 0x80, 0x85, 0x28, 0x61, 0x6E, 0x64, 0x20, + 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, + 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x6F, + 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x0A, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, + 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x8B, 0x0D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, + 0x96, 0x03, 0xDA, 0x06, 0xDA, 0x8C, 0x5E, 0xDA, 0x08, 0xCE, 0x5F, 0x28, 0x65, 0x76, 0x2F, 0x73, + 0x70, 0x61, 0x77, 0x6E, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, + 0x6E, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x60, 0x28, 0x65, 0x76, 0x2F, 0x67, 0x6F, 0x20, 0x28, 0x66, 0x6E, 0x20, 0x5B, 0x5D, + 0x20, 0x3B, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0x61, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0x38, 0x01, 0xDA, 0x06, 0xDA, 0x8C, + 0x62, 0xDA, 0x08, 0xCE, 0x81, 0x31, 0x28, 0x6F, 0x73, 0x2F, 0x6D, 0x6B, 0x74, 0x69, 0x6D, 0x65, + 0x20, 0x64, 0x61, 0x74, 0x65, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x72, 0x6F, 0x6B, 0x65, 0x6E, 0x20, 0x64, 0x6F, 0x77, 0x6E, 0x20, 0x64, 0x61, + 0x74, 0x65, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x65, + 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, + 0x73, 0x20, 0x73, 0x69, 0x6E, 0x63, 0x65, 0x20, 0x4A, 0x61, 0x6E, 0x75, 0x61, 0x72, 0x79, 0x20, + 0x31, 0x2C, 0x20, 0x31, 0x39, 0x37, 0x30, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6E, 0x69, + 0x78, 0x20, 0x65, 0x70, 0x6F, 0x63, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0x20, + 0x44, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x69, 0x6E, + 0x20, 0x55, 0x54, 0x43, 0x20, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x60, 0x6C, 0x6F, 0x63, + 0x61, 0x6C, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x69, + 0x6E, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x75, 0x74, 0x65, + 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x20, + 0x74, 0x69, 0x6D, 0x65, 0x7A, 0x6F, 0x6E, 0x65, 0x2E, 0x0A, 0x0A, 0x49, 0x6E, 0x76, 0x65, 0x72, + 0x73, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x6F, + 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0x2E, 0xDA, 0x8C, 0x63, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x3A, 0x84, 0x39, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x64, 0xDA, 0x08, 0xCE, 0x35, 0x28, + 0x65, 0x76, 0x2F, 0x66, 0x75, 0x6C, 0x6C, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x29, + 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x20, 0x6F, 0x72, 0x20, + 0x6E, 0x6F, 0x74, 0x2E, 0xDA, 0x8C, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, + 0x81, 0x95, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x66, 0xDA, 0x08, 0xCE, 0x4F, 0x28, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x26, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x69, 0x74, + 0x65, 0x6D, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x8C, 0x67, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, 0x17, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x68, 0xDA, + 0x08, 0xCE, 0x80, 0x86, 0x28, 0x6F, 0x73, 0x2F, 0x74, 0x69, 0x6D, 0x65, 0x29, 0x0A, 0x0A, 0x47, + 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x74, + 0x69, 0x6D, 0x65, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x77, + 0x68, 0x6F, 0x6C, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x73, 0x69, 0x6E, + 0x63, 0x65, 0x20, 0x4A, 0x61, 0x6E, 0x75, 0x61, 0x72, 0x79, 0x20, 0x31, 0x2C, 0x20, 0x31, 0x39, + 0x37, 0x30, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6E, 0x69, 0x78, 0x20, 0x65, 0x70, 0x6F, + 0x63, 0x68, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x61, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2E, 0xDA, 0x8B, 0xB1, 0xD3, 0x04, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x2D, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x69, 0xDA, 0x08, 0xCE, + 0x27, 0x28, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, + 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, + 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0x6B, 0xD3, 0x04, + 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xE4, 0x01, 0xDA, 0x06, + 0xDA, 0x86, 0x00, 0xDA, 0x08, 0xCE, 0x7A, 0x41, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, + 0x74, 0x6F, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, 0x20, 0x64, 0x65, 0x6E, 0x6F, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, + 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6F, 0x6D, + 0x20, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6E, 0x75, 0x6D, + 0x65, 0x72, 0x69, 0x63, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x73, + 0x2E, 0xDA, 0x8C, 0x6C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x57, 0x83, 0x8A, + 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x37, 0xDA, 0x08, 0xCE, 0x80, 0x89, 0x28, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, + 0x65, 0x77, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, + 0x2E, 0x20, 0x50, 0x61, 0x72, 0x73, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x73, 0x2E, 0xDA, 0x8C, 0x6D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, + 0x89, 0x7D, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x6E, 0xDA, 0x08, 0xCE, 0x81, 0x52, 0x28, 0x6F, 0x73, + 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x74, + 0x29, 0x0A, 0x0A, 0x43, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x61, 0x20, 0x55, 0x6E, 0x69, + 0x78, 0x20, 0x6F, 0x63, 0x74, 0x61, 0x6C, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, + 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, + 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x61, + 0x20, 0x68, 0x75, 0x6D, 0x61, 0x6E, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6C, 0x65, 0x20, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x66, 0x6F, 0x6C, + 0x6C, 0x6F, 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x55, 0x6E, 0x69, 0x78, 0x20, 0x74, 0x6F, 0x6F, 0x6C, + 0x73, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x6C, 0x73, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x20, 0x39, 0x2D, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x72, 0x2C, 0x20, 0x77, 0x2C, + 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x2D, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, + 0x65, 0x72, 0x73, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x69, 0x6E, + 0x63, 0x6C, 0x75, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2F, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, + 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, + 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x60, 0x6C, 0x73, 0x60, 0x2E, 0xDA, + 0x8C, 0x6F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x83, 0xFF, 0x01, 0xDA, 0x06, + 0xDA, 0x8C, 0x70, 0xDA, 0x08, 0xCE, 0x82, 0x79, 0x28, 0x65, 0x76, 0x2F, 0x73, 0x65, 0x6C, 0x65, + 0x63, 0x74, 0x20, 0x26, 0x20, 0x63, 0x6C, 0x61, 0x75, 0x73, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x42, + 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6C, 0x20, + 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x5B, 0x3A, 0x67, 0x69, 0x76, 0x65, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x5D, 0x2C, 0x20, 0x5B, 0x3A, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x20, + 0x78, 0x5D, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x5B, 0x3A, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x63, + 0x68, 0x61, 0x6E, 0x5D, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x20, 0x3A, 0x67, + 0x69, 0x76, 0x65, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x3A, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x20, 0x45, 0x61, + 0x63, 0x68, 0x20, 0x63, 0x6C, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, + 0x65, 0x6C, 0x20, 0x28, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, + 0x6C, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, + 0x29, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x5B, 0x63, 0x68, + 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x78, 0x5D, 0x20, 0x28, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, + 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x67, 0x69, 0x76, 0x65, 0x20, 0x6F, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x29, 0x2E, 0x20, 0x4F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6E, + 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x65, 0x61, 0x72, 0x6C, 0x69, 0x65, 0x72, 0x20, 0x63, 0x6C, 0x61, 0x75, 0x73, 0x65, 0x73, + 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x6E, 0x63, 0x65, + 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x6C, 0x61, 0x74, 0x65, 0x72, 0x20, 0x63, 0x6C, 0x61, 0x75, + 0x73, 0x65, 0x73, 0x2E, 0x20, 0x42, 0x6F, 0x74, 0x68, 0x20, 0x67, 0x69, 0x76, 0x65, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x20, + 0x5B, 0x3A, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x5D, 0x20, 0x74, 0x75, + 0x70, 0x6C, 0x65, 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, 0x20, 0x77, 0x68, 0x69, 0x6C, 0x65, + 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x77, 0x61, + 0x73, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, + 0x2E, 0xDA, 0x8C, 0x71, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x84, 0x77, 0x01, + 0xDA, 0x06, 0xDA, 0x8C, 0x72, 0xDA, 0x08, 0xCE, 0x80, 0xC2, 0x28, 0x65, 0x76, 0x2F, 0x74, 0x68, + 0x72, 0x65, 0x61, 0x64, 0x2D, 0x63, 0x68, 0x61, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, + 0x69, 0x6D, 0x69, 0x74, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, + 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x65, 0x64, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, + 0x2E, 0x20, 0x41, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x65, 0x64, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x6E, 0x65, 0x6C, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, + 0x6C, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x73, 0x68, + 0x61, 0x72, 0x65, 0x64, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x72, + 0x65, 0x61, 0x64, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x63, 0x6F, 0x6D, 0x6D, 0x75, 0x6E, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x62, 0x65, 0x74, + 0x77, 0x65, 0x65, 0x6E, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, + 0x6F, 0x66, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6D, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x2E, 0xDA, 0x8C, 0x73, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x83, 0xDC, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0x1B, + 0xDA, 0x08, 0xCE, 0x5E, 0x28, 0x65, 0x76, 0x2F, 0x74, 0x61, 0x6B, 0x65, 0x20, 0x63, 0x68, 0x61, + 0x6E, 0x6E, 0x65, 0x6C, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, + 0x20, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x6E, 0x65, 0x6C, 0x2C, 0x20, 0x73, 0x75, 0x73, 0x70, + 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0xDA, 0x8C, 0x74, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x79, + 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x75, 0xDA, 0x08, 0xCE, 0x45, 0x28, 0x75, 0x6E, 0x74, 0x72, 0x61, + 0x63, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x29, 0x0A, 0x0A, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6C, + 0x65, 0x73, 0x20, 0x74, 0x72, 0x61, 0x63, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, + 0x8C, 0x76, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x33, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0x77, 0xDA, 0x08, 0xCE, 0x80, 0xFE, 0x28, 0x61, 0x73, 0x2D, 0x6D, 0x61, 0x63, 0x72, 0x6F, + 0x20, 0x66, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x55, 0x73, 0x65, 0x20, + 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x72, 0x20, 0x6D, 0x61, + 0x63, 0x72, 0x6F, 0x20, 0x6C, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6C, 0x20, 0x60, 0x66, 0x60, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x6C, 0x65, 0x74, 0x73, 0x0A, 0x61, 0x6E, 0x79, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x49, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, + 0x71, 0x75, 0x61, 0x73, 0x69, 0x71, 0x75, 0x6F, 0x74, 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x0A, + 0x69, 0x64, 0x69, 0x6F, 0x6D, 0x20, 0x60, 0x28, 0x61, 0x73, 0x2D, 0x6D, 0x61, 0x63, 0x72, 0x6F, + 0x20, 0x2C, 0x6D, 0x79, 0x2D, 0x63, 0x75, 0x73, 0x74, 0x6F, 0x6D, 0x2D, 0x6D, 0x61, 0x63, 0x72, + 0x6F, 0x20, 0x61, 0x72, 0x67, 0x31, 0x20, 0x61, 0x72, 0x67, 0x32, 0x2E, 0x2E, 0x2E, 0x29, 0x60, + 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x0A, 0x74, 0x6F, 0x20, + 0x61, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x75, 0x6E, 0x77, 0x61, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x60, 0x6D, 0x79, 0x2D, 0x63, 0x75, 0x73, 0x74, 0x6F, 0x6D, 0x2D, 0x6D, 0x61, + 0x63, 0x72, 0x6F, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0x79, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x86, 0x71, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x7A, 0xDA, 0x08, 0xCE, 0x81, + 0x40, 0x28, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x62, 0x79, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, + 0x29, 0x0A, 0x0A, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x66, 0x60, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x70, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x73, + 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x6F, 0x66, 0x0A, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x63, 0x61, 0x6C, + 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x66, 0x60, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, + 0x60, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x0A, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x60, 0x66, 0x60, 0x20, 0x63, 0x61, 0x6C, + 0x6C, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x73, 0x0A, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, + 0x6F, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6B, 0x65, 0x79, + 0x2E, 0xDA, 0x8C, 0x7E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x57, 0x84, 0x35, + 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x7F, 0xDA, 0x08, 0xCE, 0x80, 0xE3, 0x28, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, + 0x0A, 0x0A, 0x43, 0x6C, 0x65, 0x61, 0x72, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x61, + 0x72, 0x73, 0x65, 0x20, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x73, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, + 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x65, 0x6E, 0x63, 0x6F, 0x75, + 0x6E, 0x74, 0x65, 0x72, 0x65, 0x64, 0x2E, 0x20, 0x44, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, + 0x65, 0x72, 0x2C, 0x20, 0x73, 0x6F, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6E, 0x20, + 0x70, 0x61, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x2C, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0xDA, 0x8C, + 0x80, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x95, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0x81, 0xDA, 0x08, 0xCE, 0x43, 0x28, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0x20, 0x78, + 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x49, + 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x31, 0x2E, 0xDA, 0x8C, 0x85, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, 0x65, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x86, 0xDA, 0x08, 0xCE, + 0x80, 0x82, 0x28, 0x6F, 0x73, 0x2F, 0x72, 0x65, 0x61, 0x6C, 0x70, 0x61, 0x74, 0x68, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x62, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2C, 0x20, 0x66, 0x6F, + 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x2E, 0x2E, 0x2F, 0x2C, 0x20, 0x2E, 0x2F, 0x2C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x79, 0x6D, 0x6C, 0x69, 0x6E, 0x6B, 0x73, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x6F, 0x6C, 0x75, + 0x74, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8C, 0x87, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x84, 0x44, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x88, 0xDA, 0x08, 0xCE, 0x80, 0xB7, 0x28, 0x74, 0x61, + 0x6B, 0x65, 0x20, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x54, 0x61, 0x6B, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2C, + 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x6F, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2C, 0x20, 0x74, 0x75, 0x70, + 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x0A, 0x72, 0x65, + 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, + 0x6E, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2C, 0x20, + 0x74, 0x61, 0x6B, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x60, + 0x6E, 0x60, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x2E, 0xDA, 0x8C, 0x91, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x86, 0x36, 0xDA, 0x08, + 0xCE, 0x81, 0x5C, 0x28, 0x61, 0x70, 0x70, 0x6C, 0x79, 0x20, 0x66, 0x20, 0x26, 0x20, 0x61, 0x72, + 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x6C, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, + 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x2C, 0x20, 0x65, 0x78, 0x63, + 0x65, 0x70, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x73, 0x2C, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2D, 0x6C, + 0x69, 0x6B, 0x65, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x61, + 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, + 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x70, 0x75, 0x73, 0x68, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, + 0x6E, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x2E, + 0x20, 0x46, 0x6F, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x3A, 0x0A, 0x0A, 0x09, + 0x28, 0x61, 0x70, 0x70, 0x6C, 0x79, 0x20, 0x2B, 0x20, 0x31, 0x30, 0x30, 0x30, 0x20, 0x28, 0x72, + 0x61, 0x6E, 0x67, 0x65, 0x20, 0x31, 0x30, 0x29, 0x29, 0x0A, 0x0A, 0x73, 0x75, 0x6D, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x31, 0x30, 0x20, 0x69, 0x6E, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x31, 0x30, 0x30, 0x30, 0x2E, 0xDA, + 0x8C, 0x92, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x5D, 0x3C, 0x01, 0xDA, 0x06, + 0xDA, 0x80, 0xC8, 0xDA, 0x08, 0xCE, 0x50, 0x28, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x62, 0x72, + 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x72, 0x61, 0x63, + 0x6B, 0x65, 0x74, 0x65, 0x64, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x61, 0x69, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x73, 0x20, 0x78, 0x73, 0x2E, 0xDA, 0x8C, 0x93, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x6B, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x94, 0xDA, 0x08, 0xCE, 0x27, 0x28, 0x63, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, + 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x61, 0x20, 0x63, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x8C, 0x97, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x91, 0x0C, 0x80, 0xC2, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x98, 0xDA, 0x08, 0xCE, 0x4A, 0x28, 0x69, + 0x6E, 0x74, 0x2F, 0x73, 0x36, 0x34, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x78, 0x65, 0x64, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x69, 0x6E, 0x74, 0x65, + 0x67, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x8C, 0x99, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x0C, 0x86, 0x00, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x9A, 0xDA, 0x08, 0xCE, 0x80, + 0xC3, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2D, 0x63, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x2D, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6C, 0x69, 0x6E, + 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x43, 0x20, 0x46, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x72, + 0x61, 0x77, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2E, 0x20, 0x4F, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x67, 0x69, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x61, 0x6D, 0x65, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x20, 0x74, + 0x72, 0x61, 0x63, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, + 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8C, 0x9B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, + 0x85, 0x96, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0x9C, 0xDA, 0x08, 0xCE, 0x81, 0xF1, 0x28, 0x66, 0x66, + 0x69, 0x2F, 0x74, 0x72, 0x61, 0x6D, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x63, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, 0x6B, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x43, 0x20, 0x6C, + 0x69, 0x62, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, + 0x61, 0x6C, 0x6C, 0x62, 0x61, 0x63, 0x6B, 0x20, 0x74, 0x72, 0x61, 0x6D, 0x70, 0x6F, 0x6C, 0x69, + 0x6E, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6D, 0x70, + 0x6F, 0x6C, 0x69, 0x6E, 0x65, 0x28, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x5C, 0x2A, 0x63, 0x74, 0x78, + 0x2C, 0x20, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x5C, 0x2A, 0x75, 0x73, 0x65, 0x72, 0x64, 0x61, 0x74, + 0x61, 0x29, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, + 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, + 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x73, + 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, 0x72, 0x74, + 0x65, 0x64, 0x2E, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6F, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x6D, 0x65, 0x72, 0x20, 0x74, + 0x6F, 0x20, 0x65, 0x6E, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x60, 0x75, 0x73, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x60, 0x20, 0x61, 0x72, 0x67, + 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, + 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x60, 0x63, 0x74, 0x78, 0x60, 0x20, 0x77, 0x68, 0x69, 0x63, + 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x61, 0x71, 0x75, 0x65, 0x20, 0x70, + 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x6F, 0x69, + 0x6E, 0x74, 0x65, 0x72, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x66, 0x75, 0x72, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x60, 0x66, 0x66, 0x69, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x60, 0x2E, 0xDA, 0x8C, + 0x9D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x86, 0x13, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0x9E, 0xDA, 0x08, 0xCE, 0x81, 0xCF, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, + 0x69, 0x6E, 0x67, 0x2D, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, + 0x20, 0x53, 0x6F, 0x6D, 0x65, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x20, 0x6D, 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x73, 0x6F, 0x6D, + 0x65, 0x20, 0x46, 0x46, 0x49, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x69, 0x74, 0x79, 0x20, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x2C, + 0x20, 0x66, 0x66, 0x69, 0x2F, 0x66, 0x72, 0x65, 0x65, 0x2C, 0x20, 0x66, 0x66, 0x69, 0x2F, 0x72, + 0x65, 0x61, 0x64, 0x2C, 0x20, 0x66, 0x66, 0x69, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x2C, 0x20, + 0x65, 0x74, 0x63, 0x2E, 0x29, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x73, 0x75, + 0x70, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, + 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6E, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x67, 0x65, 0x74, 0x20, + 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x63, 0x61, + 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, + 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x61, 0x72, 0x63, + 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, + 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x6E, 0x6F, 0x6E, 0x65, 0x20, 0x63, 0x61, 0x6C, + 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x6C, 0x61, 0x63, 0x65, + 0x68, 0x6F, 0x6C, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x6E, + 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, + 0x6E, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0xDA, 0x8C, 0x9F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x88, 0xA0, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xA0, 0xDA, 0x08, 0xCE, 0x80, 0xC7, 0x28, + 0x66, 0x72, 0x65, 0x65, 0x7A, 0x65, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x46, 0x72, 0x65, 0x65, 0x7A, + 0x65, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x28, 0x6D, 0x61, 0x6B, + 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x6D, 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x29, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x64, 0x6F, 0x20, 0x61, 0x20, 0x64, 0x65, 0x65, 0x70, 0x20, 0x63, 0x6F, + 0x70, 0x79, 0x2C, 0x20, 0x6D, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x0A, 0x63, 0x68, 0x69, 0x6C, 0x64, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x69, 0x6D, 0x6D, + 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x43, 0x6C, 0x6F, 0x73, 0x75, 0x72, 0x65, 0x73, + 0x2C, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x62, + 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0A, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, + 0x76, 0x65, 0x6C, 0x79, 0x20, 0x66, 0x72, 0x6F, 0x7A, 0x65, 0x6E, 0x2C, 0x20, 0x62, 0x75, 0x74, + 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x2E, 0xDA, 0x8C, 0xA3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x04, 0x85, 0x6F, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xA4, 0xDA, 0x08, 0xCE, 0x83, 0xA3, 0x28, + 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, + 0x26, 0x6F, 0x70, 0x74, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x65, 0x6E, 0x76, 0x29, 0x0A, + 0x0A, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, + 0x61, 0x6D, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x69, 0x74, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0x20, 0x60, + 0x66, 0x6C, 0x61, 0x67, 0x73, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, + 0x6F, 0x72, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x68, 0x6F, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, + 0x6D, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x2E, 0x0A, + 0x2A, 0x20, 0x3A, 0x65, 0x20, 0x2D, 0x20, 0x65, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x20, 0x70, + 0x61, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, + 0x67, 0x72, 0x61, 0x6D, 0x2E, 0x20, 0x57, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x3A, 0x65, + 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, + 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x68, + 0x65, 0x72, 0x69, 0x74, 0x65, 0x64, 0x2E, 0x0A, 0x2A, 0x20, 0x3A, 0x70, 0x20, 0x2D, 0x20, 0x61, + 0x6C, 0x6C, 0x6F, 0x77, 0x73, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x69, 0x6E, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x50, 0x41, 0x54, 0x48, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79, 0x20, + 0x74, 0x6F, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x2E, 0x20, 0x57, 0x69, 0x74, 0x68, + 0x6F, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x2C, 0x20, 0x62, + 0x69, 0x6E, 0x61, 0x72, 0x69, 0x65, 0x73, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x75, 0x73, 0x65, + 0x20, 0x61, 0x62, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2E, + 0x0A, 0x2A, 0x20, 0x3A, 0x78, 0x20, 0x2D, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, 0x64, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x7A, 0x65, 0x72, 0x6F, 0x2E, 0x0A, 0x2A, 0x20, + 0x3A, 0x64, 0x20, 0x2D, 0x20, 0x44, 0x6F, 0x6E, 0x27, 0x74, 0x20, 0x74, 0x72, 0x79, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x74, 0x65, 0x72, 0x6D, 0x69, 0x6E, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6F, 0x6E, 0x20, 0x67, 0x61, 0x72, 0x62, + 0x61, 0x67, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x28, + 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x7A, + 0x6F, 0x6D, 0x62, 0x69, 0x65, 0x73, 0x29, 0x2E, 0x0A, 0x60, 0x65, 0x6E, 0x76, 0x60, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6E, 0x76, 0x69, + 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x49, 0x74, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x3A, 0x69, 0x6E, 0x2C, 0x20, 0x3A, + 0x6F, 0x75, 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x2C, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x72, 0x65, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6F, 0x20, 0x69, 0x6E, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, + 0x3A, 0x69, 0x6E, 0x2C, 0x20, 0x3A, 0x6F, 0x75, 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, + 0x65, 0x72, 0x72, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, + 0x72, 0x65, 0x2F, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x6F, + 0x72, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x66, 0x69, 0x6C, 0x65, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x70, 0x61, + 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x3A, 0x69, 0x6E, 0x2C, 0x20, 0x3A, 0x6F, 0x75, + 0x74, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x65, 0x72, 0x72, 0x20, 0x73, 0x68, 0x6F, 0x75, + 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x64, 0x20, 0x6D, 0x61, 0x6E, + 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6F, 0x73, + 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x6E, 0x27, 0x74, + 0x20, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6D, 0x2E, 0x20, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x63, 0x6F, + 0x64, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, + 0x6D, 0x2E, 0xDA, 0x88, 0x70, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x67, + 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x5E, 0xDA, 0x08, 0xCE, 0x80, 0xC7, 0x28, 0x73, 0x6F, 0x72, 0x74, + 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, + 0x3F, 0x29, 0x0A, 0x0A, 0x53, 0x6F, 0x72, 0x74, 0x73, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, + 0x69, 0x6E, 0x2D, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x69, 0x74, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x73, 0x20, 0x71, + 0x75, 0x69, 0x63, 0x6B, 0x2D, 0x73, 0x6F, 0x72, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x73, 0x6F, + 0x72, 0x74, 0x2E, 0x0A, 0x49, 0x66, 0x20, 0x61, 0x20, 0x60, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, + 0x3F, 0x60, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x2C, 0x20, 0x73, 0x6F, 0x72, 0x74, 0x73, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x2C, 0x0A, 0x6F, + 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x60, 0x3C, + 0x60, 0x2E, 0xDA, 0x8C, 0xA5, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x82, + 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xA6, 0xDA, 0x08, 0xCE, 0x5C, 0x28, 0x69, 0x6E, 0x74, 0x3F, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x63, + 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x33, + 0x32, 0x20, 0x62, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x74, 0x77, 0x6F, + 0x27, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, + 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, 0xDA, 0x8C, 0xA7, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x81, 0x57, 0x80, 0x91, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xA8, 0xDA, 0x08, 0xCE, 0x51, 0x28, + 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, + 0x20, 0x72, 0x6E, 0x67, 0x29, 0x0A, 0x0A, 0x45, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, + 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x5B, 0x30, 0x2C, 0x20, + 0x31, 0x29, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x4E, 0x47, 0x2E, + 0xDA, 0x8C, 0xA9, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x8A, 0xD5, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xBB, 0xDA, 0x08, 0xCE, 0x2F, 0x44, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x6F, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x72, 0x73, 0x60, 0xDA, 0x8C, 0xAA, 0xD3, 0x04, + 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8C, 0x43, 0x01, 0xDA, 0x06, + 0xDA, 0x81, 0xEA, 0xDA, 0x08, 0xCE, 0x42, 0x57, 0x69, 0x64, 0x74, 0x68, 0x20, 0x69, 0x6E, 0x20, + 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70, + 0x72, 0x69, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x64, 0x6F, 0x63, + 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x60, 0x2E, 0xDA, 0x8C, 0xAB, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x80, 0x9B, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xAC, 0xDA, 0x08, + 0xCE, 0x80, 0xAB, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x6E, 0x67, 0x2D, 0x69, 0x6E, 0x74, + 0x20, 0x72, 0x6E, 0x67, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6D, 0x61, 0x78, 0x29, 0x0A, 0x0A, + 0x45, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, + 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x5B, 0x30, 0x2C, 0x20, 0x6D, 0x61, 0x78, 0x29, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x6D, 0x61, 0x78, 0x20, 0x3E, 0x20, 0x30, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x52, 0x4E, 0x47, 0x2E, 0x20, 0x20, 0x49, 0x66, 0x20, 0x6D, 0x61, 0x78, + 0x20, 0x69, 0x73, 0x20, 0x30, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x30, 0x2E, + 0x20, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x6D, 0x61, 0x78, 0x20, 0x69, 0x73, 0x20, 0x67, + 0x69, 0x76, 0x65, 0x6E, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x32, 0x5E, 0x33, 0x31, 0x20, 0x2D, 0x20, 0x31, 0x2E, 0xDA, 0x8C, + 0xAD, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x81, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0xAE, 0xDA, 0x08, 0xCE, 0x80, 0xD0, 0x28, 0x69, 0x66, 0x2D, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x5B, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x74, 0x6F, 0x72, 0x20, 0x64, 0x74, + 0x6F, 0x72, 0x5D, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, + 0x20, 0x74, 0x6F, 0x20, 0x60, 0x77, 0x69, 0x74, 0x68, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x69, 0x66, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, + 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x65, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x73, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, + 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, + 0x2C, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x49, 0x6E, 0x20, + 0x62, 0x6F, 0x74, 0x68, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x2C, 0x0A, 0x60, 0x63, 0x74, 0x6F, + 0x72, 0x60, 0x20, 0x69, 0x73, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0xB2, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0xED, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xB3, 0xDA, 0x08, + 0xCE, 0x50, 0x28, 0x6F, 0x73, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0x20, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x66, 0x6C, 0x74, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, + 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0xDA, 0x8C, 0xB4, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x0A, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xB5, 0xDA, 0x08, 0xCE, 0x2A, 0x28, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x61, 0x63, 0x6F, 0x73, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x63, 0x63, 0x6F, 0x73, 0x69, 0x6E, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8C, 0xB6, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8C, 0xB7, 0xDA, + 0x08, 0xCE, 0x80, 0x99, 0x28, 0x63, 0x6D, 0x70, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x2D, 0x31, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, + 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x6C, 0x65, 0x73, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x6E, 0x20, 0x79, 0x2C, 0x20, 0x31, 0x20, 0x69, 0x66, 0x20, 0x79, 0x20, 0x69, + 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x78, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x30, + 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2E, 0x20, 0x54, 0x6F, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x30, 0x2C, 0x20, 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x79, + 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x61, + 0x63, 0x74, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0xDA, 0x8C, 0xB9, + 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0xB1, 0xDA, 0x08, 0xCE, 0x81, 0x30, 0x28, 0x67, 0x65, 0x74, + 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x64, 0x66, 0x6C, + 0x74, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6B, 0x65, 0x79, 0x20, + 0x69, 0x6E, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x20, 0x64, 0x66, 0x6C, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, + 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, + 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, + 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, + 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x73, 0x65, 0x2C, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x67, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x6D, 0x61, 0x79, 0x20, 0x74, 0x68, 0x72, + 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x8C, 0xBA, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x66, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xBB, + 0xDA, 0x08, 0xCE, 0x80, 0x91, 0x28, 0x63, 0x61, 0x74, 0x73, 0x65, 0x71, 0x20, 0x68, 0x65, 0x61, + 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x69, 0x6D, 0x69, 0x6C, + 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x2C, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, 0x6E, 0x61, 0x74, 0x65, 0x73, 0x20, 0x65, + 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x69, + 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x2E, 0x0A, 0x53, + 0x65, 0x65, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0xBD, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xD7, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x5F, 0xDA, 0x08, 0xCE, + 0x41, 0x41, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, + 0x67, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x64, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, + 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x69, 0x72, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x2E, 0xDA, 0x80, 0x98, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x67, 0x01, + 0xDA, 0x06, 0xDA, 0x80, 0x95, 0xDA, 0x08, 0xCE, 0x24, 0x28, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, + 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0xDA, 0x8C, 0xBE, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x24, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0xBF, 0xDA, 0x08, 0xCE, 0x3D, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x72, 0x66, 0x63, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x72, 0x79, 0x20, 0x65, + 0x72, 0x72, 0x6F, 0x72, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, + 0x20, 0x78, 0x2E, 0xDA, 0x8C, 0xC0, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, + 0xBA, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xC1, 0xDA, 0x08, 0xCE, 0x81, 0x61, 0x28, 0x64, 0x65, 0x66, + 0x64, 0x79, 0x6E, 0x20, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x69, + 0x61, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x0A, 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x61, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x2C, 0x20, 0x6C, 0x65, 0x78, 0x69, 0x63, + 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x64, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x0A, + 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, + 0x76, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x79, 0x70, 0x6F, 0x73, 0x2E, 0x20, 0x60, 0x64, 0x65, 0x66, + 0x64, 0x79, 0x6E, 0x60, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, + 0x67, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x0A, + 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x60, 0x64, 0x79, 0x6E, 0x60, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x60, 0x73, 0x65, 0x74, 0x64, 0x79, 0x6E, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x61, 0x6C, 0x69, 0x61, 0x73, 0x20, 0x5F, 0x6D, 0x75, 0x73, 0x74, 0x5F, 0x20, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x60, 0x2A, 0x60, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, + 0x72, 0x2C, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x0A, 0x63, 0x61, 0x6C, 0x6C, 0x65, + 0x64, 0x20, 0x22, 0x65, 0x61, 0x72, 0x6D, 0x75, 0x66, 0x66, 0x73, 0x22, 0x2E, 0xDA, 0x37, 0xCB, + 0xDA, 0x8C, 0xCC, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0x70, 0x01, 0xDA, + 0x06, 0xDA, 0x8C, 0xCD, 0xDA, 0x08, 0xCE, 0x81, 0x41, 0x28, 0x77, 0x69, 0x74, 0x68, 0x20, 0x5B, + 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x74, 0x6F, 0x72, 0x20, 0x64, 0x74, 0x6F, + 0x72, 0x5D, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x20, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2C, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x75, + 0x74, 0x6F, 0x6D, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x63, 0x6C, 0x65, 0x61, + 0x6E, 0x65, 0x64, 0x20, 0x75, 0x70, 0x0A, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, + 0x62, 0x6F, 0x64, 0x79, 0x60, 0x2E, 0x20, 0x60, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x60, + 0x20, 0x69, 0x73, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x63, 0x74, 0x6F, + 0x72, 0x60, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x0A, 0x60, 0x64, 0x74, 0x6F, 0x72, 0x60, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x72, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x64, 0x65, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x6F, 0x72, 0x0A, 0x28, 0x60, 0x64, 0x74, 0x6F, 0x72, 0x60, 0x29, 0x20, 0x69, + 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x61, + 0x6C, 0x6C, 0x20, 0x3A, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0xD0, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x8A, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0xD1, 0xDA, 0x08, 0xCE, 0x80, 0xE8, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x72, 0x61, + 0x77, 0x67, 0x65, 0x74, 0x20, 0x74, 0x61, 0x62, 0x20, 0x6B, 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x47, + 0x65, 0x74, 0x73, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x60, 0x74, 0x61, 0x62, 0x60, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x74, 0x61, 0x62, 0x60, 0x20, + 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6C, + 0x79, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, + 0x8A, 0x85, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0xF4, 0x01, 0xDA, 0x06, + 0xDA, 0x8A, 0x82, 0xDA, 0x08, 0xCE, 0x81, 0x4F, 0x28, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x6D, + 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x73, 0x6F, 0x75, + 0x72, 0x63, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, + 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x29, 0x0A, 0x0A, 0x4D, 0x65, 0x72, 0x67, 0x65, 0x20, 0x61, + 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x69, + 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x60, + 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x61, 0x20, 0x60, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x60, 0x2C, 0x20, 0x61, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x69, 0x6D, 0x70, 0x6F, 0x72, + 0x74, 0x60, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x0A, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6C, + 0x65, 0x74, 0x73, 0x20, 0x75, 0x73, 0x65, 0x72, 0x73, 0x20, 0x65, 0x6D, 0x75, 0x6C, 0x61, 0x74, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6F, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x60, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x61, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6F, 0x6D, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x0A, 0x49, 0x66, 0x20, 0x60, 0x65, 0x78, 0x70, 0x6F, 0x72, + 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x74, 0x68, + 0x65, 0x6E, 0x20, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x64, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x61, 0x72, 0x6B, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, + 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x80, 0xA2, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x82, 0xC8, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xA0, 0xDA, 0x08, 0xCE, 0x33, 0x28, + 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x41, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x69, 0x74, 0x73, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x2E, 0xDA, 0x8C, 0xD2, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x11, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xD3, 0xDA, 0x08, 0xCE, 0x30, 0x28, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x73, 0x69, 0x6E, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x79, 0x70, 0x65, 0x72, 0x62, 0x6F, 0x6C, 0x69, 0x63, + 0x20, 0x73, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8C, 0xD4, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0xF2, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xD5, 0xDA, + 0x08, 0xCE, 0x81, 0xDB, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x2D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, + 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x63, 0x6F, + 0x75, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x61, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x75, 0x6E, 0x64, 0x65, 0x72, 0x6C, 0x79, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x61, + 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6F, 0x72, 0x20, 0x66, 0x72, 0x65, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x61, 0x72, 0x62, 0x61, 0x67, 0x65, + 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x2C, 0x20, 0x61, 0x6C, 0x6C, 0x6F, + 0x77, 0x69, 0x6E, 0x67, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x6E, 0x61, 0x67, 0x65, 0x64, 0x2C, 0x20, + 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x74, + 0x6F, 0x20, 0x62, 0x65, 0x20, 0x6D, 0x61, 0x6E, 0x69, 0x70, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x41, 0x74, 0x74, 0x65, 0x6D, 0x70, 0x74, 0x73, + 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x65, 0x78, + 0x74, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x62, 0x65, 0x79, 0x6F, 0x6E, 0x64, 0x20, 0x69, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, + 0x61, 0x6C, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x77, 0x69, 0x6C, 0x6C, + 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, + 0x20, 0x41, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6D, 0x61, 0x6E, 0x79, 0x20, 0x46, 0x46, + 0x49, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x69, 0x73, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x75, 0x6E, 0x73, 0x61, + 0x66, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x70, 0x6F, 0x74, 0x65, 0x6E, + 0x74, 0x69, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x6F, 0x75, 0x74, + 0x20, 0x6F, 0x66, 0x20, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x73, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, + 0x79, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, + 0x8C, 0xD6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x87, 0xF6, 0x01, 0xDA, 0x06, + 0xDA, 0x8C, 0xD7, 0xDA, 0x08, 0xCE, 0x80, 0xAF, 0x28, 0x6D, 0x61, 0x63, 0x6C, 0x69, 0x6E, 0x74, + 0x66, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x66, 0x6D, 0x74, 0x20, 0x26, 0x20, 0x61, 0x72, + 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x69, 0x6E, 0x73, 0x69, 0x64, 0x65, + 0x20, 0x61, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2C, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, + 0x61, 0x64, 0x64, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, 0x77, 0x61, 0x72, + 0x6E, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x54, 0x61, 0x6B, 0x65, 0x73, 0x0A, 0x61, 0x20, 0x60, 0x66, + 0x6D, 0x74, 0x60, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x69, 0x6B, + 0x65, 0x20, 0x60, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, + 0x60, 0x2C, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2E, 0xDA, 0x8C, 0xD9, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x8A, 0xC1, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xDA, 0xDA, 0x08, 0xCE, 0x72, 0x28, + 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x29, 0x0A, + 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6D, 0x61, 0x67, 0x65, + 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, + 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x60, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x60, 0x2E, 0x0A, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x20, 0x73, 0x6F, + 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x2E, 0xDA, 0x8C, 0xDD, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0xDB, 0x01, + 0xDA, 0x06, 0xDA, 0x8C, 0xDE, 0xDA, 0x08, 0xCE, 0x29, 0x28, 0x6F, 0x73, 0x2F, 0x72, 0x6D, 0x20, + 0x70, 0x61, 0x74, 0x68, 0x29, 0x0A, 0x0A, 0x44, 0x65, 0x6C, 0x65, 0x74, 0x65, 0x20, 0x61, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, + 0x6C, 0x2E, 0xDA, 0x8C, 0xDF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, + 0x59, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xE0, 0xDA, 0x08, 0xCE, 0x3D, 0x28, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x6C, 0x63, 0x6D, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x63, 0x6F, 0x6D, + 0x6D, 0x6F, 0x6E, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x78, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x79, 0x2E, 0xDA, 0x8C, 0xE1, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x83, 0xEF, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xE2, 0xDA, 0x08, 0xCE, 0x80, + 0x80, 0x28, 0x6D, 0x61, 0x70, 0x63, 0x61, 0x74, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, + 0x20, 0x69, 0x6E, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x70, 0x20, 0x61, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x65, 0x76, 0x65, 0x72, + 0x79, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x61, + 0x6E, 0x64, 0x0A, 0x75, 0x73, 0x65, 0x20, 0x60, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, + 0x6E, 0x63, 0x61, 0x74, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, + 0x6E, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x73, + 0x2E, 0xDA, 0x88, 0x11, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8E, 0xFC, 0x03, 0xDA, 0x06, 0xDA, 0x88, 0x2C, 0xDA, 0x08, 0xCE, 0x37, 0x20, 0x43, 0x75, + 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6C, 0x69, 0x62, + 0x72, 0x61, 0x72, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x66, 0x66, 0x69, 0x2F, 0x62, 0x69, 0x6E, + 0x64, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, 0x65, 0x74, 0x74, + 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x8C, 0xF0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, + 0x57, 0x81, 0x1A, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x63, 0xDA, 0x08, 0xCE, 0x2D, 0x28, 0x6D, 0x61, + 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x30, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x67, 0x20, 0x62, 0x61, 0x73, + 0x65, 0x20, 0x31, 0x30, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8C, 0xF1, 0xD3, 0x04, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x81, 0xFC, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xF2, 0xDA, 0x08, + 0xCE, 0x3D, 0x28, 0x65, 0x61, 0x63, 0x68, 0x6B, 0x20, 0x78, 0x20, 0x64, 0x73, 0x20, 0x26, 0x20, + 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, + 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x64, 0x73, + 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, + 0x37, 0xCB, 0xDA, 0x8C, 0xF4, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8A, 0x3F, 0xDA, 0x08, 0xCE, 0x81, + 0x68, 0x28, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x64, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6B, + 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, + 0x78, 0x74, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, + 0x65, 0x79, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x75, 0x6E, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, + 0x20, 0x4B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6E, + 0x74, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x65, 0x6E, 0x20, + 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x6F, 0x6E, 0x63, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x74, 0x65, 0x64, 0x20, 0x64, 0x75, 0x72, + 0x69, 0x6E, 0x67, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x49, + 0x66, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x6E, 0x65, + 0x78, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x6B, 0x65, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x65, 0x78, + 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2C, 0x20, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x20, 0x6D, 0x6F, 0x72, 0x65, + 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x72, 0x6F, 0x75, 0x67, 0x68, 0x2E, 0xDA, 0x8C, 0xF5, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0x4E, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x10, 0xDA, 0x08, 0xCE, + 0x80, 0xB1, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x6F, 0x69, 0x6E, + 0x74, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x26, 0x20, + 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x61, 0x6C, 0x6C, 0x20, 0x61, 0x20, 0x72, 0x61, + 0x77, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x2E, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x69, + 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x68, 0x6F, 0x77, 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, + 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x61, 0x72, 0x67, 0x73, 0x60, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2E, 0xDA, 0x8C, 0xF6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x90, 0x59, + 0x84, 0x1A, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xF7, 0xDA, 0x08, 0xCE, 0x80, 0xF0, 0x28, 0x61, 0x73, + 0x6D, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x2E, + 0x0A, 0x54, 0x68, 0x65, 0x20, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x20, 0x63, 0x61, 0x6E, + 0x20, 0x62, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x63, 0x6F, 0x72, 0x72, 0x65, + 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x0A, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x73, 0x6D, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x20, + 0x61, 0x6E, 0x0A, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x76, 0x61, + 0x6C, 0x69, 0x64, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, 0x2E, 0xDA, 0x8C, 0xF8, + 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x01, 0x01, 0xDA, 0x06, 0xDA, 0x8C, + 0xF9, 0xDA, 0x08, 0xCE, 0x4B, 0x28, 0x65, 0x61, 0x63, 0x68, 0x70, 0x20, 0x78, 0x20, 0x64, 0x73, + 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, + 0x76, 0x65, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x28, 0x6B, 0x65, 0x79, 0x2C, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x29, 0x20, 0x70, 0x61, 0x69, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x64, + 0x73, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x8C, 0xFB, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, + 0x37, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xFC, 0xDA, 0x08, 0xCE, 0x23, 0x28, 0x6F, 0x6E, 0x65, 0x3F, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, + 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x31, 0x2E, 0xDA, 0x8C, + 0xFE, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xAA, 0x01, 0xDA, 0x06, 0xDA, + 0x8C, 0xFF, 0xDA, 0x08, 0xCE, 0x80, 0x8B, 0x28, 0x65, 0x76, 0x65, 0x72, 0x79, 0x3F, 0x20, 0x69, + 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, + 0x6C, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, + 0x2C, 0x0A, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x65, 0x76, 0x61, 0x6C, + 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, + 0x73, 0x74, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x2E, 0xDA, 0x8D, 0x03, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x82, + 0x93, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x04, 0xDA, 0x08, 0xCE, 0x5F, 0x28, 0x78, 0x70, 0x72, 0x69, + 0x6E, 0x74, 0x66, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x6D, 0x74, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, + 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x60, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x60, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6E, + 0x20, 0x65, 0x78, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, + 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x60, 0x74, 0x6F, 0x60, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x8D, 0x05, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x9E, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x0B, 0xDA, 0x08, + 0xCE, 0x5C, 0x28, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x78, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x45, 0x78, 0x74, 0x72, + 0x61, 0x63, 0x74, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x2D, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6F, 0x72, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2E, 0xDA, 0x8D, + 0x06, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8F, 0x92, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x07, 0xDA, 0x08, 0xCE, 0x36, 0x50, 0x61, 0x74, 0x68, 0x20, 0x74, + 0x6F, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6C, + 0x6F, 0x61, 0x64, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x69, 0x6E, 0x67, 0x20, 0x75, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x2E, + 0xDA, 0x8B, 0x0B, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x88, 0x37, 0xDA, 0x08, 0xCE, 0x82, 0x57, 0x28, + 0x70, 0x75, 0x74, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x29, 0x0A, 0x0A, 0x41, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6B, + 0x65, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x61, + 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x20, 0x49, 0x6E, 0x64, 0x65, 0x78, + 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x73, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x29, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x61, 0x63, 0x63, + 0x65, 0x70, 0x74, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x2C, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x69, + 0x66, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x6F, 0x75, 0x6E, + 0x64, 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x76, + 0x69, 0x64, 0x65, 0x64, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x2C, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x6E, 0x69, 0x6C, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x6E, 0x20, + 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2C, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x66, 0x69, + 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x30, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x70, + 0x75, 0x74, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x65, 0x64, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, + 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x68, 0x69, 0x64, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x75, 0x74, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0x20, 0x50, 0x75, 0x74, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, + 0x75, 0x65, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x64, 0x73, 0x2E, 0xDA, 0x8D, 0x08, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x91, 0x0C, 0x80, 0xC9, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x09, 0xDA, 0x08, 0xCE, 0x4C, 0x28, + 0x69, 0x6E, 0x74, 0x2F, 0x75, 0x36, 0x34, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x78, 0x65, 0x64, 0x20, 0x75, + 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x8D, 0x0A, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0xD7, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x0B, + 0xDA, 0x08, 0xCE, 0x80, 0xD6, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x63, 0x68, 0x65, + 0x63, 0x6B, 0x2D, 0x73, 0x65, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, + 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x6F, 0x6E, + 0x6C, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6E, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, 0x65, 0x74, + 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, + 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6E, 0x20, + 0x60, 0x73, 0x65, 0x74, 0x60, 0x2C, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, + 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x73, + 0x74, 0x72, 0x60, 0x20, 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, + 0x72, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x73, 0x65, 0x74, 0x60, 0x2E, 0xDA, 0x8B, 0xB0, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x88, 0xCF, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x0C, 0xDA, + 0x08, 0xCE, 0x81, 0x01, 0x28, 0x76, 0x61, 0x72, 0x66, 0x6E, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, + 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, + 0x60, 0x76, 0x61, 0x72, 0x66, 0x6E, 0x60, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6D, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x74, 0x75, 0x72, 0x65, 0x0A, 0x61, + 0x73, 0x20, 0x60, 0x64, 0x65, 0x66, 0x6E, 0x60, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, + 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x61, 0x73, 0x20, 0x76, 0x61, 0x72, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, + 0x20, 0x76, 0x61, 0x72, 0x20, 0x60, 0x6E, 0x61, 0x6D, 0x65, 0x60, 0x0A, 0x61, 0x6C, 0x72, 0x65, + 0x61, 0x64, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x69, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x62, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, + 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x0A, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8D, 0x19, 0xD3, 0x04, 0xDA, 0x81, 0xC9, + 0xCB, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD9, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x1A, + 0xDA, 0x08, 0xCE, 0x55, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6E, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x72, 0x20, 0x66, 0x69, + 0x62, 0x65, 0x72, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6B, 0x2D, 0x69, 0x64, + 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x79, + 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x2E, 0xDA, 0x8D, 0x1B, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0xCF, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x1C, 0xDA, 0x08, 0xCE, + 0x80, 0xC8, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x20, 0x73, 0x74, 0x72, 0x65, + 0x61, 0x6D, 0x20, 0x6E, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x74, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, + 0x61, 0x73, 0x20, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, + 0x65, 0x61, 0x72, 0x6C, 0x79, 0x20, 0x69, 0x66, 0x20, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x6E, 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, + 0x76, 0x61, 0x69, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x20, + 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x61, 0x63, 0x68, 0x65, 0x64, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x61, + 0x6C, 0x73, 0x6F, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x65, 0x61, 0x72, 0x6C, 0x79, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2E, 0xDA, 0x8D, 0x1D, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x60, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xC6, 0xDA, 0x08, + 0xCE, 0x80, 0xB9, 0x28, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x26, 0x20, 0x78, 0x73, + 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, + 0x77, 0x6F, 0x72, 0x64, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, 0x6E, + 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x60, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2E, 0xDA, 0x8D, 0x1E, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x12, 0x83, 0xD4, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x1F, + 0xDA, 0x08, 0xCE, 0x81, 0x3A, 0x28, 0x6E, 0x65, 0x74, 0x2F, 0x73, 0x65, 0x74, 0x73, 0x6F, 0x63, + 0x6B, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x6F, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x73, 0x65, 0x74, 0x20, 0x73, + 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x0A, 0x0A, + 0x73, 0x75, 0x70, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, + 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x3A, 0x0A, 0x2D, 0x20, + 0x3A, 0x73, 0x6F, 0x2D, 0x62, 0x72, 0x6F, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x20, 0x62, 0x6F, + 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x0A, 0x2D, 0x20, 0x3A, 0x73, 0x6F, 0x2D, 0x72, 0x65, 0x75, 0x73, + 0x65, 0x61, 0x64, 0x64, 0x72, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x0A, 0x2D, 0x20, + 0x3A, 0x73, 0x6F, 0x2D, 0x6B, 0x65, 0x65, 0x70, 0x61, 0x6C, 0x69, 0x76, 0x65, 0x20, 0x62, 0x6F, + 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x0A, 0x2D, 0x20, 0x3A, 0x69, 0x70, 0x2D, 0x6D, 0x75, 0x6C, 0x74, + 0x69, 0x63, 0x61, 0x73, 0x74, 0x2D, 0x74, 0x74, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x0A, 0x2D, 0x20, 0x3A, 0x69, 0x70, 0x2D, 0x61, 0x64, 0x64, 0x2D, 0x6D, 0x65, 0x6D, 0x62, 0x65, + 0x72, 0x73, 0x68, 0x69, 0x70, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0x2D, 0x20, 0x3A, + 0x69, 0x70, 0x2D, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x6D, 0x65, 0x6D, 0x62, 0x65, 0x72, 0x73, 0x68, + 0x69, 0x70, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0x2D, 0x20, 0x3A, 0x69, 0x70, 0x76, + 0x36, 0x2D, 0x6A, 0x6F, 0x69, 0x6E, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6E, 0x67, 0x0A, 0x2D, 0x20, 0x3A, 0x69, 0x70, 0x76, 0x36, 0x2D, 0x6C, 0x65, 0x61, 0x76, + 0x65, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0xDA, + 0x84, 0x5B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0x07, 0x01, 0xDA, 0x06, + 0xDA, 0x84, 0x58, 0xDA, 0x08, 0xCE, 0x81, 0x3D, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, + 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x50, 0x6F, 0x6C, 0x79, 0x6D, 0x6F, 0x72, 0x70, 0x68, + 0x69, 0x63, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6E, 0x73, 0x20, 0x2D, 0x31, 0x2C, 0x20, 0x30, 0x2C, 0x20, 0x31, 0x20, 0x66, 0x6F, 0x72, + 0x20, 0x78, 0x20, 0x3C, 0x20, 0x79, 0x2C, 0x20, 0x78, 0x20, 0x3D, 0x20, 0x79, 0x2C, 0x20, 0x78, + 0x20, 0x3E, 0x20, 0x79, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, + 0x79, 0x2E, 0x0A, 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6D, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, + 0x6D, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x74, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x73, 0x20, 0x74, 0x6F, 0x0A, 0x73, 0x65, 0x65, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x78, 0x20, 0x6F, 0x72, 0x20, 0x79, 0x20, 0x69, + 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x20, 0x60, 0x63, 0x6F, 0x6D, 0x70, + 0x61, 0x72, 0x65, 0x60, 0x20, 0x6D, 0x65, 0x74, 0x68, 0x6F, 0x64, 0x20, 0x77, 0x68, 0x69, 0x63, + 0x68, 0x20, 0x63, 0x61, 0x6E, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x20, 0x78, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x73, 0x6F, 0x2C, 0x20, 0x69, 0x74, + 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6D, 0x65, 0x74, 0x68, 0x6F, + 0x64, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x2C, 0x20, 0x69, 0x74, 0x0A, 0x64, 0x65, + 0x6C, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x72, 0x69, 0x6D, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x61, + 0x74, 0x6F, 0x72, 0x73, 0x2E, 0xDA, 0x8D, 0x20, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x04, 0x86, 0xCC, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x21, 0xDA, 0x08, 0xCE, 0x82, 0x84, 0x28, 0x6F, + 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x69, 0x66, 0x20, 0x60, 0x74, 0x69, 0x6D, 0x65, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x6B, 0x65, + 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x4E, 0x6F, 0x74, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x30, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x2E, 0x20, 0x44, + 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x69, 0x6E, 0x20, + 0x55, 0x54, 0x43, 0x20, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x60, 0x6C, 0x6F, 0x63, 0x61, + 0x6C, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x69, 0x6E, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x64, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, + 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x20, + 0x74, 0x69, 0x6D, 0x65, 0x7A, 0x6F, 0x6E, 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x65, + 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x2D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x20, 0x5B, 0x30, 0x2D, 0x36, 0x31, 0x5D, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x69, 0x6E, 0x75, 0x74, 0x65, 0x73, 0x20, 0x2D, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x6D, 0x69, 0x6E, 0x75, 0x74, 0x65, 0x73, + 0x20, 0x5B, 0x30, 0x2D, 0x35, 0x39, 0x5D, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x68, 0x6F, 0x75, 0x72, + 0x73, 0x20, 0x2D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x68, 0x6F, + 0x75, 0x72, 0x73, 0x20, 0x5B, 0x30, 0x2D, 0x32, 0x33, 0x5D, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, + 0x6F, 0x6E, 0x74, 0x68, 0x2D, 0x64, 0x61, 0x79, 0x20, 0x2D, 0x20, 0x64, 0x61, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x20, 0x5B, 0x30, 0x2D, 0x33, 0x30, 0x5D, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x20, 0x2D, 0x20, 0x6D, 0x6F, 0x6E, 0x74, 0x68, + 0x20, 0x6F, 0x66, 0x20, 0x79, 0x65, 0x61, 0x72, 0x20, 0x5B, 0x30, 0x2C, 0x20, 0x31, 0x31, 0x5D, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x79, 0x65, 0x61, 0x72, 0x20, 0x2D, 0x20, 0x79, 0x65, 0x61, 0x72, + 0x73, 0x20, 0x73, 0x69, 0x6E, 0x63, 0x65, 0x20, 0x79, 0x65, 0x61, 0x72, 0x20, 0x30, 0x20, 0x28, + 0x65, 0x2E, 0x67, 0x2E, 0x20, 0x32, 0x30, 0x31, 0x39, 0x29, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x77, + 0x65, 0x65, 0x6B, 0x2D, 0x64, 0x61, 0x79, 0x20, 0x2D, 0x20, 0x64, 0x61, 0x79, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x65, 0x65, 0x6B, 0x20, 0x5B, 0x30, 0x2D, 0x36, 0x5D, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x79, 0x65, 0x61, 0x72, 0x2D, 0x64, 0x61, 0x79, 0x20, 0x2D, 0x20, 0x64, + 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x65, 0x61, 0x72, 0x20, 0x5B, + 0x30, 0x2D, 0x33, 0x36, 0x35, 0x5D, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, 0x73, 0x74, 0x20, 0x2D, + 0x20, 0x69, 0x66, 0x20, 0x44, 0x61, 0x79, 0x20, 0x4C, 0x69, 0x67, 0x68, 0x74, 0x20, 0x53, 0x61, + 0x76, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x65, 0x66, 0x66, 0x65, + 0x63, 0x74, 0xDA, 0x8D, 0x22, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x90, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x23, 0xDA, 0x08, 0xCE, 0x67, 0x28, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x6C, 0x65, 0x61, 0x76, 0x65, 0x20, 0x26, 0x20, 0x63, 0x6F, 0x6C, 0x73, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, 0x6F, + 0x6C, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, + 0x6E, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2C, 0x20, 0x65, 0x74, 0x63, + 0x2E, 0xDA, 0x8D, 0x26, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0x57, 0x83, 0xBC, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x27, 0xDA, 0x08, 0xCE, 0x80, 0xF2, 0x28, 0x70, 0x61, 0x72, 0x73, + 0x65, 0x72, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6D, 0x65, + 0x61, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, + 0x20, 0x6D, 0x61, 0x6E, 0x69, 0x70, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, 0x20, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x20, 0x6F, + 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x6F, + 0x75, 0x6C, 0x64, 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, + 0x20, 0x74, 0x6F, 0x20, 0x61, 0x64, 0x64, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x2C, 0x20, 0x66, 0x6F, 0x72, + 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2E, 0xDA, 0x8D, 0x28, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x55, 0x01, 0xDA, 0x06, 0xDA, 0x87, + 0x01, 0xDA, 0x08, 0xCE, 0x80, 0xB6, 0x28, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x26, 0x20, + 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, + 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, + 0x6E, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x74, 0x6F, 0x67, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x69, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x60, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0xDA, 0x8D, 0x29, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x1E, 0x01, 0xDA, 0x06, 0xDA, 0x8D, + 0x2A, 0xDA, 0x08, 0xCE, 0x51, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x65, 0x69, 0x6C, 0x20, + 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x6E, 0x20, 0x78, 0x2E, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6E, 0x61, 0x6E, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0xA4, 0x01, 0xDA, 0x06, 0xC8, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0xDA, 0x08, 0xCE, 0x1B, 0x4E, 0x6F, 0x74, 0x20, + 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x28, 0x49, 0x45, 0x45, 0x45, 0x2D, 0x37, + 0x35, 0x34, 0x20, 0x4E, 0x61, 0x4E, 0x29, 0xDA, 0x87, 0xAB, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x86, 0xBE, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xA8, 0xDA, 0x08, 0xCE, 0x69, 0x28, + 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x73, 0x65, 0x20, 0x73, 0x65, 0x70, 0x20, 0x69, 0x6E, + 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, + 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, + 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0A, 0x60, 0x73, 0x65, + 0x70, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x8D, 0x2B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x22, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x2C, 0xDA, 0x08, 0xCE, + 0x55, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x70, 0x20, 0x78, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x28, 0x6C, 0x6F, 0x67, 0x20, 0x62, 0x61, + 0x73, 0x65, 0x20, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x29, 0x20, 0x2B, 0x20, 0x31, 0x20, 0x6D, + 0x6F, 0x72, 0x65, 0x20, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61, 0x74, 0x65, 0x6C, 0x79, 0x20, 0x74, + 0x68, 0x61, 0x6E, 0x20, 0x28, 0x2B, 0x20, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, + 0x20, 0x78, 0x29, 0x20, 0x31, 0x29, 0xDA, 0x8D, 0x2D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x80, 0x82, 0x82, 0x3E, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x2E, 0xDA, 0x08, 0xCE, 0x5B, 0x28, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x63, 0x6C, 0x65, 0x61, 0x72, + 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, 0x0A, 0x0A, + 0x43, 0x6C, 0x65, 0x61, 0x72, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x20, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x69, 0x74, 0x2D, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xCF, 0x06, 0x6D, 0x61, 0x74, 0x68, + 0x2F, 0x65, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x96, 0x01, 0xDA, + 0x06, 0xC8, 0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40, 0xDA, 0x08, 0xCE, 0x1C, 0x54, 0x68, + 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, + 0x74, 0x75, 0x72, 0x61, 0x6C, 0x20, 0x6C, 0x6F, 0x67, 0x2E, 0xDA, 0x8D, 0x2F, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x86, 0x77, 0x80, 0xE9, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x30, 0xDA, + 0x08, 0xCE, 0x80, 0x9C, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, + 0x61, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, + 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x20, 0x61, + 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x61, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x61, 0x74, + 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, + 0x68, 0x72, 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, + 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, + 0xDA, 0x8D, 0x31, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8A, 0xAA, 0x01, 0xDA, + 0x06, 0xDA, 0x8C, 0xDC, 0xDA, 0x08, 0xCE, 0x80, 0x8D, 0x41, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x63, 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x6D, 0x61, 0x72, 0x73, 0x68, + 0x61, 0x6C, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x63, + 0x6F, 0x64, 0x65, 0x20, 0x28, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x73, 0x29, 0x2C, 0x20, 0x73, 0x75, + 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x0A, 0x60, 0x28, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, + 0x6D, 0x61, 0x67, 0x65, 0x20, 0x78, 0x29, 0x60, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, + 0x6C, 0x20, 0x78, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2D, 0x64, + 0x69, 0x63, 0x74, 0x29, 0x60, 0x2E, 0xDA, 0x8D, 0x32, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x04, 0x80, 0x84, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x33, 0xDA, 0x08, 0xCE, 0x81, 0x3C, 0x28, + 0x6F, 0x73, 0x2F, 0x77, 0x68, 0x69, 0x63, 0x68, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, + 0x69, 0x6E, 0x67, 0x77, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x79, 0x67, 0x77, 0x69, 0x6E, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x61, 0x63, 0x6F, 0x73, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x77, 0x65, + 0x62, 0x20, 0x2D, 0x20, 0x57, 0x65, 0x62, 0x20, 0x61, 0x73, 0x73, 0x65, 0x6D, 0x62, 0x6C, 0x79, + 0x20, 0x28, 0x65, 0x6D, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x65, 0x6E, 0x29, 0x0A, 0x0A, 0x2A, + 0x20, 0x3A, 0x6C, 0x69, 0x6E, 0x75, 0x78, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x66, 0x72, 0x65, 0x65, + 0x62, 0x73, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6F, 0x70, 0x65, 0x6E, 0x62, 0x73, 0x64, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x65, 0x74, 0x62, 0x73, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, + 0x72, 0x61, 0x67, 0x6F, 0x6E, 0x66, 0x6C, 0x79, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x62, 0x73, 0x64, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x20, 0x2D, 0x20, 0x41, 0x20, 0x50, + 0x4F, 0x53, 0x49, 0x58, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6C, 0x65, 0x20, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x28, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x29, + 0x0A, 0x0A, 0x4D, 0x61, 0x79, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x61, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6F, 0x6D, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, + 0x72, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, + 0x62, 0x75, 0x69, 0x6C, 0x64, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0xDA, 0x8D, 0x34, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0xFA, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xE3, + 0xDA, 0x08, 0xCE, 0x81, 0x41, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, 0x6E, 0x63, + 0x61, 0x74, 0x20, 0x61, 0x72, 0x72, 0x20, 0x26, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x29, 0x0A, + 0x0A, 0x43, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, 0x6E, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, + 0x6F, 0x66, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x20, 0x28, 0x61, 0x6E, 0x64, 0x20, 0x74, + 0x75, 0x70, 0x6C, 0x65, 0x73, 0x29, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, + 0x2C, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, + 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2E, 0x20, 0x4F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2C, 0x20, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x70, 0x61, 0x72, 0x74, 0x73, + 0x60, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x61, 0x72, 0x72, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x6F, + 0x72, 0x64, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x60, 0x61, 0x72, 0x72, 0x60, 0x2E, 0xDA, 0x88, 0x13, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x8F, 0x02, 0x03, 0xDA, 0x06, 0xDA, 0x8D, 0x35, 0xDA, 0x08, 0xCE, 0x80, 0xB6, 0x28, + 0x66, 0x66, 0x69, 0x2F, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x20, 0x26, 0x6F, 0x70, 0x74, + 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x6E, 0x61, + 0x6D, 0x65, 0x64, 0x20, 0x6D, 0x61, 0x70, 0x2D, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x20, + 0x6C, 0x61, 0x7A, 0x79, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, + 0x69, 0x63, 0x20, 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6D, + 0x70, 0x6C, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x2C, 0x20, 0x61, 0x73, + 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x20, 0x20, 0x20, 0x20, 0x20, 0x61, 0x73, 0x20, 0x6F, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x65, 0x61, 0x73, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6E, 0x67, 0x20, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, + 0x69, 0x6E, 0x67, 0x73, 0x2E, 0xDA, 0x8D, 0x3D, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8F, 0x98, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x3E, 0xDA, 0x08, 0xCE, 0x80, 0xA1, 0x28, 0x63, + 0x6C, 0x69, 0x2D, 0x6D, 0x61, 0x69, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x45, + 0x6E, 0x74, 0x72, 0x61, 0x6E, 0x63, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x43, 0x4C, 0x49, 0x20, 0x74, 0x6F, 0x6F, 0x6C, 0x2E, 0x20, + 0x43, 0x61, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x6D, + 0x61, 0x6E, 0x64, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x0A, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, + 0x74, 0x73, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, + 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x76, 0x6F, 0x6B, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x43, 0x4C, 0x49, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2E, 0xDA, + 0x8D, 0x99, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x33, 0x01, 0xDA, + 0x06, 0xDA, 0x8D, 0x9A, 0xDA, 0x08, 0xCE, 0x3E, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x68, 0x79, + 0x70, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x62, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x63, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x5E, 0x32, 0x20, 0x3D, 0x20, 0x61, 0x5E, 0x32, 0x20, + 0x2B, 0x20, 0x62, 0x5E, 0x32, 0x2E, 0xDA, 0x8D, 0x9B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x04, 0x89, 0x01, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x46, 0xDA, 0x08, 0xCE, 0x83, 0xB1, 0x28, + 0x6F, 0x73, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, + 0x74, 0x20, 0x74, 0x61, 0x62, 0x7C, 0x6B, 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, + 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x62, 0x6F, + 0x75, 0x74, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2C, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, + 0x6E, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, + 0x65, 0x20, 0x6F, 0x72, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x64, + 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x2C, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x6B, 0x65, 0x79, 0x73, 0x20, 0x61, 0x72, 0x65, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, 0x65, + 0x76, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x6F, 0x6E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x2D, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, + 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x3A, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x3A, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2C, 0x20, 0x3A, 0x62, 0x6C, 0x6F, 0x63, 0x6B, + 0x2C, 0x20, 0x3A, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2C, 0x20, 0x3A, 0x66, + 0x69, 0x66, 0x6F, 0x2C, 0x20, 0x3A, 0x73, 0x6F, 0x63, 0x6B, 0x65, 0x74, 0x2C, 0x20, 0x3A, 0x6C, + 0x69, 0x6E, 0x6B, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x3A, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x0A, 0x0A, + 0x2A, 0x20, 0x3A, 0x69, 0x6E, 0x74, 0x2D, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, + 0x6E, 0x73, 0x20, 0x2D, 0x20, 0x41, 0x20, 0x55, 0x6E, 0x69, 0x78, 0x20, 0x70, 0x65, 0x72, 0x6D, + 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6C, + 0x69, 0x6B, 0x65, 0x20, 0x38, 0x72, 0x37, 0x34, 0x34, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x70, 0x65, + 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x2D, 0x20, 0x41, 0x20, 0x55, 0x6E, + 0x69, 0x78, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6E, 0x67, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x22, 0x72, 0x77, 0x78, 0x72, 0x2D, + 0x2D, 0x72, 0x2D, 0x2D, 0x22, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x75, 0x69, 0x64, 0x20, 0x2D, 0x20, + 0x46, 0x69, 0x6C, 0x65, 0x20, 0x75, 0x69, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x67, 0x69, 0x64, + 0x20, 0x2D, 0x20, 0x46, 0x69, 0x6C, 0x65, 0x20, 0x67, 0x69, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, + 0x6E, 0x6C, 0x69, 0x6E, 0x6B, 0x20, 0x2D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, + 0x66, 0x20, 0x6C, 0x69, 0x6E, 0x6B, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x72, 0x64, 0x65, 0x76, 0x20, 0x2D, 0x20, 0x52, 0x65, 0x61, 0x6C, 0x20, + 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, + 0x30, 0x20, 0x6F, 0x6E, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x2D, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6F, 0x66, 0x20, + 0x66, 0x69, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0A, 0x0A, 0x2A, + 0x20, 0x3A, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0x20, 0x2D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x30, 0x20, 0x6F, 0x6E, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, + 0x73, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, 0x69, 0x7A, 0x65, 0x20, + 0x2D, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x30, 0x20, 0x6F, 0x6E, 0x20, 0x57, + 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x20, + 0x77, 0x68, 0x65, 0x6E, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x68, 0x61, 0x6E, + 0x67, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x20, + 0x77, 0x68, 0x65, 0x6E, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x20, 0x28, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x73, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x29, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x73, 0x74, 0x61, 0x6D, 0x70, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, + 0x6C, 0x61, 0x73, 0x74, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x28, 0x63, + 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x20, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x29, 0x0A, + 0xDA, 0x8D, 0x9C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xA3, 0x81, 0x62, 0x01, + 0xDA, 0x06, 0xDA, 0x8D, 0x9D, 0xDA, 0x08, 0xCE, 0x81, 0x1F, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x61, 0x74, 0x74, 0x20, + 0x73, 0x74, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2D, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x73, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x73, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x60, 0x70, 0x61, + 0x74, 0x74, 0x60, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x73, + 0x74, 0x72, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x69, 0x6E, 0x64, + 0x69, 0x63, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x2E, 0x20, 0x4F, 0x76, 0x65, 0x72, 0x6C, 0x61, 0x70, 0x70, + 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x6F, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x69, 0x76, 0x69, 0x64, + 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x2C, 0x20, 0x6D, 0x65, 0x61, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x60, 0x73, 0x74, 0x72, 0x60, 0x20, 0x6D, + 0x61, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x74, 0x6F, + 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, + 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x73, 0x2E, 0xDA, 0x8D, 0x9E, 0xD3, 0x02, 0xDA, 0x06, + 0xDA, 0x81, 0x6D, 0xDA, 0x08, 0xCE, 0x81, 0x62, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x6F, 0x72, 0x20, 0x73, + 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x70, 0x61, + 0x73, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, + 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x79, 0x69, 0x65, + 0x6C, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x20, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x73, 0x70, 0x61, 0x74, + 0x63, 0x68, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, + 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x62, 0x65, 0x72, 0x27, 0x73, 0x20, 0x64, 0x69, 0x73, 0x70, 0x61, 0x74, 0x63, 0x68, + 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x63, 0x61, 0x6C, 0x6C, + 0x20, 0x69, 0x6E, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0xDA, 0x8D, 0x9F, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8C, 0x41, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xA0, 0xDA, 0x08, + 0xCE, 0x43, 0x28, 0x65, 0x76, 0x2F, 0x72, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x2D, 0x72, 0x6C, + 0x6F, 0x63, 0x6B, 0x20, 0x72, 0x77, 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6C, + 0x65, 0x61, 0x73, 0x65, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x6C, 0x6F, 0x63, 0x6B, + 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x20, 0x6C, 0x6F, 0x63, 0x6B, 0xDA, 0x84, 0x72, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x82, 0xCD, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0x70, 0xDA, 0x08, 0xCE, 0x4A, 0x28, 0x63, 0x6F, + 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, + 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x88, 0x73, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x18, 0x86, 0x5B, 0x01, 0xDA, 0x06, 0xDA, 0x88, 0x71, 0xDA, 0x08, 0xCE, 0x44, 0x28, + 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6B, 0x65, 0x79, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x2E, 0xDA, 0x85, 0x8A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, + 0x6C, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x85, 0xDA, 0x08, 0xCE, 0x81, 0x15, 0x28, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x67, 0x65, 0x72, 0x2D, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x65, 0x6E, 0x76, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x69, + 0x73, 0x2D, 0x72, 0x65, 0x70, 0x6C, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x60, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x60, 0x27, 0x73, + 0x20, 0x60, 0x3A, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x60, 0x20, 0x20, 0x61, + 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x64, 0x72, 0x6F, 0x70, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x77, + 0x69, 0x6C, 0x6C, 0x20, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, + 0x6F, 0x6E, 0x20, 0x61, 0x62, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x3A, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x60, 0x20, 0x64, 0x79, 0x6E, 0x20, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, + 0x6F, 0x20, 0x61, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, + 0x2E, 0xDA, 0x83, 0x83, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x6D, 0x01, 0xDA, + 0x06, 0xDA, 0x83, 0x81, 0xDA, 0x08, 0xCE, 0x21, 0x28, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3F, + 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0xDA, 0x8D, 0xA1, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0x09, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xA2, 0xDA, 0x08, 0xCE, + 0x81, 0x15, 0x28, 0x6B, 0x65, 0x65, 0x70, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, + 0x20, 0x26, 0x20, 0x69, 0x6E, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x47, 0x69, 0x76, 0x65, 0x6E, 0x20, + 0x61, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x60, 0x70, 0x72, 0x65, + 0x64, 0x60, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x69, 0x6E, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6C, 0x74, 0x73, 0x0A, 0x6F, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x79, 0x69, 0x6E, 0x67, + 0x20, 0x60, 0x70, 0x72, 0x65, 0x64, 0x60, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, + 0x0A, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, + 0x60, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0x60, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, + 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0A, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0xDA, 0x8D, 0xB0, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, + 0x00, 0xDA, 0x29, 0x82, 0x55, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xF3, 0xDA, 0x08, 0xCE, 0x81, 0x1C, + 0x28, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x70, 0x72, + 0x6F, 0x6D, 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x20, 0x65, 0x6E, 0x76, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x61, 0x64, 0x73, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x69, + 0x6E, 0x70, 0x75, 0x74, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x2C, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, + 0x74, 0x65, 0x72, 0x2C, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6F, + 0x6D, 0x70, 0x74, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, + 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, + 0x6C, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x75, 0x74, 0x6F, 0x2D, 0x63, 0x6F, 0x6D, 0x70, + 0x6C, 0x65, 0x74, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, + 0x74, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x74, 0x65, 0x72, 0x6D, 0x69, + 0x6E, 0x61, 0x6C, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0xDA, 0x8D, 0xB1, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x5D, 0x63, 0x01, 0xDA, 0x06, 0xDA, 0x81, 0x00, + 0xDA, 0x08, 0xCE, 0x71, 0x28, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x6F, 0x75, 0x72, 0x63, + 0x65, 0x6D, 0x61, 0x70, 0x20, 0x74, 0x75, 0x70, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x6D, 0x61, 0x70, + 0x20, 0x6D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, + 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2C, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x28, 0x6C, 0x69, 0x6E, 0x65, 0x2C, 0x20, 0x63, 0x6F, 0x6C, + 0x75, 0x6D, 0x6E, 0x29, 0x2E, 0xDA, 0x8D, 0xB2, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x80, 0x82, 0x81, 0x34, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x02, 0xDA, 0x08, 0xCE, 0x80, 0xD5, 0x28, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, + 0x6E, 0x67, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, + 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6E, 0x63, 0x65, 0x73, 0x20, 0x6F, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, + 0x64, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, + 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6F, + 0x66, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x2C, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, + 0x72, 0x64, 0x73, 0x2C, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x2C, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x57, 0x69, 0x6C, 0x6C, 0x20, 0x74, 0x68, 0x72, + 0x6F, 0x77, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x66, 0x6C, + 0x6F, 0x77, 0x73, 0x2E, 0xDA, 0x8D, 0xB3, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, + 0x7B, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0xA1, 0xDA, 0x08, 0xCE, 0x83, 0x16, 0x28, 0x6D, 0x6F, 0x64, + 0x75, 0x6C, 0x65, 0x2F, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2D, 0x70, 0x61, 0x74, 0x68, 0x20, + 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x29, 0x0A, 0x0A, + 0x45, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x73, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, + 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, + 0x20, 0x69, 0x6E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, + 0x73, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, + 0x69, 0x6E, 0x64, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x6B, 0x65, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x28, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x29, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x74, 0x65, 0x6D, 0x70, 0x6C, + 0x61, 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x74, 0x6F, 0x20, 0x65, + 0x78, 0x70, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, + 0x6F, 0x20, 0x61, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x69, 0x6D, + 0x70, 0x6F, 0x72, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x2E, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x73, 0x3A, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x20, 0x2D, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x76, 0x65, + 0x72, 0x62, 0x61, 0x74, 0x69, 0x6D, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x40, 0x61, 0x6C, 0x6C, + 0x3A, 0x20, 0x2D, 0x2D, 0x20, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x3A, 0x61, 0x6C, + 0x6C, 0x3A, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x66, 0x20, 0x60, 0x70, 0x61, 0x74, 0x68, + 0x60, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x40, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x73, 0x65, + 0x67, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, + 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, + 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3C, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x73, 0x65, 0x67, 0x6D, 0x65, + 0x6E, 0x74, 0x20, 0x61, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3E, 0x29, 0x60, + 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x63, 0x75, 0x72, 0x3A, 0x20, 0x2D, 0x2D, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x70, 0x6F, 0x72, 0x74, + 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x2C, 0x20, 0x6F, 0x66, 0x20, + 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x2D, 0x66, 0x69, + 0x6C, 0x65, 0x29, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x64, 0x69, 0x72, 0x3A, 0x20, 0x2D, 0x2D, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x20, 0x70, 0x6F, + 0x72, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x2C, 0x20, 0x6F, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, + 0x65, 0x6E, 0x74, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x20, 0x2D, 0x2D, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6F, 0x6E, + 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2C, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x66, 0x20, 0x67, + 0x69, 0x76, 0x65, 0x6E, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, + 0x20, 0x2D, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6E, 0x73, 0x69, 0x6F, + 0x6E, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x20, 0x6E, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2C, 0x20, 0x2E, 0x73, 0x6F, 0x20, 0x6F, 0x72, 0x20, 0x2E, + 0x64, 0x6C, 0x6C, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x20, 0x2D, 0x2D, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2C, + 0x20, 0x6F, 0x72, 0x20, 0x28, 0x64, 0x79, 0x6E, 0x20, 0x3A, 0x73, 0x79, 0x73, 0x70, 0x61, 0x74, + 0x68, 0x29, 0xDA, 0x8D, 0xB4, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x86, 0x76, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xB5, 0xDA, 0x08, 0xCE, 0x30, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x77, + 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x77, 0x6F, 0x72, 0x6B, 0x69, 0x6E, 0x67, 0x20, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0xDA, 0x8B, 0xBB, 0xD3, 0x03, 0xDA, + 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, 0x86, 0x01, 0xDA, 0x06, 0xDA, 0x8B, 0xC2, 0xDA, 0x08, + 0xCE, 0x81, 0x69, 0x28, 0x64, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, + 0x26, 0x6E, 0x61, 0x6D, 0x65, 0x64, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x20, + 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x65, 0x72, 0x20, + 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2C, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x61, + 0x74, 0x68, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x61, 0x6E, + 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6C, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, + 0x6E, 0x74, 0x2E, 0x20, 0x3A, 0x65, 0x6E, 0x76, 0x2C, 0x20, 0x3A, 0x65, 0x78, 0x70, 0x61, 0x6E, + 0x64, 0x65, 0x72, 0x2C, 0x0A, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2C, 0x20, 0x3A, 0x65, + 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x6F, 0x72, 0x2C, 0x20, 0x3A, 0x72, 0x65, 0x61, 0x64, 0x2C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x75, 0x67, 0x68, 0x20, + 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6E, 0x64, 0x65, 0x72, 0x6C, 0x79, 0x69, 0x6E, + 0x67, 0x0A, 0x60, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x60, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x60, 0x65, 0x78, 0x69, 0x74, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x74, 0x6F, 0x70, + 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x77, 0x69, + 0x6C, 0x6C, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x0A, 0x63, 0x61, 0x6C, + 0x6C, 0x20, 0x74, 0x6F, 0x20, 0x60, 0x28, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0x20, 0x31, + 0x29, 0x60, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x69, 0x6E, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x8D, 0xB6, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x87, 0xC4, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xB7, + 0xDA, 0x08, 0xCE, 0x80, 0x8A, 0x28, 0x6F, 0x73, 0x2F, 0x74, 0x6F, 0x75, 0x63, 0x68, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6D, 0x65, 0x20, + 0x6D, 0x6F, 0x64, 0x74, 0x69, 0x6D, 0x65, 0x29, 0x0A, 0x0A, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x2E, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x2C, 0x20, + 0x73, 0x65, 0x74, 0x73, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0xDA, + 0x8D, 0x68, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x6B, 0x01, 0xDA, 0x06, + 0xDA, 0x8D, 0x64, 0xDA, 0x08, 0xCE, 0x81, 0x88, 0x28, 0x72, 0x65, 0x70, 0x6C, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x20, 0x6F, 0x6E, 0x73, 0x69, 0x67, 0x6E, + 0x61, 0x6C, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x72, 0x65, + 0x61, 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x2E, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, + 0x65, 0x74, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, + 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, + 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x74, 0x6F, 0x0A, 0x67, 0x65, 0x74, 0x20, 0x61, 0x20, 0x63, 0x68, + 0x75, 0x6E, 0x6B, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, + 0x64, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x6E, + 0x64, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, + 0x6E, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x69, 0x73, 0x0A, 0x63, 0x61, + 0x75, 0x67, 0x68, 0x74, 0x2E, 0x20, 0x4F, 0x6E, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x70, 0x72, + 0x6F, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, + 0x6C, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, + 0x62, 0x6C, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x75, 0x6E, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x70, 0x6C, 0x20, 0x69, 0x6E, 0x2C, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6C, 0x6C, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x61, 0x73, 0x73, 0x0A, 0x74, + 0x6F, 0x20, 0x60, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x60, 0x2E, + 0xDA, 0x8D, 0xB8, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x0C, 0x01, 0xDA, + 0x06, 0xDA, 0x8D, 0xB9, 0xDA, 0x08, 0xCE, 0x4E, 0x28, 0x66, 0x6F, 0x72, 0x65, 0x76, 0x65, 0x72, + 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, 0x61, + 0x74, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x20, + 0x69, 0x6E, 0x20, 0x61, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x75, 0x6E, + 0x74, 0x69, 0x6C, 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8D, 0xBB, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x9F, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x76, 0xDA, 0x08, 0xCE, + 0x2E, 0x28, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, + 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xDA, + 0x8D, 0xBC, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x90, 0x01, 0xDA, 0x06, + 0xDA, 0x8D, 0xBD, 0xDA, 0x08, 0xCE, 0x2B, 0x28, 0x25, 0x3D, 0x20, 0x78, 0x20, 0x26, 0x20, 0x6E, + 0x73, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, + 0x72, 0x20, 0x28, 0x73, 0x65, 0x74, 0x20, 0x78, 0x20, 0x28, 0x25, 0x20, 0x78, 0x20, 0x6E, 0x29, + 0x29, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8D, 0xBF, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x81, 0x57, 0x81, 0x25, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xC0, 0xDA, 0x08, 0xCE, 0x29, 0x28, 0x6D, + 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x2D, 0x67, 0x61, 0x6D, 0x6D, 0x61, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6C, 0x6F, 0x67, 0x2D, 0x67, 0x61, + 0x6D, 0x6D, 0x61, 0x28, 0x78, 0x29, 0x2E, 0xDA, 0x8D, 0xC1, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8D, + 0xC2, 0xDA, 0x08, 0xCE, 0x34, 0x28, 0x62, 0x6E, 0x6F, 0x74, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x2D, 0x77, + 0x69, 0x73, 0x65, 0x20, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x78, 0x2E, 0xDA, 0x8D, 0xC4, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0x8B, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xC5, 0xDA, 0x08, + 0xCE, 0x80, 0xA8, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x63, 0x61, + 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x2D, 0x61, 0x6C, + 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, + 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x29, 0x60, 0x20, 0x62, 0x75, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, + 0x62, 0x65, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6E, + 0x74, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, + 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x20, 0x69, 0x73, 0x20, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x2E, 0xDA, 0x86, 0xAE, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x16, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xC6, 0xDA, + 0x08, 0xCE, 0x89, 0x51, 0x28, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, 0x26, + 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x41, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, + 0x6C, 0x20, 0x70, 0x75, 0x72, 0x70, 0x6F, 0x73, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x6D, + 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, + 0x20, 0x69, 0x73, 0x20, 0x73, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x43, 0x6F, 0x6D, 0x6D, 0x6F, 0x6E, 0x20, 0x4C, 0x69, 0x73, 0x70, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x0A, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2C, 0x20, 0x61, 0x6C, 0x74, 0x68, 0x6F, + 0x75, 0x67, 0x68, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, + 0x79, 0x20, 0x6D, 0x75, 0x63, 0x68, 0x20, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x72, 0x20, 0x69, + 0x6E, 0x20, 0x73, 0x63, 0x6F, 0x70, 0x65, 0x2E, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x68, 0x65, + 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x0A, 0x73, + 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x65, 0x69, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x6F, 0x72, 0x0A, + 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x73, 0x2E, 0x20, 0x41, 0x20, + 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, + 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x0A, 0x74, 0x6F, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x42, 0x69, 0x6E, 0x64, 0x69, 0x6E, + 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6E, 0x20, 0x69, + 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3A, 0x0A, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x3A, 0x76, 0x65, 0x72, 0x62, + 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x2F, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x0A, 0x0A, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x60, 0x62, 0x69, 0x6E, 0x64, 0x69, + 0x6E, 0x67, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, + 0x20, 0x61, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x64, 0x65, + 0x66, 0x2C, 0x20, 0x60, 0x3A, 0x76, 0x65, 0x72, 0x62, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x0A, 0x6B, 0x65, + 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x60, 0x6F, 0x62, 0x6A, + 0x65, 0x63, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x65, 0x78, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x73, 0x75, 0x62, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x0A, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, + 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x76, 0x65, 0x72, 0x62, 0x73, 0x20, 0x61, 0x72, 0x65, 0x3A, + 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x60, 0x20, 0x2D, + 0x2D, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x6C, 0x79, 0x20, 0x65, 0x76, 0x61, + 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x20, 0x74, + 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x0A, 0x20, 0x20, 0x74, + 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x72, 0x61, 0x6E, 0x67, + 0x65, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, + 0x61, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6F, 0x62, 0x6A, + 0x65, 0x63, 0x74, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, + 0x74, 0x77, 0x6F, 0x2D, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0A, 0x20, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, + 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x74, 0x65, 0x70, 0x2E, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x68, 0x61, 0x6C, 0x66, + 0x0A, 0x20, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x2C, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, + 0x20, 0x65, 0x6E, 0x64, 0x29, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x72, 0x61, 0x6E, 0x67, + 0x65, 0x2D, 0x74, 0x6F, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, + 0x20, 0x3A, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, + 0x69, 0x76, 0x65, 0x20, 0x5B, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2C, 0x20, 0x65, 0x6E, 0x64, 0x5D, + 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x64, 0x6F, 0x77, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, + 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6E, 0x67, + 0x65, 0x2C, 0x20, 0x73, 0x74, 0x65, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x6F, 0x77, 0x6E, + 0x77, 0x61, 0x72, 0x64, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, + 0x74, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x0A, 0x20, 0x20, + 0x74, 0x77, 0x6F, 0x2D, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x28, 0x65, 0x78, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x29, 0x20, 0x65, + 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x6E, + 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x0A, 0x20, 0x20, 0x28, 0x70, 0x6F, 0x73, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x21, 0x29, 0x20, 0x73, 0x74, 0x65, 0x70, 0x20, 0x73, 0x69, 0x7A, + 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x64, 0x6F, 0x77, 0x6E, 0x2D, 0x74, 0x6F, 0x60, + 0x20, 0x2D, 0x2D, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x3A, 0x64, 0x6F, 0x77, + 0x6E, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x5B, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x2C, 0x20, 0x65, 0x6E, 0x64, 0x5D, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, + 0x3A, 0x6B, 0x65, 0x79, 0x73, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, + 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x70, 0x61, 0x69, 0x72, 0x73, 0x60, + 0x20, 0x2D, 0x2D, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x2D, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, + 0x61, 0x69, 0x72, 0x73, 0x20, 0x61, 0x73, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x20, 0x69, + 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x69, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x66, + 0x69, 0x62, 0x65, 0x72, 0x2E, 0x0A, 0x0A, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x20, 0x61, 0x6C, + 0x73, 0x6F, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, + 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x75, + 0x72, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, + 0x61, 0x6C, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6F, 0x66, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x6F, 0x72, 0x6D, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x0A, 0x0A, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x60, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 0x60, 0x20, + 0x69, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, + 0x6F, 0x66, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x60, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6B, + 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2D, 0x64, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x6E, 0x74, + 0x2E, 0x0A, 0x60, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 0x60, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, + 0x60, 0x3A, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x73, 0x20, 0x66, 0x72, + 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x20, 0x69, 0x66, 0x20, 0x60, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x60, 0x20, 0x69, 0x73, 0x0A, 0x20, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x2E, + 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x65, 0x78, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, + 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x69, 0x66, 0x20, 0x60, 0x65, 0x78, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x60, 0x20, 0x69, 0x73, 0x0A, 0x20, 0x20, 0x74, 0x72, 0x75, + 0x74, 0x68, 0x79, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, + 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x73, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x69, + 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, + 0x6F, 0x6F, 0x70, 0x20, 0x61, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x0A, 0x20, 0x20, 0x60, 0x6C, 0x65, 0x74, 0x60, 0x20, 0x6D, 0x61, 0x63, + 0x72, 0x6F, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, + 0x66, 0x6F, 0x72, 0x6D, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x20, + 0x73, 0x69, 0x64, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x20, 0x62, 0x65, 0x66, 0x6F, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6E, 0x6E, 0x65, + 0x72, 0x0A, 0x20, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x61, + 0x66, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x73, 0x61, + 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x3A, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x60, 0x2C, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x64, 0x65, 0x20, 0x65, 0x66, + 0x66, 0x65, 0x63, 0x74, 0x20, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x73, 0x20, 0x61, 0x66, 0x74, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x20, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6E, + 0x6E, 0x65, 0x72, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x20, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x72, 0x65, 0x70, 0x65, + 0x61, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6E, 0x6E, + 0x65, 0x72, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x74, 0x69, 0x6D, 0x65, + 0x73, 0x2E, 0x0A, 0x0A, 0x2A, 0x20, 0x60, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6E, + 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, + 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, + 0x77, 0x68, 0x65, 0x6E, 0x20, 0x60, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x60, + 0x0A, 0x20, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0x0A, 0x0A, 0x2A, + 0x20, 0x60, 0x3A, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, + 0x69, 0x6F, 0x6E, 0x60, 0x20, 0x2D, 0x2D, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x65, 0x76, 0x61, + 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6E, 0x74, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x77, 0x68, 0x65, + 0x6E, 0x20, 0x60, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x60, 0x0A, 0x20, 0x20, + 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x2E, 0x0A, 0x0A, 0x54, 0x68, 0x65, 0x20, + 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x20, 0x61, 0x6C, 0x77, + 0x61, 0x79, 0x73, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, + 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8D, 0xEE, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x82, 0x8B, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xEF, 0xDA, 0x08, 0xCE, 0x39, + 0x28, 0x6D, 0x65, 0x61, 0x6E, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x65, 0x61, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x78, + 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2C, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x73, 0x20, 0x4E, 0x61, 0x4E, 0x2E, 0xDA, 0x8D, 0xF4, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x0F, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xF5, 0xDA, 0x08, + 0xCE, 0x36, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0x68, 0x20, 0x78, 0x29, + 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x79, + 0x70, 0x65, 0x72, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x20, 0x61, 0x72, 0x63, 0x63, 0x6F, 0x73, 0x69, + 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8D, 0xF6, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x81, 0x62, 0x81, 0x93, 0x01, 0xDA, 0x06, 0xDA, 0x83, 0x8D, 0xDA, 0x08, 0xCE, + 0x74, 0x28, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x6E, 0x65, 0x20, 0x74, 0x61, + 0x62, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x70, + 0x79, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, + 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x6C, 0x64, 0x20, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x76, 0x69, 0x63, 0x65, 0x20, 0x76, + 0x65, 0x72, 0x73, 0x61, 0x2E, 0xDA, 0x8D, 0xF7, 0xD3, 0x04, 0xDA, 0x81, 0xC9, 0xCB, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x84, 0xD1, 0x01, 0xDA, 0x06, 0xDA, 0x8C, 0xC5, 0xDA, 0x08, 0xCE, + 0x80, 0x87, 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x74, 0x6F, 0x20, 0x61, + 0x64, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x73, 0x20, 0x64, + 0x65, 0x63, 0x6C, 0x61, 0x72, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x64, 0x65, + 0x66, 0x64, 0x79, 0x6E, 0x60, 0x2E, 0x0A, 0x20, 0x20, 0x55, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6E, 0x74, 0x20, 0x6B, 0x65, 0x79, + 0x77, 0x6F, 0x72, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x73, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, + 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x2E, 0xDA, 0x8D, 0xF8, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x69, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xF9, 0xDA, 0x08, 0xCE, 0x24, + 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, + 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8D, 0xFB, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x00, 0xDA, 0x08, 0xCE, + 0x41, 0x54, 0x68, 0x65, 0x20, 0x72, 0x6F, 0x6F, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, + 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x28, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, + 0x29, 0x2E, 0xDA, 0x8B, 0xBA, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8C, 0x0F, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0xFC, 0xDA, 0x08, 0xCE, 0x82, 0x2E, 0x28, 0x69, 0x6D, 0x70, 0x6F, + 0x72, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, + 0x0A, 0x49, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x61, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, + 0x2E, 0x20, 0x46, 0x69, 0x72, 0x73, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x73, 0x20, 0x69, 0x74, 0x73, + 0x0A, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, + 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x20, 0x61, 0x73, 0x20, 0x6E, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2E, 0x0A, 0x28, 0x75, 0x73, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x61, 0x73, 0x20, 0x6F, 0x72, 0x20, 0x3A, 0x70, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x29, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x6E, 0x6F, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, + 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x0A, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, + 0x61, 0x6D, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x2E, 0x20, 0x4F, + 0x6E, 0x65, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x61, 0x6C, 0x73, 0x6F, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x22, 0x60, 0x3A, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x74, 0x72, 0x75, 0x65, 0x60, 0x22, + 0x0A, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x2D, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, + 0x6C, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x22, 0x60, 0x3A, 0x65, 0x78, 0x69, 0x74, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x60, 0x22, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, + 0x73, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x0A, 0x61, + 0x6E, 0x79, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x65, 0x6E, 0x63, 0x6F, 0x75, 0x6E, + 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6F, 0x70, + 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, + 0x64, 0x75, 0x6C, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, + 0x60, 0x28, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0x20, 0x31, 0x29, 0x60, 0x0A, 0x74, 0x6F, + 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x2E, 0x20, 0x44, 0x79, 0x6E, 0x61, + 0x6D, 0x69, 0x63, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x4E, 0x4F, 0x54, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x65, + 0x64, 0x2E, 0x20, 0x55, 0x73, 0x65, 0x20, 0x3A, 0x66, 0x72, 0x65, 0x73, 0x68, 0x20, 0x74, 0x6F, + 0x20, 0x62, 0x79, 0x70, 0x61, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x6D, 0x6F, 0x64, 0x75, + 0x6C, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8D, 0xFF, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x89, 0x10, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x00, + 0xDA, 0x08, 0xCE, 0x81, 0x9E, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x68, 0x6D, 0x6F, 0x64, 0x20, 0x70, + 0x61, 0x74, 0x68, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x61, 0x6E, 0x67, + 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, + 0x6E, 0x73, 0x2C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, + 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x60, 0x2C, 0x20, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x69, + 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, 0x65, 0x72, 0x6D, 0x2D, 0x69, + 0x6E, 0x74, 0x60, 0x2E, 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x60, 0x6D, 0x6F, 0x64, 0x65, 0x60, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2C, 0x20, + 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x55, 0x6E, 0x69, 0x78, 0x20, 0x70, 0x65, 0x72, 0x6D, + 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, 0x20, 0x62, 0x65, + 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, + 0x6F, 0x63, 0x74, 0x61, 0x6C, 0x2C, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x38, 0x72, 0x36, 0x36, + 0x36, 0x20, 0x6F, 0x72, 0x20, 0x38, 0x72, 0x34, 0x30, 0x30, 0x2E, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x64, 0x69, 0x66, + 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x74, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, + 0x65, 0x6E, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2C, 0x20, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2C, 0x20, + 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, + 0x73, 0x69, 0x6F, 0x6E, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x75, 0x73, 0x20, + 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x63, 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x6C, 0x6C, + 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, + 0x73, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, + 0x69, 0x6C, 0x2E, 0xDA, 0x8D, 0x11, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, + 0x10, 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x0F, 0xDA, 0x08, 0xCE, 0x80, 0xCD, 0x28, 0x70, 0x75, 0x74, + 0x2D, 0x69, 0x6E, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x73, 0x20, 0x76, 0x29, 0x0A, 0x0A, 0x50, 0x75, + 0x74, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, + 0x20, 0x6E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, 0x2E, 0x20, 0x4C, 0x6F, 0x6F, + 0x6B, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x60, 0x64, 0x73, 0x60, 0x20, 0x76, 0x69, 0x61, + 0x0A, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x6B, + 0x65, 0x79, 0x73, 0x2E, 0x20, 0x4D, 0x69, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x0A, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2C, + 0x20, 0x6F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x80, 0xAC, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, 0xE7, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xA6, 0xDA, 0x08, 0xCE, + 0x6B, 0x28, 0x6D, 0x61, 0x70, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x26, 0x20, 0x69, 0x6E, + 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x70, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x0A, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x73, 0x2E, 0xDA, 0x8E, 0x01, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0x6E, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x02, + 0xDA, 0x08, 0xCE, 0x80, 0xA1, 0x28, 0x61, 0x73, 0x2D, 0x3E, 0x20, 0x78, 0x20, 0x61, 0x73, 0x20, + 0x26, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64, + 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2C, + 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x69, 0x6E, 0x67, 0x20, 0x60, 0x61, 0x73, 0x60, 0x20, + 0x69, 0x6E, 0x20, 0x60, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x0A, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6F, 0x75, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x2E, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x0A, 0x6C, 0x61, 0x73, 0x74, 0x20, + 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8E, 0x06, 0xD3, 0x04, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xED, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x07, 0xDA, 0x08, 0xCE, + 0x81, 0x48, 0x28, 0x74, 0x72, 0x79, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x63, 0x61, 0x74, 0x63, + 0x68, 0x29, 0x0A, 0x0A, 0x54, 0x72, 0x79, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x74, 0x68, 0x69, 0x6E, + 0x67, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x20, 0x65, 0x72, 0x72, 0x6F, + 0x72, 0x73, 0x2E, 0x20, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, + 0x79, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x2C, 0x0A, 0x61, 0x6E, + 0x64, 0x20, 0x60, 0x63, 0x61, 0x74, 0x63, 0x68, 0x60, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, + 0x65, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x0A, 0x73, 0x68, + 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x62, + 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, + 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, + 0x6C, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x0A, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, + 0x20, 0x60, 0x62, 0x6F, 0x64, 0x79, 0x60, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x2C, 0x0A, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x63, 0x61, 0x74, 0x63, 0x68, 0x60, 0x20, 0x69, 0x66, + 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8E, 0x0A, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x3A, 0x8B, 0xAE, 0x01, 0xDA, 0x06, 0xDA, 0x8B, + 0x67, 0xDA, 0x08, 0xCE, 0x66, 0x28, 0x65, 0x76, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, 0x0A, 0x0A, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x20, 0x61, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6F, + 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, + 0x61, 0x73, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x28, 0x3A, 0x63, 0x6C, 0x6F, + 0x73, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x29, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, + 0x6C, 0x6C, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x73, 0x2E, 0xDA, 0x85, 0x62, 0xD3, 0x03, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xE3, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0x60, 0xDA, + 0x08, 0xCE, 0x3B, 0x28, 0x6D, 0x61, 0x78, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, + 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, + 0x65, 0x72, 0x69, 0x63, 0x20, 0x6D, 0x61, 0x78, 0x69, 0x6D, 0x75, 0x6D, 0x20, 0x6F, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x2E, 0xDA, 0x8E, + 0x0B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, 0x82, 0x49, 0x01, 0xDA, 0x06, + 0xDA, 0x8E, 0x0C, 0xDA, 0x08, 0xCE, 0x6D, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, + 0x69, 0x74, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x29, + 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x20, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x69, 0x74, 0x2D, + 0x69, 0x6E, 0x64, 0x65, 0x78, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x73, 0x65, 0x74, 0x2C, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, + 0x6E, 0x6F, 0x74, 0x2E, 0xDA, 0x8E, 0x0D, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, + 0x82, 0x7F, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x0E, 0xDA, 0x08, 0xCE, 0x60, 0x28, 0x66, 0x69, 0x62, + 0x65, 0x72, 0x2D, 0x66, 0x6E, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x26, 0x20, 0x62, 0x6F, + 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x41, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x6D, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x73, + 0x2E, 0x20, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x60, 0x28, 0x66, 0x69, 0x62, 0x65, + 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x28, 0x66, 0x6E, 0x20, 0x5B, 0x5D, 0x20, 0x3B, 0x62, 0x6F, + 0x64, 0x79, 0x29, 0x20, 0x66, 0x6C, 0x61, 0x67, 0x73, 0x29, 0x60, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, + 0x8E, 0x11, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x82, 0x70, 0x01, 0xDA, 0x06, + 0xDA, 0x8E, 0x12, 0xDA, 0x08, 0xCE, 0x41, 0x28, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x66, 0x75, + 0x6E, 0x63, 0x29, 0x0A, 0x0A, 0x45, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x72, 0x61, 0x63, + 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x8E, 0x13, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x29, 0x81, 0x7F, 0x01, 0xDA, 0x06, 0xDA, 0x87, 0x13, 0xDA, 0x08, 0xCE, 0x81, + 0x54, 0x28, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x73, 0x74, + 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x62, 0x61, 0x73, 0x65, 0x29, 0x0A, 0x0A, 0x50, 0x61, + 0x72, 0x73, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, + 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x2C, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x61, 0x6C, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x61, 0x73, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, + 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x2E, 0x20, 0x57, 0x69, + 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x6F, 0x6E, + 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, + 0x65, 0x72, 0x2E, 0x20, 0x4F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x70, + 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x2D, 0x20, + 0x69, 0x66, 0x20, 0x61, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, + 0x76, 0x69, 0x64, 0x65, 0x64, 0x2C, 0x20, 0x6E, 0x6F, 0x20, 0x72, 0x61, 0x64, 0x69, 0x78, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x70, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x2E, 0xDA, 0x8E, 0x14, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x8B, 0x4C, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xA0, 0xDA, 0x08, 0xCE, 0x42, 0x41, 0x6E, 0x20, + 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x64, 0x6F, 0x74, 0x20, 0x70, 0x72, + 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, + 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x69, 0x6E, 0x67, 0x2E, 0xDA, + 0x8E, 0x15, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x0C, 0x85, 0x19, 0x01, 0xDA, 0x06, + 0xDA, 0x8E, 0x16, 0xDA, 0x08, 0xCE, 0x80, 0xCB, 0x28, 0x66, 0x66, 0x69, 0x2F, 0x6A, 0x69, 0x74, + 0x66, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, + 0x65, 0x72, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x60, + 0x66, 0x66, 0x69, 0x2F, 0x63, 0x61, 0x6C, 0x6C, 0x60, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, + 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x60, 0x20, 0x69, 0x73, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, + 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, + 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x70, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x2E, 0xDA, 0x8A, 0x89, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8B, + 0xFF, 0x01, 0xDA, 0x06, 0xDA, 0x8A, 0x79, 0xDA, 0x08, 0xCE, 0x80, 0x86, 0x28, 0x69, 0x6D, 0x70, + 0x6F, 0x72, 0x74, 0x2A, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, + 0x29, 0x0A, 0x0A, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x20, 0x6F, 0x66, 0x20, 0x60, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x60, 0x2E, 0x20, 0x53, 0x61, + 0x6D, 0x65, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x62, + 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x0A, 0x61, 0x6E, 0x64, 0x20, + 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x70, 0x61, 0x72, + 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, + 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, + 0x64, 0x2E, 0xDA, 0x8E, 0x17, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0xC3, 0x80, + 0xC5, 0x01, 0xDA, 0x06, 0xDA, 0x84, 0xC1, 0xDA, 0x08, 0xCE, 0x81, 0xAA, 0x28, 0x66, 0x69, 0x6C, + 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x20, 0x77, 0x68, 0x61, 0x74, 0x20, 0x26, 0x6F, + 0x70, 0x74, 0x20, 0x62, 0x75, 0x66, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x61, 0x20, + 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x60, 0x66, 0x60, 0x20, + 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x41, + 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x60, 0x62, 0x75, 0x66, 0x60, 0x20, 0x63, 0x61, + 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x74, 0x68, 0x69, + 0x72, 0x64, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x6F, 0x74, 0x68, + 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2E, 0x20, + 0x60, 0x77, 0x68, 0x61, 0x74, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, + 0x6F, 0x72, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x2E, 0x20, 0x52, 0x65, + 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x73, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x60, 0x77, 0x68, 0x61, 0x74, 0x60, 0x3A, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x6C, 0x6C, 0x20, + 0x2D, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x68, 0x6F, 0x6C, 0x65, + 0x20, 0x66, 0x69, 0x6C, 0x65, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x2D, + 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x64, 0x20, + 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, + 0x78, 0x74, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, + 0x63, 0x74, 0x65, 0x72, 0x0A, 0x0A, 0x2A, 0x20, 0x6E, 0x20, 0x28, 0x69, 0x6E, 0x74, 0x65, 0x67, + 0x65, 0x72, 0x29, 0x20, 0x2D, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6F, + 0x20, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0xDA, 0x8E, 0x18, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x83, 0xF9, 0x80, 0xC9, 0x01, 0xDA, 0x06, 0xDA, 0x80, 0xA8, 0xDA, 0x08, 0xCE, 0x73, 0x28, + 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x20, 0x61, 0x72, 0x72, 0x20, 0x26, + 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x78, + 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, + 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x70, 0x75, 0x74, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x69, + 0x74, 0x2E, 0xDA, 0x8E, 0x19, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0xBA, + 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x1A, 0xDA, 0x08, 0xCE, 0x6F, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x20, + 0x26, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x29, 0x0A, 0x0A, 0x54, 0x61, + 0x6B, 0x65, 0x73, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6F, 0x73, + 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x6F, 0x73, 0x65, 0x20, 0x66, + 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0xDA, 0x85, 0xC1, 0xD3, 0x03, 0xDA, 0x03, + 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x89, 0x89, 0x01, 0xDA, 0x06, 0xDA, 0x85, 0xBC, 0xDA, 0x08, 0xCE, + 0x54, 0x28, 0x77, 0x61, 0x72, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x6D, + 0x73, 0x67, 0x20, 0x6C, 0x65, 0x76, 0x65, 0x6C, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x26, + 0x6F, 0x70, 0x74, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x63, 0x6F, 0x6C, 0x29, 0x0A, 0x0A, 0x44, + 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x68, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x20, 0x66, + 0x6F, 0x72, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x77, 0x61, 0x72, + 0x6E, 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8B, 0xB2, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x4A, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x1F, 0xDA, 0x08, 0xCE, 0x43, 0x28, 0x76, 0x61, 0x72, + 0x2D, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, 0x0A, 0x0A, + 0x44, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x61, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, + 0x20, 0x76, 0x61, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2E, 0xDA, + 0x37, 0xCB, 0xDA, 0x8E, 0x21, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x85, 0xD8, + 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x22, 0xDA, 0x08, 0xCE, 0x81, 0x07, 0x28, 0x69, 0x6E, 0x76, 0x65, + 0x72, 0x74, 0x20, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x47, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x61, 0x6E, + 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x60, 0x64, 0x73, 0x60, + 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, + 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x0A, + 0x6B, 0x65, 0x79, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x64, 0x73, 0x60, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6D, 0x75, 0x6C, + 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x0A, 0x69, 0x6E, 0x20, 0x60, 0x64, + 0x73, 0x60, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, + 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x6F, + 0x73, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x0A, 0x62, + 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x69, 0x6E, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x74, 0x61, 0x62, 0x6C, + 0x65, 0x2E, 0xDA, 0x85, 0xA9, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x66, 0x01, + 0xDA, 0x06, 0xDA, 0x85, 0xA7, 0xDA, 0x08, 0xCE, 0x24, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, + 0x3F, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8B, 0x0E, + 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x8E, 0x9B, 0x03, 0xDA, 0x06, 0xDA, 0x8E, + 0x26, 0xDA, 0x08, 0xCE, 0x80, 0x84, 0x28, 0x65, 0x76, 0x2F, 0x64, 0x6F, 0x2D, 0x74, 0x68, 0x72, + 0x65, 0x61, 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x75, 0x6E, + 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2E, 0x20, 0x53, 0x75, 0x73, 0x70, + 0x65, 0x6E, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, + 0x65, 0x74, 0x65, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x0A, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8E, 0x29, + 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0x8F, 0x01, 0xDA, 0x06, 0xDA, 0x8E, + 0x2A, 0xDA, 0x08, 0xCE, 0x80, 0xCC, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x2D, + 0x66, 0x6F, 0x72, 0x6B, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x6B, 0x65, 0x20, 0x61, 0x20, 0x60, 0x66, + 0x6F, 0x72, 0x6B, 0x60, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x63, 0x61, 0x6C, 0x6C, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, + 0x6E, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6E, 0x65, 0x77, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2C, 0x20, 0x6F, 0x74, 0x68, + 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2F, 0x70, 0x72, + 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x28, 0x61, 0x73, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x6F, 0x73, 0x2F, + 0x73, 0x70, 0x61, 0x77, 0x6E, 0x29, 0x2E, 0x20, 0x4E, 0x6F, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6D, 0x73, 0x20, 0x28, 0x50, 0x4F, 0x53, 0x49, 0x58, 0x20, 0x6F, 0x6E, 0x6C, 0x79, + 0x29, 0x2E, 0xDA, 0x8E, 0x2B, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0xBA, + 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x2C, 0xDA, 0x08, 0xCE, 0x81, 0x0A, 0x28, 0x63, 0x6F, 0x6E, 0x64, + 0x20, 0x26, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x29, 0x0A, 0x0A, 0x45, 0x76, 0x61, 0x6C, 0x75, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x75, 0x6E, 0x74, + 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x75, + 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x69, 0x73, 0x20, 0x66, + 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x72, 0x72, + 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x6E, 0x0A, + 0x6F, 0x64, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6F, + 0x72, 0x6D, 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6E, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x6D, + 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x2C, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6F, 0x6E, 0x0A, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2E, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x20, + 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x2C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, + 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x37, 0xCB, 0xDA, 0x8E, 0x2E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x04, 0x82, 0x74, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x2F, 0xDA, 0x08, 0xCE, 0x81, + 0xF5, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x70, + 0x72, 0x6F, 0x63, 0x29, 0x0A, 0x0A, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, + 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, + 0x63, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x73, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x70, + 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x63, 0x6F, + 0x64, 0x65, 0x2E, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, + 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, + 0x64, 0x20, 0x74, 0x77, 0x69, 0x63, 0x65, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x61, 0x6D, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x49, 0x66, 0x20, + 0x60, 0x65, 0x76, 0x2F, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x64, 0x65, 0x61, 0x64, 0x6C, 0x69, 0x6E, + 0x65, 0x60, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, 0x6C, 0x73, 0x20, 0x60, 0x6F, 0x73, 0x2F, 0x70, + 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x60, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, + 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6F, 0x72, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, + 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x63, 0x65, + 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x20, 0x63, 0x61, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6E, + 0x79, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x6C, 0x73, 0x65, 0x2C, 0x20, 0x6F, 0x73, 0x2F, + 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x73, 0x74, 0x69, 0x6C, 0x6C, 0x20, + 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x62, 0x61, 0x63, 0x6B, 0x67, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x4F, 0x6E, 0x6C, 0x79, + 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, 0x6F, 0x63, 0x2D, 0x77, + 0x61, 0x69, 0x74, 0x20, 0x66, 0x69, 0x6E, 0x69, 0x73, 0x68, 0x65, 0x73, 0x2C, 0x20, 0x61, 0x20, + 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6C, 0x65, 0x61, 0x6E, + 0x65, 0x64, 0x20, 0x75, 0x70, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6F, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x2E, 0x20, 0x54, + 0x68, 0x75, 0x73, 0x2C, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, + 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x73, 0x20, 0x61, 0x20, 0x7A, 0x6F, 0x6D, 0x62, 0x69, 0x65, 0x20, + 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x69, 0x66, 0x20, 0x6F, 0x73, 0x2F, 0x70, 0x72, + 0x6F, 0x63, 0x2D, 0x77, 0x61, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, + 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x2E, 0xDA, 0x8E, 0x30, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, + 0xDA, 0x18, 0x85, 0xA4, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x31, 0xDA, 0x08, 0xCE, 0x31, 0x28, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0x20, 0x66, 0x20, 0x26, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x29, + 0x0A, 0x0A, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, + 0x8E, 0x33, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x81, 0x57, 0x81, 0x26, 0x01, 0xDA, + 0x06, 0xDA, 0x8E, 0x34, 0xDA, 0x08, 0xCE, 0x2D, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x62, + 0x73, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x62, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, + 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xDA, 0x8E, 0x35, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, + 0x18, 0x83, 0x6F, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x36, 0xDA, 0x08, 0xCE, 0x72, 0x28, 0x73, 0x6F, + 0x72, 0x74, 0x2D, 0x62, 0x79, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x6F, + 0x72, 0x74, 0x73, 0x20, 0x60, 0x69, 0x6E, 0x64, 0x60, 0x20, 0x69, 0x6E, 0x2D, 0x70, 0x6C, 0x61, + 0x63, 0x65, 0x20, 0x62, 0x79, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, + 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x66, 0x60, 0x20, 0x6F, 0x6E, 0x20, + 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x6E, 0x64, + 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x3C, 0x60, 0x2E, 0xDA, + 0x8E, 0x38, 0xD3, 0x02, 0xDA, 0x06, 0xDA, 0x8E, 0x39, 0xDA, 0x08, 0xCE, 0x5B, 0x28, 0x62, 0x61, + 0x6E, 0x64, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x69, 0x74, 0x2D, 0x77, 0x69, 0x73, 0x65, 0x20, 0x61, + 0x6E, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, + 0x20, 0x69, 0x6E, 0x20, 0x78, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x78, 0x20, 0x69, + 0x6E, 0x20, 0x78, 0x73, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, + 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, 0xDA, 0x8E, 0x3B, 0xD3, 0x03, 0xDA, 0x03, 0xD2, + 0x03, 0x00, 0xDA, 0x18, 0x83, 0x7C, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x3C, 0xDA, 0x08, 0xCE, 0x80, + 0x92, 0x28, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x2D, 0x62, 0x79, 0x20, 0x66, 0x20, 0x69, 0x6E, + 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, + 0x77, 0x20, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x65, 0x73, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x62, 0x79, 0x20, 0x69, 0x6E, 0x76, 0x6F, 0x6B, 0x69, 0x6E, + 0x67, 0x0A, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x60, 0x66, 0x60, + 0x20, 0x6F, 0x6E, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, + 0x3C, 0x60, 0x2E, 0xDA, 0x8E, 0x3E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x80, 0x82, + 0x82, 0x07, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x3F, 0xDA, 0x08, 0xCE, 0x60, 0x28, 0x62, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x2F, 0x70, 0x6F, 0x70, 0x6E, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, + 0x6E, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x6D, 0x6F, 0x76, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6C, 0x61, 0x73, 0x74, 0x20, 0x60, 0x6E, 0x60, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x66, + 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, + 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x8E, 0x40, 0xD3, + 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x8E, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x41, + 0xDA, 0x08, 0xCE, 0x2C, 0x28, 0x2A, 0x3D, 0x20, 0x78, 0x20, 0x26, 0x20, 0x6E, 0x73, 0x29, 0x0A, + 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x28, + 0x73, 0x65, 0x74, 0x20, 0x78, 0x20, 0x28, 0x5C, 0x2A, 0x20, 0x78, 0x20, 0x6E, 0x29, 0x29, 0x2E, + 0xDA, 0x37, 0xCB, 0xDA, 0x8E, 0x43, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x83, + 0x8E, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x44, 0xDA, 0x08, 0xCE, 0x80, 0xA3, 0x28, 0x72, 0x65, 0x64, + 0x75, 0x63, 0x65, 0x32, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x54, 0x68, 0x65, + 0x20, 0x32, 0x2D, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x60, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x74, 0x61, + 0x6B, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x61, + 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0x0A, 0x49, 0x6E, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, + 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, + 0x72, 0x61, 0x79, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, + 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, + 0x8E, 0x46, 0xD3, 0x04, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x82, 0x74, 0x01, 0xDA, 0x06, + 0xDA, 0x8E, 0x47, 0xDA, 0x08, 0xCE, 0x80, 0xA7, 0x28, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, + 0x6F, 0x72, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x75, 0x73, + 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x6C, 0x6F, 0x6F, 0x70, 0x60, 0x20, 0x73, + 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, + 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x0A, 0x74, 0x68, 0x61, 0x74, 0x20, 0x79, 0x69, 0x65, 0x6C, + 0x64, 0x73, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, + 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x69, 0x6E, + 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, 0x20, 0x53, 0x65, 0x65, 0x20, 0x60, 0x6C, 0x6F, 0x6F, + 0x70, 0x60, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, + 0x37, 0xCB, 0xDA, 0x8E, 0x49, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x80, 0xB0, + 0x01, 0xDA, 0x06, 0xDA, 0x8D, 0x5F, 0xDA, 0x08, 0xCE, 0x80, 0xA1, 0x28, 0x6F, 0x73, 0x2F, 0x61, + 0x72, 0x63, 0x68, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x49, 0x53, 0x41, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x77, + 0x61, 0x73, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x2E, + 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x78, 0x38, 0x36, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x78, 0x36, 0x34, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x72, 0x6D, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x61, 0x61, 0x72, + 0x63, 0x68, 0x36, 0x34, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x72, 0x69, 0x73, 0x63, 0x76, 0x33, 0x32, + 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x72, 0x69, 0x73, 0x63, 0x76, 0x36, 0x34, 0x0A, 0x0A, 0x2A, 0x20, + 0x3A, 0x73, 0x70, 0x61, 0x72, 0x63, 0x0A, 0x0A, 0x2A, 0x20, 0x3A, 0x77, 0x61, 0x73, 0x6D, 0x0A, + 0x0A, 0x2A, 0x20, 0x3A, 0x75, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x0A, 0xDA, 0x86, 0x86, 0xD3, + 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x86, 0x4E, 0x01, 0xDA, 0x06, 0xDA, 0x86, 0x83, + 0xDA, 0x08, 0xCE, 0x3C, 0x28, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x78, 0x29, 0x0A, 0x0A, + 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x6F, + 0x66, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, + 0xDA, 0x8E, 0x4A, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0xAC, 0x01, + 0xDA, 0x06, 0xDA, 0x8E, 0x4B, 0xDA, 0x08, 0xCE, 0x80, 0xA4, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x2F, 0x66, 0x69, 0x6C, 0x6C, 0x20, 0x61, 0x72, 0x72, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, 0x76, + 0x61, 0x6C, 0x75, 0x65, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x61, + 0x6C, 0x6C, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x61, + 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x76, 0x61, + 0x6C, 0x75, 0x65, 0x60, 0x20, 0x28, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x69, 0x6E, 0x67, + 0x20, 0x74, 0x6F, 0x20, 0x6E, 0x69, 0x6C, 0x29, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, + 0x20, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, + 0x6E, 0x67, 0x74, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, + 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x8E, + 0x4C, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x83, 0xF9, 0x80, 0x94, 0x01, 0xDA, 0x06, + 0xDA, 0x8E, 0x4D, 0xDA, 0x08, 0xCE, 0x80, 0x87, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x77, + 0x65, 0x61, 0x6B, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x29, 0x0A, 0x0A, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x65, 0x6D, 0x70, + 0x74, 0x79, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, + 0x70, 0x72, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x63, 0x61, + 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F, + 0x72, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x65, 0x61, 0x6B, 0x20, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x2E, 0x20, 0x53, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, + 0x74, 0x6F, 0x20, 0x60, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0x60, 0x2E, 0xDA, + 0x8E, 0x4E, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x29, 0x81, 0x4A, 0x01, 0xDA, 0x06, + 0xDA, 0x81, 0x12, 0xDA, 0x08, 0xCE, 0x80, 0xB6, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, + 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, + 0x74, 0x65, 0x6E, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x60, 0x78, 0x73, 0x60, 0x20, 0x74, 0x6F, + 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x69, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x60, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x60, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2E, 0xDA, 0x8E, + 0x4F, 0xD3, 0x03, 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x04, 0x85, 0x88, 0x01, 0xDA, 0x06, 0xDA, + 0x8E, 0x50, 0xDA, 0x08, 0xCE, 0x81, 0x24, 0x28, 0x6F, 0x73, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, + 0x2D, 0x65, 0x78, 0x65, 0x63, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, 0x26, 0x6F, 0x70, 0x74, 0x20, + 0x66, 0x6C, 0x61, 0x67, 0x73, 0x20, 0x65, 0x6E, 0x76, 0x29, 0x0A, 0x0A, 0x55, 0x73, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x76, 0x70, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x76, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x63, 0x61, 0x6C, + 0x6C, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, + 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x20, 0x73, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x6F, + 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x2E, 0x20, 0x48, 0x6F, 0x65, 0x76, 0x65, + 0x72, 0x2C, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x70, 0x72, 0x6F, 0x63, + 0x65, 0x73, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, + 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6C, + 0x61, 0x63, 0x65, 0x64, 0x2E, 0x20, 0x49, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x73, 0x75, 0x70, + 0x70, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, + 0x73, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, + 0x61, 0x6C, 0x6C, 0x6F, 0x77, 0x20, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6F, + 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6F, 0x2E, 0xDA, 0x8E, 0x51, 0xD3, 0x04, + 0xDA, 0x03, 0xD2, 0x03, 0x00, 0xDA, 0x18, 0x80, 0x8A, 0x01, 0xDA, 0x06, 0xDA, 0x8E, 0x52, 0xDA, + 0x08, 0xCE, 0x22, 0x28, 0x2B, 0x2B, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x63, 0x72, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x20, 0x78, 0x20, + 0x62, 0x79, 0x20, 0x31, 0x2E, 0xDA, 0x37, 0xCB, + 0 +}; + +const unsigned char *janet_core_image = janet_core_image_bytes; +size_t janet_core_image_size = sizeof(janet_core_image_bytes); diff --git a/build/janet.h b/build/janet.h new file mode 100644 index 0000000..cbbef78 --- /dev/null +++ b/build/janet.h @@ -0,0 +1,2277 @@ +/* +* Copyright (c) 2023 Calvin Rose +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to +* deal in the Software without restriction, including without limitation the +* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +*/ + +/* This will be generated by the build system if this file is not used */ + +#ifndef JANETCONF_H +#define JANETCONF_H + +#define JANET_VERSION_MAJOR 1 +#define JANET_VERSION_MINOR 34 +#define JANET_VERSION_PATCH 0 +#define JANET_VERSION_EXTRA "" +#define JANET_VERSION "1.34.0" + +/* #define JANET_BUILD "local" */ + +/* These settings all affect linking, so use cautiously. */ +/* #define JANET_SINGLE_THREADED */ +/* #define JANET_NO_DYNAMIC_MODULES */ +/* #define JANET_NO_NANBOX */ +/* #define JANET_API __attribute__((visibility ("default"))) */ + +/* These settings should be specified before amalgamation is + * built. Any build with these set should be considered non-standard, and + * certain Janet libraries should be expected not to work. */ +/* #define JANET_NO_DOCSTRINGS */ +/* #define JANET_NO_SOURCEMAPS */ +/* #define JANET_REDUCED_OS */ +/* #define JANET_NO_PROCESSES */ +/* #define JANET_NO_ASSEMBLER */ +/* #define JANET_NO_PEG */ +/* #define JANET_NO_NET */ +/* #define JANET_NO_INT_TYPES */ +/* #define JANET_NO_EV */ +/* #define JANET_NO_REALPATH */ +/* #define JANET_NO_SYMLINKS */ +/* #define JANET_NO_UMASK */ +/* #define JANET_NO_THREADS */ +/* #define JANET_NO_FFI */ +/* #define JANET_NO_FFI_JIT */ + +/* Other settings */ +/* #define JANET_DEBUG */ +/* #define JANET_PRF */ +/* #define JANET_NO_UTC_MKTIME */ +/* #define JANET_OUT_OF_MEMORY do { printf("janet out of memory\n"); exit(1); } while (0) */ +/* #define JANET_EXIT(msg) do { printf("C assert failed executing janet: %s\n", msg); exit(1); } while (0) */ +/* #define JANET_TOP_LEVEL_SIGNAL(msg) call_my_function((msg), stderr) */ +/* #define JANET_RECURSION_GUARD 1024 */ +/* #define JANET_MAX_PROTO_DEPTH 200 */ +/* #define JANET_MAX_MACRO_EXPAND 200 */ +/* #define JANET_STACK_MAX 16384 */ +/* #define JANET_OS_NAME my-custom-os */ +/* #define JANET_ARCH_NAME pdp-8 */ +/* #define JANET_EV_NO_EPOLL */ +/* #define JANET_EV_NO_KQUEUE */ +/* #define JANET_NO_INTERPRETER_INTERRUPT */ +/* #define JANET_NO_IPV6 */ +/* #define JANET_NO_CRYPTORAND */ +/* #define JANET_USE_STDATOMIC */ + +/* Custom vm allocator support */ +/* #include */ +/* #define janet_malloc(X) mi_malloc((X)) */ +/* #define janet_realloc(X, Y) mi_realloc((X), (Y)) */ +/* #define janet_calloc(X, Y) mi_calloc((X), (Y)) */ +/* #define janet_free(X) mi_free((X)) */ + +/* Main client settings, does not affect library code */ +/* #define JANET_SIMPLE_GETLINE */ + +#endif /* end of include guard: JANETCONF_H */ + + +#ifndef JANET_H_defined +#define JANET_H_defined + +#ifdef __cplusplus +extern "C" { +#endif + +/* Variable length arrays are ok */ +#ifdef _MSC_VER +#pragma warning( push ) +#pragma warning( disable : 4200 ) +#endif + +/***** START SECTION CONFIG *****/ + +#ifndef JANET_VERSION +#define JANET_VERSION "latest" +#endif + +#ifndef JANET_BUILD +#define JANET_BUILD "local" +#endif + +/* + * Detect OS and endianess. + * From webkit source. There is likely some extreneous + * detection for unsupported platforms + */ + +/* Check for any flavor of BSD (except apple) */ +#if defined(__FreeBSD__) || defined(__DragonFly__) || \ + defined(__NetBSD__) || defined(__OpenBSD__) +#define JANET_BSD 1 +#endif + +/* Check for macOS or OS X */ +#if defined(__APPLE__) && defined(__MACH__) +#define JANET_APPLE 1 +#endif + +/* Check for Linux */ +#ifdef __linux__ +#define JANET_LINUX 1 +#endif + +/* Check for Cygwin */ +#if defined(__CYGWIN__) +#define JANET_CYGWIN 1 +#endif + +/* Check Unix */ +#if defined(_AIX) \ + || defined(__APPLE__) /* Darwin */ \ + || defined(__FreeBSD__) || defined(__DragonFly__) \ + || defined(__FreeBSD_kernel__) \ + || defined(__GNU__) /* GNU/Hurd */ \ + || defined(__HAIKU__) \ + || defined(__linux__) \ + || defined(__NetBSD__) \ + || defined(__OpenBSD__) \ + || defined(__QNXNTO__) \ + || defined(sun) || defined(__sun) /* Solaris */ \ + || defined(unix) || defined(__unix) || defined(__unix__) +#define JANET_POSIX 1 +#elif defined(__EMSCRIPTEN__) +#define JANET_WEB 1 +#elif defined(WIN32) || defined(_WIN32) +#define JANET_WINDOWS 1 +#endif + +/* Check if compiling with MSVC - else assume a GCC-like compiler by default */ +#ifdef _MSC_VER +#define JANET_MSVC +#endif + +/* Check Mingw 32-bit and 64-bit */ +#ifdef __MINGW32__ +#define JANET_MINGW +#endif + +/* Check 64-bit vs 32-bit */ +#if ((defined(__x86_64__) || defined(_M_X64)) \ + && (defined(JANET_POSIX) || defined(JANET_WINDOWS))) \ + || (defined(_WIN64)) /* Windows 64 bit */ \ + || (defined(__ia64__) && defined(__LP64__)) /* Itanium in LP64 mode */ \ + || defined(__alpha__) /* DEC Alpha */ \ + || (defined(__sparc__) && defined(__arch64__) || defined (__sparcv9)) /* BE */ \ + || defined(__s390x__) /* S390 64-bit (BE) */ \ + || (defined(__ppc64__) || defined(__PPC64__)) \ + || defined(__aarch64__) /* ARM 64-bit */ \ + || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */ +#define JANET_64 1 +#else +#define JANET_32 1 +#endif + +/* Check big endian */ +#if defined(__LITTLE_ENDIAN__) || \ + (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) +/* If we know the target is LE, always use that - e.g. ppc64 little endian + * defines the __LITTLE_ENDIAN__ macro in the ABI spec, so we can rely + * on that and if that's not defined, fall back to big endian assumption + */ +#define JANET_LITTLE_ENDIAN 1 +#elif defined(__MIPSEB__) /* MIPS 32-bit */ \ + || defined(__ppc__) || defined(__PPC__) /* CPU(PPC) - PowerPC 32-bit */ \ + || defined(__powerpc__) || defined(__powerpc) || defined(__POWERPC__) \ + || defined(_M_PPC) || defined(__PPC) \ + || defined(__ppc64__) || defined(__PPC64__) /* PowerPC 64-bit */ \ + || defined(__sparc) /* Sparc 32bit */ \ + || defined(__sparc__) /* Sparc 64-bit */ \ + || defined(__s390x__) /* S390 64-bit */ \ + || defined(__s390__) /* S390 32-bit */ \ + || defined(__ARMEB__) /* ARM big endian */ \ + || ((defined(__CC_ARM) || defined(__ARMCC__)) /* ARM RealView compiler */ \ + && defined(__BIG_ENDIAN)) +#define JANET_BIG_ENDIAN 1 +#else +#define JANET_LITTLE_ENDIAN 1 +#endif + +/* Limits for converting doubles to 64 bit integers */ +#define JANET_INTMAX_DOUBLE 9007199254740992.0 +#define JANET_INTMIN_DOUBLE (-9007199254740992.0) +#define JANET_INTMAX_INT64 9007199254740992 +#define JANET_INTMIN_INT64 (-9007199254740992) + +/* Check emscripten */ +#ifdef __EMSCRIPTEN__ +#define JANET_NO_DYNAMIC_MODULES +#define JANET_NO_PROCESSES +#endif + +/* Check sun */ +#ifdef __sun +#define JANET_NO_UTC_MKTIME +#endif + +/* Define how global janet state is declared */ +/* Also enable the thread library only if not single-threaded */ +#ifdef JANET_SINGLE_THREADED +#define JANET_THREAD_LOCAL +#undef JANET_THREADS +#elif defined(__GNUC__) +#define JANET_THREAD_LOCAL __thread +#elif defined(_MSC_BUILD) +#define JANET_THREAD_LOCAL __declspec(thread) +#else +#define JANET_THREAD_LOCAL +#undef JANET_THREADS +#endif + +/* Enable or disable dynamic module loading. Enabled by default. */ +#ifndef JANET_NO_DYNAMIC_MODULES +#define JANET_DYNAMIC_MODULES +#endif + +/* Enable or disable the FFI library. Currently, FFI only enabled on + * x86-64 operating systems. */ +#ifndef JANET_NO_FFI +#if !defined(__EMSCRIPTEN__) +#define JANET_FFI +#endif +#endif + +/* If FFI is enabled and FFI-JIT is not disabled... */ +#ifdef JANET_FFI +#ifndef JANET_NO_FFI_JIT +#define JANET_FFI_JIT +#endif +#endif + +/* Enable or disable the assembler. Enabled by default. */ +#ifndef JANET_NO_ASSEMBLER +#define JANET_ASSEMBLER +#endif + +/* Enable or disable the peg module */ +#ifndef JANET_NO_PEG +#define JANET_PEG +#endif + +/* Enable or disable event loop */ +#if !defined(JANET_NO_EV) && !defined(__EMSCRIPTEN__) +#define JANET_EV +#endif + +/* Enable or disable networking */ +#if defined(JANET_EV) && !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__) +#define JANET_NET +#endif + +/* Enable or disable large int types (for now 64 bit, maybe 128 / 256 bit integer types) */ +#ifndef JANET_NO_INT_TYPES +#define JANET_INT_TYPES +#endif + +/* Enable or disable epoll on Linux */ +#if defined(JANET_LINUX) && !defined(JANET_EV_NO_EPOLL) +#define JANET_EV_EPOLL +#endif + +/* Enable or disable kqueue on BSD */ +#if defined(JANET_BSD) && !defined(JANET_EV_NO_KQUEUE) +#define JANET_EV_KQUEUE +#endif + +/* Enable or disable kqueue on Apple */ +#if defined(JANET_APPLE) && !defined(JANET_EV_NO_KQUEUE) +#define JANET_EV_KQUEUE +#endif + +/* Use poll as last resort */ +#if !defined(JANET_WINDOWS) && !defined(JANET_EV_EPOLL) && !defined(JANET_EV_KQUEUE) +#define JANET_EV_POLL +#endif + +/* How to export symbols */ +#ifndef JANET_EXPORT +#ifdef JANET_WINDOWS +#define JANET_EXPORT __declspec(dllexport) +#else +#define JANET_EXPORT __attribute__((visibility ("default"))) +#endif +#endif + +/* How declare API functions */ +#ifndef JANET_API +#ifdef JANET_WINDOWS +#ifdef JANET_DLL_IMPORT +#define JANET_API __declspec(dllimport) +#else +#define JANET_API __declspec(dllexport) +#endif +#else +#define JANET_API __attribute__((visibility ("default"))) +#endif +#endif + +/* Tell complier some functions don't return */ +#ifndef JANET_NO_RETURN +#ifdef JANET_WINDOWS +#define JANET_NO_RETURN __declspec(noreturn) +#else +#define JANET_NO_RETURN __attribute__((noreturn)) +#endif +#endif + +/* Prevent some recursive functions from recursing too deeply + * ands crashing (the parser). Instead, error out. */ +#define JANET_RECURSION_GUARD 1024 + +/* Maximum depth to follow table prototypes before giving up and returning nil. */ +#define JANET_MAX_PROTO_DEPTH 200 + +/* Prevent macros to expand too deeply and error out. */ +#define JANET_MAX_MACRO_EXPAND 200 + +/* Define default max stack size for stacks before raising a stack overflow error. + * This can also be set on a per fiber basis. */ +#ifndef JANET_STACK_MAX +#define JANET_STACK_MAX 0x7fffffff +#endif + +/* Use nanboxed values - uses 8 bytes per value instead of 12 or 16. + * To turn of nanboxing, for debugging purposes or for certain + * architectures (Nanboxing only tested on x86 and x64), comment out + * the JANET_NANBOX define.*/ + +#if defined(_M_ARM64) || defined(_M_ARM) || defined(__aarch64__) +#define JANET_NO_NANBOX +#endif + +#ifndef JANET_NO_NANBOX +#ifdef JANET_32 +#define JANET_NANBOX_32 +#elif defined(__x86_64__) || defined(_WIN64) || defined(__riscv) +/* We will only enable nanboxing by default on 64 bit systems + * for x64 and risc-v. This is mainly because the approach is tied to the + * implicit 47 bit address space. Many arches allow/require this, but not all, + * and it requires cooperation from the OS. ARM should also work in many configurations. */ +#define JANET_NANBOX_64 +#endif +#endif + +/* Runtime config constants */ +#ifdef JANET_NO_NANBOX +#define JANET_NANBOX_BIT 0 +#else +#define JANET_NANBOX_BIT 0x1 +#endif + +#ifdef JANET_SINGLE_THREADED +#define JANET_SINGLE_THREADED_BIT 0x2 +#else +#define JANET_SINGLE_THREADED_BIT 0 +#endif + +#define JANET_CURRENT_CONFIG_BITS \ + (JANET_SINGLE_THREADED_BIT | \ + JANET_NANBOX_BIT) + +/* Represents the settings used to compile Janet, as well as the version */ +typedef struct { + unsigned major; + unsigned minor; + unsigned patch; + unsigned bits; +} JanetBuildConfig; + +/* Get config of current compilation unit. */ +#ifdef __cplusplus +/* C++11 syntax */ +#define janet_config_current() (JanetBuildConfig { \ + JANET_VERSION_MAJOR, \ + JANET_VERSION_MINOR, \ + JANET_VERSION_PATCH, \ + JANET_CURRENT_CONFIG_BITS }) +#else +/* C99 syntax */ +#define janet_config_current() ((JanetBuildConfig){ \ + JANET_VERSION_MAJOR, \ + JANET_VERSION_MINOR, \ + JANET_VERSION_PATCH, \ + JANET_CURRENT_CONFIG_BITS }) +#endif + +/* Some extra includes if EV is enabled */ +#ifdef JANET_EV +typedef struct JanetOSMutex JanetOSMutex; +typedef struct JanetOSRWLock JanetOSRWLock; +#endif + +/***** END SECTION CONFIG *****/ + +/***** START SECTION TYPES *****/ + +#ifdef JANET_WINDOWS +/* Must be defined before including stdlib.h */ +#define _CRT_RAND_S +#endif + +#include +#include +#include +#include +#include +#include +#include + +/* What to do when out of memory */ +#ifndef JANET_OUT_OF_MEMORY +#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) +#endif + +#ifdef JANET_BSD +int _setjmp(jmp_buf); +JANET_NO_RETURN void _longjmp(jmp_buf, int); +#endif + +/* Names of all of the types */ +JANET_API extern const char *const janet_type_names[16]; +JANET_API extern const char *const janet_signal_names[14]; +JANET_API extern const char *const janet_status_names[16]; + +/* For various IO routines, we want to use an int on posix and HANDLE on windows */ +#ifdef JANET_WINDOWS +typedef void *JanetHandle; +#define JANET_HANDLE_NONE NULL +#else +typedef int JanetHandle; +#define JANET_HANDLE_NONE (-1) +#endif + +/* Fiber signals */ +typedef enum { + JANET_SIGNAL_OK, + JANET_SIGNAL_ERROR, + JANET_SIGNAL_DEBUG, + JANET_SIGNAL_YIELD, + JANET_SIGNAL_USER0, + JANET_SIGNAL_USER1, + JANET_SIGNAL_USER2, + JANET_SIGNAL_USER3, + JANET_SIGNAL_USER4, + JANET_SIGNAL_USER5, + JANET_SIGNAL_USER6, + JANET_SIGNAL_USER7, + JANET_SIGNAL_USER8, + JANET_SIGNAL_USER9, + JANET_SIGNAL_INTERRUPT = JANET_SIGNAL_USER8, + JANET_SIGNAL_EVENT = JANET_SIGNAL_USER9, +} JanetSignal; + +/* Fiber statuses - mostly corresponds to signals. */ +typedef enum { + JANET_STATUS_DEAD, + JANET_STATUS_ERROR, + JANET_STATUS_DEBUG, + JANET_STATUS_PENDING, + JANET_STATUS_USER0, + JANET_STATUS_USER1, + JANET_STATUS_USER2, + JANET_STATUS_USER3, + JANET_STATUS_USER4, + JANET_STATUS_USER5, + JANET_STATUS_USER6, + JANET_STATUS_USER7, + JANET_STATUS_USER8, + JANET_STATUS_USER9, + JANET_STATUS_NEW, + JANET_STATUS_ALIVE +} JanetFiberStatus; + +/* For encapsulating all thread-local Janet state (except natives) */ +typedef struct JanetVM JanetVM; + +/* Use type punning for GC objects */ +typedef struct JanetGCObject JanetGCObject; + +/* All of the primary Janet GCed types */ +typedef struct JanetFunction JanetFunction; +typedef struct JanetArray JanetArray; +typedef struct JanetBuffer JanetBuffer; +typedef struct JanetTable JanetTable; +typedef struct JanetFiber JanetFiber; + +/* Prefixed Janet types */ +typedef struct JanetTupleHead JanetTupleHead; +typedef struct JanetStructHead JanetStructHead; +typedef struct JanetStringHead JanetStringHead; +typedef struct JanetAbstractHead JanetAbstractHead; + +/* Other structs */ +typedef struct JanetFuncDef JanetFuncDef; +typedef struct JanetFuncEnv JanetFuncEnv; +typedef struct JanetKV JanetKV; +typedef struct JanetStackFrame JanetStackFrame; +typedef struct JanetAbstractType JanetAbstractType; +typedef struct JanetReg JanetReg; +typedef struct JanetRegExt JanetRegExt; +typedef struct JanetMethod JanetMethod; +typedef struct JanetSourceMapping JanetSourceMapping; +typedef struct JanetSymbolMap JanetSymbolMap; +typedef struct JanetView JanetView; +typedef struct JanetByteView JanetByteView; +typedef struct JanetDictView JanetDictView; +typedef struct JanetRange JanetRange; +typedef struct JanetRNG JanetRNG; + +/* Basic types for all Janet Values */ +typedef enum JanetType { + JANET_NUMBER, + JANET_NIL, + JANET_BOOLEAN, + JANET_FIBER, + JANET_STRING, + JANET_SYMBOL, + JANET_KEYWORD, + JANET_ARRAY, + JANET_TUPLE, + JANET_TABLE, + JANET_STRUCT, + JANET_BUFFER, + JANET_FUNCTION, + JANET_CFUNCTION, + JANET_ABSTRACT, + JANET_POINTER +} JanetType; + +/* Recursive type (Janet) */ +#ifdef JANET_NANBOX_64 +typedef union Janet Janet; +union Janet { + uint64_t u64; + int64_t i64; + double number; + void *pointer; +}; +#elif defined(JANET_NANBOX_32) +typedef union Janet Janet; +union Janet { + struct { +#ifdef JANET_BIG_ENDIAN + uint32_t type; + union { + int32_t integer; + void *pointer; + } payload; +#else + union { + int32_t integer; + void *pointer; + } payload; + uint32_t type; +#endif + } tagged; + double number; + uint64_t u64; +}; +#else +typedef struct Janet Janet; +struct Janet { + union { + uint64_t u64; + double number; + int32_t integer; + void *pointer; + const void *cpointer; + } as; + JanetType type; +}; +#endif + +/* C functions */ +typedef Janet(*JanetCFunction)(int32_t argc, Janet *argv); + +/* String and other aliased pointer types */ +typedef const uint8_t *JanetString; +typedef const uint8_t *JanetSymbol; +typedef const uint8_t *JanetKeyword; +typedef const Janet *JanetTuple; +typedef const JanetKV *JanetStruct; +typedef void *JanetAbstract; + +#define JANET_COUNT_TYPES (JANET_POINTER + 1) + +/* Type flags */ +#define JANET_TFLAG_NIL (1 << JANET_NIL) +#define JANET_TFLAG_BOOLEAN (1 << JANET_BOOLEAN) +#define JANET_TFLAG_FIBER (1 << JANET_FIBER) +#define JANET_TFLAG_NUMBER (1 << JANET_NUMBER) +#define JANET_TFLAG_STRING (1 << JANET_STRING) +#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) +#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) +#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) +#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) +#define JANET_TFLAG_TABLE (1 << JANET_TABLE) +#define JANET_TFLAG_STRUCT (1 << JANET_STRUCT) +#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) +#define JANET_TFLAG_FUNCTION (1 << JANET_FUNCTION) +#define JANET_TFLAG_CFUNCTION (1 << JANET_CFUNCTION) +#define JANET_TFLAG_ABSTRACT (1 << JANET_ABSTRACT) +#define JANET_TFLAG_POINTER (1 << JANET_POINTER) + +#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) +#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) +#define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) +#define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) +#define JANET_TFLAG_CALLABLE (JANET_TFLAG_FUNCTION | JANET_TFLAG_CFUNCTION | \ + JANET_TFLAG_LENGTHABLE | JANET_TFLAG_ABSTRACT) + +/* Event Loop Types */ +#ifdef JANET_EV + +#define JANET_STREAM_CLOSED 0x1 +#define JANET_STREAM_SOCKET 0x2 +#define JANET_STREAM_UNREGISTERED 0x4 +#define JANET_STREAM_READABLE 0x200 +#define JANET_STREAM_WRITABLE 0x400 +#define JANET_STREAM_ACCEPTABLE 0x800 +#define JANET_STREAM_UDPSERVER 0x1000 +#define JANET_STREAM_TOCLOSE 0x10000 + +typedef enum { + JANET_ASYNC_EVENT_INIT = 0, + JANET_ASYNC_EVENT_MARK = 1, + JANET_ASYNC_EVENT_DEINIT = 2, + JANET_ASYNC_EVENT_CLOSE = 3, + JANET_ASYNC_EVENT_ERR = 4, + JANET_ASYNC_EVENT_HUP = 5, + JANET_ASYNC_EVENT_READ = 6, + JANET_ASYNC_EVENT_WRITE = 7, + JANET_ASYNC_EVENT_COMPLETE = 8, /* Used on windows for IOCP */ + JANET_ASYNC_EVENT_FAILED = 9 /* Used on windows for IOCP */ +} JanetAsyncEvent; + +typedef enum { + JANET_ASYNC_LISTEN_READ = 1, + JANET_ASYNC_LISTEN_WRITE, + JANET_ASYNC_LISTEN_BOTH +} JanetAsyncMode; + +typedef struct JanetStream JanetStream; + +/* Wrapper around file descriptors and HANDLEs that can be polled. */ +struct JanetStream { + JanetHandle handle; + uint32_t flags; + uint32_t index; + JanetFiber *read_fiber; + JanetFiber *write_fiber; + const void *methods; /* Methods for this stream */ +}; + +typedef void (*JanetEVCallback)(JanetFiber *fiber, JanetAsyncEvent event); + +/* Start listening for events from a stream on the current root fiber. After + * calling this, users should call janet_await() before returning from the + * current C Function. This also will call janet_await. + * mode is which events to listen for, and callback is the function pointer to + * call when ever an event is sent from the event loop. state is an optional (can be NULL) + * pointer to data allocated with janet_malloc. This pointer will be passed to callback as + * fiber->ev_state. It will also be freed for you by the runtime when the event loop determines + * it can no longer be referenced. On windows, the contents of state MUST contained an OVERLAPPED struct. */ +JANET_API JANET_NO_RETURN void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state); + +/* Do not send any more events to the given callback. Call this after scheduling fiber to be resume + * or canceled. */ +JANET_API void janet_async_end(JanetFiber *fiber); + +/* Needed for windows to mark a fiber as waiting for an IOCP completion event. Noop on other platforms. */ +JANET_API void janet_async_in_flight(JanetFiber *fiber); + +#endif + +/* Janet uses atomic integers in several places for synchronization between threads and + * signals. Define them here */ +#ifdef JANET_WINDOWS +typedef long JanetAtomicInt; +#else +typedef int32_t JanetAtomicInt; +#endif +JANET_API JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x); +JANET_API JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x); +JANET_API JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x); + +/* We provide three possible implementations of Janets. The preferred + * nanboxing approach, for 32 or 64 bits, and the standard C version. Code in the rest of the + * application must interact through exposed interface. */ + +/* Required interface for Janet */ +/* wrap and unwrap for all types */ +/* Get type quickly */ +/* Check against type quickly */ +/* Small footprint */ +/* 32 bit integer support */ + +/* janet_type(x) + * janet_checktype(x, t) + * janet_wrap_##TYPE(x) + * janet_unwrap_##TYPE(x) + * janet_truthy(x) + * janet_memclear(p, n) - clear memory for hash tables to nils + * janet_u64(x) - get 64 bits of payload for hashing + */ + +/***** START SECTION NON-C API *****/ + +/* Some janet types use offset tricks to make operations easier in C. For + * external bindings, we should prefer using the Head structs directly, and + * use the host language to add sugar around the manipulation of the Janet types. */ + +JANET_API JanetStructHead *janet_struct_head(JanetStruct st); +JANET_API JanetAbstractHead *janet_abstract_head(const void *abstract); +JANET_API JanetStringHead *janet_string_head(JanetString s); +JANET_API JanetTupleHead *janet_tuple_head(JanetTuple tuple); + +/* Some language bindings won't have access to the macro versions. */ + +JANET_API JanetType janet_type(Janet x); +JANET_API int janet_checktype(Janet x, JanetType type); +JANET_API int janet_checktypes(Janet x, int typeflags); +JANET_API int janet_truthy(Janet x); + +JANET_API JanetStruct janet_unwrap_struct(Janet x); +JANET_API JanetTuple janet_unwrap_tuple(Janet x); +JANET_API JanetFiber *janet_unwrap_fiber(Janet x); +JANET_API JanetArray *janet_unwrap_array(Janet x); +JANET_API JanetTable *janet_unwrap_table(Janet x); +JANET_API JanetBuffer *janet_unwrap_buffer(Janet x); +JANET_API JanetString janet_unwrap_string(Janet x); +JANET_API JanetSymbol janet_unwrap_symbol(Janet x); +JANET_API JanetKeyword janet_unwrap_keyword(Janet x); +JANET_API JanetAbstract janet_unwrap_abstract(Janet x); +JANET_API void *janet_unwrap_pointer(Janet x); +JANET_API JanetFunction *janet_unwrap_function(Janet x); +JANET_API JanetCFunction janet_unwrap_cfunction(Janet x); +JANET_API int janet_unwrap_boolean(Janet x); +JANET_API double janet_unwrap_number(Janet x); +JANET_API int32_t janet_unwrap_integer(Janet x); + +JANET_API Janet janet_wrap_nil(void); +JANET_API Janet janet_wrap_number(double x); +JANET_API Janet janet_wrap_true(void); +JANET_API Janet janet_wrap_false(void); +JANET_API Janet janet_wrap_boolean(int x); +JANET_API Janet janet_wrap_string(JanetString x); +JANET_API Janet janet_wrap_symbol(JanetSymbol x); +JANET_API Janet janet_wrap_keyword(JanetKeyword x); +JANET_API Janet janet_wrap_array(JanetArray *x); +JANET_API Janet janet_wrap_tuple(JanetTuple x); +JANET_API Janet janet_wrap_struct(JanetStruct x); +JANET_API Janet janet_wrap_fiber(JanetFiber *x); +JANET_API Janet janet_wrap_buffer(JanetBuffer *x); +JANET_API Janet janet_wrap_function(JanetFunction *x); +JANET_API Janet janet_wrap_cfunction(JanetCFunction x); +JANET_API Janet janet_wrap_table(JanetTable *x); +JANET_API Janet janet_wrap_abstract(JanetAbstract x); +JANET_API Janet janet_wrap_pointer(void *x); +JANET_API Janet janet_wrap_integer(int32_t x); + +/***** END SECTION NON-C API *****/ + +#ifdef JANET_NANBOX_64 + +#include + +#define janet_u64(x) ((x).u64) + +#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu +#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu +#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) +#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) +#define janet_type(x) \ + (isnan((x).number) \ + ? (JanetType) (((x).u64 >> 47) & 0xF) \ + : JANET_NUMBER) + +#define janet_nanbox_checkauxtype(x, type) \ + (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) + +#define janet_nanbox_isnumber(x) \ + (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) + +#define janet_checktype(x, t) \ + (((t) == JANET_NUMBER) \ + ? janet_nanbox_isnumber(x) \ + : janet_nanbox_checkauxtype((x), (t))) + +/* Use JANET_API so that modules will use a local version of these functions if possible */ +JANET_API void *janet_nanbox_to_pointer(Janet x); +JANET_API Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask); +JANET_API Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask); +JANET_API Janet janet_nanbox_from_double(double d); +JANET_API Janet janet_nanbox_from_bits(uint64_t bits); + +#define janet_truthy(x) \ + (!janet_checktype((x), JANET_NIL) && \ + (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) + +#define janet_nanbox_from_payload(t, p) \ + janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) + +#define janet_nanbox_wrap_(p, t) \ + janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) + +#define janet_nanbox_wrap_c(p, t) \ + janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) + +/* Wrap the simple types */ +#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) +#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) +#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) +#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) +#define janet_wrap_number(r) janet_nanbox_from_double(r) + +/* Unwrap the simple types */ +#define janet_unwrap_boolean(x) ((x).u64 & 0x1) +#define janet_unwrap_number(x) ((x).number) + +/* Wrap the pointer types */ +#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) +#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) +#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) +#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) +#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) +#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) +#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) +#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) +#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) +#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) +#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) +#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) +#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) + +/* Unwrap the pointer types */ +#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) +#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) +#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) +#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) +#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) +#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) +#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) +#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) + +#elif defined(JANET_NANBOX_32) + +#define JANET_DOUBLE_OFFSET 0xFFFF + +#define janet_u64(x) ((x).u64) +#define janet_type(x) (((x).tagged.type < JANET_DOUBLE_OFFSET) ? (JanetType)((x).tagged.type) : JANET_NUMBER) +#define janet_checktype(x, t) ((t) == JANET_NUMBER \ + ? (x).tagged.type >= JANET_DOUBLE_OFFSET \ + : (x).tagged.type == (t)) +#define janet_truthy(x) \ + ((x).tagged.type != JANET_NIL && ((x).tagged.type != JANET_BOOLEAN || ((x).tagged.payload.integer & 0x1))) + +JANET_API Janet janet_nanbox32_from_tagi(uint32_t tag, int32_t integer); +JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer); + +#define janet_wrap_nil() janet_nanbox32_from_tagi(JANET_NIL, 0) +#define janet_wrap_true() janet_nanbox32_from_tagi(JANET_BOOLEAN, 1) +#define janet_wrap_false() janet_nanbox32_from_tagi(JANET_BOOLEAN, 0) +#define janet_wrap_boolean(b) janet_nanbox32_from_tagi(JANET_BOOLEAN, !!(b)) + +/* Wrap the pointer types */ +#define janet_wrap_struct(s) janet_nanbox32_from_tagp(JANET_STRUCT, (void *)(s)) +#define janet_wrap_tuple(s) janet_nanbox32_from_tagp(JANET_TUPLE, (void *)(s)) +#define janet_wrap_fiber(s) janet_nanbox32_from_tagp(JANET_FIBER, (void *)(s)) +#define janet_wrap_array(s) janet_nanbox32_from_tagp(JANET_ARRAY, (void *)(s)) +#define janet_wrap_table(s) janet_nanbox32_from_tagp(JANET_TABLE, (void *)(s)) +#define janet_wrap_buffer(s) janet_nanbox32_from_tagp(JANET_BUFFER, (void *)(s)) +#define janet_wrap_string(s) janet_nanbox32_from_tagp(JANET_STRING, (void *)(s)) +#define janet_wrap_symbol(s) janet_nanbox32_from_tagp(JANET_SYMBOL, (void *)(s)) +#define janet_wrap_keyword(s) janet_nanbox32_from_tagp(JANET_KEYWORD, (void *)(s)) +#define janet_wrap_abstract(s) janet_nanbox32_from_tagp(JANET_ABSTRACT, (void *)(s)) +#define janet_wrap_function(s) janet_nanbox32_from_tagp(JANET_FUNCTION, (void *)(s)) +#define janet_wrap_cfunction(s) janet_nanbox32_from_tagp(JANET_CFUNCTION, (void *)(s)) +#define janet_wrap_pointer(s) janet_nanbox32_from_tagp(JANET_POINTER, (void *)(s)) + +#define janet_unwrap_struct(x) ((JanetStruct)(x).tagged.payload.pointer) +#define janet_unwrap_tuple(x) ((JanetTuple)(x).tagged.payload.pointer) +#define janet_unwrap_fiber(x) ((JanetFiber *)(x).tagged.payload.pointer) +#define janet_unwrap_array(x) ((JanetArray *)(x).tagged.payload.pointer) +#define janet_unwrap_table(x) ((JanetTable *)(x).tagged.payload.pointer) +#define janet_unwrap_buffer(x) ((JanetBuffer *)(x).tagged.payload.pointer) +#define janet_unwrap_string(x) ((JanetString)(x).tagged.payload.pointer) +#define janet_unwrap_symbol(x) ((JanetSymbol)(x).tagged.payload.pointer) +#define janet_unwrap_keyword(x) ((JanetKeyword)(x).tagged.payload.pointer) +#define janet_unwrap_abstract(x) ((x).tagged.payload.pointer) +#define janet_unwrap_pointer(x) ((x).tagged.payload.pointer) +#define janet_unwrap_function(x) ((JanetFunction *)(x).tagged.payload.pointer) +#define janet_unwrap_cfunction(x) ((JanetCFunction)(x).tagged.payload.pointer) +#define janet_unwrap_boolean(x) ((x).tagged.payload.integer) + +#else + +#define janet_u64(x) ((x).as.u64) +#define janet_type(x) ((x).type) +#define janet_checktype(x, t) ((x).type == (t)) +#define janet_truthy(x) \ + ((x).type != JANET_NIL && ((x).type != JANET_BOOLEAN || ((x).as.u64 & 0x1))) + +#define janet_unwrap_struct(x) ((JanetStruct)(x).as.pointer) +#define janet_unwrap_tuple(x) ((JanetTuple)(x).as.pointer) +#define janet_unwrap_fiber(x) ((JanetFiber *)(x).as.pointer) +#define janet_unwrap_array(x) ((JanetArray *)(x).as.pointer) +#define janet_unwrap_table(x) ((JanetTable *)(x).as.pointer) +#define janet_unwrap_buffer(x) ((JanetBuffer *)(x).as.pointer) +#define janet_unwrap_string(x) ((JanetString)(x).as.pointer) +#define janet_unwrap_symbol(x) ((JanetSymbol)(x).as.pointer) +#define janet_unwrap_keyword(x) ((JanetKeyword)(x).as.pointer) +#define janet_unwrap_abstract(x) ((x).as.pointer) +#define janet_unwrap_pointer(x) ((x).as.pointer) +#define janet_unwrap_function(x) ((JanetFunction *)(x).as.pointer) +#define janet_unwrap_cfunction(x) ((JanetCFunction)(x).as.pointer) +#define janet_unwrap_boolean(x) ((x).as.u64 & 0x1) +#define janet_unwrap_number(x) ((x).as.number) + +/* End of tagged union implementation */ +#endif + +JANET_API int janet_checkint(Janet x); +JANET_API int janet_checkuint(Janet x); +JANET_API int janet_checkint64(Janet x); +JANET_API int janet_checkuint64(Janet x); +JANET_API int janet_checksize(Janet x); +JANET_API JanetAbstract janet_checkabstract(Janet x, const JanetAbstractType *at); +#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) +#define janet_checkuintrange(x) ((x) >= 0 && (x) <= UINT32_MAX && (x) == (uint32_t)(x)) +#define janet_checkint64range(x) ((x) >= JANET_INTMIN_DOUBLE && (x) <= JANET_INTMAX_DOUBLE && (x) == (int64_t)(x)) +#define janet_checkuint64range(x) ((x) >= 0 && (x) <= JANET_INTMAX_DOUBLE && (x) == (uint64_t)(x)) +#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) +#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) + +#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) + +/* GC Object type pun. The lower 16 bits of flags are reserved for the garbage collector, + * but the upper 16 can be used per type for custom flags. The current collector is a linked + * list of blocks, which is naive but works. */ +struct JanetGCObject { + int32_t flags; + union { + JanetGCObject *next; + volatile JanetAtomicInt refcount; /* For threaded abstract types */ + } data; +}; + +/* A lightweight green thread in janet. Does not correspond to + * operating system threads. */ +struct JanetFiber { + JanetGCObject gc; /* GC Object stuff */ + int32_t flags; /* More flags */ + int32_t frame; /* Index of the stack frame */ + int32_t stackstart; /* Beginning of next args */ + int32_t stacktop; /* Top of stack. Where values are pushed and popped from. */ + int32_t capacity; /* How big is the stack memory */ + int32_t maxstack; /* Arbitrary defined limit for stack overflow */ + JanetTable *env; /* Dynamic bindings table (usually current environment). */ + Janet *data; /* Dynamically resized stack memory */ + JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */ + Janet last_value; /* Last returned value from a fiber */ +#ifdef JANET_EV + /* These fields are only relevant for fibers that are used as "root fibers" - + * that is, fibers that are scheduled on the event loop and behave much like threads + * in a multi-tasking system. It would be possible to move these fields to a new + * type, say "JanetTask", that as separate from fibers to save a bit of space. */ + uint32_t sched_id; /* Increment everytime fiber is scheduled by event loop */ + JanetEVCallback ev_callback; /* Call this before starting scheduled fibers */ + JanetStream *ev_stream; /* which stream we are waiting on */ + void *ev_state; /* Extra data for ev callback state. On windows, first element must be OVERLAPPED. */ + void *supervisor_channel; /* Channel to push self to when complete */ +#endif +}; + +/* Mark if a stack frame is a tail call for debugging */ +#define JANET_STACKFRAME_TAILCALL 1 + +/* Mark if a stack frame is an entrance frame */ +#define JANET_STACKFRAME_ENTRANCE 2 + +/* A stack frame on the fiber. Is stored along with the stack values. */ +struct JanetStackFrame { + JanetFunction *func; + uint32_t *pc; + JanetFuncEnv *env; + int32_t prevframe; + int32_t flags; +}; + +/* Number of Janets a frame takes up in the stack + * Should be constant across architectures */ +#define JANET_FRAME_SIZE 4 + +/* A dynamic array type. */ +struct JanetArray { + JanetGCObject gc; + int32_t count; + int32_t capacity; + Janet *data; +}; + +/* A byte buffer type. Used as a mutable string or string builder. */ +struct JanetBuffer { + JanetGCObject gc; + int32_t count; + int32_t capacity; + uint8_t *data; +}; + +/* A mutable associative data type. Backed by a hashtable. */ +struct JanetTable { + JanetGCObject gc; + int32_t count; + int32_t capacity; + int32_t deleted; + JanetKV *data; + JanetTable *proto; +}; + +/* A key value pair in a struct or table */ +struct JanetKV { + Janet key; + Janet value; +}; + +/* Prefix for a tuple */ +struct JanetTupleHead { + JanetGCObject gc; + int32_t length; + int32_t hash; + int32_t sm_line; + int32_t sm_column; + const Janet data[]; +}; + +/* Prefix for a struct */ +struct JanetStructHead { + JanetGCObject gc; + int32_t length; + int32_t hash; + int32_t capacity; + const JanetKV *proto; + const JanetKV data[]; +}; + +/* Prefix for a string */ +struct JanetStringHead { + JanetGCObject gc; + int32_t length; + int32_t hash; + const uint8_t data[]; +}; + +/* Prefix for an abstract value */ +struct JanetAbstractHead { + JanetGCObject gc; + const JanetAbstractType *type; + size_t size; + long long data[]; /* Use long long to ensure most general alignment */ +}; + +/* Some function definition flags */ +#define JANET_FUNCDEF_FLAG_VARARG 0x10000 +#define JANET_FUNCDEF_FLAG_NEEDSENV 0x20000 +#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 +#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 +#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 +#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 +#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 +#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 +#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 +#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 +#define JANET_FUNCDEF_FLAG_TAG 0xFFFF + +/* Source mapping structure for a bytecode instruction */ +struct JanetSourceMapping { + int32_t line; + int32_t column; +}; + +/* Symbol to slot mapping & lifetime structure. */ +struct JanetSymbolMap { + uint32_t birth_pc; + uint32_t death_pc; + uint32_t slot_index; + const uint8_t *symbol; +}; + +/* A function definition. Contains information needed to instantiate closures. */ +struct JanetFuncDef { + JanetGCObject gc; + int32_t *environments; /* Which environments to capture from parent. */ + Janet *constants; + JanetFuncDef **defs; + uint32_t *bytecode; + uint32_t *closure_bitset; /* Bit set indicating which slots can be referenced by closures. */ + + /* Various debug information */ + JanetSourceMapping *sourcemap; + JanetString source; + JanetString name; + JanetSymbolMap *symbolmap; + + int32_t flags; + int32_t slotcount; /* The amount of stack space required for the function */ + int32_t arity; /* Not including varargs */ + int32_t min_arity; /* Including varargs */ + int32_t max_arity; /* Including varargs */ + int32_t constants_length; + int32_t bytecode_length; + int32_t environments_length; + int32_t defs_length; + int32_t symbolmap_length; +}; + +/* A function environment */ +struct JanetFuncEnv { + JanetGCObject gc; + union { + JanetFiber *fiber; + Janet *values; + } as; + int32_t length; /* Size of environment */ + int32_t offset; /* Stack offset when values still on stack. If offset is <= 0, then + environment is no longer on the stack. */ +}; + +#define JANET_FUNCFLAG_TRACE (1 << 16) + +/* A function */ +struct JanetFunction { + JanetGCObject gc; + JanetFuncDef *def; + JanetFuncEnv *envs[]; +}; + +typedef struct JanetParseState JanetParseState; +typedef struct JanetParser JanetParser; + +enum JanetParserStatus { + JANET_PARSE_ROOT, + JANET_PARSE_ERROR, + JANET_PARSE_PENDING, + JANET_PARSE_DEAD +}; + +/* A janet parser */ +struct JanetParser { + Janet *args; + const char *error; + JanetParseState *states; + uint8_t *buf; + size_t argcount; + size_t argcap; + size_t statecount; + size_t statecap; + size_t bufcount; + size_t bufcap; + size_t line; + size_t column; + size_t pending; + int lookback; + int flag; +}; + +/* A context for marshaling and unmarshaling abstract types */ +typedef struct { + void *m_state; + void *u_state; + int flags; + const uint8_t *data; + const JanetAbstractType *at; +} JanetMarshalContext; + +/* Defines an abstract type */ +struct JanetAbstractType { + const char *name; + int (*gc)(void *data, size_t len); + int (*gcmark)(void *data, size_t len); + int (*get)(void *data, Janet key, Janet *out); + void (*put)(void *data, Janet key, Janet value); + void (*marshal)(void *p, JanetMarshalContext *ctx); + void *(*unmarshal)(JanetMarshalContext *ctx); + void (*tostring)(void *p, JanetBuffer *buffer); + int (*compare)(void *lhs, void *rhs); + int32_t (*hash)(void *p, size_t len); + Janet(*next)(void *p, Janet key); + Janet(*call)(void *p, int32_t argc, Janet *argv); + size_t (*length)(void *p, size_t len); + JanetByteView(*bytes)(void *p, size_t len); +}; + +/* Some macros to let us add extra types to JanetAbstract types without + * needing to changing native modules that declare them as static const + * structures. If more fields are added, these macros are modified to include + * default values (usually NULL). This silences missing field warnings. */ +#define JANET_ATEND_NAME NULL,JANET_ATEND_GC +#define JANET_ATEND_GC NULL,JANET_ATEND_GCMARK +#define JANET_ATEND_GCMARK NULL,JANET_ATEND_GET +#define JANET_ATEND_GET NULL,JANET_ATEND_PUT +#define JANET_ATEND_PUT NULL,JANET_ATEND_MARSHAL +#define JANET_ATEND_MARSHAL NULL,JANET_ATEND_UNMARSHAL +#define JANET_ATEND_UNMARSHAL NULL,JANET_ATEND_TOSTRING +#define JANET_ATEND_TOSTRING NULL,JANET_ATEND_COMPARE +#define JANET_ATEND_COMPARE NULL,JANET_ATEND_HASH +#define JANET_ATEND_HASH NULL,JANET_ATEND_NEXT +#define JANET_ATEND_NEXT NULL,JANET_ATEND_CALL +#define JANET_ATEND_CALL NULL,JANET_ATEND_LENGTH +#define JANET_ATEND_LENGTH NULL,JANET_ATEND_BYTES +#define JANET_ATEND_BYTES + +struct JanetReg { + const char *name; + JanetCFunction cfun; + const char *documentation; +}; + +struct JanetRegExt { + const char *name; + JanetCFunction cfun; + const char *documentation; + const char *source_file; + int32_t source_line; +}; + +struct JanetMethod { + const char *name; + JanetCFunction cfun; +}; + +struct JanetView { + const Janet *items; + int32_t len; +}; + +struct JanetByteView { + const uint8_t *bytes; + int32_t len; +}; + +struct JanetDictView { + const JanetKV *kvs; + int32_t len; + int32_t cap; +}; + +struct JanetRange { + int32_t start; + int32_t end; +}; + +struct JanetRNG { + uint32_t a, b, c, d; + uint32_t counter; +}; + +typedef struct JanetFile JanetFile; +struct JanetFile { + FILE *file; + int32_t flags; +}; + +/* For janet_try and janet_restore */ +typedef struct { + /* old state */ + int32_t stackn; + int gc_handle; + JanetFiber *vm_fiber; + jmp_buf *vm_jmp_buf; + Janet *vm_return_reg; + /* new state */ + jmp_buf buf; + Janet payload; +} JanetTryState; + +/***** END SECTION TYPES *****/ + +/***** START SECTION OPCODES *****/ + +/* Bytecode op argument types */ +enum JanetOpArgType { + JANET_OAT_SLOT, + JANET_OAT_ENVIRONMENT, + JANET_OAT_CONSTANT, + JANET_OAT_INTEGER, + JANET_OAT_TYPE, + JANET_OAT_SIMPLETYPE, + JANET_OAT_LABEL, + JANET_OAT_FUNCDEF +}; + +/* Various types of instructions */ +enum JanetInstructionType { + JINT_0, /* No args */ + JINT_S, /* Slot(3) */ + JINT_L, /* Label(3) */ + JINT_SS, /* Slot(1), Slot(2) */ + JINT_SL, /* Slot(1), Label(2) */ + JINT_ST, /* Slot(1), Slot(2) */ + JINT_SI, /* Slot(1), Immediate(2) */ + JINT_SD, /* Slot(1), Closure(2) */ + JINT_SU, /* Slot(1), Unsigned Immediate(2) */ + JINT_SSS, /* Slot(1), Slot(1), Slot(1) */ + JINT_SSI, /* Slot(1), Slot(1), Immediate(1) */ + JINT_SSU, /* Slot(1), Slot(1), Unsigned Immediate(1) */ + JINT_SES, /* Slot(1), Environment(1), Far Slot(1) */ + JINT_SC /* Slot(1), Constant(2) */ +}; + +/* All opcodes for the bytecode interpreter. */ +enum JanetOpCode { + JOP_NOOP, + JOP_ERROR, + JOP_TYPECHECK, + JOP_RETURN, + JOP_RETURN_NIL, + JOP_ADD_IMMEDIATE, + JOP_ADD, + JOP_SUBTRACT_IMMEDIATE, + JOP_SUBTRACT, + JOP_MULTIPLY_IMMEDIATE, + JOP_MULTIPLY, + JOP_DIVIDE_IMMEDIATE, + JOP_DIVIDE, + JOP_DIVIDE_FLOOR, + JOP_MODULO, + JOP_REMAINDER, + JOP_BAND, + JOP_BOR, + JOP_BXOR, + JOP_BNOT, + JOP_SHIFT_LEFT, + JOP_SHIFT_LEFT_IMMEDIATE, + JOP_SHIFT_RIGHT, + JOP_SHIFT_RIGHT_IMMEDIATE, + JOP_SHIFT_RIGHT_UNSIGNED, + JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, + JOP_MOVE_FAR, + JOP_MOVE_NEAR, + JOP_JUMP, + JOP_JUMP_IF, + JOP_JUMP_IF_NOT, + JOP_JUMP_IF_NIL, + JOP_JUMP_IF_NOT_NIL, + JOP_GREATER_THAN, + JOP_GREATER_THAN_IMMEDIATE, + JOP_LESS_THAN, + JOP_LESS_THAN_IMMEDIATE, + JOP_EQUALS, + JOP_EQUALS_IMMEDIATE, + JOP_COMPARE, + JOP_LOAD_NIL, + JOP_LOAD_TRUE, + JOP_LOAD_FALSE, + JOP_LOAD_INTEGER, + JOP_LOAD_CONSTANT, + JOP_LOAD_UPVALUE, + JOP_LOAD_SELF, + JOP_SET_UPVALUE, + JOP_CLOSURE, + JOP_PUSH, + JOP_PUSH_2, + JOP_PUSH_3, + JOP_PUSH_ARRAY, + JOP_CALL, + JOP_TAILCALL, + JOP_RESUME, + JOP_SIGNAL, + JOP_PROPAGATE, + JOP_IN, + JOP_GET, + JOP_PUT, + JOP_GET_INDEX, + JOP_PUT_INDEX, + JOP_LENGTH, + JOP_MAKE_ARRAY, + JOP_MAKE_BUFFER, + JOP_MAKE_STRING, + JOP_MAKE_STRUCT, + JOP_MAKE_TABLE, + JOP_MAKE_TUPLE, + JOP_MAKE_BRACKET_TUPLE, + JOP_GREATER_THAN_EQUAL, + JOP_LESS_THAN_EQUAL, + JOP_NEXT, + JOP_NOT_EQUALS, + JOP_NOT_EQUALS_IMMEDIATE, + JOP_CANCEL, + JOP_INSTRUCTION_COUNT +}; + +/* Info about all instructions */ +extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT]; + +/***** END SECTION OPCODES *****/ + +/***** START SECTION MAIN *****/ + +#ifdef JANET_EV + +extern JANET_API const JanetAbstractType janet_stream_type; +extern JANET_API const JanetAbstractType janet_channel_type; + +/* Run the event loop */ +JANET_API void janet_loop(void); + +/* Run the event loop, but allow for user scheduled interrupts triggered + * by janet_loop1_interrupt being called in library code, a signal handler, or + * another thread. + * + * Example: + * + * while (!janet_loop_done()) { + * // One turn of the event loop + * JanetFiber *interrupted_fiber = janet_loop1(); + * // interrupted_fiber may be NULL + * // do some work here periodically... + * if (NULL != interrupted_fiber) { + * if (cancel_interrupted_fiber) { + * janet_cancel(interrupted_fiber, janet_cstringv("fiber was interrupted for [reason]")); + * } else { + * janet_schedule(interrupted_fiber, janet_wrap_nil()); + * } + * } + * } + * + */ +JANET_API int janet_loop_done(void); +JANET_API JanetFiber *janet_loop1(void); +JANET_API void janet_loop1_interrupt(JanetVM *vm); + +/* Wrapper around streams */ +JANET_API JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod *methods); +JANET_API void janet_stream_close(JanetStream *stream); +JANET_API Janet janet_cfun_stream_close(int32_t argc, Janet *argv); +JANET_API Janet janet_cfun_stream_read(int32_t argc, Janet *argv); +JANET_API Janet janet_cfun_stream_chunk(int32_t argc, Janet *argv); +JANET_API Janet janet_cfun_stream_write(int32_t argc, Janet *argv); +JANET_API void janet_stream_flags(JanetStream *stream, uint32_t flags); + +/* Queue a fiber to run on the event loop */ +JANET_API void janet_schedule(JanetFiber *fiber, Janet value); +JANET_API void janet_cancel(JanetFiber *fiber, Janet value); +JANET_API void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig); +JANET_API void janet_schedule_soon(JanetFiber *fiber, Janet value, JanetSignal sig); + +/* Shorthand for yielding to event loop in C */ +JANET_NO_RETURN JANET_API void janet_await(void); +JANET_NO_RETURN JANET_API void janet_sleep_await(double sec); + +/* For use inside listeners - adds a timeout to the current fiber, such that + * it will be resumed after sec seconds if no other event schedules the current fiber. */ +JANET_API void janet_addtimeout(double sec); +JANET_API void janet_ev_inc_refcount(void); +JANET_API void janet_ev_dec_refcount(void); + +/* Thread aware abstract types and helpers */ +JANET_API void *janet_abstract_begin_threaded(const JanetAbstractType *atype, size_t size); +JANET_API void *janet_abstract_end_threaded(void *x); +JANET_API void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size); +JANET_API int32_t janet_abstract_incref(void *abst); +JANET_API int32_t janet_abstract_decref(void *abst); + +/* Expose some OS sync primitives */ +JANET_API size_t janet_os_mutex_size(void); +JANET_API size_t janet_os_rwlock_size(void); +JANET_API void janet_os_mutex_init(JanetOSMutex *mutex); +JANET_API void janet_os_mutex_deinit(JanetOSMutex *mutex); +JANET_API void janet_os_mutex_lock(JanetOSMutex *mutex); +JANET_API void janet_os_mutex_unlock(JanetOSMutex *mutex); +JANET_API void janet_os_rwlock_init(JanetOSRWLock *rwlock); +JANET_API void janet_os_rwlock_deinit(JanetOSRWLock *rwlock); +JANET_API void janet_os_rwlock_rlock(JanetOSRWLock *rwlock); +JANET_API void janet_os_rwlock_wlock(JanetOSRWLock *rwlock); +JANET_API void janet_os_rwlock_runlock(JanetOSRWLock *rwlock); +JANET_API void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock); + +/* Get last error from an IO operation */ +JANET_API Janet janet_ev_lasterr(void); + +/* Async service for calling a function or syscall in a background thread. This is not + * as efficient in the slightest as using Streams but can be used for arbitrary blocking + * functions and syscalls. */ + +/* Used to pass data between the main thread and worker threads for simple tasks. + * We could just use a pointer but this prevents malloc/free in the common case + * of only a handful of arguments. */ +typedef struct { + int tag; + int argi; + void *argp; + Janet argj; + JanetFiber *fiber; +} JanetEVGenericMessage; + +/* How to resume or cancel after a threaded call. Not exhaustive of the possible + * ways one might want to resume after returning from a threaded call, but should + * cover most of the common cases. For something more complicated, such as resuming + * with an abstract type or a struct, one should use janet_ev_threaded_call instead + * of janet_ev_threaded_await with a custom callback. */ + +#define JANET_EV_TCTAG_NIL 0 /* resume with nil */ +#define JANET_EV_TCTAG_INTEGER 1 /* resume with janet_wrap_integer(argi) */ +#define JANET_EV_TCTAG_STRING 2 /* resume with janet_cstringv((const char *) argp) */ +#define JANET_EV_TCTAG_STRINGF 3 /* resume with janet_cstringv((const char *) argp), then call free on argp. */ +#define JANET_EV_TCTAG_KEYWORD 4 /* resume with janet_ckeywordv((const char *) argp) */ +#define JANET_EV_TCTAG_ERR_STRING 5 /* cancel with janet_cstringv((const char *) argp) */ +#define JANET_EV_TCTAG_ERR_STRINGF 6 /* cancel with janet_cstringv((const char *) argp), then call free on argp. */ +#define JANET_EV_TCTAG_ERR_KEYWORD 7 /* cancel with janet_ckeywordv((const char *) argp) */ +#define JANET_EV_TCTAG_BOOLEAN 8 /* resume with janet_wrap_boolean(argi) */ + +/* Function pointer that is run in the thread pool */ +typedef JanetEVGenericMessage(*JanetThreadedSubroutine)(JanetEVGenericMessage arguments); + +/* Handler for events posted to the event loop */ +typedef void (*JanetCallback)(JanetEVGenericMessage return_value); + +/* Handler that is run in the main thread with the result of the JanetAsyncSubroutine (same as JanetCallback) */ +typedef void (*JanetThreadedCallback)(JanetEVGenericMessage return_value); + +/* API calls for quickly offloading some work in C to a new thread or thread pool. */ +JANET_API void janet_ev_threaded_call(JanetThreadedSubroutine fp, JanetEVGenericMessage arguments, JanetThreadedCallback cb); +JANET_NO_RETURN JANET_API void janet_ev_threaded_await(JanetThreadedSubroutine fp, int tag, int argi, void *argp); + +/* Post callback + userdata to an event loop. Takes the vm parameter to allow posting from other + * threads or signal handlers. Use NULL to post to the current thread. */ +JANET_API void janet_ev_post_event(JanetVM *vm, JanetCallback cb, JanetEVGenericMessage msg); + +/* Callback used by janet_ev_threaded_await */ +JANET_API void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value); + +/* Read async from a stream */ +JANET_NO_RETURN JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes); +JANET_NO_RETURN JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes); +#ifdef JANET_NET +JANET_NO_RETURN JANET_API void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags); +JANET_NO_RETURN JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags); +JANET_NO_RETURN JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags); +#endif + +/* Write async to a stream */ +JANET_NO_RETURN JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf); +JANET_NO_RETURN JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str); +#ifdef JANET_NET +JANET_NO_RETURN JANET_API void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags); +JANET_NO_RETURN JANET_API void janet_ev_send_string(JanetStream *stream, JanetString str, int flags); +JANET_NO_RETURN JANET_API void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags); +JANET_NO_RETURN JANET_API void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags); +#endif + +#endif + +/* Parsing */ +extern JANET_API const JanetAbstractType janet_parser_type; +JANET_API void janet_parser_init(JanetParser *parser); +JANET_API void janet_parser_deinit(JanetParser *parser); +JANET_API void janet_parser_consume(JanetParser *parser, uint8_t c); +JANET_API enum JanetParserStatus janet_parser_status(JanetParser *parser); +JANET_API Janet janet_parser_produce(JanetParser *parser); +JANET_API Janet janet_parser_produce_wrapped(JanetParser *parser); +JANET_API const char *janet_parser_error(JanetParser *parser); +JANET_API void janet_parser_flush(JanetParser *parser); +JANET_API void janet_parser_eof(JanetParser *parser); +JANET_API int janet_parser_has_more(JanetParser *parser); + +/* Assembly */ +#ifdef JANET_ASSEMBLER +typedef struct JanetAssembleResult JanetAssembleResult; +enum JanetAssembleStatus { + JANET_ASSEMBLE_OK, + JANET_ASSEMBLE_ERROR +}; +struct JanetAssembleResult { + JanetFuncDef *funcdef; + JanetString error; + enum JanetAssembleStatus status; +}; +JANET_API JanetAssembleResult janet_asm(Janet source, int flags); +JANET_API Janet janet_disasm(JanetFuncDef *def); +JANET_API Janet janet_asm_decode_instruction(uint32_t instr); +#endif + +/* Compilation */ +typedef struct JanetCompileResult JanetCompileResult; +enum JanetCompileStatus { + JANET_COMPILE_OK, + JANET_COMPILE_ERROR +}; +struct JanetCompileResult { + JanetFuncDef *funcdef; + JanetString error; + JanetFiber *macrofiber; + JanetSourceMapping error_mapping; + enum JanetCompileStatus status; +}; +JANET_API JanetCompileResult janet_compile(Janet source, JanetTable *env, JanetString where); +JANET_API JanetCompileResult janet_compile_lint( + Janet source, + JanetTable *env, + JanetString where, + JanetArray *lints); + +/* Get the default environment for janet */ +JANET_API JanetTable *janet_core_env(JanetTable *replacements); +JANET_API JanetTable *janet_core_lookup_table(JanetTable *replacements); + +/* Execute strings */ +JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out); +JANET_API int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out); + +/* Run the entrypoint of a wrapped program */ +JANET_API int janet_loop_fiber(JanetFiber *fiber); + +/* Number scanning */ +JANET_API int janet_scan_number(const uint8_t *str, int32_t len, double *out); +JANET_API int janet_scan_number_base(const uint8_t *str, int32_t len, int32_t base, double *out); +JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out); +JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out); + +/* Debugging */ +JANET_API void janet_debug_break(JanetFuncDef *def, int32_t pc); +JANET_API void janet_debug_unbreak(JanetFuncDef *def, int32_t pc); +JANET_API void janet_debug_find( + JanetFuncDef **def_out, int32_t *pc_out, + JanetString source, int32_t line, int32_t column); + +/* RNG */ +extern JANET_API const JanetAbstractType janet_rng_type; +JANET_API JanetRNG *janet_default_rng(void); +JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed); +JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len); +JANET_API uint32_t janet_rng_u32(JanetRNG *rng); +JANET_API double janet_rng_double(JanetRNG *rng); + +/* Array functions */ +JANET_API JanetArray *janet_array(int32_t capacity); +JANET_API JanetArray *janet_array_weak(int32_t capacity); +JANET_API JanetArray *janet_array_n(const Janet *elements, int32_t n); +JANET_API void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth); +JANET_API void janet_array_setcount(JanetArray *array, int32_t count); +JANET_API void janet_array_push(JanetArray *array, Janet x); +JANET_API Janet janet_array_pop(JanetArray *array); +JANET_API Janet janet_array_peek(JanetArray *array); + +/* Buffer functions */ +#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 +JANET_API JanetBuffer *janet_buffer(int32_t capacity); +JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity); +JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count); +JANET_API void janet_buffer_deinit(JanetBuffer *buffer); +JANET_API void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth); +JANET_API void janet_buffer_setcount(JanetBuffer *buffer, int32_t count); +JANET_API void janet_buffer_extra(JanetBuffer *buffer, int32_t n); +JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t len); +JANET_API void janet_buffer_push_string(JanetBuffer *buffer, JanetString string); +JANET_API void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring); +JANET_API void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t x); +JANET_API void janet_buffer_push_u16(JanetBuffer *buffer, uint16_t x); +JANET_API void janet_buffer_push_u32(JanetBuffer *buffer, uint32_t x); +JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x); + +/* Tuple */ + +#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 + +#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) +#define janet_tuple_from_head(gcobject) ((JanetTuple)((char *)gcobject + offsetof(JanetTupleHead, data))) +#define janet_tuple_length(t) (janet_tuple_head(t)->length) +#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) +#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) +#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) +#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) +JANET_API Janet *janet_tuple_begin(int32_t length); +JANET_API JanetTuple janet_tuple_end(Janet *tuple); +JANET_API JanetTuple janet_tuple_n(const Janet *values, int32_t n); + +/* String/Symbol functions */ +#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) +#define janet_string_length(s) (janet_string_head(s)->length) +#define janet_string_hash(s) (janet_string_head(s)->hash) +JANET_API uint8_t *janet_string_begin(int32_t length); +JANET_API JanetString janet_string_end(uint8_t *str); +JANET_API JanetString janet_string(const uint8_t *buf, int32_t len); +JANET_API JanetString janet_cstring(const char *cstring); +JANET_API int janet_string_compare(JanetString lhs, JanetString rhs); +JANET_API int janet_string_equal(JanetString lhs, JanetString rhs); +JANET_API int janet_string_equalconst(JanetString lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash); +JANET_API JanetString janet_description(Janet x); +JANET_API JanetString janet_to_string(Janet x); +JANET_API void janet_to_string_b(JanetBuffer *buffer, Janet x); +JANET_API void janet_description_b(JanetBuffer *buffer, Janet x); +#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) +#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) +JANET_API JanetString janet_formatc(const char *format, ...); +JANET_API JanetBuffer *janet_formatb(JanetBuffer *bufp, const char *format, ...); +JANET_API void janet_formatbv(JanetBuffer *bufp, const char *format, va_list args); + +/* Symbol functions */ +JANET_API JanetSymbol janet_symbol(const uint8_t *str, int32_t len); +JANET_API JanetSymbol janet_csymbol(const char *str); +JANET_API JanetSymbol janet_symbol_gen(void); +#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) +#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) + +/* Keyword functions */ +#define janet_keyword janet_symbol +#define janet_ckeyword janet_csymbol +#define janet_keywordv(str, len) janet_wrap_keyword(janet_keyword((str), (len))) +#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) + +/* Structs */ +#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) +#define janet_struct_from_head(t) ((JanetStruct)((char *)gcobject + offsetof(JanetStructHead, data))) +#define janet_struct_length(t) (janet_struct_head(t)->length) +#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) +#define janet_struct_hash(t) (janet_struct_head(t)->hash) +#define janet_struct_proto(t) (janet_struct_head(t)->proto) +JANET_API JanetKV *janet_struct_begin(int32_t count); +JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value); +JANET_API JanetStruct janet_struct_end(JanetKV *st); +JANET_API Janet janet_struct_get(JanetStruct st, Janet key); +JANET_API Janet janet_struct_rawget(JanetStruct st, Janet key); +JANET_API Janet janet_struct_get_ex(JanetStruct st, Janet key, JanetStruct *which); +JANET_API JanetTable *janet_struct_to_table(JanetStruct st); +JANET_API const JanetKV *janet_struct_find(JanetStruct st, Janet key); + +/* Table functions */ +JANET_API JanetTable *janet_table(int32_t capacity); +JANET_API JanetTable *janet_table_init(JanetTable *table, int32_t capacity); +JANET_API JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity); +JANET_API void janet_table_deinit(JanetTable *table); +JANET_API Janet janet_table_get(JanetTable *t, Janet key); +JANET_API Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which); +JANET_API Janet janet_table_rawget(JanetTable *t, Janet key); +JANET_API Janet janet_table_remove(JanetTable *t, Janet key); +JANET_API void janet_table_put(JanetTable *t, Janet key, Janet value); +JANET_API JanetStruct janet_table_to_struct(JanetTable *t); +JANET_API void janet_table_merge_table(JanetTable *table, JanetTable *other); +JANET_API void janet_table_merge_struct(JanetTable *table, JanetStruct other); +JANET_API JanetKV *janet_table_find(JanetTable *t, Janet key); +JANET_API JanetTable *janet_table_clone(JanetTable *table); +JANET_API void janet_table_clear(JanetTable *table); + +/* Fiber */ +JANET_API JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv); +JANET_API JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv); +JANET_API JanetFiberStatus janet_fiber_status(JanetFiber *fiber); +JANET_API int janet_fiber_can_resume(JanetFiber *fiber); +JANET_API JanetFiber *janet_current_fiber(void); +JANET_API JanetFiber *janet_root_fiber(void); + +/* Treat similar types through uniform interfaces for iteration */ +JANET_API int janet_indexed_view(Janet seq, const Janet **data, int32_t *len); +JANET_API int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len); +JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap); +JANET_API Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key); +JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv); + +/* Abstract */ +#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) +#define janet_abstract_from_head(gcobject) ((JanetAbstract)((char *)gcobject + offsetof(JanetAbstractHead, data))) +#define janet_abstract_type(u) (janet_abstract_head(u)->type) +#define janet_abstract_size(u) (janet_abstract_head(u)->size) +JANET_API void *janet_abstract_begin(const JanetAbstractType *type, size_t size); +JANET_API JanetAbstract janet_abstract_end(void *abstractTemplate); +JANET_API JanetAbstract janet_abstract(const JanetAbstractType *type, size_t size); /* begin and end in one call */ + +/* Native */ +typedef void (*JanetModule)(JanetTable *); +typedef JanetBuildConfig(*JanetModconf)(void); +JANET_API JanetModule janet_native(const char *name, JanetString *error); + +/* Marshaling */ +#define JANET_MARSHAL_UNSAFE 0x20000 +#define JANET_MARSHAL_NO_CYCLES 0x40000 + +JANET_API void janet_marshal( + JanetBuffer *buf, + Janet x, + JanetTable *rreg, + int flags); +JANET_API Janet janet_unmarshal( + const uint8_t *bytes, + size_t len, + int flags, + JanetTable *reg, + const uint8_t **next); +JANET_API JanetTable *janet_env_lookup(JanetTable *env); +JANET_API void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse); + +/* GC */ +JANET_API void janet_mark(Janet x); +JANET_API void janet_sweep(void); +JANET_API void janet_collect(void); +JANET_API void janet_clear_memory(void); +JANET_API void janet_gcroot(Janet root); +JANET_API int janet_gcunroot(Janet root); +JANET_API int janet_gcunrootall(Janet root); +JANET_API int janet_gclock(void); +JANET_API void janet_gcunlock(int handle); +JANET_API void janet_gcpressure(size_t s); + +/* Functions */ +JANET_API JanetFuncDef *janet_funcdef_alloc(void); +JANET_API JanetFunction *janet_thunk(JanetFuncDef *def); +JANET_API int janet_verify(JanetFuncDef *def); + +/* Pretty printing */ +#define JANET_PRETTY_COLOR 1 +#define JANET_PRETTY_ONELINE 2 +#define JANET_PRETTY_NOTRUNC 4 +JANET_API JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x); + +/* Misc */ +#ifdef JANET_PRF +#define JANET_HASH_KEY_SIZE 16 +JANET_API void janet_init_hash_key(uint8_t key[JANET_HASH_KEY_SIZE]); +#endif +JANET_API void janet_try_init(JanetTryState *state); +#if defined(JANET_BSD) || defined(JANET_APPLE) +#define janet_try(state) (janet_try_init(state), (JanetSignal) _setjmp((state)->buf)) +#else +#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) +#endif +JANET_API void janet_restore(JanetTryState *state); +JANET_API int janet_equals(Janet x, Janet y); +JANET_API int32_t janet_hash(Janet x); +JANET_API int janet_compare(Janet x, Janet y); +JANET_API int janet_cstrcmp(JanetString str, const char *other); +JANET_API Janet janet_in(Janet ds, Janet key); +JANET_API Janet janet_get(Janet ds, Janet key); +JANET_API Janet janet_next(Janet ds, Janet key); +JANET_API Janet janet_getindex(Janet ds, int32_t index); +JANET_API int32_t janet_length(Janet x); +JANET_API Janet janet_lengthv(Janet x); +JANET_API void janet_put(Janet ds, Janet key, Janet value); +JANET_API void janet_putindex(Janet ds, int32_t index, Janet value); +#define janet_flag_at(F, I) ((F) & ((1ULL) << (I))) +JANET_API Janet janet_wrap_number_safe(double x); +JANET_API int janet_keyeq(Janet x, const char *cstring); +JANET_API int janet_streq(Janet x, const char *cstring); +JANET_API int janet_symeq(Janet x, const char *cstring); +JANET_API int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer); + +/* VM functions */ +JANET_API int janet_init(void); +JANET_API void janet_deinit(void); +JANET_API JanetVM *janet_vm_alloc(void); +JANET_API JanetVM *janet_local_vm(void); +JANET_API void janet_vm_free(JanetVM *vm); +JANET_API void janet_vm_save(JanetVM *into); +JANET_API void janet_vm_load(JanetVM *from); +JANET_API void janet_interpreter_interrupt(JanetVM *vm); +JANET_API void janet_interpreter_interrupt_handled(JanetVM *vm); +JANET_API JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out); +JANET_API JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig); +JANET_API JanetSignal janet_pcall(JanetFunction *fun, int32_t argn, const Janet *argv, Janet *out, JanetFiber **f); +JANET_API JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out); +JANET_API Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv); +JANET_API Janet janet_mcall(const char *name, int32_t argc, Janet *argv); +JANET_API void janet_stacktrace(JanetFiber *fiber, Janet err); +JANET_API void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix); + +/* Sandboxing API */ +#define JANET_SANDBOX_SANDBOX 1 +#define JANET_SANDBOX_SUBPROCESS 2 +#define JANET_SANDBOX_NET_CONNECT 4 +#define JANET_SANDBOX_NET_LISTEN 8 +#define JANET_SANDBOX_FFI_DEFINE 16 +#define JANET_SANDBOX_FS_WRITE 32 +#define JANET_SANDBOX_FS_READ 64 +#define JANET_SANDBOX_HRTIME 128 +#define JANET_SANDBOX_ENV 256 +#define JANET_SANDBOX_DYNAMIC_MODULES 512 +#define JANET_SANDBOX_FS_TEMP 1024 +#define JANET_SANDBOX_FFI_USE 2048 +#define JANET_SANDBOX_FFI_JIT 4096 +#define JANET_SANDBOX_SIGNAL 8192 +#define JANET_SANDBOX_FFI (JANET_SANDBOX_FFI_DEFINE | JANET_SANDBOX_FFI_USE | JANET_SANDBOX_FFI_JIT) +#define JANET_SANDBOX_FS (JANET_SANDBOX_FS_WRITE | JANET_SANDBOX_FS_READ | JANET_SANDBOX_FS_TEMP) +#define JANET_SANDBOX_NET (JANET_SANDBOX_NET_CONNECT | JANET_SANDBOX_NET_LISTEN) +#define JANET_SANDBOX_ALL (UINT32_MAX) +JANET_API void janet_sandbox(uint32_t flags); +JANET_API void janet_sandbox_assert(uint32_t forbidden_flags); + +/* Scratch Memory API */ +typedef void (*JanetScratchFinalizer)(void *); + +JANET_API void *janet_smalloc(size_t size); +JANET_API void *janet_srealloc(void *mem, size_t size); +JANET_API void *janet_scalloc(size_t nmemb, size_t size); +JANET_API void janet_sfinalizer(void *mem, JanetScratchFinalizer finalizer); +JANET_API void janet_sfree(void *mem); + +/* C Library helpers */ +typedef enum { + JANET_BINDING_NONE, + JANET_BINDING_DEF, + JANET_BINDING_VAR, + JANET_BINDING_MACRO, + JANET_BINDING_DYNAMIC_DEF, + JANET_BINDING_DYNAMIC_MACRO +} JanetBindingType; + +typedef struct { + JanetBindingType type; + Janet value; + enum { + JANET_BINDING_DEP_NONE, + JANET_BINDING_DEP_RELAXED, + JANET_BINDING_DEP_NORMAL, + JANET_BINDING_DEP_STRICT, + } deprecation; +} JanetBinding; + +JANET_API void janet_def(JanetTable *env, const char *name, Janet val, const char *documentation); +JANET_API void janet_var(JanetTable *env, const char *name, Janet val, const char *documentation); +JANET_API void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns); +JANET_API void janet_cfuns_prefix(JanetTable *env, const char *regprefix, const JanetReg *cfuns); +JANET_API JanetBindingType janet_resolve(JanetTable *env, JanetSymbol sym, Janet *out); +JANET_API JanetBinding janet_resolve_ext(JanetTable *env, JanetSymbol sym); + +/* Get values from the core environment. */ +JANET_API Janet janet_resolve_core(const char *name); + +/* New C API */ + +/* Shorthand for janet C function declarations */ +#define JANET_CFUN(name) Janet name (int32_t argc, Janet *argv) + +/* Declare a C function with documentation and source mapping */ +#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} + +/* no docstrings or sourcemaps */ +#define JANET_REG_(JNAME, CNAME) {JNAME, CNAME, NULL, NULL, 0} +#define JANET_FN_(CNAME, USAGE, DOCSTRING) \ + Janet CNAME (int32_t argc, Janet *argv) +#define JANET_DEF_(ENV, JNAME, VAL, DOC) \ + janet_def(ENV, JNAME, VAL, NULL) + +/* sourcemaps only */ +#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} +#define JANET_FN_S(CNAME, USAGE, DOCSTRING) \ + static const int32_t CNAME##_sourceline_ = __LINE__; \ + Janet CNAME (int32_t argc, Janet *argv) +#define JANET_DEF_S(ENV, JNAME, VAL, DOC) \ + janet_def_sm(ENV, JNAME, VAL, NULL, __FILE__, __LINE__) + +/* docstring only */ +#define JANET_REG_D(JNAME, CNAME) {JNAME, CNAME, CNAME##_docstring_, NULL, 0} +#define JANET_FN_D(CNAME, USAGE, DOCSTRING) \ + static const char CNAME##_docstring_[] = USAGE "\n\n" DOCSTRING; \ + Janet CNAME (int32_t argc, Janet *argv) +#define JANET_DEF_D(ENV, JNAME, VAL, DOC) \ + janet_def(ENV, JNAME, VAL, DOC) + +/* sourcemaps and docstrings */ +#define JANET_REG_SD(JNAME, CNAME) {JNAME, CNAME, CNAME##_docstring_, __FILE__, CNAME##_sourceline_} +#define JANET_FN_SD(CNAME, USAGE, DOCSTRING) \ + static const int32_t CNAME##_sourceline_ = __LINE__; \ + static const char CNAME##_docstring_[] = USAGE "\n\n" DOCSTRING; \ + Janet CNAME (int32_t argc, Janet *argv) +#define JANET_DEF_SD(ENV, JNAME, VAL, DOC) \ + janet_def_sm(ENV, JNAME, VAL, DOC, __FILE__, __LINE__) + +/* Choose defaults for source mapping and docstring based on config defs */ +#if defined(JANET_NO_SOURCEMAPS) && defined(JANET_NO_DOCSTRINGS) +#define JANET_REG JANET_REG_ +#define JANET_FN JANET_FN_ +#define JANET_DEF JANET_DEF_ +#elif defined(JANET_NO_SOURCEMAPS) && !defined(JANET_NO_DOCSTRINGS) +#define JANET_REG JANET_REG_D +#define JANET_FN JANET_FN_D +#define JANET_DEF JANET_DEF_D +#elif !defined(JANET_NO_SOURCEMAPS) && defined(JANET_NO_DOCSTRINGS) +#define JANET_REG JANET_REG_S +#define JANET_FN JANET_FN_S +#define JANET_DEF JANET_DEF_S +#elif !defined(JANET_NO_SOURCEMAPS) && !defined(JANET_NO_DOCSTRINGS) +#define JANET_REG JANET_REG_SD +#define JANET_FN JANET_FN_SD +#define JANET_DEF JANET_DEF_SD +#endif + +/* Define things with source mapping information */ +JANET_API void janet_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns); +JANET_API void janet_cfuns_ext_prefix(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns); +JANET_API void janet_def_sm(JanetTable *env, const char *name, Janet val, const char *documentation, const char *source_file, int32_t source_line); +JANET_API void janet_var_sm(JanetTable *env, const char *name, Janet val, const char *documentation, const char *source_file, int32_t source_line); + +/* Legacy definition of C functions */ +JANET_API void janet_register(const char *name, JanetCFunction cfun); + +/* Allow setting entry name for static libraries */ +#ifdef __cplusplus +#define JANET_MODULE_PREFIX extern "C" +#else +#define JANET_MODULE_PREFIX +#endif +#ifndef JANET_ENTRY_NAME +#define JANET_MODULE_ENTRY \ + JANET_MODULE_PREFIX JANET_EXPORT JanetBuildConfig _janet_mod_config(void) { \ + return janet_config_current(); \ + } \ + JANET_MODULE_PREFIX JANET_EXPORT void _janet_init +#else +#define JANET_MODULE_ENTRY JANET_MODULE_PREFIX JANET_API void JANET_ENTRY_NAME +#endif + +JANET_NO_RETURN JANET_API void janet_signalv(JanetSignal signal, Janet message); +JANET_NO_RETURN JANET_API void janet_panicv(Janet message); +JANET_NO_RETURN JANET_API void janet_panic(const char *message); +JANET_NO_RETURN JANET_API void janet_panics(JanetString message); +JANET_NO_RETURN JANET_API void janet_panicf(const char *format, ...); +JANET_API void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...); +#define janet_printf(...) janet_dynprintf("out", stdout, __VA_ARGS__) +#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) +JANET_NO_RETURN JANET_API void janet_panic_type(Janet x, int32_t n, int expected); +JANET_NO_RETURN JANET_API void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at); +JANET_API void janet_arity(int32_t arity, int32_t min, int32_t max); +JANET_API void janet_fixarity(int32_t arity, int32_t fix); + +JANET_API int janet_getmethod(JanetKeyword method, const JanetMethod *methods, Janet *out); +JANET_API Janet janet_nextmethod(const JanetMethod *methods, Janet key); + +JANET_API double janet_getnumber(const Janet *argv, int32_t n); +JANET_API JanetArray *janet_getarray(const Janet *argv, int32_t n); +JANET_API JanetTuple janet_gettuple(const Janet *argv, int32_t n); +JANET_API JanetTable *janet_gettable(const Janet *argv, int32_t n); +JANET_API JanetStruct janet_getstruct(const Janet *argv, int32_t n); +JANET_API JanetString janet_getstring(const Janet *argv, int32_t n); +JANET_API const char *janet_getcstring(const Janet *argv, int32_t n); +JANET_API const char *janet_getcbytes(const Janet *argv, int32_t n); +JANET_API JanetSymbol janet_getsymbol(const Janet *argv, int32_t n); +JANET_API JanetKeyword janet_getkeyword(const Janet *argv, int32_t n); +JANET_API JanetBuffer *janet_getbuffer(const Janet *argv, int32_t n); +JANET_API JanetFiber *janet_getfiber(const Janet *argv, int32_t n); +JANET_API JanetFunction *janet_getfunction(const Janet *argv, int32_t n); +JANET_API JanetCFunction janet_getcfunction(const Janet *argv, int32_t n); +JANET_API int janet_getboolean(const Janet *argv, int32_t n); +JANET_API void *janet_getpointer(const Janet *argv, int32_t n); + +JANET_API int32_t janet_getnat(const Janet *argv, int32_t n); +JANET_API int32_t janet_getinteger(const Janet *argv, int32_t n); +JANET_API int64_t janet_getinteger64(const Janet *argv, int32_t n); +JANET_API uint64_t janet_getuinteger64(const Janet *argv, int32_t n); +JANET_API size_t janet_getsize(const Janet *argv, int32_t n); +JANET_API JanetView janet_getindexed(const Janet *argv, int32_t n); +JANET_API JanetByteView janet_getbytes(const Janet *argv, int32_t n); +JANET_API JanetDictView janet_getdictionary(const Janet *argv, int32_t n); +JANET_API void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *at); +JANET_API JanetRange janet_getslice(int32_t argc, const Janet *argv); +JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which); +JANET_API int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length); +JANET_API int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length); +JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which); +JANET_API uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags); + +/* Optionals */ +JANET_API double janet_optnumber(const Janet *argv, int32_t argc, int32_t n, double dflt); +JANET_API JanetTuple janet_opttuple(const Janet *argv, int32_t argc, int32_t n, JanetTuple dflt); +JANET_API JanetStruct janet_optstruct(const Janet *argv, int32_t argc, int32_t n, JanetStruct dflt); +JANET_API JanetString janet_optstring(const Janet *argv, int32_t argc, int32_t n, JanetString dflt); +JANET_API const char *janet_optcstring(const Janet *argv, int32_t argc, int32_t n, const char *dflt); +JANET_API const char *janet_optcbytes(const Janet *argv, int32_t argc, int32_t n, const char *dflt); +JANET_API JanetSymbol janet_optsymbol(const Janet *argv, int32_t argc, int32_t n, JanetString dflt); +JANET_API JanetKeyword janet_optkeyword(const Janet *argv, int32_t argc, int32_t n, JanetString dflt); +JANET_API JanetFiber *janet_optfiber(const Janet *argv, int32_t argc, int32_t n, JanetFiber *dflt); +JANET_API JanetFunction *janet_optfunction(const Janet *argv, int32_t argc, int32_t n, JanetFunction *dflt); +JANET_API JanetCFunction janet_optcfunction(const Janet *argv, int32_t argc, int32_t n, JanetCFunction dflt); +JANET_API int janet_optboolean(const Janet *argv, int32_t argc, int32_t n, int dflt); +JANET_API void *janet_optpointer(const Janet *argv, int32_t argc, int32_t n, void *dflt); +JANET_API int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32_t dflt); +JANET_API int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt); +JANET_API int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt); +JANET_API size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt); +JANET_API JanetAbstract janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, JanetAbstract dflt); + +/* Mutable optional types specify a size default, and construct a new value if none is provided */ +JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len); +JANET_API JanetTable *janet_opttable(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len); +JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len); + +JANET_API Janet janet_dyn(const char *name); +JANET_API void janet_setdyn(const char *name, Janet value); + +extern JANET_API const JanetAbstractType janet_file_type; + +#define JANET_FILE_WRITE 1 +#define JANET_FILE_READ 2 +#define JANET_FILE_APPEND 4 +#define JANET_FILE_UPDATE 8 +#define JANET_FILE_NOT_CLOSEABLE 16 +#define JANET_FILE_CLOSED 32 +#define JANET_FILE_BINARY 64 +#define JANET_FILE_SERIALIZABLE 128 +#define JANET_FILE_NONIL 512 + +JANET_API Janet janet_makefile(FILE *f, int32_t flags); +JANET_API JanetFile *janet_makejfile(FILE *f, int32_t flags); +JANET_API FILE *janet_getfile(const Janet *argv, int32_t n, int32_t *flags); +JANET_API FILE *janet_dynfile(const char *name, FILE *def); +JANET_API JanetFile *janet_getjfile(const Janet *argv, int32_t n); +JANET_API JanetAbstract janet_checkfile(Janet j); +JANET_API FILE *janet_unwrapfile(Janet j, int32_t *flags); +JANET_API int janet_file_close(JanetFile *file); + +JANET_API int janet_cryptorand(uint8_t *out, size_t n); + +/* Marshal API */ +JANET_API void janet_marshal_size(JanetMarshalContext *ctx, size_t value); +JANET_API void janet_marshal_int(JanetMarshalContext *ctx, int32_t value); +JANET_API void janet_marshal_int64(JanetMarshalContext *ctx, int64_t value); +JANET_API void janet_marshal_ptr(JanetMarshalContext *ctx, const void *value); +JANET_API void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value); +JANET_API void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, size_t len); +JANET_API void janet_marshal_janet(JanetMarshalContext *ctx, Janet x); +JANET_API void janet_marshal_abstract(JanetMarshalContext *ctx, JanetAbstract abstract); + +JANET_API void janet_unmarshal_ensure(JanetMarshalContext *ctx, size_t size); +JANET_API size_t janet_unmarshal_size(JanetMarshalContext *ctx); +JANET_API int32_t janet_unmarshal_int(JanetMarshalContext *ctx); +JANET_API int64_t janet_unmarshal_int64(JanetMarshalContext *ctx); +JANET_API void *janet_unmarshal_ptr(JanetMarshalContext *ctx); +JANET_API uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx); +JANET_API void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, size_t len); +JANET_API Janet janet_unmarshal_janet(JanetMarshalContext *ctx); +JANET_API JanetAbstract janet_unmarshal_abstract(JanetMarshalContext *ctx, size_t size); +JANET_API JanetAbstract janet_unmarshal_abstract_threaded(JanetMarshalContext *ctx, size_t size); +JANET_API void janet_unmarshal_abstract_reuse(JanetMarshalContext *ctx, void *p); + +JANET_API void janet_register_abstract_type(const JanetAbstractType *at); +JANET_API const JanetAbstractType *janet_get_abstract_type(Janet key); + +#ifdef JANET_PEG + +extern JANET_API const JanetAbstractType janet_peg_type; + +/* opcodes for peg vm */ +typedef enum { + RULE_LITERAL, /* [len, bytes...] */ + RULE_NCHAR, /* [n] */ + RULE_NOTNCHAR, /* [n] */ + RULE_RANGE, /* [lo | hi << 16 (1 word)] */ + RULE_SET, /* [bitmap (8 words)] */ + RULE_LOOK, /* [offset, rule] */ + RULE_CHOICE, /* [len, rules...] */ + RULE_SEQUENCE, /* [len, rules...] */ + RULE_IF, /* [rule_a, rule_b (b if a)] */ + RULE_IFNOT, /* [rule_a, rule_b (b if not a)] */ + RULE_NOT, /* [rule] */ + RULE_BETWEEN, /* [lo, hi, rule] */ + RULE_GETTAG, /* [searchtag, tag] */ + RULE_CAPTURE, /* [rule, tag] */ + RULE_POSITION, /* [tag] */ + RULE_ARGUMENT, /* [argument-index, tag] */ + RULE_CONSTANT, /* [constant, tag] */ + RULE_ACCUMULATE, /* [rule, tag] */ + RULE_GROUP, /* [rule, tag] */ + RULE_REPLACE, /* [rule, constant, tag] */ + RULE_MATCHTIME, /* [rule, constant, tag] */ + RULE_ERROR, /* [rule] */ + RULE_DROP, /* [rule] */ + RULE_BACKMATCH, /* [tag] */ + RULE_TO, /* [rule] */ + RULE_THRU, /* [rule] */ + RULE_LENPREFIX, /* [rule_a, rule_b (repeat rule_b rule_a times)] */ + RULE_READINT, /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */ + RULE_LINE, /* [tag] */ + RULE_COLUMN, /* [tag] */ + RULE_UNREF, /* [rule, tag] */ + RULE_CAPTURE_NUM, /* [rule, tag] */ + RULE_SUB, /* [rule, rule] */ + RULE_SPLIT /* [rule, rule] */ +} JanetPegOpcod; + +typedef struct { + uint32_t *bytecode; + Janet *constants; + size_t bytecode_len; + uint32_t num_constants; + int has_backref; +} JanetPeg; + +#endif + +#ifdef JANET_INT_TYPES + +extern JANET_API const JanetAbstractType janet_s64_type; +extern JANET_API const JanetAbstractType janet_u64_type; + +typedef enum { + JANET_INT_NONE, + JANET_INT_S64, + JANET_INT_U64 +} JanetIntType; + +JANET_API JanetIntType janet_is_int(Janet x); +JANET_API Janet janet_wrap_s64(int64_t x); +JANET_API Janet janet_wrap_u64(uint64_t x); +JANET_API int64_t janet_unwrap_s64(Janet x); +JANET_API uint64_t janet_unwrap_u64(Janet x); +JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out); +JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out); + +#endif + +/* Custom allocator support */ +JANET_API void *(janet_malloc)(size_t); +JANET_API void *(janet_realloc)(void *, size_t); +JANET_API void *(janet_calloc)(size_t, size_t); +JANET_API void (janet_free)(void *); +#ifndef janet_malloc +#define janet_malloc(X) malloc((X)) +#endif +#ifndef janet_realloc +#define janet_realloc(X, Y) realloc((X), (Y)) +#endif +#ifndef janet_calloc +#define janet_calloc(X, Y) calloc((X), (Y)) +#endif +#ifndef janet_free +#define janet_free(X) free((X)) +#endif + +/***** END SECTION MAIN *****/ + +/* Re-enable popped variable length array warnings */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* JANET_H_defined */ diff --git a/build/justfile b/build/justfile new file mode 100644 index 0000000..0b9e7de --- /dev/null +++ b/build/justfile @@ -0,0 +1,15 @@ +build: + # compile the janet into an image + # janet -c src/ludus.janet build/ludus.jimage + # the complex emscripten invocation + # note we have the stack size set to 1024*1024 (1 MB) + emcc \ + -o out.mjs \ + janet.c driver.cpp \ + --embed-file ludus.jimage \ + -lembind \ + -s "EXPORTED_FUNCTIONS=['_main']" \ + -s EXPORT_ES6 \ + -s ALLOW_MEMORY_GROWTH=1 \ + -s STACK_SIZE=1048576 \ + -s MODULARIZE diff --git a/build/ludus.jimage b/build/ludus.jimage new file mode 100644 index 0000000000000000000000000000000000000000..4edde6c71f26634f0918b7edfcd316de42bde4b5 GIT binary patch literal 433427 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 literal 0 HcmV?d00001 diff --git a/build/ludus.mjs b/build/ludus.mjs new file mode 100644 index 0000000..d8f8163 --- /dev/null +++ b/build/ludus.mjs @@ -0,0 +1,8 @@ +import init from "./out.mjs" + +const mod = await init() + +export function run (source) { + const result = mod.ludus(source).value + return JSON.parse(result) +} diff --git a/build/out.mjs b/build/out.mjs new file mode 100644 index 0000000..6a1c944 --- /dev/null +++ b/build/out.mjs @@ -0,0 +1,7170 @@ + +var Module = (() => { + var _scriptName = import.meta.url; + + return ( +async function(moduleArg = {}) { + var moduleRtn; + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = Object.assign({}, moduleArg); + +// Set up the promise that indicates the Module is initialized +var readyPromiseResolve, readyPromiseReject; +var readyPromise = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); +["_memory","___indirect_function_table","___original_main","___emscripten_embedded_file_data","_main","onRuntimeInitialized"].forEach((prop) => { + if (!Object.getOwnPropertyDescriptor(readyPromise, prop)) { + Object.defineProperty(readyPromise, prop, { + get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'), + set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'), + }); + } +}); + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (Module['ENVIRONMENT']) { + throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'); +} + +if (ENVIRONMENT_IS_NODE) { + // `require()` is no-op in an ESM module, use `createRequire()` to construct + // the require()` function. This is only necessary for multi-environment + // builds, `-sENVIRONMENT=node` emits a static import declaration instead. + // TODO: Swap all `require()`'s with `import()`'s? + const { createRequire } = await import('module'); + /** @suppress{duplicate} */ + var require = createRequire(import.meta.url); + +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary; + +if (ENVIRONMENT_IS_NODE) { + if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + var nodeVersion = process.versions.node; + var numericVersion = nodeVersion.split('.').slice(0, 3); + numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1); + var minVersion = 160000; + if (numericVersion < 160000) { + throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')'); + } + + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require('fs'); + var nodePath = require('path'); + + // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url, + // since there's no way getting the current absolute path of the module when + // support for that is not available. + scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url)); // includes trailing slash + +// include: node_shell_read.js +read_ = (filename, binary) => { + // We need to re-wrap `file://` strings to URLs. Normalizing isn't + // necessary in that case, the path should already be absolute. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return fs.readFileSync(filename, binary ? undefined : 'utf8'); +}; + +readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; +}; + +readAsync = (filename, onload, onerror, binary = true) => { + // See the comment in the `read_` function. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => { + if (err) onerror(err); + else onload(binary ? data.buffer : data); + }); +}; +// end include: node_shell_read.js + if (!Module['thisProgram'] && process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, '/'); + } + + arguments_ = process.argv.slice(2); + + // MODULARIZE will export the module in the proper place outside, we don't need to export here + + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; + +} else +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE, this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptName) { + scriptDirectory = _scriptName; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.startsWith('blob:')) { + scriptDirectory = ''; + } else { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/')+1); + } + + if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + { +// include: web_or_worker_shell_read.js +read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.error.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('asm', 'wasmExports'); +legacyModuleProp('read', 'read_'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; +var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js'; +var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js'; +var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js'; +var OPFS = 'OPFS is no longer included by default; build with -lopfs.js'; + +var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; + +assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.'); + +// end include: shell.js + +// include: preamble.js +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); + +if (typeof WebAssembly != 'object') { + err('no native wasm support detected'); +} + +// include: base64Utils.js +// Converts a string of base64 into a byte array (Uint8Array). +function intArrayFromBase64(s) { + if (typeof ENVIRONMENT_IS_NODE != 'undefined' && ENVIRONMENT_IS_NODE) { + var buf = Buffer.from(s, 'base64'); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.length); + } + + var decoded = atob(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0 ; i < decoded.length ; ++i) { + bytes[i] = decoded.charCodeAt(i); + } + return bytes; +} + +// If filename is a base64 data URI, parses and returns data (Buffer on node, +// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined. +function tryParseAsDataURI(filename) { + if (!isDataURI(filename)) { + return; + } + + return intArrayFromBase64(filename.slice(dataURIPrefix.length)); +} +// end include: base64Utils.js +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we +// don't define it at all in release modes. This matches the behaviour of +// MINIMAL_RUNTIME. +// TODO(sbc): Make this the default even without STRICT enabled. +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// Memory management + +var HEAP, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +// include: runtime_shared.js +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); +} +// end include: runtime_shared.js +assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time') + +assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, + 'JS engine does not provide full typed array support'); + +// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_stack_check.js +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // If the stack ends at address zero we write our cookies 4 bytes into the + // stack. This prevents interference with SAFE_HEAP and ASAN which also + // monitor writes to address zero. + if (max == 0) { + max += 4; + } + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAPU32[((max)>>2)] = 0x02135467; + HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAPU32[((0)>>2)] = 1668509029; +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + // See writeStackCookie(). + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) { + abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`); + } + // Also test the global address 0 for integrity. + if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) { + abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); + } +} +// end include: runtime_stack_check.js +// include: runtime_assertions.js +// Endianness check +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +function preRun() { + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + + checkStackCookie(); + + +if (!Module['noFSInit'] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + + callRuntimeCallbacks(__ATMAIN__); +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + Module['monitorRunDependencies']?.(runDependencies); + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(() => { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err('still waiting on run dependencies:'); + } + err(`dependency: ${dep}`); + } + if (shown) { + err('(end of list)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + Module['monitorRunDependencies']?.(runDependencies); + + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + Module['onAbort']?.(what); + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + readyPromiseReject(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// include: URIUtils.js +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +/** + * Indicates whether filename is a base64 data URI. + * @noinline + */ +var isDataURI = (filename) => filename.startsWith(dataURIPrefix); + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ +var isFileURI = (filename) => filename.startsWith('file://'); +// end include: URIUtils.js +function createExportWrapper(name, nargs) { + return (...args) => { + assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`); + var f = wasmExports[name]; + assert(f, `exported native function \`${name}\` not found`); + // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled. + assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`); + return f(...args); + }; +} + +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +function findWasmBinary() { + if (Module['locateFile']) { + var f = 'out.wasm'; + if (!isDataURI(f)) { + return locateFile(f); + } + return f; + } + // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. + return new URL('out.wasm', import.meta.url).href; +} + +var wasmBinaryFile; + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw 'both async and sync fetching of the wasm failed'; +} + +function getBinaryPromise(binaryFile) { + // If we don't have the binary yet, try to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary + && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + && !isFileURI(binaryFile) + ) { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + if (!response['ok']) { + throw `failed to load wasm binary file at '${binaryFile}'`; + } + return response['arrayBuffer'](); + }).catch(() => getBinarySync(binaryFile)); + } + else if (readAsync) { + // fetch is not available or url is file => try XHR (readAsync uses XHR internally) + return new Promise((resolve, reject) => { + readAsync(binaryFile, (response) => resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))), reject) + }); + } + } + + // Otherwise, getBinarySync should be able to get it synchronously + return Promise.resolve().then(() => getBinarySync(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then((binary) => { + return WebAssembly.instantiate(binary, imports); + }).then(receiver, (reason) => { + err(`failed to asynchronously prepare wasm: ${reason}`); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`); + } + abort(reason); + }); +} + +function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(binaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(binaryFile) && + // Avoid instantiateStreaming() on Node.js environment for now, as while + // Node.js v18.1.0 implements it, it does not have a full fetch() + // implementation yet. + // + // Reference: + // https://github.com/emscripten-core/emscripten/pull/16917 + !ENVIRONMENT_IS_NODE && + typeof fetch == 'function') { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, imports); + + return result.then( + callback, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } + return instantiateArrayBuffer(binaryFile, imports, callback); +} + +function getWasmImports() { + // prepare imports + return { + 'env': wasmImports, + 'wasi_snapshot_preview1': wasmImports, + } +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + var info = getWasmImports(); + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + wasmExports = instance.exports; + + + + wasmMemory = wasmExports['memory']; + + assert(wasmMemory, 'memory not found in wasm exports'); + updateMemoryViews(); + + wasmTable = wasmExports['__indirect_function_table']; + + assert(wasmTable, 'table not found in wasm exports'); + + addOnInit(wasmExports['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module['instantiateWasm']) { + try { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + err(`Module.instantiateWasm callback failed with error: ${e}`); + // If instantiation fails, reject the module ready promise. + readyPromiseReject(e); + } + } + + if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary(); + + // If instantiation fails, reject the module ready promise. + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// include: runtime_debug.js +function legacyModuleProp(prop, newName, incoming=true) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get() { + let extra = incoming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : ''; + abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra); + + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`); + } +} + +// forcing the filesystem exports a few things by default +function isExportedByForceFilesystem(name) { + return name === 'FS_createPath' || + name === 'FS_createDataFile' || + name === 'FS_createPreloadedFile' || + name === 'FS_unlink' || + name === 'addRunDependency' || + // The old FS has some functionality that WasmFS lacks. + name === 'FS_createLazyFile' || + name === 'FS_createDevice' || + name === 'removeRunDependency'; +} + +function missingGlobal(sym, msg) { + if (typeof globalThis != 'undefined') { + Object.defineProperty(globalThis, sym, { + configurable: true, + get() { + warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`); + return undefined; + } + }); + } +} + +missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer'); +missingGlobal('asm', 'Please use wasmExports instead'); + +function missingLibrarySymbol(sym) { + if (typeof globalThis != 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get() { + // Can't `abort()` here because it would break code that does runtime + // checks. e.g. `if (typeof SDL === 'undefined')`. + var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`; + // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in + // library.js, which means $name for a JS name with no prefix, or name + // for a JS name like _name. + var librarySymbol = sym; + if (!librarySymbol.startsWith('_')) { + librarySymbol = '$' + sym; + } + msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + warnOnce(msg); + return undefined; + } + }); + } + // Any symbol that is not included from the JS library is also (by definition) + // not exported on the Module object. + unexportedRuntimeSymbol(sym); +} + +function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get() { + var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + abort(msg); + } + }); + } +} + +// Used by XXXXX_DEBUG settings to output debug messages. +function dbg(...args) { + // TODO(sbc): Make this configurable somehow. Its not always convenient for + // logging to show up as warnings. + console.warn(...args); +} +// end include: runtime_debug.js +// === Body === +// end include: preamble.js + + + /** @constructor */ + function ExitStatus(status) { + this.name = 'ExitStatus'; + this.message = `Program terminated with exit(${status})`; + this.status = status; + } + + var callRuntimeCallbacks = (callbacks) => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } + }; + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': return HEAP8[ptr]; + case 'i8': return HEAP8[ptr]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': abort('to do getValue(i64) use WASM_BIGINT'); + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + case '*': return HEAPU32[((ptr)>>2)]; + default: abort(`invalid type for getValue: ${type}`); + } + } + + var noExitRuntime = Module['noExitRuntime'] || true; + + var ptrToString = (ptr) => { + assert(typeof ptr === 'number'); + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + ptr >>>= 0; + return '0x' + ptr.toString(16).padStart(8, '0'); + }; + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': HEAP8[ptr] = value; break; + case 'i8': HEAP8[ptr] = value; break; + case 'i16': HEAP16[((ptr)>>1)] = value; break; + case 'i32': HEAP32[((ptr)>>2)] = value; break; + case 'i64': abort('to do setValue(i64) use WASM_BIGINT'); + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + case '*': HEAPU32[((ptr)>>2)] = value; break; + default: abort(`invalid type for setValue: ${type}`); + } + } + + var stackRestore = (val) => __emscripten_stack_restore(val); + + var stackSave = () => _emscripten_stack_get_current(); + + var warnOnce = (text) => { + warnOnce.shown ||= {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text; + err(text); + } + }; + + var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + + /** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ''; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + return str; + }; + + /** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ + var UTF8ToString = (ptr, maxBytesToRead) => { + assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`); + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + }; + var ___assert_fail = (condition, filename, line, func) => { + abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + }; + + var PATH = { + isAbs:(path) => path.charAt(0) === '/', + splitPath:(filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray:(parts, allowAboveRoot) => { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + }, + normalize:(path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter((p) => !!p), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + }, + dirname:(path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename:(path) => { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + }, + join:(...paths) => PATH.normalize(paths.join('/')), + join2:(l, r) => PATH.normalize(l + '/' + r), + }; + + var initRandomFill = () => { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + // for modern web browsers + return (view) => crypto.getRandomValues(view); + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + var randomFillSync = crypto_module['randomFillSync']; + if (randomFillSync) { + // nodejs with LTS crypto support + return (view) => crypto_module['randomFillSync'](view); + } + // very old nodejs with the original crypto API + var randomBytes = crypto_module['randomBytes']; + return (view) => ( + view.set(randomBytes(view.byteLength)), + // Return the original view to match modern native implementations. + view + ); + } catch (e) { + // nodejs doesn't have crypto support + } + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + abort('no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };'); + }; + var randomFill = (view) => { + // Lazily init on the first invocation. + return (randomFill = initRandomFill())(view); + }; + + + + var PATH_FS = { + resolve:(...args) => { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? args[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path != 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter((p) => !!p), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + }, + relative:(from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }, + }; + + + + var FS_stdin_getChar_buffer = []; + + var lengthBytesUTF8 = (str) => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); // possibly a lead surrogate + if (c <= 0x7F) { + len++; + } else if (c <= 0x7FF) { + len += 2; + } else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; ++i; + } else { + len += 3; + } + } + return len; + }; + + var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`); + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'); + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; + }; + /** @type {function(string, boolean=, number=)} */ + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + var FS_stdin_getChar = () => { + if (!FS_stdin_getChar_buffer.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + // For some reason we must suppress a closure warning here, even though + // fd definitely exists on process.stdin, and is even the proper way to + // get the fd of stdin, + // https://github.com/nodejs/help/issues/2136#issuecomment-523649904 + // This started to happen after moving this logic out of library_tty.js, + // so it is related to the surrounding code in some unclear manner. + /** @suppress {missingProperties} */ + var fd = process.stdin.fd; + + try { + bytesRead = fs.readSync(fd, buf, 0, BUFSIZE); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an + // exception, but on other OSes, reading EOF returns 0. Uniformize + // behavior by treating the EOF exception to return 0. + if (e.toString().includes('EOF')) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else + {} + if (!result) { + return null; + } + FS_stdin_getChar_buffer = intArrayFromString(result, true); + } + return FS_stdin_getChar_buffer.shift(); + }; + var TTY = { + ttys:[], + init() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process.stdin.setEncoding('utf8'); + // } + }, + shutdown() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process.stdin.pause(); + // } + }, + register(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + }, + stream_ops:{ + open(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, + close(stream) { + // flush any pending line data + stream.tty.ops.fsync(stream.tty); + }, + fsync(stream) { + stream.tty.ops.fsync(stream.tty); + }, + read(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }, + default_tty_ops:{ + get_char(tty) { + return FS_stdin_getChar(); + }, + put_char(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + }, + fsync(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + ioctl_tcgets(tty) { + // typical setting + return { + c_iflag: 25856, + c_oflag: 5, + c_cflag: 191, + c_lflag: 35387, + c_cc: [ + 0x03, 0x1c, 0x7f, 0x15, 0x04, 0x00, 0x01, 0x00, 0x11, 0x13, 0x1a, 0x00, + 0x12, 0x0f, 0x17, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + ] + }; + }, + ioctl_tcsets(tty, optional_actions, data) { + // currently just ignore + return 0; + }, + ioctl_tiocgwinsz(tty) { + return [24, 80]; + }, + }, + default_tty1_ops:{ + put_char(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + }, + }; + + + var zeroMemory = (address, size) => { + HEAPU8.fill(0, address, address + size); + return address; + }; + + var alignMemory = (size, alignment) => { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + }; + var mmapAlloc = (size) => { + abort('internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported'); + }; + var MEMFS = { + ops_table:null, + mount(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + }, + createNode(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + MEMFS.ops_table ||= { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + }; + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + }, + getFileDataAsTypedArray(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + }, + expandFileStorage(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + }, + resizeFileStorage(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + }, + node_ops:{ + getattr(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + }, + setattr(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, + lookup(parent, name) { + throw FS.genericErrors[44]; + }, + mknod(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }, + rename(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + }, + unlink(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + rmdir(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + readdir(node) { + var entries = ['.', '..']; + for (var key of Object.keys(node.contents)) { + entries.push(key); + } + return entries; + }, + symlink(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + }, + readlink(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }, + }, + stream_ops:{ + read(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + }, + write(stream, buffer, offset, length, position, canOwn) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + assert(position === 0, 'canOwn must imply no weird position inside the file'); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + }, + allocate(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + }, + mmap(stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents.buffer === HEAP8.buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the + // buffer we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr, allocated }; + }, + msync(stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }, + }, + }; + + /** @param {boolean=} noRunDep */ + var asyncLoad = (url, onload, onerror, noRunDep) => { + var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : ''; + readAsync(url, (arrayBuffer) => { + assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, (event) => { + if (onerror) { + onerror(); + } else { + throw `Loading data file "${url}" failed.`; + } + }); + if (dep) addRunDependency(dep); + }; + + + var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => { + FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn); + }; + + var preloadPlugins = Module['preloadPlugins'] || []; + var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => { + // Ensure plugins are ready. + if (typeof Browser != 'undefined') Browser.init(); + + var handled = false; + preloadPlugins.forEach((plugin) => { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; + }; + var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency(`cp ${fullname}`); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + preFinish?.(); + if (!dontCreateFile) { + FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + onload?.(); + removeRunDependency(dep); + } + if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { + onerror?.(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, processData, onerror); + } else { + processData(url); + } + }; + + var FS_modeStringToFlags = (str) => { + var flagModes = { + 'r': 0, + 'r+': 2, + 'w': 512 | 64 | 1, + 'w+': 512 | 64 | 2, + 'a': 1024 | 64 | 1, + 'a+': 1024 | 64 | 2, + }; + var flags = flagModes[str]; + if (typeof flags == 'undefined') { + throw new Error(`Unknown file open mode: ${str}`); + } + return flags; + }; + + var FS_getMode = (canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + }; + + + + + var ERRNO_MESSAGES = { + 0:"Success", + 1:"Arg list too long", + 2:"Permission denied", + 3:"Address already in use", + 4:"Address not available", + 5:"Address family not supported by protocol family", + 6:"No more processes", + 7:"Socket already connected", + 8:"Bad file number", + 9:"Trying to read unreadable message", + 10:"Mount device busy", + 11:"Operation canceled", + 12:"No children", + 13:"Connection aborted", + 14:"Connection refused", + 15:"Connection reset by peer", + 16:"File locking deadlock error", + 17:"Destination address required", + 18:"Math arg out of domain of func", + 19:"Quota exceeded", + 20:"File exists", + 21:"Bad address", + 22:"File too large", + 23:"Host is unreachable", + 24:"Identifier removed", + 25:"Illegal byte sequence", + 26:"Connection already in progress", + 27:"Interrupted system call", + 28:"Invalid argument", + 29:"I/O error", + 30:"Socket is already connected", + 31:"Is a directory", + 32:"Too many symbolic links", + 33:"Too many open files", + 34:"Too many links", + 35:"Message too long", + 36:"Multihop attempted", + 37:"File or path name too long", + 38:"Network interface is not configured", + 39:"Connection reset by network", + 40:"Network is unreachable", + 41:"Too many open files in system", + 42:"No buffer space available", + 43:"No such device", + 44:"No such file or directory", + 45:"Exec format error", + 46:"No record locks available", + 47:"The link has been severed", + 48:"Not enough core", + 49:"No message of desired type", + 50:"Protocol not available", + 51:"No space left on device", + 52:"Function not implemented", + 53:"Socket is not connected", + 54:"Not a directory", + 55:"Directory not empty", + 56:"State not recoverable", + 57:"Socket operation on non-socket", + 59:"Not a typewriter", + 60:"No such device or address", + 61:"Value too large for defined data type", + 62:"Previous owner died", + 63:"Not super-user", + 64:"Broken pipe", + 65:"Protocol error", + 66:"Unknown protocol", + 67:"Protocol wrong type for socket", + 68:"Math result not representable", + 69:"Read only file system", + 70:"Illegal seek", + 71:"No such process", + 72:"Stale file handle", + 73:"Connection timed out", + 74:"Text file busy", + 75:"Cross-device link", + 100:"Device not a stream", + 101:"Bad font file fmt", + 102:"Invalid slot", + 103:"Invalid request code", + 104:"No anode", + 105:"Block device required", + 106:"Channel number out of range", + 107:"Level 3 halted", + 108:"Level 3 reset", + 109:"Link number out of range", + 110:"Protocol driver not attached", + 111:"No CSI structure available", + 112:"Level 2 halted", + 113:"Invalid exchange", + 114:"Invalid request descriptor", + 115:"Exchange full", + 116:"No data (for no delay io)", + 117:"Timer expired", + 118:"Out of streams resources", + 119:"Machine is not on the network", + 120:"Package not installed", + 121:"The object is remote", + 122:"Advertise error", + 123:"Srmount error", + 124:"Communication error on send", + 125:"Cross mount point (not really error)", + 126:"Given log. name not unique", + 127:"f.d. invalid for this operation", + 128:"Remote address changed", + 129:"Can access a needed shared lib", + 130:"Accessing a corrupted shared lib", + 131:".lib section in a.out corrupted", + 132:"Attempting to link in too many libs", + 133:"Attempting to exec a shared library", + 135:"Streams pipe error", + 136:"Too many users", + 137:"Socket type not supported", + 138:"Not supported", + 139:"Protocol family not supported", + 140:"Can't send after socket shutdown", + 141:"Too many references", + 142:"Host is down", + 148:"No medium (in tape drive)", + 156:"Level 2 not synchronized", + }; + + var ERRNO_CODES = { + 'EPERM': 63, + 'ENOENT': 44, + 'ESRCH': 71, + 'EINTR': 27, + 'EIO': 29, + 'ENXIO': 60, + 'E2BIG': 1, + 'ENOEXEC': 45, + 'EBADF': 8, + 'ECHILD': 12, + 'EAGAIN': 6, + 'EWOULDBLOCK': 6, + 'ENOMEM': 48, + 'EACCES': 2, + 'EFAULT': 21, + 'ENOTBLK': 105, + 'EBUSY': 10, + 'EEXIST': 20, + 'EXDEV': 75, + 'ENODEV': 43, + 'ENOTDIR': 54, + 'EISDIR': 31, + 'EINVAL': 28, + 'ENFILE': 41, + 'EMFILE': 33, + 'ENOTTY': 59, + 'ETXTBSY': 74, + 'EFBIG': 22, + 'ENOSPC': 51, + 'ESPIPE': 70, + 'EROFS': 69, + 'EMLINK': 34, + 'EPIPE': 64, + 'EDOM': 18, + 'ERANGE': 68, + 'ENOMSG': 49, + 'EIDRM': 24, + 'ECHRNG': 106, + 'EL2NSYNC': 156, + 'EL3HLT': 107, + 'EL3RST': 108, + 'ELNRNG': 109, + 'EUNATCH': 110, + 'ENOCSI': 111, + 'EL2HLT': 112, + 'EDEADLK': 16, + 'ENOLCK': 46, + 'EBADE': 113, + 'EBADR': 114, + 'EXFULL': 115, + 'ENOANO': 104, + 'EBADRQC': 103, + 'EBADSLT': 102, + 'EDEADLOCK': 16, + 'EBFONT': 101, + 'ENOSTR': 100, + 'ENODATA': 116, + 'ETIME': 117, + 'ENOSR': 118, + 'ENONET': 119, + 'ENOPKG': 120, + 'EREMOTE': 121, + 'ENOLINK': 47, + 'EADV': 122, + 'ESRMNT': 123, + 'ECOMM': 124, + 'EPROTO': 65, + 'EMULTIHOP': 36, + 'EDOTDOT': 125, + 'EBADMSG': 9, + 'ENOTUNIQ': 126, + 'EBADFD': 127, + 'EREMCHG': 128, + 'ELIBACC': 129, + 'ELIBBAD': 130, + 'ELIBSCN': 131, + 'ELIBMAX': 132, + 'ELIBEXEC': 133, + 'ENOSYS': 52, + 'ENOTEMPTY': 55, + 'ENAMETOOLONG': 37, + 'ELOOP': 32, + 'EOPNOTSUPP': 138, + 'EPFNOSUPPORT': 139, + 'ECONNRESET': 15, + 'ENOBUFS': 42, + 'EAFNOSUPPORT': 5, + 'EPROTOTYPE': 67, + 'ENOTSOCK': 57, + 'ENOPROTOOPT': 50, + 'ESHUTDOWN': 140, + 'ECONNREFUSED': 14, + 'EADDRINUSE': 3, + 'ECONNABORTED': 13, + 'ENETUNREACH': 40, + 'ENETDOWN': 38, + 'ETIMEDOUT': 73, + 'EHOSTDOWN': 142, + 'EHOSTUNREACH': 23, + 'EINPROGRESS': 26, + 'EALREADY': 7, + 'EDESTADDRREQ': 17, + 'EMSGSIZE': 35, + 'EPROTONOSUPPORT': 66, + 'ESOCKTNOSUPPORT': 137, + 'EADDRNOTAVAIL': 4, + 'ENETRESET': 39, + 'EISCONN': 30, + 'ENOTCONN': 53, + 'ETOOMANYREFS': 141, + 'EUSERS': 136, + 'EDQUOT': 19, + 'ESTALE': 72, + 'ENOTSUP': 138, + 'ENOMEDIUM': 148, + 'EILSEQ': 25, + 'EOVERFLOW': 61, + 'ECANCELED': 11, + 'ENOTRECOVERABLE': 56, + 'EOWNERDEAD': 62, + 'ESTRPIPE': 135, + }; + var FS = { + root:null, + mounts:[], + devices:{ + }, + streams:[], + nextInode:1, + nameTable:null, + currentPath:"/", + initialized:false, + ignorePermissions:true, + ErrnoError:class extends Error { + // We set the `name` property to be able to identify `FS.ErrnoError` + // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway. + // - when using PROXYFS, an error can come from an underlying FS + // as different FS objects have their own FS.ErrnoError each, + // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs. + // we'll use the reliable test `err.name == "ErrnoError"` instead + constructor(errno) { + super(ERRNO_MESSAGES[errno]); + // TODO(sbc): Use the inline member declaration syntax once we + // support it in acorn and closure. + this.name = 'ErrnoError'; + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + } + }, + genericErrors:{ + }, + filesystems:null, + syncFSRequests:0, + FSStream:class { + constructor() { + // TODO(https://github.com/emscripten-core/emscripten/issues/21414): + // Use inline field declarations. + this.shared = {}; + } + get object() { + return this.node; + } + set object(val) { + this.node = val; + } + get isRead() { + return (this.flags & 2097155) !== 1; + } + get isWrite() { + return (this.flags & 2097155) !== 0; + } + get isAppend() { + return (this.flags & 1024); + } + get flags() { + return this.shared.flags; + } + set flags(val) { + this.shared.flags = val; + } + get position() { + return this.shared.position; + } + set position(val) { + this.shared.position = val; + } + }, + FSNode:class { + constructor(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + this.readMode = 292/*292*/ | 73/*73*/; + this.writeMode = 146/*146*/; + } + get read() { + return (this.mode & this.readMode) === this.readMode; + } + set read(val) { + val ? this.mode |= this.readMode : this.mode &= ~this.readMode; + } + get write() { + return (this.mode & this.writeMode) === this.writeMode; + } + set write(val) { + val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode; + } + get isFolder() { + return FS.isDir(this.mode); + } + get isDevice() { + return FS.isChrdev(this.mode); + } + }, + lookupPath(path, opts = {}) { + path = PATH_FS.resolve(path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts) + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the absolute path + var parts = path.split('/').filter((p) => !!p); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + }, + getPath(node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? `${mount}/${path}` : mount + path; + } + path = path ? `${node.name}/${path}` : node.name; + node = node.parent; + } + }, + hashName(parentid, name) { + var hash = 0; + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + }, + hashAddNode(node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + }, + hashRemoveNode(node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + }, + lookupNode(parent, name) { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + }, + createNode(parent, name, mode, rdev) { + assert(typeof parent == 'object') + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + }, + destroyNode(node) { + FS.hashRemoveNode(node); + }, + isRoot(node) { + return node === node.parent; + }, + isMountpoint(node) { + return !!node.mounted; + }, + isFile(mode) { + return (mode & 61440) === 32768; + }, + isDir(mode) { + return (mode & 61440) === 16384; + }, + isLink(mode) { + return (mode & 61440) === 40960; + }, + isChrdev(mode) { + return (mode & 61440) === 8192; + }, + isBlkdev(mode) { + return (mode & 61440) === 24576; + }, + isFIFO(mode) { + return (mode & 61440) === 4096; + }, + isSocket(mode) { + return (mode & 49152) === 49152; + }, + flagsToPermissionString(flag) { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + }, + nodePermissions(node, perms) { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.includes('r') && !(node.mode & 292)) { + return 2; + } else if (perms.includes('w') && !(node.mode & 146)) { + return 2; + } else if (perms.includes('x') && !(node.mode & 73)) { + return 2; + } + return 0; + }, + mayLookup(dir) { + if (!FS.isDir(dir.mode)) return 54; + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + }, + mayCreate(dir, name) { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + }, + mayDelete(dir, name, isdir) { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + }, + mayOpen(node, flags) { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, + MAX_OPEN_FDS:4096, + nextfd() { + for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, + getStreamChecked(fd) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + return stream; + }, + getStream:(fd) => FS.streams[fd], + createStream(stream, fd = -1) { + + // clone it, so we can return an instance of FSStream + stream = Object.assign(new FS.FSStream(), stream); + if (fd == -1) { + fd = FS.nextfd(); + } + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, + closeStream(fd) { + FS.streams[fd] = null; + }, + dupStream(origStream, fd = -1) { + var stream = FS.createStream(origStream, fd); + stream.stream_ops?.dup?.(stream); + return stream; + }, + chrdev_stream_ops:{ + open(stream) { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + stream.stream_ops.open?.(stream); + }, + llseek() { + throw new FS.ErrnoError(70); + }, + }, + major:(dev) => ((dev) >> 8), + minor:(dev) => ((dev) & 0xff), + makedev:(ma, mi) => ((ma) << 8 | (mi)), + registerDevice(dev, ops) { + FS.devices[dev] = { stream_ops: ops }; + }, + getDevice:(dev) => FS.devices[dev], + getMounts(mount) { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push(...m.mounts); + } + + return mounts; + }, + syncfs(populate, callback) { + if (typeof populate == 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount(type, opts, mountpoint) { + if (typeof type == 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + throw type; + } + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type, + opts, + mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + }, + unmount(mountpoint) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + }, + lookup(parent, name) { + return parent.node_ops.lookup(parent, name); + }, + mknod(path, mode, dev) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + }, + create(path, mode) { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir(path, mode) { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, + mkdirTree(path, mode) { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + }, + mkdev(path, mode, dev) { + if (typeof dev == 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, + symlink(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, + rename(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existent directories percolate up + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + }, + rmdir(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + }, + readdir(path) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + }, + unlink(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + }, + readlink(path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + }, + stat(path, dontFollow) { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + }, + lstat(path) { + return FS.stat(path, true); + }, + chmod(path, mode, dontFollow) { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + }, + lchmod(path, mode) { + FS.chmod(path, mode, true); + }, + fchmod(fd, mode) { + var stream = FS.getStreamChecked(fd); + FS.chmod(stream.node, mode); + }, + chown(path, uid, gid, dontFollow) { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + }, + lchown(path, uid, gid) { + FS.chown(path, uid, gid, true); + }, + fchown(fd, uid, gid) { + var stream = FS.getStreamChecked(fd); + FS.chown(stream.node, uid, gid); + }, + truncate(path, len) { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + }, + ftruncate(fd, len) { + var stream = FS.getStreamChecked(fd); + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + }, + utime(path, atime, mtime) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + }, + open(path, flags, mode) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == 'string' ? FS_modeStringToFlags(flags) : flags; + if ((flags & 64)) { + mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode; + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node, + path: FS.getPath(node), // we want the absolute path to the node + flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + }, + close(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + }, + isClosed(stream) { + return stream.fd === null; + }, + llseek(stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + }, + read(stream, buffer, offset, length, position) { + assert(offset >= 0); + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write(stream, buffer, offset, length, position, canOwn) { + assert(offset >= 0); + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + }, + allocate(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + }, + mmap(stream, length, position, prot, flags) { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + }, + msync(stream, buffer, offset, length, mmapFlags) { + assert(offset >= 0); + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + }, + ioctl(stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + }, + readFile(path, opts = {}) { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error(`Invalid encoding type "${opts.encoding}"`); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + }, + writeFile(path, data, opts = {}) { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + }, + cwd:() => FS.currentPath, + chdir(path) { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + }, + createDefaultDirectories() { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + }, + createDefaultDevices() { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + // use a buffer to avoid overhead of individual crypto calls per byte + var randomBuffer = new Uint8Array(1024), randomLeft = 0; + var randomByte = () => { + if (randomLeft === 0) { + randomLeft = randomFill(randomBuffer).byteLength; + } + return randomBuffer[--randomLeft]; + }; + FS.createDevice('/dev', 'random', randomByte); + FS.createDevice('/dev', 'urandom', randomByte); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + }, + createSpecialDirectories() { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount() { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup(parent, name) { + var fd = +name; + var stream = FS.getStreamChecked(fd); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + }, + createStandardStreams() { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`); + assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`); + assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`); + }, + staticInit() { + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + }, + init(input, output, error) { + assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); + FS.init.initialized = true; + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + }, + quit() { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + _fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + }, + findObject(path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + }, + analyzePath(path, dontResolveLastLink) { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + }, + createPath(parent, path, canRead, canWrite) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + }, + createFile(parent, name, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS_getMode(canRead, canWrite); + return FS.create(path, mode); + }, + createDataFile(parent, name, data, canRead, canWrite, canOwn) { + var path = name; + if (parent) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS_getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + }, + createDevice(parent, name, input, output) { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS_getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open(stream) { + stream.seekable = false; + }, + close(stream) { + // flush any pending line data + if (output?.buffer?.length) { + output(10); + } + }, + read(stream, buffer, offset, length, pos /* ignored */) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write(stream, buffer, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + }, + forceLoadFile(obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + }, + createLazyFile(parent, name, url, canRead, canWrite) { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). + // Actual getting is abstracted away for eventual reuse. + class LazyUint8Array { + constructor() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + } + setDataGetter(getter) { + this.getter = getter; + } + cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } + return intArrayFromString(xhr.responseText || '', true); + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof lazyArray.chunks[chunkNum] == 'undefined') { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!'); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + } + get length() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + get chunkSize() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + + if (typeof XMLHttpRequest != 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = (...args) => { + FS.forceLoadFile(node); + return fn(...args); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + // use a custom read function + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position) + }; + // use a custom mmap function + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + }, + absolutePath() { + abort('FS.absolutePath has been removed; use PATH_FS.resolve instead'); + }, + createFolder() { + abort('FS.createFolder has been removed; use FS.mkdir instead'); + }, + createLink() { + abort('FS.createLink has been removed; use FS.symlink instead'); + }, + joinPath() { + abort('FS.joinPath has been removed; use PATH.join instead'); + }, + mmapAlloc() { + abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc'); + }, + standardizePath() { + abort('FS.standardizePath has been removed; use PATH.normalize instead'); + }, + }; + + var SYSCALLS = { + DEFAULT_POLLMASK:5, + calculateAt(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + }, + doStat(func, path, buf) { + var stat = func(path); + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(4))>>2)] = stat.mode; + HEAPU32[(((buf)+(8))>>2)] = stat.nlink; + HEAP32[(((buf)+(12))>>2)] = stat.uid; + HEAP32[(((buf)+(16))>>2)] = stat.gid; + HEAP32[(((buf)+(20))>>2)] = stat.rdev; + (tempI64 = [stat.size>>>0,(tempDouble = stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(24))>>2)] = tempI64[0],HEAP32[(((buf)+(28))>>2)] = tempI64[1]); + HEAP32[(((buf)+(32))>>2)] = 4096; + HEAP32[(((buf)+(36))>>2)] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + (tempI64 = [Math.floor(atime / 1000)>>>0,(tempDouble = Math.floor(atime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(48))>>2)] = (atime % 1000) * 1000; + (tempI64 = [Math.floor(mtime / 1000)>>>0,(tempDouble = Math.floor(mtime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(56))>>2)] = tempI64[0],HEAP32[(((buf)+(60))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(64))>>2)] = (mtime % 1000) * 1000; + (tempI64 = [Math.floor(ctime / 1000)>>>0,(tempDouble = Math.floor(ctime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(72))>>2)] = tempI64[0],HEAP32[(((buf)+(76))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(80))>>2)] = (ctime % 1000) * 1000; + (tempI64 = [stat.ino>>>0,(tempDouble = stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(88))>>2)] = tempI64[0],HEAP32[(((buf)+(92))>>2)] = tempI64[1]); + return 0; + }, + doMsync(addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + }, + getStreamFromFD(fd) { + var stream = FS.getStreamChecked(fd); + return stream; + }, + varargs:undefined, + getStr(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + }; + function ___syscall_chdir(path) { + try { + + path = SYSCALLS.getStr(path); + FS.chdir(path); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_chmod(path, mode) { + try { + + path = SYSCALLS.getStr(path); + FS.chmod(path, mode); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + /** @suppress {duplicate } */ + function syscallGetVarargI() { + assert(SYSCALLS.varargs != undefined); + // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number. + var ret = HEAP32[((+SYSCALLS.varargs)>>2)]; + SYSCALLS.varargs += 4; + return ret; + } + var syscallGetVarargP = syscallGetVarargI; + + + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = syscallGetVarargI(); + if (arg < 0) { + return -28; + } + while (FS.streams[arg]) { + arg++; + } + var newStream; + newStream = FS.dupStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = syscallGetVarargI(); + stream.flags |= arg; + return 0; + } + case 12: { + var arg = syscallGetVarargP(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 13: + case 14: + return 0; // Pretend that the locking is successful. + } + return -28; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_fstat64(fd, buf) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + var stringToUTF8 = (str, outPtr, maxBytesToWrite) => { + assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + }; + function ___syscall_getcwd(buf, size) { + try { + + if (size === 0) return -28; + var cwd = FS.cwd(); + var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1; + if (size < cwdLengthInBytes) return -68; + stringToUTF8(cwd, buf, size); + return cwdLengthInBytes; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + function ___syscall_getdents64(fd, dirp, count) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd) + stream.getdents ||= FS.readdir(stream.path); + + var struct_size = 280; + var pos = 0; + var off = FS.llseek(stream, 0, 1); + + var idx = Math.floor(off / struct_size); + + while (idx < stream.getdents.length && pos + struct_size <= count) { + var id; + var type; + var name = stream.getdents[idx]; + if (name === '.') { + id = stream.node.id; + type = 4; // DT_DIR + } + else if (name === '..') { + var lookup = FS.lookupPath(stream.path, { parent: true }); + id = lookup.node.id; + type = 4; // DT_DIR + } + else { + var child = FS.lookupNode(stream.node, name); + id = child.id; + type = FS.isChrdev(child.mode) ? 2 : // DT_CHR, character device. + FS.isDir(child.mode) ? 4 : // DT_DIR, directory. + FS.isLink(child.mode) ? 10 : // DT_LNK, symbolic link. + 8; // DT_REG, regular file. + } + assert(id); + (tempI64 = [id>>>0,(tempDouble = id,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[((dirp + pos)>>2)] = tempI64[0],HEAP32[(((dirp + pos)+(4))>>2)] = tempI64[1]); + (tempI64 = [(idx + 1) * struct_size>>>0,(tempDouble = (idx + 1) * struct_size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((dirp + pos)+(8))>>2)] = tempI64[0],HEAP32[(((dirp + pos)+(12))>>2)] = tempI64[1]); + HEAP16[(((dirp + pos)+(16))>>1)] = 280; + HEAP8[(dirp + pos)+(18)] = type; + stringToUTF8(name, dirp + pos + 19, 256); + pos += struct_size; + idx += 1; + } + FS.llseek(stream, idx * struct_size, 0); + return pos; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: { + if (!stream.tty) return -59; + return 0; + } + case 21505: { + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tcgets) { + var termios = stream.tty.ops.ioctl_tcgets(stream); + var argp = syscallGetVarargP(); + HEAP32[((argp)>>2)] = termios.c_iflag || 0; + HEAP32[(((argp)+(4))>>2)] = termios.c_oflag || 0; + HEAP32[(((argp)+(8))>>2)] = termios.c_cflag || 0; + HEAP32[(((argp)+(12))>>2)] = termios.c_lflag || 0; + for (var i = 0; i < 32; i++) { + HEAP8[(argp + i)+(17)] = termios.c_cc[i] || 0; + } + return 0; + } + return 0; + } + case 21510: + case 21511: + case 21512: { + if (!stream.tty) return -59; + return 0; // no-op, not actually adjusting terminal settings + } + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tcsets) { + var argp = syscallGetVarargP(); + var c_iflag = HEAP32[((argp)>>2)]; + var c_oflag = HEAP32[(((argp)+(4))>>2)]; + var c_cflag = HEAP32[(((argp)+(8))>>2)]; + var c_lflag = HEAP32[(((argp)+(12))>>2)]; + var c_cc = [] + for (var i = 0; i < 32; i++) { + c_cc.push(HEAP8[(argp + i)+(17)]); + } + return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc }); + } + return 0; // no-op, not actually adjusting terminal settings + } + case 21519: { + if (!stream.tty) return -59; + var argp = syscallGetVarargP(); + HEAP32[((argp)>>2)] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; // not supported + } + case 21531: { + var argp = syscallGetVarargP(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + // TODO: in theory we should write to the winsize struct that gets + // passed in, but for now musl doesn't read anything on it + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tiocgwinsz) { + var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty); + var argp = syscallGetVarargP(); + HEAP16[((argp)>>1)] = winsize[0]; + HEAP16[(((argp)+(2))>>1)] = winsize[1]; + } + return 0; + } + case 21524: { + // TODO: technically, this ioctl call should change the window size. + // but, since emscripten doesn't have any concept of a terminal window + // yet, we'll just silently throw it away as we do TIOCGWINSZ + if (!stream.tty) return -59; + return 0; + } + case 21515: { + if (!stream.tty) return -59; + return 0; + } + default: return -28; // not supported + } + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_lstat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_mkdirat(dirfd, path, mode) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + // remove a trailing slash, if one - /a/b/ has basename of '', but + // we want to create b in the context of this function + path = PATH.normalize(path); + if (path[path.length-1] === '/') path = path.substr(0, path.length-1); + FS.mkdir(path, mode, 0); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & (~6400); + assert(!flags, `unknown flags in __syscall_newfstatat: ${flags}`); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? syscallGetVarargI() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + + function ___syscall_readlinkat(dirfd, path, buf, bufsize) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf+len]; + stringToUTF8(ret, buf, bufsize+1); + // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!) + // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write. + HEAP8[buf+len] = endChar; + return len; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) { + try { + + oldpath = SYSCALLS.getStr(oldpath); + newpath = SYSCALLS.getStr(newpath); + oldpath = SYSCALLS.calculateAt(olddirfd, oldpath); + newpath = SYSCALLS.calculateAt(newdirfd, newpath); + FS.rename(oldpath, newpath); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_rmdir(path) { + try { + + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_stat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_symlink(target, linkpath) { + try { + + target = SYSCALLS.getStr(target); + linkpath = SYSCALLS.getStr(linkpath); + FS.symlink(target, linkpath); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_unlinkat(dirfd, path, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort('Invalid flags passed to unlinkat'); + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + var readI53FromI64 = (ptr) => { + return HEAPU32[((ptr)>>2)] + HEAP32[(((ptr)+(4))>>2)] * 4294967296; + }; + + function ___syscall_utimensat(dirfd, path, times, flags) { + try { + + path = SYSCALLS.getStr(path); + assert(flags === 0); + path = SYSCALLS.calculateAt(dirfd, path, true); + if (!times) { + var atime = Date.now(); + var mtime = atime; + } else { + var seconds = readI53FromI64(times); + var nanoseconds = HEAP32[(((times)+(8))>>2)]; + atime = (seconds*1000) + (nanoseconds/(1000*1000)); + times += 16; + seconds = readI53FromI64(times); + nanoseconds = HEAP32[(((times)+(8))>>2)]; + mtime = (seconds*1000) + (nanoseconds/(1000*1000)); + } + FS.utime(path, atime, mtime); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + var __abort_js = () => { + abort('native code called abort()'); + }; + + var structRegistrations = { + }; + + var runDestructors = (destructors) => { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + }; + + /** @suppress {globalThis} */ + function readPointer(pointer) { + return this['fromWireType'](HEAPU32[((pointer)>>2)]); + } + + var awaitingDependencies = { + }; + + var registeredTypes = { + }; + + var typeDependencies = { + }; + + var InternalError; + var throwInternalError = (message) => { throw new InternalError(message); }; + var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + }; + var __embind_finalize_value_object = (structType) => { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map((field) => field.getterReturnType). + concat(fieldRecords.map((field) => field.setterArgumentType)); + whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: (ptr) => getterReturnType['fromWireType'](getter(getterContext, ptr)), + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o)); + runDestructors(destructors); + } + }; + }); + + return [{ + name: reg.name, + 'fromWireType': (ptr) => { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + 'toWireType': (destructors, o) => { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: + // assume all fields are present without checking. + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError(`Missing field: "${fieldName}"`); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction: rawDestructor, + }]; + }); + }; + + var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {}; + + var embind_init_charCodes = () => { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + }; + var embind_charCodes; + var readLatin1String = (ptr) => { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + }; + + + + + var BindingError; + var throwBindingError = (message) => { throw new BindingError(message); }; + + /** @param {Object=} options */ + function sharedRegisterType(rawType, registeredInstance, options = {}) { + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + return sharedRegisterType(rawType, registeredInstance, options); + } + + var GenericWireTypeSize = 8; + /** @suppress {globalThis} */ + var __embind_register_bool = (rawType, name, trueValue, falseValue) => { + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': function(pointer) { + return this['fromWireType'](HEAPU8[pointer]); + }, + destructorFunction: null, // This type does not need a destructor + }); + }; + + + var emval_freelist = []; + + var emval_handles = []; + var __emval_decref = (handle) => { + if (handle > 9 && 0 === --emval_handles[handle + 1]) { + assert(emval_handles[handle] !== undefined, `Decref for unallocated handle.`); + emval_handles[handle] = undefined; + emval_freelist.push(handle); + } + }; + + + + + + var count_emval_handles = () => { + return emval_handles.length / 2 - 5 - emval_freelist.length; + }; + + var init_emval = () => { + // reserve 0 and some special values. These never get de-allocated. + emval_handles.push( + 0, 1, + undefined, 1, + null, 1, + true, 1, + false, 1, + ); + assert(emval_handles.length === 5 * 2); + Module['count_emval_handles'] = count_emval_handles; + }; + var Emval = { + toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + // handle 2 is supposed to be `undefined`. + assert(handle === 2 || emval_handles[handle] !== undefined && handle % 2 === 0, `invalid handle: ${handle}`); + return emval_handles[handle]; + }, + toHandle:(value) => { + switch (value) { + case undefined: return 2; + case null: return 4; + case true: return 6; + case false: return 8; + default:{ + const handle = emval_freelist.pop() || emval_handles.length; + emval_handles[handle] = value; + emval_handles[handle + 1] = 1; + return handle; + } + } + }, + }; + + + var EmValType = { + name: 'emscripten::val', + 'fromWireType': (handle) => { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': (destructors, value) => Emval.toHandle(value), + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }; + var __embind_register_emval = (rawType) => registerType(rawType, EmValType); + + var embindRepr = (v) => { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + }; + + var floatReadValueFromPointer = (name, width) => { + switch (width) { + case 4: return function(pointer) { + return this['fromWireType'](HEAPF32[((pointer)>>2)]); + }; + case 8: return function(pointer) { + return this['fromWireType'](HEAPF64[((pointer)>>3)]); + }; + default: + throw new TypeError(`invalid float width (${width}): ${name}`); + } + }; + + + var __embind_register_float = (rawType, name, size) => { + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': (value) => value, + 'toWireType': (destructors, value) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`); + } + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': floatReadValueFromPointer(name, size), + destructorFunction: null, // This type does not need a destructor + }); + }; + + var createNamedFunction = (name, body) => Object.defineProperty(body, 'name', { + value: name + }); + + + + function usesDestructorStack(argTypes) { + // Skip return value at index 0 - it's not deleted here. + for (var i = 1; i < argTypes.length; ++i) { + // The type does not define a destructor function - must use dynamic stack + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + return true; + } + } + return false; + } + + function newFunc(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError(`new_ called with constructor type ${typeof(constructor)} which is not a function`); + } + /* + * Previously, the following line was just: + * function dummy() {}; + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even + * though at creation, the 'dummy' has the correct constructor name. Thus, + * objects created with IMVU.new would show up in the debugger as 'dummy', + * which isn't very helpful. Using IMVU.createNamedFunction addresses the + * issue. Doubly-unfortunately, there's no way to write a test for this + * behavior. -NRD 2013.02.22 + */ + var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){}); + dummy.prototype = constructor.prototype; + var obj = new dummy; + + var r = constructor.apply(obj, argumentList); + return (r instanceof Object) ? r : obj; + } + + function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { + var needsDestructorStack = usesDestructorStack(argTypes); + var argCount = argTypes.length; + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i!==0?", ":"")+"arg"+i; + argsListWired += (i!==0?", ":"")+"arg"+i+"Wired"; + } + + var invokerFnBody = ` + return function (${argsList}) { + if (arguments.length !== ${argCount - 2}) { + throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ${argCount - 2}'); + }`; + + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; + + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam['toWireType']("+dtorStack+", this);\n"; + } + + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg"+i+"Wired = argType"+i+"['toWireType']("+dtorStack+", arg"+i+");\n"; + args1.push("argType"+i); + } + + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + + invokerFnBody += + (returns || isAsync ? "var rv = ":"") + "invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n"; + + var returnVal = returns ? "rv" : ""; + + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + var paramName = (i === 1 ? "thisWired" : ("arg"+(i - 2)+"Wired")); + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += `${paramName}_dtor(${paramName});\n`; + args1.push(`${paramName}_dtor`); + } + } + } + + if (returns) { + invokerFnBody += "var ret = retType['fromWireType'](rv);\n" + + "return ret;\n"; + } else { + } + + invokerFnBody += "}\n"; + + invokerFnBody = `if (arguments.length !== ${args1.length}){ throw new Error(humanName + "Expected ${args1.length} closure arguments " + arguments.length + " given."); }\n${invokerFnBody}`; + return [args1, invokerFnBody]; + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + + assert(!isAsync, 'Async bindings are only supported with JSPI.'); + + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = usesDestructorStack(argTypes); + + var returns = (argTypes[0].name !== "void"); + + // Builld the arguments that will be passed into the closure around the invoker + // function. + var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + for (var i = 0; i < argCount - 2; ++i) { + closureArgs.push(argTypes[i+2]); + } + if (!needsDestructorStack) { + for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + if (argTypes[i].destructorFunction !== null) { + closureArgs.push(argTypes[i].destructorFunction); + } + } + } + + let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); + args.push(invokerFnBody); + var invokerFn = newFunc(Function, args)(...closureArgs); + return createNamedFunction(humanName, invokerFn); + } + + var ensureOverloadTable = (proto, methodName, humanName) => { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function(...args) { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[args.length].apply(this, args); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + }; + + /** @param {number=} numArguments */ + var exposePublicSymbol = (name, value, numArguments) => { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + }; + + var heap32VectorToArray = (count, firstElement) => { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]); + } + return array; + }; + + + /** @param {number=} numArguments */ + var replacePublicSymbol = (name, value, numArguments) => { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistent public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + }; + + + + var dynCallLegacy = (sig, ptr, args) => { + sig = sig.replace(/p/g, 'i') + assert(('dynCall_' + sig) in Module, `bad function pointer type - dynCall function not found for sig '${sig}'`); + if (args?.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + } else { + assert(sig.length == 1); + } + var f = Module['dynCall_' + sig]; + return f(ptr, ...args); + }; + + var wasmTableMirror = []; + + /** @type {WebAssembly.Table} */ + var wasmTable; + var getWasmTableEntry = (funcPtr) => { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert(wasmTable.get(funcPtr) == func, 'JavaScript-side Wasm function table mirror is out of date!'); + return func; + }; + + var dynCall = (sig, ptr, args = []) => { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of their signature, so we rely on the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`); + var rtn = getWasmTableEntry(ptr)(...args); + return rtn; + }; + var getDynCaller = (sig, ptr) => { + assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs') + return (...args) => dynCall(sig, ptr, args); + }; + + + var embind__requireFunction = (signature, rawFunction) => { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; + }; + + + + var extendError = (baseErrorType, errorName) => { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return `${this.name}: ${this.message}`; + } + }; + + return errorClass; + }; + var UnboundTypeError; + + + + var getTypeName = (type) => { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + }; + var throwUnboundTypeError = (message, types) => { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', '])); + }; + + + var getFunctionName = (signature) => { + signature = signature.trim(); + const argsIndex = signature.indexOf("("); + if (argsIndex !== -1) { + assert(signature[signature.length - 1] == ")", "Parentheses for argument names should match."); + return signature.substr(0, argsIndex); + } else { + return signature; + } + }; + var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + name = getFunctionName(name); + + rawInvoker = embind__requireFunction(signature, rawInvoker); + + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + + whenDependentTypesAreResolved([], argTypes, (argTypes) => { + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); + }; + + + var integerReadValueFromPointer = (name, width, signed) => { + // integers are quite common, so generate very specialized functions + switch (width) { + case 1: return signed ? + (pointer) => HEAP8[pointer] : + (pointer) => HEAPU8[pointer]; + case 2: return signed ? + (pointer) => HEAP16[((pointer)>>1)] : + (pointer) => HEAPU16[((pointer)>>1)] + case 4: return signed ? + (pointer) => HEAP32[((pointer)>>2)] : + (pointer) => HEAPU32[((pointer)>>2)] + default: + throw new TypeError(`invalid integer width (${width}): ${name}`); + } + }; + + + /** @suppress {globalThis} */ + var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { + name = readLatin1String(name); + // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come + // out as 'i32 -1'. Always treat those as max u32. + if (maxRange === -1) { + maxRange = 4294967295; + } + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${toTypeName}`); + } + if (value < minRange || value > maxRange) { + throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`); + } + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + }; + + + var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + var size = HEAPU32[((handle)>>2)]; + var data = HEAPU32[(((handle)+(4))>>2)]; + return new TA(HEAP8.buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + }; + + + + + + + + + + var __embind_register_std_string = (rawType, name) => { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name, + // For some method names we use string keys here since they are part of + // the public/external API and/or used by the runtime-generated code. + 'fromWireType'(value) { + var length = HEAPU32[((value)>>2)]; + var payload = value + 4; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(''); + } + + _free(value); + + return str; + }, + 'toWireType'(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + + var length; + var valueIsOfTypeString = (typeof value == 'string'); + + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError('Cannot pass non-string to std::string'); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + + // assumes POINTER_SIZE alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base)>>2)] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction(ptr) { + _free(ptr); + }, + }); + }; + + + + + var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;; + var UTF16ToString = (ptr, maxBytesToRead) => { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // Also, use the length info to avoid running tiny strings through + // TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + + // Fallback: decode without UTF16Decoder + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + }; + + var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 0x7FFFFFFF; + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; + }; + + var lengthBytesUTF16 = (str) => { + return str.length*2; + }; + + var UTF32ToString = (ptr, maxBytesToRead) => { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + }; + + var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 0x7FFFFFFF; + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; + }; + + var lengthBytesUTF32 = (str) => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; + }; + var __embind_register_std_wstring = (rawType, charSize, name) => { + name = readLatin1String(name); + var decodeString, encodeString, readCharAt, lengthBytesUTF; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + readCharAt = (pointer) => HEAPU16[((pointer)>>1)]; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + readCharAt = (pointer) => HEAPU32[((pointer)>>2)]; + } + registerType(rawType, { + name, + 'fromWireType': (value) => { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[((value)>>2)]; + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || readCharAt(currentBytePtr) == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + _free(value); + + return str; + }, + 'toWireType': (destructors, value) => { + if (!(typeof value == 'string')) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + + // assumes POINTER_SIZE alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[((ptr)>>2)] = length / charSize; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); + }; + + + + var __embind_register_value_object = ( + rawType, + name, + constructorSignature, + rawConstructor, + destructorSignature, + rawDestructor + ) => { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [], + }; + }; + + + + var __embind_register_value_object_field = ( + structType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext + ) => { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext, + setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext, + }); + }; + + + var __embind_register_void = (rawType, name) => { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name, + 'argPackAdvance': 0, + 'fromWireType': () => undefined, + // TODO: assert if anything else is given? + 'toWireType': (destructors, o) => undefined, + }); + }; + + + + var __emscripten_fs_load_embedded_files = (ptr) => { + do { + var name_addr = HEAPU32[((ptr)>>2)]; + ptr += 4; + var len = HEAPU32[((ptr)>>2)]; + ptr += 4; + var content = HEAPU32[((ptr)>>2)]; + ptr += 4; + var name = UTF8ToString(name_addr) + FS.createPath('/', PATH.dirname(name), true, true); + // canOwn this data in the filesystem, it is a slice of wasm memory that will never change + FS.createDataFile(name, null, HEAP8.subarray(content, content + len), true, true, true); + } while (HEAPU32[((ptr)>>2)]); + }; + + var nowIsMonotonic = 1; + var __emscripten_get_now_is_monotonic = () => nowIsMonotonic; + + var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num); + + var __emscripten_throw_longjmp = () => { + throw Infinity; + }; + + var convertI32PairToI53Checked = (lo, hi) => { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + }; + function __gmtime_js(time_low, time_high,tmPtr) { + var time = convertI32PairToI53Checked(time_low, time_high); + + + var date = new Date(time * 1000); + HEAP32[((tmPtr)>>2)] = date.getUTCSeconds(); + HEAP32[(((tmPtr)+(4))>>2)] = date.getUTCMinutes(); + HEAP32[(((tmPtr)+(8))>>2)] = date.getUTCHours(); + HEAP32[(((tmPtr)+(12))>>2)] = date.getUTCDate(); + HEAP32[(((tmPtr)+(16))>>2)] = date.getUTCMonth(); + HEAP32[(((tmPtr)+(20))>>2)] = date.getUTCFullYear()-1900; + HEAP32[(((tmPtr)+(24))>>2)] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0; + HEAP32[(((tmPtr)+(28))>>2)] = yday; + ; + } + + var isLeapYear = (year) => year%4 === 0 && (year%100 !== 0 || year%400 === 0); + + var MONTH_DAYS_LEAP_CUMULATIVE = [0,31,60,91,121,152,182,213,244,274,305,335]; + + var MONTH_DAYS_REGULAR_CUMULATIVE = [0,31,59,90,120,151,181,212,243,273,304,334]; + var ydayFromDate = (date) => { + var leap = isLeapYear(date.getFullYear()); + var monthDaysCumulative = (leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE); + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; // -1 since it's days since Jan 1 + + return yday; + }; + + function __localtime_js(time_low, time_high,tmPtr) { + var time = convertI32PairToI53Checked(time_low, time_high); + + + var date = new Date(time*1000); + HEAP32[((tmPtr)>>2)] = date.getSeconds(); + HEAP32[(((tmPtr)+(4))>>2)] = date.getMinutes(); + HEAP32[(((tmPtr)+(8))>>2)] = date.getHours(); + HEAP32[(((tmPtr)+(12))>>2)] = date.getDate(); + HEAP32[(((tmPtr)+(16))>>2)] = date.getMonth(); + HEAP32[(((tmPtr)+(20))>>2)] = date.getFullYear()-1900; + HEAP32[(((tmPtr)+(24))>>2)] = date.getDay(); + + var yday = ydayFromDate(date)|0; + HEAP32[(((tmPtr)+(28))>>2)] = yday; + HEAP32[(((tmPtr)+(36))>>2)] = -(date.getTimezoneOffset() * 60); + + // Attention: DST is in December in South, and some regions don't have DST at all. + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset))|0; + HEAP32[(((tmPtr)+(32))>>2)] = dst; + ; + } + + + /** @suppress {duplicate } */ + var setTempRet0 = (val) => __emscripten_tempret_set(val); + var _setTempRet0 = setTempRet0; + + var __mktime_js = function(tmPtr) { + + var ret = (() => { + var date = new Date(HEAP32[(((tmPtr)+(20))>>2)] + 1900, + HEAP32[(((tmPtr)+(16))>>2)], + HEAP32[(((tmPtr)+(12))>>2)], + HEAP32[(((tmPtr)+(8))>>2)], + HEAP32[(((tmPtr)+(4))>>2)], + HEAP32[((tmPtr)>>2)], + 0); + + // There's an ambiguous hour when the time goes back; the tm_isdst field is + // used to disambiguate it. Date() basically guesses, so we fix it up if it + // guessed wrong, or fill in tm_isdst with the guess if it's -1. + var dst = HEAP32[(((tmPtr)+(32))>>2)]; + var guessedOffset = date.getTimezoneOffset(); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dstOffset = Math.min(winterOffset, summerOffset); // DST is in December in South + if (dst < 0) { + // Attention: some regions don't have DST at all. + HEAP32[(((tmPtr)+(32))>>2)] = Number(summerOffset != winterOffset && dstOffset == guessedOffset); + } else if ((dst > 0) != (dstOffset == guessedOffset)) { + var nonDstOffset = Math.max(winterOffset, summerOffset); + var trueOffset = dst > 0 ? dstOffset : nonDstOffset; + // Don't try setMinutes(date.getMinutes() + ...) -- it's messed up. + date.setTime(date.getTime() + (trueOffset - guessedOffset)*60000); + } + + HEAP32[(((tmPtr)+(24))>>2)] = date.getDay(); + var yday = ydayFromDate(date)|0; + HEAP32[(((tmPtr)+(28))>>2)] = yday; + // To match expected behavior, update fields from date + HEAP32[((tmPtr)>>2)] = date.getSeconds(); + HEAP32[(((tmPtr)+(4))>>2)] = date.getMinutes(); + HEAP32[(((tmPtr)+(8))>>2)] = date.getHours(); + HEAP32[(((tmPtr)+(12))>>2)] = date.getDate(); + HEAP32[(((tmPtr)+(16))>>2)] = date.getMonth(); + HEAP32[(((tmPtr)+(20))>>2)] = date.getYear(); + + var timeMs = date.getTime(); + if (isNaN(timeMs)) { + return -1; + } + // Return time in microseconds + return timeMs / 1000; + })(); + return (setTempRet0((tempDouble = ret,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)), ret>>>0); + }; + + + var __timegm_js = function(tmPtr) { + + var ret = (() => { + var time = Date.UTC(HEAP32[(((tmPtr)+(20))>>2)] + 1900, + HEAP32[(((tmPtr)+(16))>>2)], + HEAP32[(((tmPtr)+(12))>>2)], + HEAP32[(((tmPtr)+(8))>>2)], + HEAP32[(((tmPtr)+(4))>>2)], + HEAP32[((tmPtr)>>2)], + 0); + var date = new Date(time); + + HEAP32[(((tmPtr)+(24))>>2)] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0; + HEAP32[(((tmPtr)+(28))>>2)] = yday; + + return date.getTime() / 1000; + })(); + return (setTempRet0((tempDouble = ret,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)), ret>>>0); + }; + + + var __tzset_js = (timezone, daylight, std_name, dst_name) => { + // TODO: Use (malleable) environment variables instead of system settings. + var currentYear = new Date().getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + + // Local standard timezone offset. Local standard time is not adjusted for + // daylight savings. This code uses the fact that getTimezoneOffset returns + // a greater value during Standard Time versus Daylight Saving Time (DST). + // Thus it determines the expected output during Standard Time, and it + // compares whether the output of the given date the same (Standard) or less + // (DST). + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + + // timezone is specified as seconds west of UTC ("The external variable + // `timezone` shall be set to the difference, in seconds, between + // Coordinated Universal Time (UTC) and local standard time."), the same + // as returned by stdTimezoneOffset. + // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html + HEAPU32[((timezone)>>2)] = stdTimezoneOffset * 60; + + HEAP32[((daylight)>>2)] = Number(winterOffset != summerOffset); + + var extractZone = (date) => date.toLocaleTimeString(undefined, {hour12:false, timeZoneName:'short'}).split(' ')[1]; + var winterName = extractZone(winter); + var summerName = extractZone(summer); + assert(winterName); + assert(summerName); + assert(lengthBytesUTF8(winterName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${winterName})`); + assert(lengthBytesUTF8(summerName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${summerName})`); + if (summerOffset < winterOffset) { + // Northern hemisphere + stringToUTF8(winterName, std_name, 17); + stringToUTF8(summerName, dst_name, 17); + } else { + stringToUTF8(winterName, dst_name, 17); + stringToUTF8(summerName, std_name, 17); + } + }; + + var _emscripten_date_now = () => Date.now(); + + var _emscripten_get_now; + // Modern environment where performance.now() is supported: + // N.B. a shorter form "_emscripten_get_now = performance.now;" is + // unfortunately not allowed even in current browsers (e.g. FF Nightly 75). + _emscripten_get_now = () => performance.now(); + ; + + var getHeapMax = () => + // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate + // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side + // for any code that deals with heap sizes, which would require special + // casing all heap size related code to treat 0 specially. + 2147483648; + + var growMemory = (size) => { + var b = wasmMemory.buffer; + var pages = (size - b.byteLength + 65535) / 65536; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1 /*success*/; + } catch(e) { + err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`); + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + }; + var _emscripten_resize_heap = (requestedSize) => { + var oldSize = HEAPU8.length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + assert(requestedSize > oldSize); + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`); + return false; + } + + var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + var replacement = growMemory(newSize); + if (replacement) { + + return true; + } + } + err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`); + return false; + }; + + var ENV = { + }; + + var getExecutableName = () => { + return thisProgram || './this.program'; + }; + var getEnvStrings = () => { + if (!getEnvStrings.strings) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator == 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + 'LANG': lang, + '_': getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(`${x}=${env[x]}`); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + }; + + var stringToAscii = (str, buffer) => { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff)); + HEAP8[buffer++] = str.charCodeAt(i); + } + // Null-terminate the string + HEAP8[buffer] = 0; + }; + var _environ_get = (__environ, environ_buf) => { + var bufSize = 0; + getEnvStrings().forEach((string, i) => { + var ptr = environ_buf + bufSize; + HEAPU32[(((__environ)+(i*4))>>2)] = ptr; + stringToAscii(string, ptr); + bufSize += string.length + 1; + }); + return 0; + }; + + var _environ_sizes_get = (penviron_count, penviron_buf_size) => { + var strings = getEnvStrings(); + HEAPU32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach((string) => bufSize += string.length + 1); + HEAPU32[((penviron_buf_size)>>2)] = bufSize; + return 0; + }; + + + var runtimeKeepaliveCounter = 0; + var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0; + var _proc_exit = (code) => { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + Module['onExit']?.(code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); + }; + + /** @suppress {duplicate } */ + /** @param {boolean|number=} implicit */ + var exitJS = (status, implicit) => { + EXITSTATUS = status; + + checkUnflushedContent(); + + // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down + if (keepRuntimeAlive() && !implicit) { + var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`; + readyPromiseReject(msg); + err(msg); + } + + _proc_exit(status); + }; + var _exit = exitJS; + + function _fd_close(fd) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + function _fd_fdstat_get(fd, pbuf) { + try { + + var rightsBase = 0; + var rightsInheriting = 0; + var flags = 0; + { + var stream = SYSCALLS.getStreamFromFD(fd); + // All character devices are terminals (other things a Linux system would + // assume is a character device, like the mouse, we have special APIs for). + var type = stream.tty ? 2 : + FS.isDir(stream.mode) ? 3 : + FS.isLink(stream.mode) ? 7 : + 4; + } + HEAP8[pbuf] = type; + HEAP16[(((pbuf)+(2))>>1)] = flags; + (tempI64 = [rightsBase>>>0,(tempDouble = rightsBase,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((pbuf)+(8))>>2)] = tempI64[0],HEAP32[(((pbuf)+(12))>>2)] = tempI64[1]); + (tempI64 = [rightsInheriting>>>0,(tempDouble = rightsInheriting,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((pbuf)+(16))>>2)] = tempI64[0],HEAP32[(((pbuf)+(20))>>2)] = tempI64[1]); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + var doReadv = (stream, iov, iovcnt, offset) => { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + if (typeof offset != 'undefined') { + offset += curr; + } + } + return ret; + }; + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + + function _fd_seek(fd,offset_low, offset_high,whence,newOffset) { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + + + try { + + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble = stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + ; + } + + /** @param {number=} offset */ + var doWritev = (stream, iov, iovcnt, offset) => { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (typeof offset != 'undefined') { + offset += curr; + } + } + return ret; + }; + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + + + var arraySum = (array, index) => { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + // no-op + } + return sum; + }; + + + var MONTH_DAYS_LEAP = [31,29,31,30,31,30,31,31,30,31,30,31]; + + var MONTH_DAYS_REGULAR = [31,28,31,30,31,30,31,31,30,31,30,31]; + var addDays = (date, days) => { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + }; + + + + + var writeArrayToMemory = (array, buffer) => { + assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') + HEAP8.set(array, buffer); + }; + + var _strftime = (s, maxsize, format, tm) => { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAPU32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value == 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } + return thisDate.getFullYear(); + } + return thisDate.getFullYear()-1; + } + + var EXPANSION_RULES_2 = { + '%a': (date) => WEEKDAYS[date.tm_wday].substring(0,3) , + '%A': (date) => WEEKDAYS[date.tm_wday], + '%b': (date) => MONTHS[date.tm_mon].substring(0,3), + '%B': (date) => MONTHS[date.tm_mon], + '%C': (date) => { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': (date) => leadingNulls(date.tm_mday, 2), + '%e': (date) => leadingSomething(date.tm_mday, 2, ' '), + '%g': (date) => { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': getWeekBasedYear, + '%H': (date) => leadingNulls(date.tm_hour, 2), + '%I': (date) => { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': (date) => { + // Day of the year (001-366) + return leadingNulls(date.tm_mday + arraySum(isLeapYear(date.tm_year+1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': (date) => leadingNulls(date.tm_mon+1, 2), + '%M': (date) => leadingNulls(date.tm_min, 2), + '%n': () => '\n', + '%p': (date) => { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } + return 'PM'; + }, + '%S': (date) => leadingNulls(date.tm_sec, 2), + '%t': () => '\t', + '%u': (date) => date.tm_wday || 7, + '%U': (date) => { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + '%V': (date) => { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7 ) / 7); + // If 1 Jan is just 1-3 days past Monday, the previous week + // is also in this year. + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + // If 31 December of prev year a Thursday, or Friday of a + // leap year, then the prev year has 53 weeks. + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || (dec31 == 5 && isLeapYear(date.tm_year%400-1))) { + val++; + } + } else if (val == 53) { + // If 1 January is not a Thursday, and not a Wednesday of a + // leap year, then this year has only 52 weeks. + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year))) + val = 1; + } + return leadingNulls(val, 2); + }, + '%w': (date) => date.tm_wday, + '%W': (date) => { + var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); + return leadingNulls(Math.floor(days / 7), 2); + }, + '%y': (date) => { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + '%Y': (date) => date.tm_year+1900, + '%z': (date) => { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': (date) => date.tm_zone, + '%%': () => '%' + }; + + // Replace %% with a pair of NULLs (which cannot occur in a C string), then + // re-inject them after processing. + pattern = pattern.replace(/%%/g, '\0\0') + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, '%') + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + }; + + + var handleException = (e) => { + // Certain exception types we do not treat as errors since they are used for + // internal control flow. + // 1. ExitStatus, which is thrown by exit() + // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others + // that wish to return to JS event loop. + if (e instanceof ExitStatus || e == 'unwind') { + return EXITSTATUS; + } + checkStackCookie(); + if (e instanceof WebAssembly.RuntimeError) { + if (_emscripten_stack_get_current() <= 0) { + err('Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 1048576)'); + } + } + quit_(1, e); + }; + + + + var FS_createPath = FS.createPath; + + + + var FS_unlink = (path) => FS.unlink(path); + + var FS_createLazyFile = FS.createLazyFile; + + var FS_createDevice = FS.createDevice; + + FS.createPreloadedFile = FS_createPreloadedFile; + FS.staticInit();Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_unlink"] = FS.unlink;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createDevice"] = FS.createDevice;; +InternalError = Module['InternalError'] = class InternalError extends Error { constructor(message) { super(message); this.name = 'InternalError'; }}; +embind_init_charCodes(); +BindingError = Module['BindingError'] = class BindingError extends Error { constructor(message) { super(message); this.name = 'BindingError'; }}; +init_emval();; +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var wasmImports = { + /** @export */ + __assert_fail: ___assert_fail, + /** @export */ + __syscall_chdir: ___syscall_chdir, + /** @export */ + __syscall_chmod: ___syscall_chmod, + /** @export */ + __syscall_fcntl64: ___syscall_fcntl64, + /** @export */ + __syscall_fstat64: ___syscall_fstat64, + /** @export */ + __syscall_getcwd: ___syscall_getcwd, + /** @export */ + __syscall_getdents64: ___syscall_getdents64, + /** @export */ + __syscall_ioctl: ___syscall_ioctl, + /** @export */ + __syscall_lstat64: ___syscall_lstat64, + /** @export */ + __syscall_mkdirat: ___syscall_mkdirat, + /** @export */ + __syscall_newfstatat: ___syscall_newfstatat, + /** @export */ + __syscall_openat: ___syscall_openat, + /** @export */ + __syscall_readlinkat: ___syscall_readlinkat, + /** @export */ + __syscall_renameat: ___syscall_renameat, + /** @export */ + __syscall_rmdir: ___syscall_rmdir, + /** @export */ + __syscall_stat64: ___syscall_stat64, + /** @export */ + __syscall_symlink: ___syscall_symlink, + /** @export */ + __syscall_unlinkat: ___syscall_unlinkat, + /** @export */ + __syscall_utimensat: ___syscall_utimensat, + /** @export */ + _abort_js: __abort_js, + /** @export */ + _embind_finalize_value_object: __embind_finalize_value_object, + /** @export */ + _embind_register_bigint: __embind_register_bigint, + /** @export */ + _embind_register_bool: __embind_register_bool, + /** @export */ + _embind_register_emval: __embind_register_emval, + /** @export */ + _embind_register_float: __embind_register_float, + /** @export */ + _embind_register_function: __embind_register_function, + /** @export */ + _embind_register_integer: __embind_register_integer, + /** @export */ + _embind_register_memory_view: __embind_register_memory_view, + /** @export */ + _embind_register_std_string: __embind_register_std_string, + /** @export */ + _embind_register_std_wstring: __embind_register_std_wstring, + /** @export */ + _embind_register_value_object: __embind_register_value_object, + /** @export */ + _embind_register_value_object_field: __embind_register_value_object_field, + /** @export */ + _embind_register_void: __embind_register_void, + /** @export */ + _emscripten_fs_load_embedded_files: __emscripten_fs_load_embedded_files, + /** @export */ + _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic, + /** @export */ + _emscripten_memcpy_js: __emscripten_memcpy_js, + /** @export */ + _emscripten_throw_longjmp: __emscripten_throw_longjmp, + /** @export */ + _gmtime_js: __gmtime_js, + /** @export */ + _localtime_js: __localtime_js, + /** @export */ + _mktime_js: __mktime_js, + /** @export */ + _timegm_js: __timegm_js, + /** @export */ + _tzset_js: __tzset_js, + /** @export */ + emscripten_date_now: _emscripten_date_now, + /** @export */ + emscripten_get_now: _emscripten_get_now, + /** @export */ + emscripten_resize_heap: _emscripten_resize_heap, + /** @export */ + environ_get: _environ_get, + /** @export */ + environ_sizes_get: _environ_sizes_get, + /** @export */ + exit: _exit, + /** @export */ + fd_close: _fd_close, + /** @export */ + fd_fdstat_get: _fd_fdstat_get, + /** @export */ + fd_read: _fd_read, + /** @export */ + fd_seek: _fd_seek, + /** @export */ + fd_write: _fd_write, + /** @export */ + invoke_di, + /** @export */ + invoke_i, + /** @export */ + invoke_ii, + /** @export */ + invoke_iii, + /** @export */ + invoke_iiii, + /** @export */ + invoke_iiiii, + /** @export */ + invoke_vi, + /** @export */ + invoke_vid, + /** @export */ + invoke_vii, + /** @export */ + invoke_viii, + /** @export */ + invoke_viiii, + /** @export */ + proc_exit: _proc_exit, + /** @export */ + strftime: _strftime +}; +var wasmExports = createWasm(); +var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors', 0); +var _malloc = createExportWrapper('malloc', 1); +var _free = createExportWrapper('free', 1); +var _fflush = createExportWrapper('fflush', 1); +var ___original_main = Module['___original_main'] = createExportWrapper('__original_main', 0); +var _main = Module['_main'] = createExportWrapper('main', 2); +var ___getTypeName = createExportWrapper('__getTypeName', 1); +var _setThrew = createExportWrapper('setThrew', 2); +var __emscripten_tempret_set = createExportWrapper('_emscripten_tempret_set', 1); +var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])(); +var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])(); +var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])(); +var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])(); +var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'])(a0); +var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0); +var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])(); +var ___cxa_is_pointer_type = createExportWrapper('__cxa_is_pointer_type', 1); +var dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji', 5); +var ___emscripten_embedded_file_data = Module['___emscripten_embedded_file_data'] = 1783292; +function invoke_i(index) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index,a1,a2,a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index,a1,a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index,a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index,a1,a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index,a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_di(index,a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vid(index,a1,a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === + +Module['addRunDependency'] = addRunDependency; +Module['removeRunDependency'] = removeRunDependency; +Module['FS_createPreloadedFile'] = FS_createPreloadedFile; +Module['FS_unlink'] = FS_unlink; +Module['FS_createPath'] = FS_createPath; +Module['FS_createDevice'] = FS_createDevice; +Module['FS_createDataFile'] = FS_createDataFile; +Module['FS_createLazyFile'] = FS_createLazyFile; +var missingLibrarySymbols = [ + 'writeI53ToI64', + 'writeI53ToI64Clamped', + 'writeI53ToI64Signaling', + 'writeI53ToU64Clamped', + 'writeI53ToU64Signaling', + 'readI53FromU64', + 'convertI32PairToI53', + 'convertU32PairToI53', + 'stackAlloc', + 'getTempRet0', + 'inetPton4', + 'inetNtop4', + 'inetPton6', + 'inetNtop6', + 'readSockaddr', + 'writeSockaddr', + 'emscriptenLog', + 'readEmAsmArgs', + 'jstoi_q', + 'listenOnce', + 'autoResumeAudioContext', + 'runtimeKeepalivePush', + 'runtimeKeepalivePop', + 'callUserCallback', + 'maybeExit', + 'asmjsMangle', + 'HandleAllocator', + 'getNativeTypeSize', + 'STACK_SIZE', + 'STACK_ALIGN', + 'POINTER_SIZE', + 'ASSERTIONS', + 'getCFunc', + 'ccall', + 'cwrap', + 'uleb128Encode', + 'sigToWasmTypes', + 'generateFuncType', + 'convertJsFunctionToWasm', + 'getEmptyTableSlot', + 'updateTableMap', + 'getFunctionAddress', + 'addFunction', + 'removeFunction', + 'reallyNegative', + 'unSign', + 'strLen', + 'reSign', + 'formatString', + 'intArrayToString', + 'AsciiToString', + 'stringToNewUTF8', + 'stringToUTF8OnStack', + 'registerKeyEventCallback', + 'maybeCStringToJsString', + 'findEventTarget', + 'getBoundingClientRect', + 'fillMouseEventData', + 'registerMouseEventCallback', + 'registerWheelEventCallback', + 'registerUiEventCallback', + 'registerFocusEventCallback', + 'fillDeviceOrientationEventData', + 'registerDeviceOrientationEventCallback', + 'fillDeviceMotionEventData', + 'registerDeviceMotionEventCallback', + 'screenOrientation', + 'fillOrientationChangeEventData', + 'registerOrientationChangeEventCallback', + 'fillFullscreenChangeEventData', + 'registerFullscreenChangeEventCallback', + 'JSEvents_requestFullscreen', + 'JSEvents_resizeCanvasForFullscreen', + 'registerRestoreOldStyle', + 'hideEverythingExceptGivenElement', + 'restoreHiddenElements', + 'setLetterbox', + 'softFullscreenResizeWebGLRenderTarget', + 'doRequestFullscreen', + 'fillPointerlockChangeEventData', + 'registerPointerlockChangeEventCallback', + 'registerPointerlockErrorEventCallback', + 'requestPointerLock', + 'fillVisibilityChangeEventData', + 'registerVisibilityChangeEventCallback', + 'registerTouchEventCallback', + 'fillGamepadEventData', + 'registerGamepadEventCallback', + 'registerBeforeUnloadEventCallback', + 'fillBatteryEventData', + 'battery', + 'registerBatteryEventCallback', + 'setCanvasElementSize', + 'getCanvasElementSize', + 'jsStackTrace', + 'getCallstack', + 'convertPCtoSourceLocation', + 'checkWasiClock', + 'wasiRightsToMuslOFlags', + 'wasiOFlagsToMuslOFlags', + 'createDyncallWrapper', + 'safeSetTimeout', + 'setImmediateWrapped', + 'clearImmediateWrapped', + 'polyfillSetImmediate', + 'getPromise', + 'makePromise', + 'idsToPromises', + 'makePromiseCallback', + 'ExceptionInfo', + 'findMatchingCatch', + 'Browser_asyncPrepareDataCounter', + 'setMainLoop', + 'getSocketFromFD', + 'getSocketAddress', + 'FS_mkdirTree', + '_setNetworkCallback', + 'heapObjectForWebGLType', + 'toTypedArrayIndex', + 'webgl_enable_ANGLE_instanced_arrays', + 'webgl_enable_OES_vertex_array_object', + 'webgl_enable_WEBGL_draw_buffers', + 'webgl_enable_WEBGL_multi_draw', + 'emscriptenWebGLGet', + 'computeUnpackAlignedImageSize', + 'colorChannelsInGlTextureFormat', + 'emscriptenWebGLGetTexPixelData', + 'emscriptenWebGLGetUniform', + 'webglGetUniformLocation', + 'webglPrepareUniformLocationsBeforeFirstUse', + 'webglGetLeftBracePos', + 'emscriptenWebGLGetVertexAttrib', + '__glGetActiveAttribOrUniform', + 'writeGLArray', + 'registerWebGlEventCallback', + 'runAndAbortIfError', + 'ALLOC_NORMAL', + 'ALLOC_STACK', + 'allocate', + 'writeStringToMemory', + 'writeAsciiToMemory', + 'setErrNo', + 'demangle', + 'stackTrace', + 'getFunctionArgsName', + 'requireRegisteredType', + 'createJsInvokerSignature', + 'init_embind', + 'getBasestPointer', + 'registerInheritedInstance', + 'unregisterInheritedInstance', + 'getInheritedInstance', + 'getInheritedInstanceCount', + 'getLiveInheritedInstances', + 'enumReadValueFromPointer', + 'genericPointerToWireType', + 'constNoSmartPtrRawPointerToWireType', + 'nonConstNoSmartPtrRawPointerToWireType', + 'init_RegisteredPointer', + 'RegisteredPointer', + 'RegisteredPointer_fromWireType', + 'runDestructor', + 'releaseClassHandle', + 'detachFinalizer', + 'attachFinalizer', + 'makeClassHandle', + 'init_ClassHandle', + 'ClassHandle', + 'throwInstanceAlreadyDeleted', + 'flushPendingDeletes', + 'setDelayFunction', + 'RegisteredClass', + 'shallowCopyInternalPointer', + 'downcastPointer', + 'upcastPointer', + 'validateThis', + 'char_0', + 'char_9', + 'makeLegalFunctionName', + 'getStringOrSymbol', + 'emval_get_global', + 'emval_returnValue', + 'emval_lookupTypes', + 'emval_addMethodCaller', +]; +missingLibrarySymbols.forEach(missingLibrarySymbol) + +var unexportedSymbols = [ + 'run', + 'addOnPreRun', + 'addOnInit', + 'addOnPreMain', + 'addOnExit', + 'addOnPostRun', + 'out', + 'err', + 'callMain', + 'abort', + 'wasmMemory', + 'wasmExports', + 'writeStackCookie', + 'checkStackCookie', + 'readI53FromI64', + 'convertI32PairToI53Checked', + 'stackSave', + 'stackRestore', + 'setTempRet0', + 'ptrToString', + 'zeroMemory', + 'exitJS', + 'getHeapMax', + 'growMemory', + 'ENV', + 'MONTH_DAYS_REGULAR', + 'MONTH_DAYS_LEAP', + 'MONTH_DAYS_REGULAR_CUMULATIVE', + 'MONTH_DAYS_LEAP_CUMULATIVE', + 'isLeapYear', + 'ydayFromDate', + 'arraySum', + 'addDays', + 'ERRNO_CODES', + 'ERRNO_MESSAGES', + 'DNS', + 'Protocols', + 'Sockets', + 'initRandomFill', + 'randomFill', + 'timers', + 'warnOnce', + 'readEmAsmArgsArray', + 'jstoi_s', + 'getExecutableName', + 'dynCallLegacy', + 'getDynCaller', + 'dynCall', + 'handleException', + 'keepRuntimeAlive', + 'asyncLoad', + 'alignMemory', + 'mmapAlloc', + 'wasmTable', + 'noExitRuntime', + 'freeTableIndexes', + 'functionsInTableMap', + 'setValue', + 'getValue', + 'PATH', + 'PATH_FS', + 'UTF8Decoder', + 'UTF8ArrayToString', + 'UTF8ToString', + 'stringToUTF8Array', + 'stringToUTF8', + 'lengthBytesUTF8', + 'intArrayFromString', + 'stringToAscii', + 'UTF16Decoder', + 'UTF16ToString', + 'stringToUTF16', + 'lengthBytesUTF16', + 'UTF32ToString', + 'stringToUTF32', + 'lengthBytesUTF32', + 'writeArrayToMemory', + 'JSEvents', + 'specialHTMLTargets', + 'findCanvasEventTarget', + 'currentFullscreenStrategy', + 'restoreOldWindowedStyle', + 'UNWIND_CACHE', + 'ExitStatus', + 'getEnvStrings', + 'doReadv', + 'doWritev', + 'promiseMap', + 'uncaughtExceptionCount', + 'exceptionLast', + 'exceptionCaught', + 'Browser', + 'getPreloadedImageData__data', + 'wget', + 'SYSCALLS', + 'preloadPlugins', + 'FS_modeStringToFlags', + 'FS_getMode', + 'FS_stdin_getChar_buffer', + 'FS_stdin_getChar', + 'FS_readFile', + 'FS', + 'MEMFS', + 'TTY', + 'PIPEFS', + 'SOCKFS', + 'tempFixedLengthArray', + 'miniTempWebGLFloatBuffers', + 'miniTempWebGLIntBuffers', + 'GL', + 'AL', + 'GLUT', + 'EGL', + 'GLEW', + 'IDBStore', + 'SDL', + 'SDL_gfx', + 'allocateUTF8', + 'allocateUTF8OnStack', + 'print', + 'printErr', + 'InternalError', + 'BindingError', + 'throwInternalError', + 'throwBindingError', + 'registeredTypes', + 'awaitingDependencies', + 'typeDependencies', + 'tupleRegistrations', + 'structRegistrations', + 'sharedRegisterType', + 'whenDependentTypesAreResolved', + 'embind_charCodes', + 'embind_init_charCodes', + 'readLatin1String', + 'getTypeName', + 'getFunctionName', + 'heap32VectorToArray', + 'usesDestructorStack', + 'createJsInvoker', + 'UnboundTypeError', + 'PureVirtualError', + 'GenericWireTypeSize', + 'EmValType', + 'throwUnboundTypeError', + 'ensureOverloadTable', + 'exposePublicSymbol', + 'replacePublicSymbol', + 'extendError', + 'createNamedFunction', + 'embindRepr', + 'registeredInstances', + 'registeredPointers', + 'registerType', + 'integerReadValueFromPointer', + 'floatReadValueFromPointer', + 'readPointer', + 'runDestructors', + 'newFunc', + 'craftInvokerFunction', + 'embind__requireFunction', + 'finalizationRegistry', + 'detachFinalizer_deps', + 'deletionQueue', + 'delayFunction', + 'emval_freelist', + 'emval_handles', + 'emval_symbols', + 'init_emval', + 'count_emval_handles', + 'Emval', + 'emval_methodCallers', + 'reflectConstruct', +]; +unexportedSymbols.forEach(unexportedRuntimeSymbol); + + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain() { + assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])'); + assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called'); + + var entryFunction = _main; + + var argc = 0; + var argv = 0; + + try { + + var ret = entryFunction(argc, argv); + + // if we're not running an evented main loop, it's time to exit + exitJS(ret, /* implicit = */ true); + return ret; + } + catch (e) { + return handleException(e); + } +} + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + _emscripten_stack_init(); + // TODO(sbc): Move writeStackCookie to native to to avoid this. + writeStackCookie(); +} + +function run() { + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + readyPromiseResolve(Module); + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + _fflush(0); + // also flush in the JS FS layer + ['stdout', 'stderr'].forEach(function(name) { + var info = FS.analyzePath('/dev/' + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty?.output?.length) { + has = true; + } + }); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.'); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + +run(); + +// end include: postamble.js + +// include: postamble_modularize.js +// In MODULARIZE mode we wrap the generated code in a factory function +// and return either the Module itself, or a promise of the module. +// +// We assign to the `moduleRtn` global here and configure closure to see +// this as and extern so it won't get minified. + +moduleRtn = readyPromise; + +// Assertion for attempting to access module properties on the incoming +// moduleArg. In the past we used this object as the prototype of the module +// and assigned properties to it, but now we return a distinct object. This +// keeps the instance private until it is ready (i.e the promise has been +// resolved). +for (const prop of Object.keys(Module)) { + if (!(prop in moduleArg)) { + Object.defineProperty(moduleArg, prop, { + configurable: true, + get() { + abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`) + } + }); + } +} +// end include: postamble_modularize.js + + + + return moduleRtn; +} +); +})(); +export default Module; diff --git a/build/out.wasm b/build/out.wasm new file mode 100755 index 0000000000000000000000000000000000000000..542374a76e37e4f4d6f27150e9cdecbd19aed411 GIT binary patch literal 1581475 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Ν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

S@iXBRWU5sk+M=Agh%%Ps~($O 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 @jTmQ>Tqs-0RPwqt)AlW@PQK45VgUDLA$yytyu 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 z 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

sW4 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 }J`yQ&1ztm}DM3sm7^R}yJD>b+^U2dx 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 z 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 N{|RKHQnSw*{U5sVIOqTX literal 0 HcmV?d00001 diff --git a/build/test.mjs b/build/test.mjs new file mode 100644 index 0000000..f483a8c --- /dev/null +++ b/build/test.mjs @@ -0,0 +1,11 @@ +console.log("Starting wasm test run.") + +import init from "./out.mjs" + +console.log("Imported module") + +const mod = await init() + +console.log("Initted module") + +console.log(mod.ludus(":hello_from_ludus").value) diff --git a/clj_to_janet.md b/clj_to_janet.md deleted file mode 100644 index 191dba6..0000000 --- a/clj_to_janet.md +++ /dev/null @@ -1,42 +0,0 @@ -# From Clojure to Janet -## How to convert files - -### Comments -`% s ; r # ` - - -### called keyword property access -Use a macro: -- Select `\ \( : ret ` -- Record the macro: `Q n v e c get e e a p Q` -- Then just `q` until you've changed everything - -### Chars don't exist -- \char -> "char", e.g. -- \newline -> "\n", etc. -- \a -> "a" - -### Use mutable arrays and tables -Where data structures are mutable, add `@`s. - -### Sets & tables -Sets don't exist in Janet. Use tables with values set to `true`. - -### Strings -> number literals -- Clj uses `edn/read-string`; Janet uses `parse-all` - -### `loop` -> `defn recur` -- Clj's `loop` is very different from Janet's `loop` -- As a quick and dirty workaround, change it to an interior recursive function -- Janet has tail calls, so this is nearly as efficient (paying the overhead for creating the function) -- An optimization is to pull out these functions and declare them at the toplevel - -### current-char - - -### Straight replacements: -- nth -> get -- assoc -> put -- conj -> array/push -- str -> string -- substr -> slice diff --git a/computer_class.md b/computer_class.md deleted file mode 100644 index 7f16017..0000000 --- a/computer_class.md +++ /dev/null @@ -1,10 +0,0 @@ -# TODO for Computer Class - -* Devise graphics protocol - - Untether from p5 - - Devise SVG situation - - Save code to SVG - - Load code from SVG -* Find interfaces for stdin, out, err -* Coroutines -* State w/ refs diff --git a/deps.edn b/deps.edn deleted file mode 100644 index 97c722b..0000000 --- a/deps.edn +++ /dev/null @@ -1,17 +0,0 @@ -{:deps - {org.clojure/clojurescript {:mvn/version "1.11.121"} - thheller/shadow-cljs {:mvn/version "2.26.0"} - babashka/fs {:mvn/version "0.4.19"} - } - - :source-paths ["src/ludus"] - - :aliases - {:main - {:exec-fn ludus.core/main!} - :repl - {:exec-fn clojure.core.server/start-server - :exec-args {:name "repl" - :port 5555 - :accept clojure.core.server/repl - :server-daemon false}}}} \ No newline at end of file diff --git a/foo.ld b/foo.ld deleted file mode 100644 index fa4dd25..0000000 --- a/foo.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT "foo" -"foo" \ No newline at end of file diff --git a/graal-compile.sh b/graal-compile.sh deleted file mode 100755 index a261acd..0000000 --- a/graal-compile.sh +++ /dev/null @@ -1,7 +0,0 @@ -#!/opt/homebrew/bin/fish - -jenv shell graalvm64-19.0.2 - -lein uberjar - -native-image --enable-preview --report-unsupported-elements-at-runtime --initialize-at-build-time -jar ./target/ludus-0.1.0-SNAPSHOT-standalone.jar -H:Name=./target/ludus diff --git a/justfile b/justfile index 506d08b..bfaf000 100644 --- a/justfile +++ b/justfile @@ -1,7 +1,3 @@ -# build clojurescript release -build: - shadow-cljs release module - # open a janet repl in a different os window repl: kitten @ launch --type=os-window --allow-remote-control --cwd=current --title=hx_repl:ludus --keep-focus diff --git a/ludus.sublime-project b/ludus.sublime-project deleted file mode 100644 index 7361a1a..0000000 --- a/ludus.sublime-project +++ /dev/null @@ -1,19 +0,0 @@ -{ - "folders": - [ - { - "path": "." - } - ], - "settings": { - "on_post_save_project": [ - { - "command": "exec", - "args": { - "shell_cmd": "lein cljfmt fix" - }, - "scope": "window" - } - ] - } -} diff --git a/package.json b/package.json index 177ef9a..ebe065a 100644 --- a/package.json +++ b/package.json @@ -1,16 +1,16 @@ { "name": "@ludus/ludus-js-pure", - "version": "0.1.0-alpha.8", + "version": "0.1.0-alpha.10", "description": "A Ludus interpreter in a pure JS function.", - "main": "target/js/ludus.js", "type": "module", + "main": "build/ludus.mjs", "directories": {}, "keywords": [], "author": "Scott Richmond", "license": "GPL-3.0", - "files": ["target/js/*"], - "devDependencies": { - "shadow-cljs": "^2.26.0", - "tap": "^18.6.1" - } + "files": [ + "build/out.wasm", + "build/out.mjs", + "build/ludus.mjs"], + "devDependencies": {} } diff --git a/janet/postlude.ld b/postlude.ld similarity index 100% rename from janet/postlude.ld rename to postlude.ld diff --git a/janet/prelude.ld b/prelude.ld similarity index 100% rename from janet/prelude.ld rename to prelude.ld diff --git a/project.clj b/project.clj deleted file mode 100644 index b5ac384..0000000 --- a/project.clj +++ /dev/null @@ -1,14 +0,0 @@ -(defproject ludus "0.1.0-SNAPSHOT" - :description "FIXME: write description" - :url "http://ludus.dev" - :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0" - :url "https://www.eclipse.org/legal/epl-2.0/"} - :dependencies [[org.clojure/clojure "1.11.1"] - [babashka/fs "0.4.19"] - ] - :plugins [[lein-cljfmt "0.8.0"]] - :repl-options {:init-ns ludus.core} - :main ludus.core - :profiles {:uberjar {:aot :all}} - :jvm-opts ["--enable-preview"] - ) diff --git a/sandbox.ld b/sandbox.ld deleted file mode 100644 index 470428f..0000000 --- a/sandbox.ld +++ /dev/null @@ -1,111 +0,0 @@ -fn fib { - "Tells you a fib number." - (0) -> 0 - (1) -> 1 - (n) -> add ( - fib (dec (n)) - fib (sub (n, 2)) - ) -} - -fn unwrap { - ((:some, value)) -> value - ((:ok, value)) -> value -} - -fn default (default_value) -> fn (maybe) -> when maybe is { - (:ok, value) -> value - (:err, _) -> default_value - nil -> default_value - value -> value -} - -fn some (value) -> (:some, value) - -fn ok (value) -> (:ok, value) - -let foo = unwrap ((:ok, 42)) - -print (:foo, foo) - -let bar = unwrap ((:some, 23)) - -print (:bar, bar) - -let baz = do 69 > default (12) > print (:baz, _) - -let quux = do nil > default (12) > print (:quux, _) - -& unwrap ((:err, "message")) - -fn map { - (f) -> fn mapper (xs) -> map (f, xs) - (f, xs) -> { - let n = count (xs) - loop (0, []) with (i, ys) -> if eq (i, n) - then ys - else recur ( - inc (i) - conj (ys, f (nth (i, xs)))) - } -} - -fn reduce { - (f) -> fn reducer { - (xs) -> reduce (f, xs) - (xs, init) -> reduce (f, xs, init) - } - (f, xs) -> { - let first_x = first (xs) - let more_xs = rest (xs) - reduce (f, more_xs, first_x) - } - (f, xs, init) -> { - let n = count (xs) - loop (0, init) with (i, acc) -> if eq (i, n) - then acc - else { - let curr = nth (i, xs) - let next = f (acc, curr) - recur (inc (i), next) - } - } -} - -fn filter { - (f) -> fn filterer (xs) -> filter (f, xs) - (f, xs) -> { - let n = count (xs) - loop (0, []) with (i, ys) -> when { - eq (i, n) -> ys - f (nth (i, xs)) -> recur (inc (i), conj (ys, nth (i, xs))) - else -> recur (inc (i), ys) - } - } -} - -& fn shuffle - -ref x = 4 - -set! (x, "foo") - -set! (x, :foo) - -deref (x) - -let greater_than_two? = gt (_, 2) - -fn square (x) -> mult (x, x) - -let xs = [1, 2, 3] - -let ys = #{:a 1, :b 2} - -ys :a - -:a (ys) - -let y = 1 - -do y > inc > square > sub (_, 3) diff --git a/shadow-cljs.edn b/shadow-cljs.edn deleted file mode 100644 index e9a8650..0000000 --- a/shadow-cljs.edn +++ /dev/null @@ -1,18 +0,0 @@ -;; shadow-cljs configuration -{:deps true - - :dev-http {8234 "target"} - - :builds - {:node {:target :node-library - :output-to "target/js/ludus.js" - :exports {:run ludus.node/run} - :modules {:main {:entries [ludus.node]}}} - :module {:target :esm - :output-dir "target/js" - :modules {:ludus {:exports {run ludus.node/run test ludus.node/run-test}}} - } - :browser {:target :browser - :output-dir "target/js" - :asset-path "target" - :modules {:main {:init-fn ludus.web/init}}}}} diff --git a/janet/base.janet b/src/base.janet similarity index 90% rename from janet/base.janet rename to src/base.janet index 08a5704..063bdbd 100644 --- a/janet/base.janet +++ b/src/base.janet @@ -71,6 +71,30 @@ :pkg (show-pkg x) (stringify x))) +(var json nil) + +(defn- dict-json [dict] + (string/join + (map + (fn [[k v]] (string (json k) ": " (json v))) + (pairs dict)) + ", ")) + +(defn- json* [x] + (case (ludus/type x) + :nil "null" + :number (string x) + :bool (if true "true" "false") + :string (string "\"" x "\"") + :keyword (string "\"" x "\"") + :tuple (string "[" (string/join (map json x) ", ") "]") + :list (string "[" (string/join (map json x) ", ")"]") + :dict (string "{" (dict-json x) "}") + :set (string "[" (string/join (map json (keys x)) ", ") "]") + (show x))) + +(set json json*) + (defn show-patt [x] (case (x :type) :nil "nil" diff --git a/janet/errors.janet b/src/errors.janet similarity index 96% rename from janet/errors.janet rename to src/errors.janet index 7d3e8dc..d4fff55 100644 --- a/janet/errors.janet +++ b/src/errors.janet @@ -1,6 +1,4 @@ -(import spork/json :as j) -(try (os/cd "janet") ([_] nil)) -(import /base :as b) +(import /src/base :as b) (defn- get-line [source line] ((string/split "\n" source) (dec line))) diff --git a/janet/interpreter.janet b/src/interpreter.janet similarity index 95% rename from janet/interpreter.janet rename to src/interpreter.janet index f5f00d4..6d62913 100644 --- a/janet/interpreter.janet +++ b/src/interpreter.janet @@ -1,9 +1,6 @@ # A tree walk interpreter for ludus -# for repl imports -(try (os/cd "janet") ([_] nil)) - -(import ./base :as b) +(import /src/base :as b) (var interpret nil) (var match-pattern nil) @@ -622,33 +619,33 @@ (set interpret interpret*) -# repl -(import ./scanner :as s) -(import ./parser :as p) -(import ./validate :as v) +# # repl +# (import ./scanner :as s) +# (import ./parser :as p) +# (import ./validate :as v) -(var source nil) +# (var source nil) -(defn- has-errors? [{:errors errors}] (and errors (not (empty? errors)))) +# (defn- has-errors? [{:errors errors}] (and errors (not (empty? errors)))) -(defn run [] - (def scanned (s/scan source)) - (when (has-errors? scanned) (break (scanned :errors))) - (def parsed (p/parse scanned)) - (when (has-errors? parsed) (break (parsed :errors))) - (def validated (v/valid parsed b/ctx)) - # (when (has-errors? validated) (break (validated :errors))) - # (def cleaned (get-in parsed [:ast :data 1])) - # # (pp cleaned) - # (interpret (parsed :ast) @{:^parent b/ctx}) - (try (interpret (parsed :ast) @{:^parent b/ctx}) - ([e] (if (struct? e) (error (e :msg)) (error e))))) +# (defn run [] +# (def scanned (s/scan source)) +# (when (has-errors? scanned) (break (scanned :errors))) +# (def parsed (p/parse scanned)) +# (when (has-errors? parsed) (break (parsed :errors))) +# (def validated (v/valid parsed b/ctx)) +# # (when (has-errors? validated) (break (validated :errors))) +# # (def cleaned (get-in parsed [:ast :data 1])) +# # # (pp cleaned) +# # (interpret (parsed :ast) @{:^parent b/ctx}) +# (try (interpret (parsed :ast) @{:^parent b/ctx}) +# ([e] (if (struct? e) (error (e :msg)) (error e))))) -# (do -(comment -(set source ` +# # (do +# (comment +# (set source ` -`) -(def result (run)) -) +# `) +# (def result (run)) +# ) diff --git a/janet/judge b/src/judge similarity index 100% rename from janet/judge rename to src/judge diff --git a/janet/judgy.fish b/src/judgy.fish similarity index 100% rename from janet/judgy.fish rename to src/judgy.fish diff --git a/janet/language.test.janet b/src/language.test.janet similarity index 100% rename from janet/language.test.janet rename to src/language.test.janet diff --git a/janet/ludus.janet b/src/ludus.janet similarity index 77% rename from janet/ludus.janet rename to src/ludus.janet index 3b031e8..25c39cd 100644 --- a/janet/ludus.janet +++ b/src/ludus.janet @@ -1,17 +1,16 @@ # an integrated Ludus interpreter # devised in order to run under wasm # takes a string, returns a string with a json object -(try (os/cd "janet") ([_] nil)) # for REPL -(import /scanner :as s) -(import /parser :as p) -(import /validate :as v) -(import /interpreter :as i) -(import /errors :as e) -(import /base :as b) -(import /prelude :as prelude) -(import spork/json :as j) +# (try (os/cd "janet") ([_] nil)) # for REPL +(import /src/scanner :as s) +(import /src/parser :as p) +(import /src/validate :as v) +(import /src/interpreter :as i) +(import /src/errors :as e) +(import /src/base :as b) +(import /src/prelude :as prelude) -(defn run [source] +(defn ludus [source] (when (= :error prelude/pkg) (error "could not load prelude")) (def ctx @{:^parent prelude/ctx}) (def errors @[]) @@ -45,11 +44,13 @@ (set (out :errors) [err]) (break out))) (setdyn :out stdout) - (set (out :result) result) + (set (out :result) (b/show result)) (var post @{}) (try (set post (i/interpret prelude/post/ast ctx)) ([err] (e/runtime-error err))) (set (out :draw) (post :draw)) - (j/encode out)) + (b/json out)) + +(defn hello [] (print "hello")) diff --git a/src/ludus/ast.cljc b/src/ludus/ast.cljc deleted file mode 100644 index 0f8ca7c..0000000 --- a/src/ludus/ast.cljc +++ /dev/null @@ -1,2 +0,0 @@ -(ns ludus.ast) - diff --git a/src/ludus/base.cljc b/src/ludus/base.cljc deleted file mode 100644 index 7601496..0000000 --- a/src/ludus/base.cljc +++ /dev/null @@ -1,434 +0,0 @@ -(ns ludus.base - (:require - [ludus.data :as data] - [ludus.show :as show] - [clojure.math :as math] - ;[ludus.draw :as d] - #?(:cljs [cljs.reader]) - #?(:cljs [goog.object :as o]) - )) - -;; TODO: make eq, and, or special forms that short-circuit -;; Right now, they evaluate all their args -(def eq {:name "eq" - ::data/type ::data/clj - :body =}) - -(defn- id [x] x) - -(def and- {:name "and" - ::data/type ::data/clj - :body (fn [& args] (every? id args))}) - -(def or- {:name "or" - ::data/type ::data/clj - :body (fn [& args] (some id args))}) - -(def add {:name "add" - ::data/type ::data/clj - :body +}) - -(def sub {:name "sub" - ::data/type ::data/clj - :body -}) - -(def mult {:name "mult" - ::data/type ::data/clj - :body *}) - -(def div {:name "div" - ::data/type ::data/clj - :body /}) - -(def gt {:name "gt" - ::data/type ::data/clj - :body >}) - -(def gte {:name "gte" - ::data/type ::data/clj - :body >=}) - -(def lt {:name "lt" - ::data/type ::data/clj - :body <}) - -(def lte {:name "lte" - ::data/type ::data/clj - :body <=}) - -(def inc- {:name "inc" - ::data/type ::data/clj - :body inc}) - -(def dec- {:name "dec" - ::data/type ::data/clj - :body dec}) - -(def not- {:name "not" - ::data/type ::data/clj - :body not}) - -(defn- print-show [lvalue] - (if (string? lvalue) lvalue (show/show lvalue))) - -(defn- stringify-args [arglist] - (apply str (interpose " " (into [] (map print-show) (rest arglist))))) -; (def panic! {:name "panic!" -; ::data/type ::data/clj -; :body (fn panic-inner -; ([] (panic-inner [::data/list])) -; ([args] (throw (ex-info (stringify-args args) {}))))}) - -(def print- {:name "print" - ::data/type ::data/clj - :body (fn [args] - (println (stringify-args args)) - :ok)}) - -(def refs (atom {})) ;; atom not volatile!, maybe we'll be multithreaded someday - -(def deref- {:name "deref" - ::data/type ::data/clj - :body (fn [ref] - (if (::data/ref ref) - (get @refs (::data/name ref)) - (throw (ex-info "Cannot deref something that is not a ref" {}))))}) - -(def set!- {:name "set!" - ::data/type ::data/clj - :body (fn [ref value] - (if (::data/ref ref) - (do - (swap! refs assoc (::data/name ref) value) - (reset! (::data/value ref) value) - value) - (throw (ex-info "Cannot set! something that is not a ref" {}))))}) - -(def show {:name "show" - ::data/type ::data/clj - :body ludus.show/show}) - -(def conj- {:name "conj" - ::data/type ::data/clj - :body conj}) - -(def assoc- {:name "assoc" - ::data/type ::data/clj - :body assoc}) - -(def dissoc- {name "dissoc" - ::data/type ::data/clj - :body dissoc}) - -(def get- {:name "get" - ::data/type ::data/clj - :body (fn - ([key, map] - (if (map? map) - (get map key) - nil)) - ([key, map, default] - (if (map? map) - (get map key default) - default)))}) - -(def rest- {:name "rest" - ::data/type ::data/clj - :body (fn [v] - (into [::data/list] (nthrest v 2)))}) - -(def nth- {:name "nth" - ::data/type ::data/clj - :body nth}) - -(def slice {:name "slice" - ::data/type ::data/clj - :body subvec}) - -(def types { - :keyword - #?( - :clj clojure.lang.Keyword - :cljs cljs.core/Keyword - ) - - :long - #?( - :clj java.lang.Long - :cljs js/Number - ) - - :double - #?( - :clj java.lang.Double - :cljs js/Number - ) - - :integer - #?( - :clj java.lang.Integer - :cljs js/Number - ) - - :ratio - #?( - :clj clojure.lang.Ratio - :cljs js/Number - ) - - :string - #?( - :clj java.lang.String - :cljs js/String - ) - - :boolean - #?( - :clj java.lang.Boolean - :cljs js/Boolean - ) - - :set - #?( - :clj clojure.lang.PersistentHashSet - :cljs cljs.core/PersistentHashSet - ) - - :vector - #?( - :clj clojure.lang.PersistentVector - :cljs cljs.core/PersistentVector - ) - - :map - #?( - :clj clojure.lang.PersistentArrayMap - :cljs cljs.core/PersistentArrayMap - ) - }) - -(defn get-type [value] - (let [t (type value)] - (cond - (nil? value) :nil - - (= (:keyword types) t) :keyword - - (= (:long types) t) :number - - (= (:double types) t) :number - - (= (:integer types) t) :number - - (= (:ratio types) t) :number - - (= (:string types) t) :string - - (= (:boolean types) t) :boolean - - (= (:set types) t) :set - - ;; tuples and lists - (= (:vector types) t) - (if (= ::data/tuple (first value)) :tuple :list) - - ;; structs dicts namespaces refs - (= (:map types) t) - (cond - (::data/type value) (case (::data/type value) - (::data/fn ::data/clj) :fn - ::data/ns :ns) - (::data/dict value) :dict - (::data/struct value) :struct - (::data/ref value) :ref - :else :none - )))) - -(def type- {:name "type" - ::data/type ::data/clj - :body get-type}) - -(defn- kv->tuple [[k v]] [::data/tuple k v]) - -(def to_list {name "to_list" - ::data/type ::data/clj - :body (fn [item] - (case (get-type item) - (:number :nil :boolean :fn :string :ref :keyword) [::data/list item] - :list item - :set (into [::data/list] item) - :tuple (into [::data/list] (rest item)) - :dict (into [::data/list] (map kv->tuple) (dissoc item ::data/dict)) - :struct (into [::data/list] (map kv->tuple) (dissoc item ::data/struct)) - :ns (into [::data/list] (map kv->tuple) (dissoc item ::data/struct ::data/type ::data/name)) - ))}) - -(def to_dict {name "to_dict" - ::data/type ::data/clj - :body (fn [struct] (-> struct (assoc ::data/dict true) (dissoc ::data/struct ::data/type ::data/name)))}) - -(defn strpart [kw] (->> kw str rest (apply str))) - -(def readstr - #?( - :clj read-string - :cljs cljs.reader/read-string - )) - -(defn- resolve-str [str] - #?( - :clj (eval str) - :cljs (.bind (o/get js/window str) js/window) - )) - -(def extern {:name "extern" - ::data/type ::data/clj - :body (fn [& args] - ;(println "Args passed: " args) - (let [called (-> args first strpart readstr resolve-str) - fn-args (rest args)] - ;(println "Fn: " called) - ;(println "Args: " (clj->js fn-args)) - #?( - :clj (apply called fn-args) - :cljs (.apply called js/window (clj->js fn-args)))))}) - -(def count- {:name "count" - ::data/type ::data/clj - :body count}) - -(def into- {:name "into" - ::data/type ::data/clj - :body into}) - -(def to_vec {:name "to_vec" - ::data/type ::data/clj - :body (fn [xs] (into [] (dissoc xs ::data/type ::data/struct ::data/name)))}) - -(def fold {:name "fold" - ::data/type ::data/clj - :body reduce}) - -(def map- {:name "map" - ::data/type ::data/clj - :body map}) - -(def prn- {:name "raw" - ::data/type ::data/clj - :body println}) - -(def concat- {:name "concat" - ::data/type ::data/clj - :body (fn [xs ys] - (if (= ::data/list (first xs)) - (into [::data/list] (concat (rest xs) (rest ys))) - (into #{} (concat xs ys))))}) - -(def str- {:name "str" - ::data/type ::data/clj - :body str}) - -(def doc- {:name "doc" - ::data/type ::data/clj - :body (fn [f] - (let [name (:name f) - docstring (:doc f) - clauses (:clauses f) - patterns (map first clauses) - pretty-patterns (map show/show-pattern patterns) - doc (into [name docstring] pretty-patterns)] - (apply str (interpose "\n" doc))) - )}) - -(def sin {:name "sin" - ::data/type ::data/clj - :body math/sin}) - -(def cos {:name "cos" - ::data/type ::data/clj - :body math/cos}) - -(def tan {:name "tan" - ::data/type ::data/clj - :body math/tan}) - -(def atan_2 {:name "atan_2" - ::data/type ::data/clj - :body math/atan2}) - -(def sqrt {:name "sqrt" - ::data/type ::data/clj - :body math/sqrt}) - -(def random {:name "random" - ::data/type ::data/clj - :body rand}) - -(def floor {:name "floor" - ::data/type ::data/clj - :body math/floor}) - -(def ceil {:name "ceil" - ::data/type ::data/clj - :body math/ceil}) - -(def round {:name "round" - ::data/type ::data/clj - :body math/round}) - -(def range- {:name "range" - ::data/type ::data/clj - :body (fn [start end] (into [::data/list] (range (-> start math/ceil int) end)))}) - -(def base { - :id id - :eq eq - :add add - :print print- - :sub sub - :mult mult - :div div - :gt gt - :gte gte - :lt lt - :lte lte - :inc inc- - :dec dec- - :not not- - :show show - :deref deref- - :set! set!- - :and and- - :or or- - :assoc assoc- - :dissoc dissoc- - :conj conj- - :get get- - :type type- - :extern extern - :rest rest- - :nth nth- - :slice slice - :count count- - :into into- - :to_vec to_vec - :fold fold - :map map - ; :panic! panic! - :prn prn- - :concat concat- - :str str- - :to_list to_list - :doc doc- - :pi math/PI - :sin sin - :cos cos - :tan tan - :atan_2 atan_2 - :sqrt sqrt - :random random - :ceil ceil - :floor floor - :round round - :range range- - }) \ No newline at end of file diff --git a/src/ludus/collections.cljc b/src/ludus/collections.cljc deleted file mode 100644 index 5637314..0000000 --- a/src/ludus/collections.cljc +++ /dev/null @@ -1 +0,0 @@ -(ns ludus.collections) \ No newline at end of file diff --git a/src/ludus/core.clj b/src/ludus/core.clj deleted file mode 100644 index 6767476..0000000 --- a/src/ludus/core.clj +++ /dev/null @@ -1,38 +0,0 @@ -(ns ludus.core - "A tree-walk interpreter for the Ludus language." - (:require - [ludus.scanner :as scanner] - [ludus.parser :as p] - [ludus.grammar :as g] - [ludus.interpreter :as interpreter] - [ludus.show :as show] - [clojure.pprint :as pp] - [ludus.loader :as loader] - [ludus.repl :as repl]) - (:gen-class)) - -(defn- run [file source] - (let [scanned (scanner/scan source)] - (if (not-empty (:errors scanned)) - (do - (println "I found some scanning errors!") - (pp/pprint (:errors scanned)) - (System/exit 65)) - (let [parsed (p/apply-parser g/script (:tokens scanned))] - (if (p/fail? parsed) - (do - (println "I found some parsing errors!") - (println (p/err-msg parsed)) - (System/exit 66)) - (let [interpreted (interpreter/interpret source file parsed)] - (println (show/show interpreted)) - (System/exit 0))))))) - -(defn -main [& args] - (cond - (= (count args) 1) - (let [file (first args) - source (loader/load-import file)] - (run file source)) - - :else (repl/launch))) \ No newline at end of file diff --git a/src/ludus/data.cljc b/src/ludus/data.cljc deleted file mode 100644 index dcddd0b..0000000 --- a/src/ludus/data.cljc +++ /dev/null @@ -1,2 +0,0 @@ -(ns ludus.data) - diff --git a/src/ludus/doc.cljc b/src/ludus/doc.cljc deleted file mode 100644 index 6537884..0000000 --- a/src/ludus/doc.cljc +++ /dev/null @@ -1,126 +0,0 @@ -(ns ludus.doc - (:require [ludus.interpreter :as interpreter] - [ludus.base :as base] - [ludus.data :as data] - [clojure.string :as string])) - -(def prelude interpreter/ludus-prelude) - -(def exports-only (dissoc prelude ::data/type ::data/struct)) - -(defn map-values [f] (fn [[k v]] [k (f v)])) - -(def ludus-doc (base/doc- :body)) - -(def with-docs (into {} (map (map-values ludus-doc)) exports-only)) - -(def sorted-names (-> with-docs keys sort)) - -(defn escape-underscores [the-str] (string/replace the-str #"_" "\\_")) - -(defn escape-punctuation [the-str] (string/replace the-str #"[\!\?]" "")) - -(defn toc-entry [name] (let [escaped (escape-underscores name)] (str "[" escaped "](#" (escape-punctuation escaped) ")"))) - -(def alphabetical-list (string/join "    " (map toc-entry sorted-names))) - -(def topics { - "math" ["abs" "add" "angle" "atan/2" "ceil" "cos" "dec" "deg/rad" "deg/turn" "dist" "div" - "div/0" "div/safe" "even?" "floor" "gt?" "gte?" "heading/vector" "inc" "lt?" "lte?" "mod" - "mult" "neg" "neg?" "odd?" "pi" "pos?" "rad/deg" "rad/turn" "random" "range" "round" - "sin" "square" "sub" "sum_of_squares" "tan" "tau" "turn/deg" "turn/rad" "zero?"] - "boolean" ["and" "bool" "bool?" "false?" "or" "not"] - "dicts" ["assoc" "assoc?" "dict" "diff" "dissoc" "get" "keys" "update" "values"] - "lists" ["append" "at" "butlast" "concat" "count" "each!" "first" "fold" "last" "list" "list?" "map" "ordered?" "range" - "rest" "second" "slice"] - "sets" ["set" "set?"] - "strings" ["count" "join" "show" "string" "string?"] - "types and values" ["bool?" "coll?" "dict?" "eq?" "fn?" "keyword?" "list?" "neq?" "nil?" "number?" "ordered?" "show" "some" "some?" "type"] - "references and state" ["deref" "make!" "update!"] - "results" ["err" "err?" "ok" "ok?" "unwrap!" "unwrap_or"] - "errors" ["assert!" "panic!"] - "turtle graphics" ["back!" "background!" "bk!" "clear!" "fd!" "forward!" "goto!" "heading" "heading/vector" "home!" "left!" "lt!" "pc!" "pd!" "pencolor" - "pencolor!" "pendown!" "pendown?" "penup!" "penwidth" "penwidth!" "position" "pu!" "pw!" "render_turtle!" "reset_turtle!" - "right!" "rt!" "turtle_state"] - "environment and i/o" ["doc!" "flush!" "print!" "prn!" "report!"] - }) - -(defn topic-entry [topic] (str "### " (string/capitalize topic) "\n" - (->> topic (get topics) sort (map toc-entry) (string/join "    ")) - "\n")) - -(def by-topic (let [the-topics (-> topics keys sort) - topics-entries (map topic-entry the-topics)] - (string/join "\n" topics-entries))) - -(defn compose-entry [name] - (let [the-doc (get with-docs name) - header (str "### " name "\n") - lines (string/split-lines the-doc)] - (if (empty? lines) (str header "No documentation available.\n") - (let [ - description (second lines) - pattern-lines (subvec lines 2) - patterns (string/join "\n" pattern-lines) - ] - (str header description "\n```\n" patterns "\n```") - )))) - -(def entries (string/join "\n\n" (map compose-entry sorted-names))) - -(def doc-file - (str - "# Ludus prelude documentation -These functions are available in every Ludus script. -The documentation for any function can be found within Ludus by passing the function to `doc!`, -e.g., running `doc! (add)` will send the documentation for `add` to the console. - -For more information on the syntax & semantics of the Ludus language, see [language.md](./language.md). - -## A few notes -**Naming conventions.** Functions whose name ends with a question mark, e.g., `eq?`, return booleans. -Functions whose name ends with an exclamation point, e.g., `make!`, change state in some way. -In other words, they _do things_ rather than _calculating values_. -Functions whose name includes a slash either convert from one value to another, e.g. `deg/rad`, -or they are variations on a function, e.g. `div/0` as a variation on `div`. - -**How entries are formatted.** Each entry has a brief (sometimes too brief!) description of what it does. -It is followed by the patterns for each of its function clauses. -This should be enough to indicate order of arguments, types, and so on. - -**Patterns often, but do not always, indicate types.** Typed patterns are written as `foo as :bar`, -where the type is indicated by the keyword. -Possible ludus types are: `:nil`, `:boolean`, `:number`, `:keyword` (atomic values); -`:string` (strings are their own beast); `:tuple` and `:list` (indexed collections); `:set` (sets are specific), -`:dict` and `:ns` (associative collections); and `:ref` (references). - -**Conventional types.** Ludus has two types based on conventions. -* _Result tuples._ Results are a way of modeling the result of a calculation that might fail. -The two possible values are `(:ok, value)` and `(:err, msg)`. -`msg` is usually a string describing what went wrong. -To work with result tuples, see [`unwrap!`](#unwrap) and [`unwrap_or`](#unwrap_or). -That said, usually you work with these using pattern matching. - -* _Vectors._ Vectors are 2-element tuples of x and y coordinates. -The origin is `(0, 0)`. -Many math functions take vectors as well as numbers, e.g., `add` and `mult`. -You will see vectors indicated in patterns by an `(x, y)` tuple. -You can see what this looks like in the last clause of `add`: `((x1, y1), (x2, y2))`. - -## Functions by topic - -" - by-topic - - " - -## All functions, alphabetically -" - alphabetical-list - " -## Function documentation -" - entries - )) - -(spit "prelude.md" doc-file) diff --git a/src/ludus/draw.cljs b/src/ludus/draw.cljs deleted file mode 100644 index 302b27b..0000000 --- a/src/ludus/draw.cljs +++ /dev/null @@ -1,15 +0,0 @@ -(ns ludus.draw) - -(defn background - ([x] (js/background x)) - ([r g b] (js/background r g b)) - ([r g b a] (js/background r g b a))) - -(defn rect [[x y] [w h]] - (js/rect x y w h)) - -(defn ellipse [[x y] [w h]]) - -(def draw { - - }) \ No newline at end of file diff --git a/src/ludus/error.cljc b/src/ludus/error.cljc deleted file mode 100644 index 2fc5ec9..0000000 --- a/src/ludus/error.cljc +++ /dev/null @@ -1,46 +0,0 @@ -(ns ludus.error - (:require [clojure.string :as string])) - -(defn get-line [source line] - (let [lines (string/split-lines source) - the_line (nth lines (dec line))] - the_line)) - -(string/split-lines "abcd") - -(defn get-underline [source {:keys [line start lexeme]} prefix] - (let [lines (string/split-lines source) - lines-before (subvec lines 0 (dec line)) - line-start (reduce (fn [len line] (+ len (count line))) (count lines-before) lines-before) - from-start (- start line-start) - underline-length (count lexeme) - padding (string/join (take (+ prefix from-start) (repeat "-"))) - underline (string/join (take underline-length (repeat "^")))] - (apply str padding underline) - )) - -(defn scan-error [] :TODO) - -(defn parse-error [{:keys [trace token]}] - (let [source (:source token) - input (:input token) - line-num (:line token) - line (get-line source line-num) - line-num (:line token) - prefix (str line-num ": ") - underline (get-underline source token (count prefix)) - expected (first trace) - got (:type token) - message (str "Ludus found a parsing error on line " line-num " in " input ".\nExpected: " expected "\nGot: " got "\n") - ] - (str message "\n" prefix line "\n" underline) - ) - ) - -(defn run-error [{:keys [message token line]}] - (let [source (:source token) input (:input token)] - (if line - (str "Ludus panicked!: " message "\nOn line " line " in " input "\n" (get-line source line)) - (str "Ludus panicked!\n" message) - ))) - diff --git a/src/ludus/grammar.cljc b/src/ludus/grammar.cljc deleted file mode 100644 index 334c491..0000000 --- a/src/ludus/grammar.cljc +++ /dev/null @@ -1,273 +0,0 @@ -(ns ludus.grammar - (:require - #?( - :clj [ludus.parser :refer :all] - :cljs [ludus.parser - :refer [choice quiet one+ zero+ group order-0 order-1 flat maybe weak-order] - :refer-macros [defp] - ] - ) - [ludus.scanner :as s] - )) - -(declare expression pattern binding-expr non-binding simple) - -(defp separator choice [:comma :newline :break]) - -(defp separators quiet one+ separator) - -(defp terminator choice [:newline :semicolon :break]) - -(defp terminators quiet one+ terminator) - -(defp nls? quiet zero+ :newline) - -(defp splat group order-1 [(quiet :splat) :word]) - -(defp patt-splat-able flat choice [:word :ignored :placeholder]) - -(defp splattern group order-1 [(quiet :splat) (maybe patt-splat-able)]) - -(defp literal flat choice [:nil :true :false :number :string]) - -(defp tuple-pattern-term flat choice [pattern splattern]) - -(defp tuple-pattern-entry weak-order [tuple-pattern-term separators]) - -(defp tuple-pattern group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ tuple-pattern-entry) - (quiet :rparen)]) - -(defp list-pattern group order-1 [(quiet :lbracket) - (quiet (zero+ separator)) - (zero+ tuple-pattern-entry) - (quiet :rbracket)]) - -(defp pair-pattern group weak-order [:keyword pattern]) - -(defp typed group weak-order [:word (quiet :as) :keyword]) - -(defp dict-pattern-term flat choice [pair-pattern typed :word splattern]) - -(defp dict-pattern-entry weak-order [dict-pattern-term separators]) - -(defp dict-pattern group order-1 [(quiet :startdict) - (quiet (zero+ separator)) - (zero+ dict-pattern-entry) - (quiet :rbrace) - ]) - -; (defp struct-pattern group order-1 [(quiet :startstruct) -; (quiet (zero+ separator)) -; (zero+ dict-pattern-entry) -; (quiet :rbrace) -; ]) - -(defp guard order-0 [(quiet :if) simple]) - -(defp pattern flat choice [literal - :ignored - :placeholder - typed - :word - :keyword - :else - tuple-pattern - dict-pattern - ;struct-pattern - list-pattern]) - -(defp match-clause group weak-order [pattern (maybe guard) (quiet :rarrow) expression]) - -(defp match-entry weak-order [match-clause terminators]) - -(defp match group order-1 [(quiet :match) simple nls? - (quiet :with) (quiet :lbrace) - (quiet (zero+ terminator)) - (one+ match-entry) - (quiet :rbrace) - ]) - -(defp when-lhs flat choice [simple :placeholder :else]) - -(defp when-clause group weak-order [when-lhs (quiet :rarrow) expression]) - -(defp when-entry weak-order [when-clause terminators]) - -(defp when-expr group order-1 [(quiet :when) (quiet :lbrace) - (quiet (zero+ terminator)) - (one+ when-entry) - (quiet :rbrace)]) - -(defp let-expr group order-1 [(quiet :let) - pattern - (quiet :equals) - nls? - non-binding]) - -(defp condition flat choice [simple let-expr]) - -(defp if-expr group order-1 [(quiet :if) - nls? - condition - nls? - (quiet :then) - expression - nls? - (quiet :else) - expression]) - -(defp tuple-entry weak-order [non-binding separators]) - -(defp tuple group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ tuple-entry) - (quiet :rparen)]) - -(defp list-term flat choice [splat non-binding]) - -(defp list-entry order-1 [list-term separators]) - -(defp list-literal group order-1 [(quiet :lbracket) - (quiet (zero+ separator)) - (zero+ list-entry) - (quiet :rbracket)]) - -(defp set-literal group order-1 [(quiet :startset) - (quiet (zero+ separator)) - (zero+ list-entry) - (quiet :rbrace)]) - -(defp pair group order-0 [:keyword non-binding]) - -;; "struct-term" and "struct-entry" are necessary for nses -(defp struct-term flat choice [:word pair]) - -(defp struct-entry order-1 [struct-term separators]) - -; (defp struct-literal group order-1 [(quiet :startstruct) -; (quiet (zero+ separator)) -; (zero+ struct-entry) -; (quiet :rbrace)]) - -(defp dict-term flat choice [splat :word pair]) - -(defp dict-entry order-1 [dict-term separators]) - -(defp dict group order-1 [(quiet :startdict) - (quiet (zero+ separator)) - (zero+ dict-entry) - (quiet :rbrace)]) - -(defp arg-expr flat choice [:placeholder non-binding]) - -(defp arg-entry weak-order [arg-expr separators]) - -(defp args group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ arg-entry) - (quiet :rparen)]) - -(defp recur-call group order-1 [(quiet :recur) tuple]) - -(defp synth-root flat choice [:keyword :word]) - -(defp synth-term flat choice [args :keyword]) - -(defp synthetic group order-1 [synth-root (zero+ synth-term)]) - -(defp fn-clause group order-1 [tuple-pattern (maybe guard) (quiet :rarrow) expression]) - -(defp fn-entry order-1 [fn-clause terminators]) - -(defp fn-compound group order-1 [(quiet :lbrace) - nls? - (maybe :string) - (quiet (zero+ terminator)) - (one+ fn-entry) - (quiet :rbrace) - ]) - -(defp clauses flat choice [fn-clause fn-compound]) - -(defp fn-named group order-1 [(quiet :fn) :word clauses]) - -(defp lambda group order-1 [(quiet :fn) fn-clause]) - -(defp block-line weak-order [expression terminators]) - -(defp block group order-1 [(quiet :lbrace) - (quiet (zero+ terminator)) - (one+ block-line) - (quiet :rbrace)]) - -(defp pipeline quiet order-0 [nls? :pipeline]) - -(defp do-entry order-1 [pipeline expression]) - -(defp do-expr group order-1 [(quiet :do) - expression - (one+ do-entry) - ]) - -(defp ref-expr group order-1 [(quiet :ref) :word (quiet :equals) expression]) - -; (defp spawn group order-1 [(quiet :spawn) expression]) - -; (defp receive group order-1 [(quiet :receive) (quiet :lbrace) -; (quiet (zero+ terminator)) -; (one+ match-entry) -; (quiet :rbrace) -; ]) - -(defp compound-loop group order-0 [(quiet :lbrace) - (quiet (zero+ terminator)) - (one+ fn-entry) - (quiet :rbrace)]) - -(defp loop-expr group order-1 [(quiet :loop) tuple (quiet :with) - (flat (choice :loop-body [fn-clause compound-loop]))]) - -(defp repeat-expr group order-1 [(quiet :repeat) (choice :times [:word :number]) non-binding]) - -(defp collection flat choice [;struct-literal - dict list-literal set-literal tuple]) - -(defp panic group order-1 [(quiet :panic) expression]) - -(defp simple flat choice [literal collection synthetic recur-call lambda panic]) - -(defp compound flat choice [match loop-expr if-expr when-expr do-expr block repeat-expr]) - -(defp binding-expr flat choice [fn-named let-expr ref-expr]) - -(defp non-binding flat choice [simple compound]) - -(defp expression flat choice [binding-expr non-binding]) - -(defp test-expr group order-1 [(quiet :test) :string non-binding]) - -(defp import-expr group order-1 [(quiet :import) :string (quiet :as) :word]) - -(defp ns-expr group order-1 [(quiet :ns) - :word - (quiet :lbrace) - (quiet (zero+ separator)) - (zero+ struct-entry) - (quiet :rbrace)]) - -(defp use-expr group order-1 [(quiet :use) :word]) - -(defp toplevel flat choice [import-expr - ns-expr - expression - test-expr - use-expr]) - -(defp script-line weak-order [toplevel terminators]) - -(defp script order-0 [nls? - (one+ script-line) - (quiet :eof)]) - diff --git a/src/ludus/grammar.janet b/src/ludus/grammar.janet deleted file mode 100644 index 334c491..0000000 --- a/src/ludus/grammar.janet +++ /dev/null @@ -1,273 +0,0 @@ -(ns ludus.grammar - (:require - #?( - :clj [ludus.parser :refer :all] - :cljs [ludus.parser - :refer [choice quiet one+ zero+ group order-0 order-1 flat maybe weak-order] - :refer-macros [defp] - ] - ) - [ludus.scanner :as s] - )) - -(declare expression pattern binding-expr non-binding simple) - -(defp separator choice [:comma :newline :break]) - -(defp separators quiet one+ separator) - -(defp terminator choice [:newline :semicolon :break]) - -(defp terminators quiet one+ terminator) - -(defp nls? quiet zero+ :newline) - -(defp splat group order-1 [(quiet :splat) :word]) - -(defp patt-splat-able flat choice [:word :ignored :placeholder]) - -(defp splattern group order-1 [(quiet :splat) (maybe patt-splat-able)]) - -(defp literal flat choice [:nil :true :false :number :string]) - -(defp tuple-pattern-term flat choice [pattern splattern]) - -(defp tuple-pattern-entry weak-order [tuple-pattern-term separators]) - -(defp tuple-pattern group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ tuple-pattern-entry) - (quiet :rparen)]) - -(defp list-pattern group order-1 [(quiet :lbracket) - (quiet (zero+ separator)) - (zero+ tuple-pattern-entry) - (quiet :rbracket)]) - -(defp pair-pattern group weak-order [:keyword pattern]) - -(defp typed group weak-order [:word (quiet :as) :keyword]) - -(defp dict-pattern-term flat choice [pair-pattern typed :word splattern]) - -(defp dict-pattern-entry weak-order [dict-pattern-term separators]) - -(defp dict-pattern group order-1 [(quiet :startdict) - (quiet (zero+ separator)) - (zero+ dict-pattern-entry) - (quiet :rbrace) - ]) - -; (defp struct-pattern group order-1 [(quiet :startstruct) -; (quiet (zero+ separator)) -; (zero+ dict-pattern-entry) -; (quiet :rbrace) -; ]) - -(defp guard order-0 [(quiet :if) simple]) - -(defp pattern flat choice [literal - :ignored - :placeholder - typed - :word - :keyword - :else - tuple-pattern - dict-pattern - ;struct-pattern - list-pattern]) - -(defp match-clause group weak-order [pattern (maybe guard) (quiet :rarrow) expression]) - -(defp match-entry weak-order [match-clause terminators]) - -(defp match group order-1 [(quiet :match) simple nls? - (quiet :with) (quiet :lbrace) - (quiet (zero+ terminator)) - (one+ match-entry) - (quiet :rbrace) - ]) - -(defp when-lhs flat choice [simple :placeholder :else]) - -(defp when-clause group weak-order [when-lhs (quiet :rarrow) expression]) - -(defp when-entry weak-order [when-clause terminators]) - -(defp when-expr group order-1 [(quiet :when) (quiet :lbrace) - (quiet (zero+ terminator)) - (one+ when-entry) - (quiet :rbrace)]) - -(defp let-expr group order-1 [(quiet :let) - pattern - (quiet :equals) - nls? - non-binding]) - -(defp condition flat choice [simple let-expr]) - -(defp if-expr group order-1 [(quiet :if) - nls? - condition - nls? - (quiet :then) - expression - nls? - (quiet :else) - expression]) - -(defp tuple-entry weak-order [non-binding separators]) - -(defp tuple group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ tuple-entry) - (quiet :rparen)]) - -(defp list-term flat choice [splat non-binding]) - -(defp list-entry order-1 [list-term separators]) - -(defp list-literal group order-1 [(quiet :lbracket) - (quiet (zero+ separator)) - (zero+ list-entry) - (quiet :rbracket)]) - -(defp set-literal group order-1 [(quiet :startset) - (quiet (zero+ separator)) - (zero+ list-entry) - (quiet :rbrace)]) - -(defp pair group order-0 [:keyword non-binding]) - -;; "struct-term" and "struct-entry" are necessary for nses -(defp struct-term flat choice [:word pair]) - -(defp struct-entry order-1 [struct-term separators]) - -; (defp struct-literal group order-1 [(quiet :startstruct) -; (quiet (zero+ separator)) -; (zero+ struct-entry) -; (quiet :rbrace)]) - -(defp dict-term flat choice [splat :word pair]) - -(defp dict-entry order-1 [dict-term separators]) - -(defp dict group order-1 [(quiet :startdict) - (quiet (zero+ separator)) - (zero+ dict-entry) - (quiet :rbrace)]) - -(defp arg-expr flat choice [:placeholder non-binding]) - -(defp arg-entry weak-order [arg-expr separators]) - -(defp args group order-1 [(quiet :lparen) - (quiet (zero+ separator)) - (zero+ arg-entry) - (quiet :rparen)]) - -(defp recur-call group order-1 [(quiet :recur) tuple]) - -(defp synth-root flat choice [:keyword :word]) - -(defp synth-term flat choice [args :keyword]) - -(defp synthetic group order-1 [synth-root (zero+ synth-term)]) - -(defp fn-clause group order-1 [tuple-pattern (maybe guard) (quiet :rarrow) expression]) - -(defp fn-entry order-1 [fn-clause terminators]) - -(defp fn-compound group order-1 [(quiet :lbrace) - nls? - (maybe :string) - (quiet (zero+ terminator)) - (one+ fn-entry) - (quiet :rbrace) - ]) - -(defp clauses flat choice [fn-clause fn-compound]) - -(defp fn-named group order-1 [(quiet :fn) :word clauses]) - -(defp lambda group order-1 [(quiet :fn) fn-clause]) - -(defp block-line weak-order [expression terminators]) - -(defp block group order-1 [(quiet :lbrace) - (quiet (zero+ terminator)) - (one+ block-line) - (quiet :rbrace)]) - -(defp pipeline quiet order-0 [nls? :pipeline]) - -(defp do-entry order-1 [pipeline expression]) - -(defp do-expr group order-1 [(quiet :do) - expression - (one+ do-entry) - ]) - -(defp ref-expr group order-1 [(quiet :ref) :word (quiet :equals) expression]) - -; (defp spawn group order-1 [(quiet :spawn) expression]) - -; (defp receive group order-1 [(quiet :receive) (quiet :lbrace) -; (quiet (zero+ terminator)) -; (one+ match-entry) -; (quiet :rbrace) -; ]) - -(defp compound-loop group order-0 [(quiet :lbrace) - (quiet (zero+ terminator)) - (one+ fn-entry) - (quiet :rbrace)]) - -(defp loop-expr group order-1 [(quiet :loop) tuple (quiet :with) - (flat (choice :loop-body [fn-clause compound-loop]))]) - -(defp repeat-expr group order-1 [(quiet :repeat) (choice :times [:word :number]) non-binding]) - -(defp collection flat choice [;struct-literal - dict list-literal set-literal tuple]) - -(defp panic group order-1 [(quiet :panic) expression]) - -(defp simple flat choice [literal collection synthetic recur-call lambda panic]) - -(defp compound flat choice [match loop-expr if-expr when-expr do-expr block repeat-expr]) - -(defp binding-expr flat choice [fn-named let-expr ref-expr]) - -(defp non-binding flat choice [simple compound]) - -(defp expression flat choice [binding-expr non-binding]) - -(defp test-expr group order-1 [(quiet :test) :string non-binding]) - -(defp import-expr group order-1 [(quiet :import) :string (quiet :as) :word]) - -(defp ns-expr group order-1 [(quiet :ns) - :word - (quiet :lbrace) - (quiet (zero+ separator)) - (zero+ struct-entry) - (quiet :rbrace)]) - -(defp use-expr group order-1 [(quiet :use) :word]) - -(defp toplevel flat choice [import-expr - ns-expr - expression - test-expr - use-expr]) - -(defp script-line weak-order [toplevel terminators]) - -(defp script order-0 [nls? - (one+ script-line) - (quiet :eof)]) - diff --git a/src/ludus/interpreter.cljc b/src/ludus/interpreter.cljc deleted file mode 100644 index ef572fd..0000000 --- a/src/ludus/interpreter.cljc +++ /dev/null @@ -1,1072 +0,0 @@ -(ns ludus.interpreter - (:require - [ludus.parser :as p] - [ludus.grammar :as g] - [ludus.scanner :as scanner] - [ludus.ast :as ast] - [ludus.base :as base] - [ludus.prelude :as prelude] - [ludus.data :as data] - [ludus.show :as show] - [ludus.error :as error] - ;;[ludus.loader :as loader] - [clojure.pprint :as pp] - [clojure.set] - [clojure.string])) - -(defn prettify-ast [ast] - (cond - (not (map? ast)) ast - (not (:data ast)) (dissoc ast :remaining :token) - :else (let [{:keys [type data]} ast] - {:type type ;:token token - :data (into [] (map prettify-ast) data)}) - )) - -;; right now this is not very efficient: -;; it's got runtime checking -;; we should be able to do these checks statically -;; that's for later, tho -(defn- ludus-resolve [key ctx-vol] - (let [ctx @ctx-vol] - ;(println "Resolving " key " in context " (keys ctx)) - ;(println "Current context: " (keys ctx)) - ;(println "Parent context: " (keys (if (::parent ctx) (deref (::parent ctx)) {}))) - (if (contains? ctx key) - (get ctx key) - (if (contains? ctx ::parent) - (recur key (::parent ctx)) - ::not-found)))) - -(defn- resolve-word [word ctx] - (let [value (ludus-resolve (-> word :data first) ctx)] - (if (= ::not-found value) - (throw (ex-info (str "Unbound name: " (-> word :data first)) {:ast word})) - value))) - -(declare interpret-ast match interpret interpret-file) - -(defn- match-splatted [pattern value ctx-vol] - (let [members (:data pattern) - non-splat (pop members) - splattern (peek members) - length (count members) - ctx-diff (volatile! @ctx-vol)] - (if (> length (-> value count dec)) - {:success false :reason "Could not match different lengths"} - (loop [i 0] - (if (= (dec length) i) - (let [last-binding (-> splattern :data first) - binding-type (:type last-binding)] - (if (= binding-type :word) - (let [splat-ctx (:ctx (match - last-binding - (into [::data/list] (subvec value (inc i))) - ctx-diff))] - {:success true :ctx (merge @ctx-diff splat-ctx)}) - {:success true :ctx @ctx-diff})) - (let [match? (match (nth non-splat i) (nth value (inc i)) ctx-diff)] - (if (:success match?) - (do - (vswap! ctx-diff #(merge % (:ctx match?))) - ;(println "current context: " (dissoc @ctx-diff ::parent)) - (recur (inc i))) - {:success :false :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show value))} - ))))))) - -;; Match-tuple is misbehaving when the first value is a function and the second is a list -;; Hangs on success! -;; printlns at top run just fine -;; println at top of :else - loop happens once -;; println in :else - loop - if - let binding match? does not happen -;; that suggets that match is hanging here - -(defn- match-tuple [pattern value ctx-vol] - ;(println "\n\n\n**********Matching tuple") - ;(println "*****Value: " (show/show value)) - ;(println "*****Pattern: " (show/show-pattern pattern)) - (let [members (:data pattern) - length (count members)] - (cond - (not (vector? value)) {:success false :reason "Could not match non-tuple value to tuple"} - - (not (= ::data/tuple (first value))) {:success false :reason "Could not match list to tuple"} - - (= :splattern (:type (peek members))) - (match-splatted pattern value ctx-vol) - - (not (= length (dec (count value)))) - {:success false :reason "Cannot match tuples of different lengths"} - - (= 0 length (dec (count value))) {:success true :ctx {}} - - :else - (let [ctx-diff (volatile! @ctx-vol)] - (loop [i length] - ;(println "Matching tuple elements at index " i) - (if (= 0 i) - {:success true :ctx @ctx-diff} - (let [match? (match (nth members (dec i)) (nth value i) ctx-diff)] - ;(println "Maybe a match?: " (dissoc match? :ctx)) - (if (:success match?) - (do - (vswap! ctx-diff #(merge % (:ctx match?))) - (recur (dec i))) - {:success false :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show value) " because " (:reason match?))})))))))) - -;; TODO: update this to use new AST representation -;; TODO: update this to reflect first element of list is ::data/list -(defn- match-list [pattern value ctx-vol] - (let [members (:data pattern) - splatted? (= :splattern (-> members peek :type))] - (cond - (not (vector? value)) - {:success false :reason (str "Could not match non-list value " (show/show value) " to list pattern " (show/show-pattern pattern))} - - (= ::data/tuple (first value)) - {:success false :reason (str "Could not match tuple value " (show/show value) " to list pattern " (show/show-pattern pattern))} - - splatted? - (match-splatted pattern value ctx-vol) - - ;; TODO: fix this with splats - (not= (count members) (dec (count value))) - {:success false :reason "Cannot match lists of different lengths"} - - (= 0 (count members) (dec (count value))) - {:success true :ctx {}} - - :else - (let [ctx-diff (volatile! @ctx-vol)] - (loop [i (dec (count members))] - (if (> 0 i) - {:success true :ctx @ctx-diff} - (let [match? (match (nth members i) (nth value (inc i)) ctx-diff)] - (if (:success match?) - (do - (vswap! ctx-diff #(merge % (:ctx match?))) - (recur (dec i))) - {:success false :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show value) " because " (:reason match?))})))))))) - -(defn- member->kv [map member] - (let [type (:type member) - data (:data member)] - (case type - :word - (assoc map (keyword (first data)) member) - - :pair-pattern - (assoc map (-> data first :data first) (second data)) - - :typed - (assoc map (-> data first :data first keyword) member) - - map ;;ignore splats - ))) - -(defn- pattern-to-map [pattern] - (let [members (:data pattern)] - (reduce member->kv {} members))) - -;; TODO: update this to match new AST representation -(defn- match-dict [pattern dict ctx-vol] - (let [ - members (:data pattern) - pattern-map (pattern-to-map pattern) - kws (keys pattern-map)] - ;(println "Matching with " pattern-map) - (cond - (not (map? dict)) - {:success false :reason (str "Could not match non-dict value " (show/show dict) " to dict pattern " (show/show-pattern pattern))} - - (not (::data/dict dict)) - {:success false :reason (str "Cannot match non-dict data types (ns, struct) " (show/show dict) " to a dict pattern " (show/show-pattern pattern))} - - (empty? members) - {:success true :ctx {}} - - :else - (let [ctx-diff (volatile! @ctx-vol) - splat? (= :splattern (-> members peek :type)) - length (count kws)] - (loop [i 0] - (cond - (> length i) - (let [kw (nth kws i) - pattern-at (kw pattern-map) - value (kw dict)] - (if (contains? dict kw) - (let [match? (match pattern-at value ctx-diff)] - (if (:success match?) - (do - (vswap! ctx-diff #(merge % (:ctx match?))) - (recur (inc i))) - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with value " (show/show dict) " at key " kw " because " (:reason match?))} - )) - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show dict) " at key " kw " because there is no value at " kw)})) - - splat? - (let [splat (-> members peek) - splat-data (-> splat :data first) - splat-type (-> splat-data :type)] - (if (= :word splat-type) - (let [unmatched (apply dissoc dict kws) - match? (match splat-data unmatched ctx-diff)] - (if (:success match?) - {:success true :ctx (merge @ctx-diff (:ctx match?))} - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with value " (show/show dict) " because " (:reason match?))} - )) - {:success true :ctx @ctx-diff} - )) - - :else - {:success true :ctx @ctx-diff} - - )))))) - -(defn- match-struct [pattern dict ctx-vol] - (let [members (:data pattern) - pattern-map (pattern-to-map pattern) - kws (keys pattern-map)] - (cond - (not (map? dict)) - {:success false :reason (str "Could not match non-struct value " (show/show dict) " to struct pattern " (show/show-pattern pattern))} - - (not (::data/struct dict)) - {:success false :reason (str "Cannot match non-struct value " (show/show dict) " to struct pattern " (show/show-pattern pattern))} - - (empty? members) - {:success true :ctx {}} - - :else - (let [ctx-diff (volatile! @ctx-vol) - splat? (= :splattern (-> members peek :type)) - length (count kws)] - (loop [i 0] - (cond - (> length i) - (let [kw (nth kws i) - pattern-at (kw pattern-map) - value (kw dict)] - (if (contains? dict kw) - (let [match? (match pattern-at value ctx-diff)] - (if (:success match?) - (do - (vswap! ctx-diff #(merge % (:ctx match?))) - (recur (inc i))) - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with value " (show/show dict) " at key " kw " because " (:reason match?))} - )) - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show dict) " at key " kw " because there is no value at " kw)})) - - splat? - (let [splat (-> members peek) - splat-data (-> splat :data first) - splat-type (-> splat-data :type)] - (if (= :word splat-type) - (let [unmatched (assoc (apply dissoc dict ::data/struct kws) ::data/dict true) - match? (match splat-data unmatched ctx-diff)] - (if (:success match?) - {:success true :ctx (merge @ctx-diff (:ctx match?))} - {:success false - :reason (str "Could not match " (show/show-pattern pattern) " with value " (show/show dict) " because " (:reason match?))} - )) - {:success true :ctx @ctx-diff} - )) - - :else - {:success true :ctx @ctx-diff})))))) - -(defn- match-typed [pattern value ctx] - (let [data (:data pattern) - name (-> data first :data first) - type (-> data second :data first)] - (cond - (contains? ctx name) {:success false :reason (str "Name " name "is already bound") :code :name-error} - (not (= type (base/get-type value))) {:success false :reason (str "Could not match " (show/show-pattern pattern) " with " (show/show value) ", because types do not match")} - :else {:success true :ctx {name value}}))) - -(defn- match [pattern value ctx-vol] - ;(println "Matching " (show/show value) " with pattern " (show/show-pattern pattern)) - (let [ctx @ctx-vol] - (case (:type pattern) - (:placeholder :ignored :else) - {:success true :ctx {}} - - (:number :nil :true :false :string :keyword) - (let [match-value (-> pattern :data first)] - (if (= match-value value) - {:success true :ctx {}} - {:success false - :reason (str "No match: Could not match " (show/show-pattern pattern) " with " (show/show value))})) - - :word - (let [word (-> pattern :data first)] - (if (contains? ctx word) - {:success false :reason (str "Name " word " is already bound") :code :name-error} - {:success true :ctx {word value}})) - - :typed (match-typed pattern value ctx) - - :tuple-pattern (match-tuple pattern value ctx-vol) - - :list-pattern (match-list pattern value ctx-vol) - - :dict-pattern (match-dict pattern value ctx-vol) - - :struct-pattern (match-struct pattern value ctx-vol) - - (throw (ex-info (str "Unknown pattern type " (:type pattern)) {:ast pattern :value value}))))) - -(defn- update-ctx [ctx new-ctx] - (merge ctx new-ctx)) - -(defn- interpret-let [ast ctx] - (let [data (:data ast) - pattern (first data) - expr (second data) - value (interpret-ast expr ctx) - match (match pattern value ctx) - success (:success match)] - (if success - (vswap! ctx update-ctx (:ctx match)) - (throw (ex-info (:reason match) {:ast ast}))) - value)) - -(defn- interpret-if-let [ast ctx] - (let [data (:data ast) - if-ast (first data) - then-expr (second data) - else-expr (nth data 2) - if-data (:data if-ast) - let-pattern (first if-data) - let-expr (second if-data) - let-value (interpret-ast let-expr ctx) - if-match (match let-pattern let-value ctx) - success (:success if-match)] - (if success - (interpret-ast then-expr (volatile! (merge (:ctx if-match) {:parent ctx}))) - (if (:code if-match) - (throw (ex-info (:reason if-match) {:ast if-ast})) - (interpret-ast else-expr ctx))))) - -(defn- interpret-if [ast ctx] - (let [data (:data ast) - if-expr (first data) - then-expr (second data) - else-expr (nth data 2)] - (if (= (:type if-expr) :let-expr) - (interpret-if-let ast ctx) - (if (interpret-ast if-expr ctx) - (interpret-ast then-expr ctx) - (interpret-ast else-expr ctx))))) - -(defn- interpret-match [ast ctx] - (let [data (:data ast) - match-expr (first data) - value (interpret-ast match-expr ctx) - clauses (rest data)] - (loop [clause (first clauses) - clauses (rest clauses)] - (if clause - (let [clause-data (:data clause) - pattern (first clause-data) - guard (if (= 3 (count clause-data)) - (second clause-data) - nil) - body (peek clause-data) - new-ctx (volatile! {::parent ctx}) - match? (match pattern value new-ctx) - success (:success match?) - clause-ctx (:ctx match?)] - (if success - (if guard - (if (interpret-ast guard (volatile! clause-ctx)) - (do - (vswap! new-ctx #(merge % clause-ctx)) - (interpret-ast body new-ctx)) - (recur (first clauses) (rest clauses))) - (do - (vswap! new-ctx #(merge % clause-ctx)) - (interpret-ast body new-ctx))) - (recur (first clauses) (rest clauses)))) - (throw (ex-info "Match Error: No match found" {:ast ast})))))) - -(defn- interpret-cond [ast ctx] - (let [clauses (:data ast)] - (loop [clause (first clauses) - clauses (rest clauses)] - (if (not clause) - (throw (ex-info "Cond Error: No match found" {:ast ast})) - (let [data (:data clause) - test-expr (first data) - test-type (:type test-expr) - body (second data) - truthy? (or - (= :placeholder test-type) - (= :else test-type) - (interpret-ast test-expr ctx))] - (if truthy? - (interpret-ast body ctx) - (recur (first clauses) (rest clauses)))))))) - -(defn- validate-args [args] - (>= 1 (count (filter #(= :placeholder (:type %)) args)))) - -(defn- partial? [args] - (some #(= :placeholder (:type %)) args)) - -(defn- interpret-called-kw [kw tuple ctx] - (let [members (:data tuple) - length (count members)] - ;; TODO: check this statically - (cond - (not (= 1 length)) - (throw (ex-info "Called keywords must be unary" {:ast tuple})) - - (partial? members) - (throw (ex-info "Called keywords may not be partially applied" {:ast tuple})) - - :else - (let [kw (interpret-ast kw ctx) - map (second (interpret-ast tuple ctx))] - (if (::data/struct map) - (if (contains? map kw) - (kw map) - (if (= (::data/type map) ::data/ns) - (throw (ex-info (str "Namespace error: no member " kw " in ns " (::data/name map)) {:ast kw})) - (throw (ex-info (str "Struct error: no member at " kw) {:ast kw})))) - (get map kw)))))) - -(defn- call-fn [lfn args ctx from] - ;(println "Calling function " (:name lfn)) - (cond - (= ::data/partial (first args)) - {::data/type ::data/clj - :name (str (:name lfn) "{partial}") - :body (fn [arg] - (call-fn - lfn - (into [::data/tuple] (replace {::data/placeholder arg} (rest args))) - ctx - from))} - - (= (::data/type lfn) ::data/clj) (apply (:body lfn) (next args)) - - (= (::data/type lfn) ::data/fn) - (let [clauses (:clauses lfn) - closed-over (:ctx lfn)] - (loop [clause (first clauses) - clauses (rest clauses)] - ;(println "Matching clause " clause) - ;(println "With args " args) - (if clause - (let [pattern (first clause) - guard (if (= 3 (count clause)) - (second clause) - nil) - body (peek clause) - fn-ctx (volatile! {::parent closed-over}) - match? (match pattern args fn-ctx) - success (:success match?) - clause-ctx (:ctx match?) - vclause (volatile! (assoc clause-ctx ::parent closed-over))] - ;(println "Pattern: " pattern) - ;(println "Body: " body) - (if success - (if guard - (if (do - ;(println "######### Testing guard") - ;(println "Context: " clause-ctx) - (interpret-ast guard vclause)) - (do - ;(println "passed guard") - (vswap! fn-ctx #(merge % clause-ctx)) - (interpret-ast body fn-ctx)) - (recur (first clauses) (rest clauses))) - (do - (vswap! fn-ctx #(merge % clause-ctx)) - (interpret-ast body fn-ctx))) - (recur (first clauses) (rest clauses)))) - - (throw (ex-info (str "Match Error: No match found for " (show/show args) " in function " (:name lfn)) {:ast from}))))) - - (keyword? lfn) - (if (= 2 (count args)) - (let [target (second args) kw lfn] - (if (::data/struct target) - (if (contains? target kw) - (kw target) - (if (= (::data/type target) ::data/ns) - (throw (ex-info (str "Namespace error: no member " kw " in ns" (::data/name target)) {:ast kw})) - (throw (ex-info (str "Struct error: no member at " kw) {:ast kw})))) - - (kw target))) - (throw (ex-info "Called keywords take a single argument" {:ast lfn}))) - - :else (throw (ex-info (str "I don't know how to call " (show/show lfn)) {:ast lfn})))) - -(defn- interpret-args [args ctx] - ;(println "interpreting arg" args) - (if (partial? args) - (if (validate-args args) - (into [::data/partial] (map #(interpret-ast % ctx)) args) ; do the thing - (throw (ex-info "Partially applied functions may only take a single argument" {:ast args}))) - (into [::data/tuple] (map #(interpret-ast % ctx)) args)) - ) - -(defn- interpret-synthetic-term [prev-value curr ctx] - (let [type (:type curr) - data (:data curr)] - ;(println "interpreting synthetic type " type) - ;(println "interpreting synthetic node " curr) - (if (= type :keyword) - (if (::data/struct prev-value) - (if (contains? prev-value (first data)) - (get prev-value (first data)) - (if (= (::data/type prev-value) ::data/ns) - (throw (ex-info (str "Namespace error: no member " (:value curr) " in ns " (::data/name prev-value)) {:ast curr})) - (throw (ex-info (str "Struct error: no member " (:value curr)) {:ast curr})))) - (get prev-value (first data))) - (call-fn prev-value (interpret-args data ctx) ctx curr)))) - -(defn- interpret-synthetic [ast ctx] - ;;(println "interpreting synthetic " ast) - (let [data (:data ast) - root (first data) - terms (rest data)] - ;(println "!!!!!!!!!Interpreting synthetic w/ root " (:data root)) - (if (seq terms) - (do - ;;(println "I've got terms!: " terms) - (let [first-term (first terms) - remaining (rest terms) - first-val (if (= (:type root) :keyword) - (interpret-called-kw root first-term ctx) - (interpret-synthetic-term (interpret-ast root ctx) first-term ctx))] - (reduce #(interpret-synthetic-term %1 %2 ctx) first-val remaining))) - (interpret-ast root ctx)))) - -(defn- interpret-fn-inner [ast ctx] ;; TODO: fix context/closure (no cycles)? - (let [name (:name ast) - clauses (:clauses ast)] - (if (= name ::ast/anon) - {::data/type ::data/fn - :name name - :ast ast - :clauses clauses - :ctx ctx} - (let [fn {::data/type ::data/fn - :name name - :clauses clauses - :ctx ctx}] - (if (contains? @ctx name) - (throw (ex-info (str "Name " name " is already bound") {:ast ast})) - (do - (vswap! ctx update-ctx {name fn}) - fn)))))) - -(defn- build-fn - ([ast ctx name clauses] (build-fn ast ctx name clauses nil)) - ([ast ctx name clauses docstring] - (let [fnn {::data/type ::data/fn - :name name - :ast ast - :clauses clauses - :ctx ctx - :doc docstring}] - (if (= name :anon) - fnn - (if (contains? @ctx name) - (throw (ex-info (str "Name " name " is already bound") {:ast ast})) - (do - (vswap! ctx update-ctx {name fnn}) - fnn)))))) - -(defn- build-named-fn [ast ctx data] - (let [name (-> data first :data first) - body (-> data second) - compound? (= :fn-compound (:type body))] - (if compound? - (if (= :string (-> body :data first :type)) - (build-fn ast ctx name (map :data (rest (:data body))) (-> body :data first :data first)) - (build-fn ast ctx name (map :data (:data body)))) - (build-fn ast ctx name [(:data body)])))) - -(defn- interpret-fn [ast ctx] - (let [data (:data ast)] - (case (:type (first data)) - :fn-clause (build-fn ast ctx :anon [(-> data first :data)]) - :word (build-named-fn ast ctx data)))) - -(defn- interpret-do [ast ctx] - (let [data (:data ast) - root (interpret-ast (first data) ctx) - fns (rest data)] - (reduce #(call-fn (interpret-ast %2 ctx) [::data/tuple %1] ctx ast) root fns))) - -(defn- map-values [f] - (map (fn [kv] - (let [[k v] kv] - [k (f v)])))) - -(defn- map-keys [f] - (map (fn [[k v]] [(f k) v]))) - -; (defn- interpret-import [ast ctx] -; (let [data (:data ast) -; path (-> data first :data first) -; name (-> data second :data first) -; file (ludus-resolve :file ctx) -; from (if (= ::not-found file) :cwd file)] -; (if (contains? @ctx name) -; (throw (ex-info (str "Name " name " is alrady bound") {:ast ast})) -; (let [source (try -; (loader/load-import path from) -; (catch Exception e -; (if (::loader/error (ex-data e)) -; (throw (ex-info (ex-message e) {:ast ast})) -; (throw e)))) -; parsed (->> source (scanner/scan) :tokens (p/apply-parser g/script))] -; (if (p/fail? parsed) -; (throw (ex-info -; (str "Parse error in file " path "\n" -; (p/err-msg parsed)) -; {:ast ast})) -; (let [interpret-result (interpret-file source path parsed)] -; (vswap! ctx update-ctx {name interpret-result}) -; interpret-result)) -; )))) - -(defn- kw->str [kw] (apply str (rest (str kw)))) - -(defn- str->word [wordstr] {:type :word :data [wordstr]}) - -(defn- interpret-use [ast ctx] - (let [data (:data ast) - word (first data) - ns (resolve-word word ctx)] - ; (println "use: " ns) - (if (not (= (::data/type ns) ::data/ns)) - (throw (ex-info (str "`use` may only use namespaces; " (-> word :data first) " is not a namespace") {:ast ast})) - (let [ns-entries (dissoc ns ::data/type ::data/name ::data/struct) - ns-keys (map kw->str (keys ns-entries)) - ns-words (into [] (map str->word) ns-keys) - implied-pattern {:type :struct-pattern :data ns-words} - implied-synthetic {:type :synthetic :data [word]} - sugared-let {:type :let-expr :data [implied-pattern implied-synthetic]}] - (interpret-let sugared-let ctx) - ) - ) - )) - -(defn- interpret-ref [ast ctx] - (let [data (:data ast) - name (-> data first :data first) - expr (-> data second)] - (when (contains? @ctx name) - (throw (ex-info (str "Name " name " is already bound") {:ast ast}))) - (let [value (interpret-ast expr ctx) - box (atom value) - ref {::data/ref true ::data/value box ::data/name name}] - (swap! base/refs assoc name value) - (vswap! ctx update-ctx {name ref}) - ref))) - -(defn- interpret-loop [ast ctx] - (let [data (:data ast) - tuple (interpret-ast (first data) ctx) - loop-type (-> data second :type) - clauses (if (= loop-type :fn-clause) - [(-> data second :data)] - (into [] (map :data) (-> data second :data)))] - (loop [input tuple] - (let [output (loop [clause (first clauses) - clauses (rest clauses)] - (if clause - (let [pattern (first clause) - guard (if (= 3 (count clause)) - (second clause) - nil) - body (peek clause) - new-ctx (volatile! {::parent ctx}) - match? (match pattern input new-ctx) - success (:success match?) - clause-ctx (:ctx match?)] - (if success - (if guard - (if (interpret-ast guard (volatile! (assoc clause-ctx ::parent ctx))) - (do - (vswap! new-ctx #(merge % clause-ctx)) - (interpret-ast body new-ctx)) - (recur (first clauses) (rest clauses))) - (do - (vswap! new-ctx #(merge % clause-ctx)) - (interpret-ast body new-ctx))) - (recur (first clauses) (rest clauses)))) - - (throw (ex-info (str "Match Error: No match found in loop for " (show/show input)) {:ast ast}))))] - (if (::data/recur output) - (recur (:args output)) - output))))) - -(defn- list-term [ctx] - (fn [list member] - (if (= (:type member) :splat) - (let [splatted (interpret-ast (-> member :data first) ctx) - splattable? (vector? splatted) - tuple-splat? (= (first splatted) ::data/tuple)] - (if splattable? - (if tuple-splat? - (into [::data/list] (concat list (rest splatted))) - (concat list splatted)) - (throw (ex-info "Cannot splat non-list into list" {:ast member})))) - (conj list (interpret-ast member ctx))))) - -(defn- interpret-list [ast ctx] - (let [members (:data ast)] - (into [::data/list] (reduce (list-term ctx) [] members)))) - -(defn- set-term [ctx] - (fn [set member] - (if (= (:type member) :splat) - (let [splatted (interpret-ast (-> member :data first) ctx) - splat-set? (set? splatted)] - (if splat-set? - (clojure.set/union set splatted) - (throw (ex-info "Cannot splat non-set into set" {:ast member})))) - (conj set (interpret-ast member ctx))))) - -(defn- interpret-set [ast ctx] - (let [members (:data ast)] - (reduce (set-term ctx) #{} members))) - -(defn- dict-term [ctx] - (fn [dict member] - (case (:type member) - :splat (let [splatted (interpret-ast (-> member :data first) ctx) - splat-map? (or (::data/dict splatted) - (::data/struct splatted))] - (if splat-map? - (merge dict splatted) - (throw (ex-info "Cannot splat non-dict into dict" {:ast member})))) - :word (let [data (:data member) k (-> data first keyword)] - (assoc dict k (interpret-ast member ctx))) - - :pair (let [data (:data member) k (-> data first :data first) v (second data)] - (assoc dict k (interpret-ast v ctx)))))) - -(defn- interpret-dict [ast ctx] - (let [members (:data ast)] - (assoc (reduce (dict-term ctx) {} members) ::data/dict true))) - -(defn- struct-term [ctx] - (fn [struct member] - (case (:type member) - :splat (throw (ex-info "Cannot splat into struct" {:ast member})) - - :word (let [data (:data member) k (-> data first keyword)] - (assoc struct k (interpret-ast member ctx))) - - :pair (let [data (:data member) k (-> data first :data first) v (second data)] - (assoc struct k (interpret-ast v ctx)))))) - -; (defn- interpret-struct [ast ctx] -; (let [members (:data ast)] -; (assoc (reduce (struct-term ctx) {} members) ::data/struct true))) - -(defn- ns-term [ctx] - (fn [ns member] - (case (:type member) - :splat (throw (ex-info "Cannot splat into ns" {:ast member})) - - :word (let [data (:data member) k (-> data first keyword)] - (assoc ns k (interpret-ast member ctx))) - - :pair (let [data (:data member) k (-> data first :data first) v (second data)] - (assoc ns k (interpret-ast v ctx)))))) - -(defn- interpret-ns [ast ctx] - (let [data (:data ast) - name (-> data first :data first) - members (rest data)] - (if (contains? @ctx name) - (throw (ex-info (str "ns name " name " is already bound") {:ast ast})) - (let [ns (merge { - ::data/struct true - ::data/type ::data/ns - ::data/name name} - (reduce (ns-term ctx) {} members))] - (vswap! ctx update-ctx {name ns}) - ns)))) - -;; TODO: make this more robust: can dotimes choke on numbers Ludus passes in? -;; TODO: -(defn- interpret-repeat [ast ctx] - (let [data (:data ast) - times-expr (-> data first :data first) - times (if (= :word (:type times-expr)) - (resolve-word times-expr ctx) - (-> times-expr :data first)) - expr (second data)] - (if (not (number? times)) (throw (ex-info (str "Repeat needs a number, not a " (base/get-type times)) {}))) - (dotimes [_ times] (interpret-ast expr ctx)))) - -(defn- interpret-literal [ast] (-> ast :data first)) - -(defn- interpret-panic [ast ctx] - (let [msg-value (interpret-ast (-> ast :data first) ctx) - msg-string (show/show msg-value)] - (throw (ex-info msg-string {:ast ast})))) - -; TODO: -; this "are we testing?" variable should only obtain on direct-runs, -; not in scripts evaluated using `import` -(def testing? (volatile! false)) - -(def test-results (volatile! [::data/list])) - -(defn- add-test-result [line name status msg] - (vswap! test-results conj [::data/tuple line name status msg])) - -(defn- eval-test [ast ctx] - (let [name (-> ast :data first :data first) - line (-> ast :token :line) - expr (-> ast :data second)] - (println "Testing " name) - (try - (let [result (interpret-ast expr ctx)] - (if result - (add-test-result line name :pass result) - (add-test-result line name :fail result))) - (catch #?(:clj Throwable :cljs js/Object) e - (add-test-result line name :panic (ex-message e)) - ; {::data/error true - ; :token (get-in (ex-data e) [:ast :token]) - ; :line (get-in (ex-data e) [:ast :token :line]) - ; :message (ex-message e)} - ) - ))) - -(defn- interpret-test [ast ctx] - (let [testing? @testing?] - (if testing? (eval-test ast ctx)) - ::test)) - -(def script-result (volatile! nil)) - -(defn- interpret-script [ast ctx] - (let [lines (:data ast) - result (volatile! nil)] - (doseq [line lines] - (let [line-result (interpret-ast line ctx)] - (if (not= ::test line-result) (vreset! result line-result)))) - @result)) - -(defn interpret-ast [ast ctx] - (case (:type ast) - - (:nil :true :false :number :string :keyword) (interpret-literal ast) - - :panic (interpret-panic ast ctx) - - :let-expr (interpret-let ast ctx) - - :if-expr (interpret-if ast ctx) - - :word (resolve-word ast ctx) - - :synthetic (interpret-synthetic ast ctx) - - :match (interpret-match ast ctx) - - :when-expr (interpret-cond ast ctx) - - (:fn-named :lambda) (interpret-fn ast ctx) - - :do-expr (interpret-do ast ctx) - - :placeholder ::data/placeholder - - :ns-expr (interpret-ns ast ctx) - - :use-expr (interpret-use ast ctx) - - ;; :import-expr (interpret-import ast ctx) - - :ref-expr (interpret-ref ast ctx) - - :recur-call - {::data/recur true :args (interpret-ast (-> ast :data first) ctx)} - - :loop-expr (interpret-loop ast ctx) - - :repeat-expr (interpret-repeat ast ctx) - - :block - (let [exprs (:data ast) - inner (pop exprs) - last (peek exprs) - ctx (volatile! {::parent ctx})] - (run! #(interpret-ast % ctx) inner) - (interpret-ast last ctx)) - - :script - (interpret-script ast ctx) - ; (let [exprs (:data ast) - ; inner (pop exprs) - ; last (peek exprs)] - ; (run! #(interpret-ast % ctx) inner) - ; (interpret-ast last ctx)) - - ;; note that, excepting tuples and structs, - ;; runtime representations are bare - ;; tuples are vectors with a special first member - (:tuple :args) - (let [members (:data ast)] - (into [::data/tuple] (map #(interpret-ast % ctx)) members)) - - :list-literal (interpret-list ast ctx) - - :set-literal (interpret-set ast ctx) - - :dict (interpret-dict ast ctx) - - ; :struct-literal - ; (interpret-struct ast ctx) - - :test-expr (interpret-test ast ctx) - - (throw (ex-info (str "Unknown AST node type " (get ast :type :none) " on line " (get-in ast [:token :line])) {:ast ast})))) - -(defn get-line [source line] - (if line - (let [lines (clojure.string/split source #"\n") - numlines (count lines) - gettable? (> numlines line)] - (if gettable? - (clojure.string/trim (nth lines (dec line))) - nil)) - )) - -(def runtime-error - #?( - :clj clojure.lang.ExceptionInfo - :cljs js/Object - )) - -(defn- ns->ctx [ns] - (into {} (map-keys kw->str) ns)) - -(def ludus-prelude - (let [scanned (scanner/scan prelude/prelude "prelude") - parsed (p/apply-parser g/script (:tokens scanned)) - ; _ (println "Parse status: " (:status parsed)) - ; _ (if (= :err (:status parsed)) - ; (throw (ex-info (error/parse-error parsed) {}))) - base-ctx (volatile! {::parent (volatile! {"base" base/base})}) - interpreted (interpret-ast parsed base-ctx) - namespace (dissoc interpreted ::data/type ::data/name ::data/struct) - context (ns->ctx namespace)] - ;(println "Prelude fully loaded.") - context)) - -; ;; TODO: update this to use new parser pipeline & new AST representation -; (defn interpret -; ([source parsed] (interpret source parsed {})) -; ([source parsed ctx] -; (try -; (let [base-ctx (volatile! {::parent (volatile! (merge ludus-prelude ctx))})] -; (interpret-ast parsed base-ctx)) -; (catch #?(:cljs :default :clj Throwable) e -; (println "Ludus panicked!") -; (println "On line" (get-in (ex-data e) [:ast :token :line])) -; (println ">>> " (get-line source (get-in (ex-data e) [:ast :token :line]))) -; (println (ex-message e)) -; (pp/pprint (ex-data e) -; #?(:clj (System/exit 67)) -; ))))) - -; ;; TODO: update this to use new parser pipeline & new AST representation -; (defn interpret-file [source path parsed] -; (try -; (let [base-ctx (volatile! {::parent (volatile! ludus-prelude) :file path})] -; (interpret-ast parsed base-ctx)) -; (catch clojure.lang.ExceptionInfo e -; (println "Ludus panicked in" path) -; (println "On line" (get-in (ex-data e) [:ast :token :line])) -; (println ">>> " (get-line source (get-in (ex-data e) [:ast :token :line]))) -; (println (ex-message e)) -; (System/exit 67)))) - -; ;; TODO: update this to use new parser pipeline & new AST representation -(defn interpret-repl - ([parsed ctx] - (let [orig-ctx @ctx] - (try - (let [result (interpret-ast parsed ctx)] - {:result result :ctx ctx}) - (catch #?(:clj Throwable :cljs js/Object) e - (println "Ludus panicked!") - (println (ex-message e)) - {:result :error :ctx (volatile! orig-ctx)}))))) - -(defn interpret-safe [source parsed ctx test?] - (let [base-ctx (volatile! {::parent (volatile! (merge ludus-prelude ctx))})] - (vreset! testing? test?) - (vreset! test-results [::data/list]) - (try - ;(println "Running source: " source) - (interpret-ast parsed base-ctx) - (catch #?(:clj Throwable :cljs js/Object) e - ;(println "Ludus panicked!") - ;(println "On line" (get-in (ex-data e) [:ast :token :line])) - ;(println ">>> " (get-line source (get-in (ex-data e) [:ast :token :line]))) - ;(println (ex-message e)) - ;(pp/pprint (ex-data e)) - ;(throw e) - {::data/error true - :token (get-in (ex-data e) [:ast :token]) - :line (get-in (ex-data e) [:ast :token :line]) - :message (ex-message e)} - )))) - -; No prelude; helps when there are errors in the prelude -(defn interpret-bare [source parsed ctx] - (let [base-ctx (volatile! {::parent (volatile! ctx)})] - (try - (interpret-ast parsed base-ctx) - (catch #?(:clj Throwable :cljs js/Object) e - {::data/error true - :token (get-in (ex-data e) [:ast :token]) - :line (get-in (ex-data e) [:ast :token :line]) - :message (ex-message e)})))) - - -;; repl -(comment - - (println "***********") - - (def source " - panic! (:oh, :no) -") - - (def tokens (-> source (scanner/scan "test input") :tokens)) - - (def ast (p/apply-parser g/script tokens)) - - (def result (interpret-bare source ast {})) - - (println tokens) - - (-> ast prettify-ast println) - - (println result) - - result - ) \ No newline at end of file diff --git a/src/ludus/loader.clj b/src/ludus/loader.clj deleted file mode 100644 index f8ba0a0..0000000 --- a/src/ludus/loader.clj +++ /dev/null @@ -1,16 +0,0 @@ -(ns ludus.loader - (:require [babashka.fs :as fs])) - -(defn cwd [] (fs/cwd)) - -(defn load-import - ([file] - (let [path (-> file (fs/canonicalize) (fs/file))] - (try (slurp path) - (catch java.io.FileNotFoundException _ - (throw (ex-info (str "File " path " not found") {:path path ::error true})))))) - ([file from] - (load-import - (fs/path - (if (= from :cwd) (fs/cwd) (fs/parent (fs/canonicalize from))) - (fs/path file))))) diff --git a/src/ludus/node.cljc b/src/ludus/node.cljc deleted file mode 100644 index b5c8db7..0000000 --- a/src/ludus/node.cljc +++ /dev/null @@ -1,79 +0,0 @@ -(ns ludus.node - (:require [ludus.interpreter :as i] - [ludus.grammar :as g] - [ludus.parser :as p] - [ludus.scanner :as s] - [ludus.prelude :as pre] - [ludus.show :as show] - [ludus.base :as base] - [ludus.data :as data] - [ludus.error :as error] - ) - ) - -(declare ld->clj) - -(defn cljify [[k v]] [k (ld->clj v)]) - -(defn ld->clj [value] - (case (base/get-type value) - (:nil :number :string :boolean :keyword :set) value - - (:list :tuple) (into [] (map ld->clj) (rest value)) - - (:dict :struct :ns) (into {} (map cljify) (dissoc value ::data/dict ::data/struct ::data/type ::data/name)) - - :ref (ld->clj @(::value value)) - - :fn (throw (ex-info (str "Cannot export functions from Ludus to Clojure. You tried exporting " (show/show value)) {})))) - -(defn clean-out [value] - #?(:clj value :cljs (clj->js value))) - -(defn run - ([source] (run source false)) - ([source testing?] - (let [user_scanned (s/scan source "user input") - user_tokens (:tokens user_scanned) - user_parsed (p/apply-parser g/script user_tokens) - user_result (i/interpret-safe source user_parsed {} testing?) - result_str (show/show user_result) - test_results @i/test-results - state @base/refs - post_scanned (s/scan pre/postlude "postlude") - post_tokens (:tokens post_scanned) - post_parsed (p/apply-parser g/script post_tokens) - post_result (i/interpret-safe source post_parsed {} false) - ludus_result (assoc post_result :result result_str :test test_results :state state) - clj_result (ld->clj ludus_result) - ] - (cond - (not-empty (:errors user_tokens)) - (clean-out {:errors (:errors user_tokens)}) - - (= :err (:status user_parsed)) - (clean-out {:errors [(error/parse-error user_parsed)]}) - - (::data/error user_result) - (clean-out (assoc (ld->clj post_result) :errors [(error/run-error user_result)])) - - :else - (clean-out clj_result) - ) - )) - ) - -(defn test-run [source] (run source true)) - -(do - - (def source " - -add (1, 2) - -") - (-> source run :result) - - ) - -(+ 1 2) diff --git a/src/ludus/parser.cljc b/src/ludus/parser.cljc deleted file mode 100644 index ec1eb3e..0000000 --- a/src/ludus/parser.cljc +++ /dev/null @@ -1,316 +0,0 @@ -(ns ludus.parser) - -(defn ? [val default] (if (nil? val) default val)) - -(defn ok? [{status :status}] - (= status :ok)) - -(def failing #{:err :none}) - -(def passing #{:ok :group :quiet}) - -(defn pass? [{status :status}] (contains? passing status)) - -(defn fail? [{status :status}] (contains? failing status)) - -(defn data [{d :data}] d) - -(defn remaining [{r :remaining}] r) - -(defn pname [parser] (? (:name parser) parser)) - -(defn str-part [kw] (apply str (next (str kw)))) - -(defn kw+str [kw mystr] (keyword (str (str-part kw) mystr))) - -(defn value [token] - (if (= :none (:literal token)) (:lexeme token) (:literal token))) - -(defn apply-kw-parser [kw tokens] - (let [token (first tokens)] - ;(if (= kw (:type token)) (println "Matched " kw)) - (if (= kw (:type token)) - {:status :ok - :type kw - :data (if (some? (value token)) [(value token)] []) - :token token - :remaining (rest tokens)} - {:status :none :token token :trace [kw] :remaining (rest tokens)}))) - -(defn apply-fn-parser [parser tokens] - (let [rule (:rule parser) name (:name parser) result (rule tokens)] - ;(if (pass? result) (println "Matched " (:name parser))) - result)) - -(defn apply-parser [parser tokens] - ;(println "Applying parser " (? (:name parser) parser)) - (let [result (cond - (keyword? parser) (apply-kw-parser parser tokens) - (:rule parser) (apply-fn-parser parser tokens) - (fn? parser) (apply-fn-parser (parser) tokens) - :else (throw (ex-info "`apply-parser` requires a parser" {})))] - ;(println "Parser result " (? (:name parser) parser) (:status result)) - result - )) - -(defn choice [name parsers] - {:name name - :rule (fn choice-fn [tokens] - (loop [ps parsers] - (let [result (apply-parser (first ps) tokens) - rem-ts (remaining result) - rem-ps (rest ps)] - (cond - (pass? result) - {:status :ok :type name :data [result] :token (first tokens) :remaining rem-ts} - - (= :err (:status result)) - (update result :trace #(conj % name)) - - (empty? rem-ps) - {:status :none :token (first tokens) :trace [name] :remaining rem-ts} - - :else (recur rem-ps)))))}) - -(defn order-1 [name parsers] - {:name name - :rule (fn order-fn [tokens] - (let [origin (first tokens) - first-result (apply-parser (first parsers) tokens)] - (case (:status first-result) - (:err :none) - (assoc (update first-result :trace #(conj % name)) :status :none) - - (:ok :quiet :group) - (loop [ps (rest parsers) - results (case (:status first-result) - :ok [first-result] - :quiet [] - :group (:data first-result)) - ts (remaining first-result)] - (let [result (apply-parser (first ps) ts) - res-rem (remaining result)] - (if (empty? (rest ps)) - (case (:status result) - :ok {:status :group - :type name - :data (conj results result) - :token origin - :remaining res-rem} - - :quiet {:status :group - :type name - :data results - :token origin - :remaining res-rem} - - :group {:status :group - :type name - :data (vec (concat results (:data result))) - :token origin - :remaining res-rem} - - (:err :none) - (assoc (update result :trace #(conj % name)) :status :err)) - - (case (:status result) - :ok (recur (rest ps) (conj results result) res-rem) - :group (recur (rest ps) - (vec (concat results (:data result))) - res-rem) - :quiet (recur (rest ps) results res-rem) - - (:err :none) - (assoc (update result :trace #(conj % name)) :status :err))))))))}) - -(defn order-0 [name parsers] - {:name name - :rule (fn order-fn [tokens] - (let [origin (first tokens)] - (loop [ps parsers - results [] - ts tokens] - (let [result (apply-parser (first ps) ts) - res-rem (remaining result)] - (if (empty? (rest ps)) - ;; Nothing more: return - (case (:status result) - :ok {:status :group - :type name - :data (conj results result) - :token origin - :remaining res-rem} - - :quiet {:status :group - :type name - :data results - :token origin - :remaining res-rem} - - :group {:status :group - :type name - :data (vec (concat results (:data result))) - :token origin - :remaining res-rem} - - (:err :none) - (assoc (update result :trace #(conj % name)) :status :err)) - - ;; Still parsers left in the vector: recur - (case (:status result) - :ok (recur (rest ps) (conj results result) res-rem) - :group (recur (rest ps) - (vec (concat results (:data result))) - res-rem) - :quiet (recur (rest ps) results res-rem) - - (:err :none) - (assoc (update result :trace #(conj % name)) :status :err) - - (throw (ex-info (str "Got bad result: " (:status result)) result))))))))}) - -(defn weak-order [name parsers] - {:name name - :rule (fn order-fn [tokens] - (let [origin (first tokens)] - (loop [ps parsers - results [] - ts tokens] - (let [result (apply-parser (first ps) ts) - res-rem (remaining result)] - (if (empty? (rest ps)) - ;; Nothing more: return - (case (:status result) - :ok {:status :group - :type name - :data (conj results result) - :token origin - :remaining res-rem} - - :quiet {:status :group - :type name - :data results - :token origin - :remaining res-rem} - - :group {:status :group - :type name - :data (vec (concat results (:data result))) - :token origin - :remaining res-rem} - - (:err :none) - (update result :trace #(conj % name))) - - ;; Still parsers left in the vector: recur - (case (:status result) - :ok (recur (rest ps) (conj results result) res-rem) - :group (recur (rest ps) - (vec (concat results (:data result))) - res-rem) - :quiet (recur (rest ps) results res-rem) - - (:err :none) - (update result :trace #(conj % name))))))))}) - - -(defn quiet [parser] - {:name (kw+str (? (:name parser) parser) "-quiet") - :rule (fn quiet-fn [tokens] - (let [result (apply-parser parser tokens)] - (if (pass? result) - (assoc result :status :quiet) - result)))}) - -(defn zero+ - ([parser] (zero+ (pname parser) parser)) - ([name parser] - {:name (kw+str name "-zero+") - :rule (fn zero+fn [tokens] - (loop [results [] - ts tokens] - (let [result (apply-parser parser ts)] - (case (:status result) - :ok (recur (conj results result) (remaining result)) - :group (recur (vec (concat results (:data result))) (remaining result)) - :quiet (recur results (remaining result)) - :err (update result :trace #(conj % name)) - :none {:status :group - :type name - :data results - :token (first tokens) - :remaining ts}))))})) - -(defn one+ - ([parser] (one+ (pname parser) parser)) - ([name parser] - {:name (kw+str name "-one+") - :rule (fn one+fn [tokens] - (let [first-result (apply-parser parser tokens) - rest-parser (zero+ name parser)] - (case (:status first-result) - (:ok :group) - (let [rest-result (apply-parser rest-parser (remaining first-result))] - (case (:status rest-result) - - (:ok :group :quiet) - {:status :group - :type name - :data (vec (concat (:data first-result) (data rest-result))) - :token (first tokens) - :remaining (remaining rest-result)} - - :none {:status :group :type name - :data first-result - :token (first tokens) - :remaining (remaining rest-result)} - - :err (update rest-result :trace #(conj % name)))) - - :quiet - (let [rest-result (apply-parser rest-parser (remaining first-result))] - {:status :quiet - :type name - :data [] - :token (first tokens) - :remaining (remaining rest-result)}) - - (:err :none) first-result)))})) - -(defn maybe - ([parser] (maybe (pname parser) parser)) - ([name parser] - {:name (kw+str name "-maybe") - :rule (fn maybe-fn [tokens] - (let [result (apply-parser parser tokens)] - (if (pass? result) - result - {:status :group :type name :data [] :token (first tokens) :remaining tokens} - )))})) - -(defn flat - ([parser] (flat (pname parser) parser)) - ([name parser] - {:name (kw+str name "-flat") - :rule (fn flat-fn [tokens] - (let [result (apply-parser parser tokens)] - (if (pass? result) (first (:data result)) result)))})) - -(defn group - ([parser] (group (pname parser) parser)) - ([name parser] - {:name (kw+str name "-group") - :rule (fn group-fn [tokens] - (let [result (apply-parser parser tokens)] - (if (= :group (:status result)) - (assoc result :status :ok) - result)))})) - -(defn err-msg [{token :token trace :trace}] - (println "Unexpected token " (:type token) " on line " (:line token)) - (println "Expected token " (first trace))) - -(defmacro defp [name & items] - (let [arg (last items) - fns (into [] (butlast items))] - `(defn ~name [] ((apply comp ~fns) (keyword '~name) ~arg)))) diff --git a/src/ludus/postlude.ld b/src/ludus/postlude.ld deleted file mode 100644 index 2594255..0000000 --- a/src/ludus/postlude.ld +++ /dev/null @@ -1,25 +0,0 @@ -& this file runs after any given interpretation -& even if the original interpretation panics -& the goal is to output any global state held in Ludus -& this does not have base loaded into it, only prelude: must be pure Ludus - -if turtle_state() :visible? then render_turtle! () else nil - -reset_turtle! () - -let console_msgs = flush! () - -let (r, g, b, a) = deref (bgcolor) -make! (bgcolor, colors :black) - -let draw_calls = deref (p5_calls) -make! (p5_calls, []) - -#{ - & :result result is provided elsewhere - & :errors [] & if we get here there are no errors - :console console_msgs - :draw concat ( - [(:background, r, g, b, a), (:stroke, 255, 255, 255, 255)] - draw_calls) -} diff --git a/src/ludus/prelude.cljc b/src/ludus/prelude.cljc deleted file mode 100644 index 5775776..0000000 --- a/src/ludus/prelude.cljc +++ /dev/null @@ -1,15 +0,0 @@ -(ns ludus.prelude - #?(:cljs (:require [shadow.resource :as r])) - ) - -(def prelude - #?( - :clj (slurp "src/ludus/prelude.ld") - :cljs (r/inline "./prelude.ld") - )) - -(def postlude - #?( - :clj (slurp "src/ludus/postlude.ld") - :cljs (r/inline "./postlude.ld") - )) \ No newline at end of file diff --git a/src/ludus/prelude.ld b/src/ludus/prelude.ld deleted file mode 100644 index 4daa175..0000000 --- a/src/ludus/prelude.ld +++ /dev/null @@ -1,1303 +0,0 @@ -& this file, uniquely, gets `base` loaded as context. See src/ludus/base.cljc for exports - -&&& TODO -& functions to add: -& true? -& set? -& tuple? -& ref? - -& the very base: know something's type -fn type { - "Returns a keyword representing the type of the value passed in." - (x) -> base :type (x) -} - -& ...and if two things are the same -fn eq? { - "Returns true if all arguments have the same value." - (x) -> true - (x, y) -> base :eq (x, y) - (x, y, ...zs) -> if eq? (x, y) - then loop (y, zs) with { - (a, []) -> eq? (a, x) - (a, [b, ...cs]) -> if eq? (a, x) - then recur (b, cs) - else false - } - else false -} - -fn neq? { - "Returns true if none of the arguments have the same value." - (x) -> false - (x, y) -> not (eq? (x, y)) - (x, y, ...zs) -> if eq? (x, y) - then false - else loop (y, zs) with { - (a, []) -> neq? (a, x) - (a, [b, ...cs]) -> if neq? (a, x) - then recur (b, cs) - else false - } -} - -& tuples: not a lot you can do with them functionally -fn tuple? { - "Returns true if a value is a tuple." - (tuple as :tuple) -> true - (_) -> false -} - -&&& functions: getting things done -fn fn? { - "Returns true if an argument is a function." - (f as :fn) -> true - (_) -> false -} - -& what we need for some very basic list manipulation -fn rest { - "Returns all but the first element of a list or tuple, as a list." - (xs as :list) -> base :rest (xs) - (xs as :tuple) -> base :rest (xs) -} - -fn inc { - "Increments a number." - (x as :number) -> base :inc (x) -} - -fn dec { - "Decrements a number." - (x as :number) -> base :dec (x) -} - -fn at { - "Returns the element at index n of a list or tuple. Zero-indexed: the first element is at index 0." - (xs as :list, n as :number) -> when { - neg? (n) -> nil - gte? (n, count (xs)) -> nil - else -> base :nth (xs, inc (n)) - } - (xs as :tuple, n as :number) -> when { - neg? (n) -> nil - gte? (n, count (xs)) -> nil - else -> base :nth (xs, inc (n)) - } - (_) -> nil -} - -fn first { - "Returns the first element of a list or tuple." - (xs) -> at (xs, 0) -} - -fn second { - "Returns the second element of a list or tuple." - (xs) -> at (xs, 1) -} - -fn last { - "Returns the last element of a list or tuple." - (xs) -> at (xs, sub (count (xs), 1)) -} - -fn butlast { - "Returns a list, omitting the last element." - (xs as :list) -> base :slice (xs, sub (count (xs), 1)) -} - -fn slice { - "Returns a slice of a list, representing a sub-list." - (xs as :list, end as :number) -> slice (xs, 0, end) - (xs as :list, start as :number, end as :number) -> when { - gte? (start, end) -> [] - gt? (end, count (xs)) -> slice (xs, start, count (xs)) - neg? (start) -> slice (xs, 0, end) - else -> { - let slice = base :slice (xs, inc (start), inc (end)) - base :into ([], slice) - } - } -} - -fn count { - "Returns the number of elements in a collection (including string)." - (xs as :list) -> dec (base :count (xs)) - (xs as :tuple) -> dec (base :count (xs)) - (xs as :dict) -> base :count (xs) - (xs as :string) -> base :count (xs) - (xs as :set) -> base :count (xs) - (xs as :struct) -> dec (base :count (xs)) -} - -fn empty? { - "Returns true if something is empty. Otherwise returns false (including for things that can't logically be empty, like numbers)." - ([]) -> true - (#{}) -> true - (s as :set) -> eq (s, ${}) - (()) -> true - ("") -> true - (_) -> false -} - -fn list? { - "Returns true if the value is a list." - (l as :list) -> true - (_) -> false -} - -fn list { - "Takes a value and returns it as a list. For values, it simply wraps them in a list. For collections, conversions are as follows. A tuple->list conversion preservers order and length. Unordered collections do not preserve order. Associative collections return lists of (key, value) tuples." - (x) -> base :to_list (x) -} - -fn set { - "Takes an ordered collection--list or tuple--and turns it into a set." - (xs as :list) -> base :into (${}, xs) - (xs as :tuple) -> base :into (${}, xs) -} - -fn set? { - "Returns true if a value is a set." - (xs as :set) -> true - (_) -> false -} - -fn fold { - "Folds a list." - (f as :fn, xs as :list) -> fold (f, xs, f ()) - (f as :fn, xs as :list, root) -> loop (root, first (xs), rest (xs)) with { - (prev, curr, []) -> f (prev, curr) - (prev, curr, remaining) -> recur ( - f (prev, curr) - first (remaining) - rest (remaining) - ) - } -} - -fn map { - "Maps over a list." - (f as :fn, xs) -> { - fn mapper (prev, curr) -> append (prev, f (curr)) - fold (mapper, xs, []) - } - (kw as :keyword, xs) -> { - fn mapper (prev, curr) -> append (prev, kw (curr)) - fold (mapper, xs, []) - } -} - -fn filter { - "Takes a list and a predicate function, and returns a new list with only the items that produce truthy values when the function is called on them." - (p? as :fn, xs) -> { - fn filterer (filtered, x) -> if p? (x) - then append (filtered, x) - else filtered - fold (filterer, xs, []) - } -} - -fn keep { - "Takes a list and returns a new list with any `nil` values omitted." - (xs) -> filter (some?, xs) -} - -fn append { - "Adds an element to a list or set." - () -> [] - (xs as :list) -> xs - (xs as :list, x) -> base :conj (xs, x) - (xs as :set) -> xs - (xs as :set, x) -> base :conj (xs, x) -} - -fn concat { - "Combines two lists, strings, or sets." - (x as :string, y as :string) -> base :str (x, y) - (xs as :list, ys as :list) -> base :concat (xs, ys) - (xs as :set, ys as :set) -> base :concat (xs, ys) - (xs, ys, ...zs) -> fold (concat, zs, concat (xs, ys)) -} - -& the console: sending messages to the outside world -& the console is *both* something we send to the host language's console -& ...and also a list of messages. -ref console = [] - -fn flush! { - "Clears the console, and returns the messages." - () -> { - let msgs = deref (console) - make! (console, []) - msgs - } -} - -fn add_msg! { - "Adds a message to the console." - (msg as :string) -> update! (console, append (_, msg)) - (msgs as :list) -> { - let msg = do msgs > map (string, _) > join - update! (console, append (_, msg)) - } -} - -fn print! { - "Sends a text representation of Ludus values to the console." - (...args) -> { - base :print (args) - add_msg! (args) - :ok - } -} - -fn show { - "Returns a text representation of a Ludus value as a string." - (x) -> base :show (x) -} - -fn prn! { - "Prints the underlying Clojure data structure of a Ludus value." - (x) -> base :prn (x) -} - -fn report! { - "Prints a value, then returns it." - (x) -> { - print! (x) - x - } - (msg as :string, x) -> { - print! (concat (msg, show (x))) - x - } -} - -fn doc! { - "Prints the documentation of a function to the console." - (f as :fn) -> do f > base :doc > print! - (_) -> :none -} - -&&& strings: harder than they look! -fn string? { - "Returns true if a value is a string." - (x as :string) -> true - (_) -> false -} - -fn string { - "Converts a value to a string by using `show`. If it is a string, returns it unharmed. Use this to build up strings of differen kinds of values." - (x as :string) -> x - (x) -> show (x) - (x, ...xs) -> loop (x, xs) with { - (out, [x]) -> concat (out, show(x)) - (out, [x, ...xs]) -> recur (concat (out, show (x)), xs) - } -} - -fn join { - "Takes a list of strings, and joins them into a single string, interposing an optional separator." - ([]) -> "" - ([str as :string]) -> str - (strs as :list) -> join (strs, "") - ([str, ...strs], separator as :string) -> fold ( - fn (joined, to_join) -> concat (joined, separator, to_join) - strs - str - ) -} - -& in another prelude, with a better actual base language than Java (thanks, Rich), counting strings would be reasonable but complex: count/bytes, count/points, count/glyphs. Java's UTF16 strings make this unweildy. - -& TODO: add trim, trim/left, trim/right; pad/left, pad/right -& ...also a version of at, - -&&& references: mutable state and state changes - -fn ref? { - "Returns true if a value is a ref." - (r as :ref) -> true - (_) -> false -} - -fn deref { - "Resolves a ref into a value." - (r as :ref) -> base :deref (r) -} - -fn make! { - "Sets the value of a ref." - (r as :ref, value) -> base :set! (r, value) -} - -fn update! { - "Updates a ref by applying a function to its value. Returns the new value." - (r as :ref, f as :fn) -> { - let current = deref (r) - let new = f (current) - make! (r, new) - } -} - -&&& numbers, basically: arithmetic and not much else, yet -& TODO: add nan?, -fn number? { - "Returns true if a value is a number." - (x as :number) -> true - (_) -> false -} - -fn add { - "Adds numbers or vectors." - () -> 0 - (x as :number) -> x - (x as :number, y as :number) -> base :add (x, y) - (x, y, ...zs) -> fold (base :add, zs, base :add (x, y)) - & add vectors - ((x1, y1), (x2, y2)) -> (add (x1, x2), add (y1, y2)) -} - -fn sub { - "Subtracts numbers or vectors." - () -> 0 - (x as :number) -> x - (x as :number, y as :number) -> base :sub (x, y) - (x, y, ...zs) -> fold (base :sub, zs, base :sub (x, y)) - ((x1, y1), (x2, y2)) -> (base :sub (x1, x2), base :sub (x2, y2)) -} - -fn mult { - "Multiplies numbers or vectors." - () -> 1 - (x as :number) -> x - (x as :number, y as :number) -> base :mult (x, y) - (x, y, ...zs) -> fold (base :mult, mult (x, y), zs) - (scalar as :number, (x, y)) -> (mult (x, scalar), mult (y, scalar)) - ((x, y), scalar as :number) -> mult (scalar, (x, y)) -} - -fn div { - "Divides numbers. Panics on division by zero." - (x as :number) -> x - (_, 0) -> panic! "Division by zero." - (x as :number, y as :number) -> base :div (x, y) - (x, y, ...zs) -> { - let divisor = fold (mult, zs, y) - div (x, divisor) - } -} - -fn div/0 { - "Divides numbers. Returns 0 on division by zero." - (x as :number) -> x - (_, 0) -> 0 - (x as :number, y as :number) -> base :div (x, y) - (x, y, ...zs) -> { - let divisor = fold (mult, zs, y) - div/0 (x, divisor) - } -} - -fn div/safe { - "Divides a number. Returns a result tuple." - (x as :number) -> (:ok, x) - (_, 0) -> (:err, "Division by zero") - (x, y) -> (:ok, div (x, y)) - (x, y, ...zs) -> { - let divisor = fold (mult, zs, y) - div/safe (x, divisor) - } -} - -fn abs { - "Returns the absolute value of a number." - (0) -> 0 - (n) -> if neg? (n) then mult (-1, n) else n -} - -fn neg { - "Multiplies a number by -1, negating it." - (n as :number) -> mult (n, -1) -} - -fn angle { - "Calculates the angle between two vectors." - (v1, v2) -> sub (atan/2 (v2), atan/2 (v1)) -} - -fn zero? { - "Returns true if a number is 0." - (0) -> true - (_) -> false -} - -fn gt? { - "Returns true if numbers are in decreasing order." - (x as :number) -> true - (x as :number, y as :number) -> base :gt (x, y) - (x, y, ...zs) -> loop (y, zs) with { - (a, [b]) -> base :gt (a, b) - (a, [b, ...cs]) -> if base :gt (a, b) - then recur (b, cs) - else false - } -} - -fn gte? { - "Returns true if numbers are in decreasing or flat order." - (x as :number) -> true - (x as :number, y as :number) -> base :gte (x, y) - (x, y, ...zs) -> loop (y, zs) with { - (a, [b]) -> base :gte (a, b) - (a, [b, ...cs]) -> if base :gte (a, b) - then recur (b, cs) - else false - } -} - -fn lt? { - "Returns true if numbers are in increasing order." - (x as :number) -> true - (x as :number, y as :number) -> base :lt (x, y) - (x, y, ...zs) -> loop (y, zs) with { - (a, [b]) -> base :lt (a, b) - (a, [b, ...cs]) -> if base :lt (a, b) - then recur (b, cs) - else false - } -} - -fn lte? { - "Returns true if numbers are in increasing or flat order." - (x as :number) -> true - (x as :number, y as :number) -> base :lte (x, y) - (x, y, ...zs) -> loop (y, zs) with { - (a, [b]) -> base :lte (a, b) - (a, [b, ...cs]) -> if base :lte (a, b) - then recur (b, cs) - else false - } -} - -fn neg? { - "Returns true if a value is a negative number, otherwise returns false." - (x as :number) if lt? (x, 0) -> true - (_) -> false -} - -fn pos? { - "Returns true if a value is a positive number, otherwise returns false." - (x as :number) if gt? (x, 0) -> true - (_) -> false -} - -fn even? { - "Returns true if a value is an even number, otherwise returns false." - (x as :number) if eq (0, mod (x, 2)) -> true - (_) -> false -} - -fn odd? { - "Returns true if a value is an odd number, otherwise returns false." - (x as :number) if eq (1, mod (x, 2)) -> true - (_) -> false -} - -&&& keywords: funny names -fn keyword? { - "Returns true if a value is a keyword, otherwise returns false." - (kw as :keyword) -> true - (_) -> false -} - -& TODO: determine if Ludus should have a `keyword` function that takes a string and returns a keyword. Too many panics, it has weird memory consequences, etc. - -&&& nil: working with nothing - -fn nil? { - "Returns true if a value is nil." - (nil) -> true - (_) -> false -} - -fn some? { - "Returns true if a value is not nil." - (nil) -> false - (_) -> true -} - -fn some { - "Takes a possibly nil value and a default value. Returns the value if it's not nil, returns the default if it's nil." - (nil, default) -> default - (value, _) -> value -} - -&&& true & false: boolean logic - -fn bool? { - "Returns true if a value is of type :boolean." - (false) -> true - (true) -> true - (_) -> false -} - -fn true? { - "Returns true if a value is boolean `true`. Useful to distinguish between `true` and anything else." - (true) -> true - (_) -> false -} - -fn false? { - "Returns `true` if a value is `false`, otherwise returns `false`. Useful to distinguish between `false` and `nil`." - (false) -> true - (_) -> false -} - -fn bool { - "Returns false if a value is nil or false, otherwise returns true." - (nil) -> false - (false) -> false - (_) -> true -} - -fn not { - "Returns false if a value is truthy, true if a value is falsy." - (nil) -> true - (false) -> true - (_) -> false -} - -& TODO: make `and` and `or` special forms which lazily evaluate arguments -fn and { - "Returns true if all values passed in are truthy. Note that this does not short-circuit: all arguments are evaulated before they are passed in." - () -> true - (x) -> bool (x) - (x, y) -> base :and (x, y) - (x, y, ...zs) -> fold (base :and, zs, base :and (x, y)) -} - -fn or { - "Returns true if any value passed in is truthy. Note that this does not short-circuit: all arguments are evaluated before they are passed in." - () -> true - (x) -> bool (x) - (x, y) -> base :or (x, y) - (x, y, ...zs) -> fold (base :or, zs, base :or (x, y)) -} - -&&& associative collections: dicts, structs, namespaces -& TODO?: get_in, update_in, merge -fn assoc { - "Takes a dict, key, and value, and returns a new dict with the key set to value." - () -> #{} - (dict as :dict) -> dict - (dict as :dict, key as :keyword, value) -> base :assoc (dict, key, value) - (dict as :dict, (key as :keyword, value)) -> base :assoc (dict, key, value) -} - -fn dissoc { - "Takes a dict and a key, and returns a new dict with the key and associated value omitted." - (dict as :dict) -> dict - (dict as :dict, key as :keyword) -> base :dissoc (dict, key) -} - -fn update { - "Takes a dict, key, and function, and returns a new dict with the key set to the result of applying the function to original value held at the key." - (dict as :dict) -> dict - (dict as :dict, key as :keyword, updater as :fn) -> base :assoc (dict, key, updater (get (key, dict))) -} - -fn keys { - "Takes an associative collection and returns a list of keys in that collection. Returns an empty list on anything other than a collection." - (coll) -> if not (assoc? (coll)) - then [] - else do coll > list > map (first, _) -} - -fn values { - "Takes an associative collection and returns a list of values in that collection. Returns an empty list on anything other than a collection." - (coll) -> if not (assoc? (coll)) - then [] - else do coll > list > map (second, _) -} - -fn diff { - "Takes two associate data structures and returns a dict describing their differences. Does this shallowly, offering diffs only for keys in the original dict." - (d1 as :dict, d2 as :dict) -> { - let key1 = keys (d1) - let key2 = keys (d2) - let all = do concat (d1, d2) > set > list - let diffs = loop (all, []) with { - & TODO: reduce this redundancy? - ([k, ...ks], diffs) -> { - let v1 = get (k, d1) - let v2 = get (k, d2) - if eq? (v1, v2) - then recur (ks, diffs) - else recur (ks, append (diffs, (k, (v1, v2)))) - } - ([k], diffs) -> { - let v1 = get (k, d1) - let v2 = get (k, d2) - if eq? (v1, v2) - then diffs - else append (diffs, (k, (v1, v2))) - } - } - dict (diffs) - } -} - -fn coll? { - "Returns true if a value is a collection: dict, struct, list, tuple, or set." - (coll as :dict) -> true - (coll as :struct) -> true - (coll as :list) -> true - (coll as :tuple) -> true - (coll as :set) -> true - (coll as :ns) -> true - (_) -> false -} - -fn ordered? { - "Returns true if a value is an indexed collection: list or tuple." - (coll as :list) -> true - (coll as :tuple) -> true - (_) -> false -} - -fn assoc? { - "Returns true if a value is an associative collection: a dict, struct, or namespace." - (assoc as :dict) -> true - (assoc as :struct) -> true - (assoc as :ns) -> true - (_) -> false -} - -fn get { - "Takes a dict or struct, key, and optional default value; returns the value at key. If the value is not found, returns nil or the default value. Returns nil or default if the first argument is not a dict or struct." - (key as :keyword) -> get (key, _) - (key as :keyword, coll) -> base :get (key, coll) - (key as :keyword, coll, default) -> base :get (key, coll, default) -} - -fn has? { - "Takes a key and a dict, and returns true if there is a non-`nil` value stored at the key." - (key as :keyword) -> has? (key, _) - (key as :keyword, dict as :dict) -> do dict > key > nil? -} - -fn dict { - "Takes a struct or ns, and returns it as a dict. Or, takes a list or tuple of (key, value) tuples and returns it as a dict. Returns dicts unharmed." - (struct as :struct) -> base :to_dict (struct) - (ns_ as :ns) -> base :to_dict (ns_) - (dict as :dict) -> dict - (list as :list) -> fold (assoc, list) - (tup as :tuple) -> do tup > list > dict -} - -fn dict? { - "Returns true if a value is a dict." - (dict as :dict) -> true - (_) -> false -} - -& TODO: make this less awkward once we have tail recursion -fn each! { - "Takes a list and applies a function, presumably with side effects, to each element in the list. Returns nil." - (f! as :fn, []) -> nil - (f! as :fn, [x]) -> { f! (x); nil } - (f! as :fn, [...xs]) -> loop (xs) with { - ([x]) -> { f! (x); nil } - ([x, ...xs]) -> { f! (x); recur (xs) } - } -} - -&&& Trigonometry functions - -& Ludus uses turns as its default unit to measure angles -& However, anything that takes an angle can also take a -& units argument, that's a keyword of :turns, :degrees, or :radians - -let pi = base :pi - -let tau = mult (2, pi) - -fn sin { - "Returns the sine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in." - (a as :number) -> do a > turn/rad > base :sin - (a as :number, :turns) -> do a > turn/rad > base :sin - (a as :number, :degrees) -> do a > deg/rad > base :sin - (a as :number, :radians) -> base :sin (a) -} - -fn cos { - "Returns the cosine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in." - (a as :number) -> do a > turn/rad > base :cos - (a as :number, :turns) -> do a > turn/rad > base :cos - (a as :number, :degrees) -> do a > deg/rad > base :cos - (a as :number, :radians) -> base :cos (a) -} - -fn tan { - "Returns the sine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in." - (a as :number) -> do a > turn/rad > base :tan - (a as :number, :turns) -> do a > turn/rad > base :tan - (a as :number, :degrees) -> do a > deg/rad > base :tan - (a as :number, :radians) -> base :tan (a) -} - -fn rotate { - "Rotates a vector by an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in." - ((x, y), angle) -> rotate ((x, y), angle, :turns) - ((x, y), angle, units as :keyword) -> ( - sub (mult (x, cos (angle, units)), mult (y, sin (angle, units))) - add (mult (x, sin (angle, units)), mult (y, cos (angle, units))) - ) -} - -fn turn/deg { - "Converts an angle in turns to an angle in degrees." - (a as :number) -> mult (a, 360) -} - -fn deg/turn { - "Converts an angle in degrees to an angle in turns." - (a as :number) -> div (a, 360) -} - -fn turn/rad { - "Converts an angle in turns to an angle in radians." - (a as :number) -> mult (a, tau) -} - -fn rad/turn { - "Converts an angle in radians to an angle in turns." - (a as :number) -> div (a, tau) -} - -fn deg/rad { - "Converts an angle in degrees to an angle in radians." - (a as :number) -> mult (tau, div (a, 360)) -} - -fn rad/deg { - "Converts an angle in radians to an angle in degrees." - (a as :number) -> mult (360, div (a, tau)) -} - -fn atan/2 { - "Returns an angle from a slope. Takes an optional keyword argument to specify units. Takes either two numbers or a vector tuple." - (x as :number, y as :number) -> do base :atan_2 (x, y) > rad/turn - (x, y, :turns) -> atan/2 (x, y) - (x, y, :radians) -> base :atan_2 (x, y) - (x, y, :degrees) -> do base :atan_2 (x, y) > rad/deg - ((x, y)) -> atan/2 (x, y) - ((x, y), units as :keyword) -> atan/2 (x, y, units) -} - -fn mod { - "Returns the modulus of num and div. Truncates towards negative infinity." - (num as :number, y as :number) -> base :mod (num, div) -} - -fn square { - "Squares a number." - (x as :number) -> mult (x, x) -} - -fn sqrt { - "Returns the square root of a number." - (x as :number) -> base :sqrt (x) -} - -fn sum_of_squares { - "Returns the sum of squares of numbers." - () -> 0 - (x as :number) -> square (x) - (x as :number, y as :number) -> add (square (x), square (y)) - (x, y, ...zs) -> fold (sum_of_squares, zs, sum_of_squares (x, y)) -} - -fn dist { - "Returns the distance from the origin to a point described by (x, y)." - (x as :number, y as :number) -> sqrt (sum_of_squares (x, y)) - ((x, y)) -> dist (x, y) -} - -&&& more number functions -& TODO: add max, min -fn random { - "Returns a random number. With zero arguments, returns a random number between 0 (inclusive) and 1 (exclusive). With one argument, returns a random number between 0 and n. With two arguments, returns a random number between m and n." - () -> base :random () - (n as :number) -> base :random (n) - (m as :number, n as :number) -> add (m, random (n)) -} - -fn floor { - "Truncates a number towards negative infinity. With positive numbers, it returns the integer part. With negative numbers, returns the next more-negative integer." - (n as :number) -> base :floor (n) -} - -fn ceil { - "Truncates a number towards positive infinity. With negative numbers, it returns the integer part. With positive numbers, returns the next more-positive integer." - (n as :number) -> base :ceil (n) -} - -fn round { - "Rounds a number to the nearest integer." - (n as :number) -> base :round (n) -} - -fn range { - "Returns the set of integers between start (inclusive) and end (exclusive) as a list. With one argument, starts at 0. If end is less than start, returns an empty list." - (end as :number) -> base :range (0, end) - (start as :number, end as :number) -> base :range (start, end) -} - -&&& Results, errors and other unhappy values - -fn ok { - "Takes a value and wraps it in an :ok result tuple." - (value) -> (:ok, value) -} - -fn ok? { - "Takes a value and returns true if it is an :ok result tuple." - ((:ok, _)) -> true - (_) -> false -} - -fn err { - "Takes a value and wraps it in an :err result tuple, presumably as an error message." - (msg) -> (:err, msg) -} - -fn err? { - "Takes a value and returns true if it is an :err result tuple." - ((:err, _)) -> true - (_) -> false -} - -fn unwrap! { - "Takes a result tuple. If it's :ok, then returns the value. If it's not :ok, then it panics. If it's not a result tuple, it also panics." - ((:ok, value)) -> value - ((:err, msg)) -> panic! string ("Unwrapped :err! ", msg) - (_) -> panic! "Cannot unwrap something that's not an error tuple." -} - -fn unwrap_or { - "Takes a value that is a result tuple and a default value. If it's :ok, then it returns the value. If it's :err, returns the default value." - ((:ok, value), _) -> value - ((:err, _), default) -> default -} - -fn assert! { - "Asserts a condition: returns the value if the value is truthy, panics if the value is falsy. Takes an optional message." - (value) -> if value then value else panic! string ("Assert failed:", value) - (msg, value) -> if value - then value - else panic! string ("Assert failed: ", msg, " with ", value) -} - -&&& Turtle & other graphics - -& some basic colors -&&& TODO: add colors -let colors = #{ - :white (255, 255, 255, 255) - :light_gray (150, 150, 150, 255) - :dark_gray (50, 50, 50, 255) - :red (255, 0, 0, 255) - :green (0, 255, 0, 255) - :blue (0, 0, 255, 255) - :black (0, 0, 0, 255) -} - -& the initial turtle state -let turtle_init = #{ - :position (0, 0) & let's call this the origin for now - :heading 0 & this is straight up - :pendown? true - :color colors :white - :penwidth 1 - :visible? true -} - -& turtle states: refs that get modified by calls -& turtle_commands is a list of commands, expressed as tuples -ref turtle_commands = [] - -& and a list of turtle states -ref turtle_states = [turtle_init] - -fn reset_turtle! { - "Resets the turtle to its original state." - () -> make! (turtle_states, [turtle_init]) -} - -& and a list of calls to p5--at least for now -ref p5_calls = [] - -& ...and finally, a background color -& we need to store this separately because, while it can be updated later, -& it must be the first call to p5. -ref bgcolor = colors :black - -fn add_call! (call) -> update! (p5_calls, append (_, call)) - -fn add_command! (command) -> { - update! (turtle_commands, append (_, command)) - let prev = do turtle_states > deref > last - let curr = apply_command (prev, command) - update! (turtle_states, append (_, curr)) - let call = state/call () - if call then { add_call! (call); :ok } else :ok -} - -fn make_line ((x1, y1), (x2, y2)) -> (:line, x1, y1, x2, y2) - -let turtle_radius = 20 - -let turtle_angle = 0.385 - -let turtle_color = (255, 255, 255, 150) - -fn render_turtle! () -> { - let state = do turtle_states > deref > last - if state :visible? - then { - let (r, g, b, a) = turtle_color - add_call! ((:fill, r, g, b, a)) - let #{heading, :position (x, y)} = state - let first = mult ((0, 1), turtle_radius) - let (x1, y1) = first - let (x2, y2) = rotate (first, turtle_angle) - let (x3, y3) = rotate (first, neg (turtle_angle)) - add_call! ((:push)) - add_call! ((:translate, x, y)) - add_call! ((:rotate, turn/rad (heading))) - add_call! ((:noStroke)) - add_call! ((:beginShape)) - add_call! ((:vertex, x1, y1)) - add_call! ((:vertex, x2, y2)) - add_call! ((:vertex, x3, y3)) - add_call! ((:endShape)) - add_call! ((:stroke, 0)) - add_call! ((:line, 0, 0, x1, y1)) - add_call! ((:pop)) - :ok - } - else :ok -} - -fn state/call () -> { - let cmd = do turtle_commands > deref > last > first - let states = deref (turtle_states) - let curr = last (states) - let prev = at (states, sub (count (states), 2)) - match cmd with { - :forward -> if curr :pendown? - then make_line (prev :position, curr :position) - else nil - :back -> if curr :pendown? - then make_line (prev :position, curr :position) - else nil - :home -> if curr :pendown? - then make_line (prev :position, curr :position) - else nil - :goto -> if curr :pendown? - then make_line (prev :position, curr :position) - else nil - :penwidth -> (:strokeWeight, curr :penwidth) - :pencolor -> { - let (r, g, b, a) = curr :pencolor - (:stroke, r, g, b, a) - } - :clear -> (:background, 0, 0, 0, 255) - else -> nil - } -} - -fn forward! { - "Moves the turtle forward by a number of steps. Alias: fd!" - (steps as :number) -> add_command! ((:forward, steps)) -} - -let fd! = forward! - -fn back! { - "Moves the turtle backward by a number of steps. Alias: bk!" - (steps as :number) -> add_command! ((:back, steps)) -} - -let bk! = back! - -& turtles, like eveyrthing else in Ludus, use turns by default, -& not degrees -fn left! { - "Rotates the turtle left, measured in turns. Alias: lt!" - (turns as :number) -> add_command! ((:left, turns)) -} - -let lt! = left! - -fn right! { - "Rotates the turtle right, measured in turns. Alias: rt!" - (turns as :number) -> add_command! ((:right, turns)) -} - -let rt! = right! - -fn penup! { - "Lifts the turtle's pen, stopping it from drawing. Alias: pu!" - () -> add_command! ((:penup)) -} - -let pu! = penup! - -fn pendown! { - "Lowers the turtle's pen, causing it to draw. Alias: pd!" - () -> add_command! ((:pendown)) -} - -let pd! = pendown! - -fn pencolor! { - "Changes the turtle's pen color. Takes a single grayscale value, an rgb tuple, or an rgba tuple. Alias: pc!" - (gray as :number) -> add_command! ((:pencolor, (gray, gray, gray, 255))) - ((r as :number, g as :number, b as :number)) -> add_command! ((:pencolor, (r, g, b, 255))) - ((r as :number, g as :number, b as :number, a as :number)) -> add_command! ((:pencolor, (r, g, b, a))) -} - -let pc! = pencolor! - -fn penwidth! { - "Sets the width of the turtle's pen, measured in pixels. Alias: pw!" - (width as :number) -> add_command! ((:penwidth, width)) -} - -let pw! = penwidth! - -fn background! { - "Sets the background color behind the turtle and path. Alias: bg!" - (gray as :number) -> make! (bgcolor, (gray, gray, gray, 255)) - ((r as :number, g as :number, b as :number)) -> make! (bgcolor, (r, b, g, 255)) - ((r as :number, g as :number, b as :number, a as :number)) -> make! (bgcolor, (r, g, b, a)) -} - -let bg! = background! - -fn home! { - "Sends the turtle home: to the centre of the screen, pointing up. If the pen is down, the turtle will draw a path to home." - () -> add_command! ((:home)) -} - -fn clear! { - "Clears the canvas and sends the turtle home." - () -> add_command! ((:clear)) -} - -fn goto! { - "Sends the turtle to (x, y) coordinates. If the pen is down, the turtle will draw a path to its new location." - (x as :number, y as :number) -> add_command! ((:goto, (x, y))) - ((x, y)) -> goto! (x, y) -} - -fn heading/vector { - "Takes a turtle heading, and returns a unit vector of that heading." - (heading) -> { - & 0 is 90º/0.25T, 0.25 is 180º/0.5T, 0.5 is 270º/0.75T, 0.75 is 0º/0T - let angle = add (heading, 0.25) - (cos (angle), sin (angle)) - } -} - -fn apply_command { - "Takes a turtle state and a command and calculates a new state." - (state, command) -> match command with { - (:goto, (x, y)) -> assoc (state, :position, (x, y)) - (:home) -> assoc (state, :position, (0, 0)) - (:clear) -> assoc (state, :position, (0, 0)) - (:right, turns) -> update (state, :heading, add (_, turns)) - (:left, turns) -> update (state, :heading, sub (_, turns)) - (:forward, steps) -> { - let #{heading, position} = state - let unit = heading/vector (heading) - let vect = mult (steps, unit) - update (state, :position, add (vect, _)) - } - (:back, steps) -> { - let #{heading, position} = state - let unit = heading/vector (heading) - let vect = mult (steps, unit) - update (state, :position, sub (_, vect)) - } - (:penup) -> assoc (state, :pendown?, false) - (:pendown) -> assoc (state, :pendown?, true) - (:penwidth, pixels) -> assoc (state, :penwidth, pixels) - (:pencolor, color) -> assoc (state, :pencolor, color) - } -} - -fn turtle_state { - "Returns the turtle's current state." - () -> do turtle_states > deref > last -} - -& position () -> (x, y) -fn position { - "Returns the turtle's current position." - () -> turtle_state () :position -} - -fn heading { - "Returns the turtle's current heading." - () -> turtle_state () :heading -} - -fn pendown? { - "Returns the turtle's pen state: true if the pen is down." - () -> turtle_state () :pendown? -} - -fn pencolor { - "Returns the turtle's pen color as an (r, g, b, a) tuple." - () -> turtle_state () :pencolor -} - -fn penwidth { - "Returns the turtle's pen width in pixels." - () -> turtle_state () :pencolor -} - -ns prelude { - type - eq? - neq? - tuple? - fn? - first - second - rest - at - last - butlast - slice - count - append - fold - map - filter - keep - list - set - set? - inc - dec - print! - flush! - console - show - prn! - report! - doc! - concat - ref? - deref - make! - update! - string - string? - join - add - sub - mult - div - div/0 - div/safe - angle - abs - neg - zero? - neg? - pos? - even? - odd? - gt? - gte? - lt? - lte? - keyword? - nil? - some? - some - bool? - false? - bool - not - and - or - coll? - ordered? - assoc? - assoc - dissoc - update - get - dict - dict? - keys - values - diff - each! - sin - cos - tan - turn/rad - rad/turn - turn/deg - deg/turn - rad/deg - deg/rad - atan/2 - mod - square - sqrt - sum_of_squares - dist - random - pi - tau - floor - ceil - round - range - ok - ok? - err - err? - unwrap! - unwrap_or - assert! - colors - forward!, fd! - back!, bk! - right!, rt! - left!, lt! - penup!, pu! - pendown!, pd! - pencolor!, pc! - background!, bg! - penwidth!, pw! - home!, clear!, goto!, - heading, position, pendown? - pencolor, penwidth - heading/vector - turtle_state - p5_calls, turtle_states, turtle_commands, bgcolor - render_turtle!, reset_turtle! -} diff --git a/src/ludus/repl.clj b/src/ludus/repl.clj deleted file mode 100644 index ec5fc09..0000000 --- a/src/ludus/repl.clj +++ /dev/null @@ -1,118 +0,0 @@ -(ns ludus.repl - (:require - [ludus.scanner :as scanner] - [ludus.parser :as p] - [ludus.grammar :as g] - [ludus.interpreter :as interpreter] - [ludus.base :as base] - [ludus.show :as show] - [ludus.data :as data] - ;[ludus.process :as process] - )) - -(declare repl-prelude new-session) - -(def sessions (atom {})) - -(def current-session (atom nil)) - -(def prompt "=> ") - -(defn- exit [] - (println "\nGoodbye!") - (System/exit 0)) - -(def repl-ctx (merge interpreter/ludus-prelude - {::repl true - "repl" - {::data/struct true - ::data/type ::data/ns - ::data/name "repl" - - :flush - {:name "flush" - ::data/type ::data/clj - :body (fn - ([] - (let [session @current-session] - (swap! session #(assoc % :ctx (volatile! repl-ctx))) - :ok)) - ([name] - (if-let [session (get @sessions name)] - (do - (swap! session #(assoc % :ctx (volatile! repl-ctx))) - :ok) - (do - (println "No session named" name) - :error))))} - - :new - {:name "new" - ::data/type ::data/clj - :body (fn [name] - (let [session (new-session name)] - (reset! current-session session) - :ok))} - - :switch - {:name "switch" - ::data/type ::data/clj - :body (fn [name] - (if-let [session (get @sessions name)] - (do - (reset! current-session session) - :ok) - (do - (println "No session named" name) - :error)))} - - :quit - {:name "quit" - ::data/type ::data/clj - :body (fn [] (exit))} - }})) - -(defn- new-session [name] - (let [session (atom {:name name - :ctx (volatile! repl-ctx) - :history []})] - (swap! sessions #(assoc % name session)) - session)) - -(defn repl-loop [] - (let [session-atom @current-session - session @session-atom - orig-ctx (:ctx session)] - (print (str (:name session) prompt)) - (flush) - (let [input (read-line)] - (cond - (= nil input) (exit) - - (= "" input) (recur) - - :else - (let [parsed (->> input - (scanner/scan) - :tokens - (p/apply-parser g/script))] - (if (= :err (:status parsed)) - (do - (println (p/err-msg parsed)) - (recur)) - (let [{result :result ctx :ctx} - (interpreter/interpret-repl parsed orig-ctx true)] - (if (= result :error) - (recur) - (do - (println (show/show result)) - (when (not (= @ctx @orig-ctx)) - (swap! session-atom #(assoc % :ctx ctx))) - (recur)))))))))) - -(defn launch [] - (println "Welcome to Ludus (v. 0.1.0-alpha)") - (let [session (new-session :ludus)] - (reset! current-session session) - (repl-loop))) - diff --git a/src/ludus/scanner.cljc b/src/ludus/scanner.cljc deleted file mode 100644 index f55531a..0000000 --- a/src/ludus/scanner.cljc +++ /dev/null @@ -1,336 +0,0 @@ -(ns ludus.scanner - (:require - [ludus.token :as token] - ;; [clojure.pprint :as pp] - [clojure.edn :as edn])) - -(def reserved-words - "List of Ludus reserved words." - ;; see ludus-spec repo for more info - {"as" :as ;; impl for `import`; not yet for patterns - ;"cond" :cond ;; impl - "do" :do ;; impl - "else" :else ;; impl - "false" :false ;; impl -> literal word - "fn" :fn ;; impl - "if" :if ;; impl - "import" :import ;; impl - "let" :let ;; impl - "loop" :loop ;; impl - "match" :match ;; impl - "nil" :nil ;; impl -> literal word - "ns" :ns ;; impl - "panic!" :panic ;; impl (should _not_ be a function) - "recur" :recur ;; impl - "ref" :ref ;; impl - "then" :then ;; impl - "true" :true ;; impl -> literal word - "use" :use ;; wip - "with" :with ;; impl - "when" :when ;; impl, replaces cond - - ;; actor model/concurrency - ;"receive" :receive - ;;"self" :self ;; maybe not necessary?: self() is a function - ;;"send" :send ;; not necessary: send(pid, message) is a function - ;"spawn" :spawn - ;;"to" :to ;; not necessary if send is a function - ;; type system - ;; "data" :data ;; we are going to tear out datatypes for now: see if dynamism works for us - ;; others - "repeat" :repeat ;; syntax sugar over "loop": still unclear what this syntax could be - "test" :test - ;; "module" :module ;; not necessary if we don't have datatypes - }) - -(def literal-words { - "true" true - "false" false - "nil" nil - }) - -(defn- new-scanner - "Creates a new scanner." - [source input] - {:source source - :input input - :length (count source) - :errors [] - :start 0 - :current 0 - :line 1 - :tokens []}) - -(defn- at-end? - "Tests if a scanner is at end of input." - [scanner] - (>= (:current scanner) (:length scanner))) - -(defn- current-char - "Gets the current character of the scanner." - [scanner] - (nth (:source scanner) (:current scanner) nil)) - -(defn- advance - "Advances the scanner by a single character." - [scanner] - (update scanner :current inc)) - -(defn- next-char - "Gets the next character from the scanner." - [scanner] - (current-char (advance scanner))) - -(defn- current-lexeme - [scanner] - (subs (:source scanner) (:start scanner) (:current scanner))) - -(defn- char-code [char] - #?( - :clj (int char) - :cljs (.charCodeAt char 0) - )) - -(defn- char-in-range? [start end char] - (and char - (>= (char-code char) (char-code start)) - (<= (char-code char) (char-code end)))) - -(defn- digit? [c] - (char-in-range? \0 \9 c)) - -(defn- nonzero-digit? [c] - (char-in-range? \1 \9 c)) - -;; for now, use very basic ASCII charset in words -;; TODO: research the implications of using the whole -;; (defn- alpha? [c] (boolean (re-find #"\p{L}" (str c)))) -(defn- alpha? [c] - (or (char-in-range? \a \z c) (char-in-range? \A \Z c))) - -(defn- lower? [c] (char-in-range? \a \z c)) - -(defn- upper? [c] (char-in-range? \A \Z c)) - -;; legal characters in words -(def word-chars #{\_ \? \! \* \/}) - -(defn- word-char? [c] - (or (alpha? c) (digit? c) (contains? word-chars c))) - -(defn- whitespace? [c] - (or (= c \space) (= c \tab))) - -(def terminators #{\: \; \newline \{ \} \( \) \[ \] \$ \# \- \= \& \, \> nil \\}) - -(defn- terminates? [c] - (or (whitespace? c) (contains? terminators c))) - -(defn- add-token - ([scanner token-type] - (add-token scanner token-type nil)) - ([scanner token-type literal] - (update scanner :tokens conj - (token/token - token-type - (current-lexeme scanner) - literal - (:line scanner) - (:start scanner) - (:source scanner) - (:input scanner))))) - -;; TODO: errors should also be in the vector of tokens -;; The goal is to be able to be able to hand this to an LSP? -;; Do we need a different structure -(defn- add-error [scanner msg] - (let [token (token/token - :error - (current-lexeme scanner) - nil - (:line scanner) - (:start scanner) - (:source scanner) - (:input scanner)) - err-token (assoc token :message msg)] - (-> scanner - (update :errors conj err-token) - (update :tokens conj err-token)))) - -(defn- add-keyword - [scanner] - (loop [scanner scanner - key ""] - (let [char (current-char scanner)] - (cond - (terminates? char) (add-token scanner :keyword (keyword key)) - (word-char? char) (recur (advance scanner) (str key char)) - :else (add-error scanner (str "Unexpected " char "after keyword :" key)))))) - -;; TODO: improve number parsing? -;; Currently this uses Clojure's number formatting rules (since we use the EDN reader) -;; These rules are here: https://cljs.github.io/api/syntax/number -(defn- add-number [char scanner] - (loop [scanner scanner - num (str char) - float? false] - (let [curr (current-char scanner)] - (cond - (= curr \_) (recur (advance scanner) num float?) ;; consume underscores unharmed - (= curr \.) (if float? - (add-error scanner (str "Unexpected second decimal point after " num ".")) - (recur (advance scanner) (str num curr) true)) - (terminates? curr) (add-token scanner :number (edn/read-string num)) - (digit? curr) (recur (advance scanner) (str num curr) float?) - :else (add-error scanner (str "Unexpected " curr " after number " num ".")))))) - -;; TODO: activate string interpolation -(defn- add-string - [scanner] - (loop [scanner scanner - string "" - interpolate? false] - (let [char (current-char scanner)] - (case char - \{ (recur (advance scanner) (str string char) true) - ; allow multiline strings - \newline (recur (update (advance scanner) :line inc) (str string char) interpolate?) - \" (if interpolate? - ;(add-token (advance scanner) :interpolated string) - (add-token (advance scanner) :string string) - (add-token (advance scanner) :string string)) - \\ (let [next (next-char scanner) - scanner (if (= next \newline) - (update scanner :line inc) - scanner)] - (recur (advance (advance scanner)) (str string next) interpolate?)) - (if (at-end? scanner) - (add-error scanner "Unterminated string.") - (recur (advance scanner) (str string char) interpolate?)))))) - -(defn- add-word - [char scanner] - (loop [scanner scanner - word (str char)] - (let [curr (current-char scanner)] - (cond - (terminates? curr) (add-token scanner - (get reserved-words word :word) - (get literal-words word :none)) - (word-char? curr) (recur (advance scanner) (str word curr)) - :else (add-error scanner (str "Unexpected " curr " after word " word ".")))))) - -(defn- add-data - [char scanner] - (loop [scanner scanner - word (str char)] - (let [curr (current-char scanner)] - (cond - (terminates? curr) (add-token scanner :datatype) - (word-char? curr) (recur (advance scanner) (str word curr)) - :else (add-error scanner (str "Unexpected " curr " after datatype " word ".")))))) - -(defn- add-ignored - [scanner] - (loop [scanner scanner - ignored "_"] - (let [char (current-char scanner)] - (cond - (terminates? char) (add-token scanner :ignored) - (word-char? char) (recur (advance scanner) (str ignored char)) - :else (add-error scanner (str "Unexpected " char " after word " ignored ".")))))) - -(defn- add-comment [char scanner] - (loop [scanner scanner - comm (str char)] - (let [char (current-char scanner)] - (if (= \newline char) - scanner - (recur (advance scanner) (str comm char)))))) - -(defn- scan-token [scanner] - (let [char (current-char scanner) - scanner (advance scanner) - next (current-char scanner)] - (case char - ;; one-character tokens - \( (add-token scanner :lparen) - ;; :break is a special zero-char token before closing braces - ;; it makes parsing much simpler - \) (add-token (add-token scanner :break) :rparen) - \{ (add-token scanner :lbrace) - \} (add-token (add-token scanner :break) :rbrace) - \[ (add-token scanner :lbracket) - \] (add-token (add-token scanner :break) :rbracket) - \; (add-token scanner :semicolon) - \, (add-token scanner :comma) - \newline (add-token (update scanner :line inc) :newline) - \\ (add-token scanner :backslash) - \= (add-token scanner :equals) - \> (add-token scanner :pipeline) - - ;; two-character tokens - ;; -> - \- (cond - (= next \>) (add-token (advance scanner) :rarrow) - (digit? next) (add-number char scanner) - :else (add-error scanner (str "Expected -> or negative number after `-`. Got `" char next "`"))) - - ;; dict #{ - \# (if (= next \{) - (add-token (advance scanner) :startdict) - (add-error scanner (str "Expected beginning of dict: #{. Got " char next))) - - ;; set ${ - \$ (if (= next \{) - (add-token (advance scanner) :startset) - (add-error scanner (str "Expected beginning of set: ${. Got " char next))) - - ;; struct @{: Deleted from the language in December 2023 - ; \@ (if (= next \{) - ; (add-token (advance scanner) :startstruct) - ; (add-error scanner (str "Expected beginning of struct: @{. Got " char next))) - - ;; placeholders - ;; there's a flat _, and then ignored words - \_ (cond - (terminates? next) (add-token scanner :placeholder) - (alpha? next) (add-ignored scanner) - :else (add-error scanner (str "Expected placeholder: _. Got " char next))) - - ;; comments - ;; & starts an inline comment - \& (add-comment char scanner) - - ;; keywords - \: (cond - (alpha? next) (add-keyword scanner) - :else (add-error scanner (str "Expected keyword. Got " char next))) - - ;; splats - \. (let [after_next (current-char (advance scanner))] - (if (= ".." (str next after_next)) - (add-token (advance (advance scanner)) :splat) - (add-error scanner (str "Expected splat: ... . Got " (str "." next after_next))))) - - ;; strings - \" (add-string scanner) - - ;; word matches - (cond - (whitespace? char) scanner ;; for now just skip whitespace characters - (digit? char) (add-number char scanner) - (upper? char) (add-word char scanner) ;; no datatypes for now - (lower? char) (add-word char scanner) - :else (add-error scanner (str "Unexpected character: " char)))))) - -(defn- next-token [scanner] - (assoc scanner :start (:current scanner))) - -(defn scan [source input] - (loop [scanner (new-scanner source input)] - (if (at-end? scanner) - (let [scanner (add-token (add-token scanner :break) :eof)] - {:tokens (:tokens scanner) - :errors (:errors scanner)}) - (recur (-> scanner (scan-token) (next-token)))))) diff --git a/src/ludus/show.cljc b/src/ludus/show.cljc deleted file mode 100644 index e419f7e..0000000 --- a/src/ludus/show.cljc +++ /dev/null @@ -1,122 +0,0 @@ -(ns ludus.show - (:require - [ludus.data :as data] - ; [ludus.scanner :as s] - ; [ludus.parser :as p] - ; [ludus.grammar :as g] - ; [ludus.interpreter :as i] - [clojure.pprint :as pp])) - -(declare show show-linear show-keyed) - -(defn- show-vector [v] - (if (= (first v) ::data/tuple) - (str "(" (apply str (into [] show-linear (next v))) ")") - (str "[" (apply str (into [] show-linear (next v))) "]"))) - -(defn- show-map [v] - (cond - (or (= (::data/type v) ::data/fn) - (= (::data/type v) ::data/clj)) - (str "fn " (:name v)) - - (= (::data/type v) ::data/ns) - (str "ns " (::data/name v) " {" - (apply str (into [] show-keyed (dissoc v ::data/struct ::data/type ::data/name))) - "}") - - (::data/struct v) - (str "@{" (apply str (into [] show-keyed (dissoc v ::data/struct))) "}") - - (::data/ref v) ;; TODO: reconsider this - (str "ref: " (::data/name v) " {" (-> v ::data/value deref show) "}") - - (::data/dict v) - (str "#{" (apply str (into [] show-keyed (dissoc v ::data/dict))) "}") - - :else - (with-out-str (pp/pprint v)))) - -(defn- show-set [v] - (str "${" (apply str (into [] show-linear v)) "}")) - -(defn show - ([v] - (cond - (string? v) (str "\"" v "\"") - (number? v) (str v) - (keyword? v) (str v) - (boolean? v) (str v) - (nil? v) "nil" - (vector? v) (show-vector v) - (set? v) (show-set v) - (map? v) (show-map v) - :else - (with-out-str (pp/pprint v)) - )) - ([v & vs] (apply str (into [] (comp (map show) (interpose " ")) (concat [v] vs)))) - ) - -(def show-linear (comp (map show) (interpose ", "))) - -(def show-keyed (comp - (map #(str (show (first %)) " " (show (second %)))) - (interpose ", "))) - -(declare show-pattern) - -(defn show-coll-pattern [pattern [start end]] - (let [data (:data pattern) - members (map show-pattern data) - output (apply str (interpose ", " members))] - (str start output end))) - -(defn show-pattern [pattern] - (case (:type pattern) - nil "" - - :placeholder "_" - - :else "else" - - :true "true" - - :false "false" - - :nil "nil" - - :string (-> pattern :data first show) - - (:word :number :keyword) (-> pattern :data first str) - - :typed - (let [word (-> pattern :data first :data first) - type (-> pattern :data second :data first)] - (str word " as " type)) - - :splattern - (let [splatted (-> pattern :data first show-pattern)] - (str "..." splatted)) - - :pair-pattern - (let [key (-> pattern :data first) - value (-> pattern :data second)] - (str (show-pattern key) " " (show-pattern value))) - - :tuple-pattern (show-coll-pattern pattern ["(" ")"]) - - :list-pattern (show-coll-pattern pattern ["[" "]"]) - - :dict-pattern (show-coll-pattern pattern ["#{" "}"]) - - :struct-pattern (show-coll-pattern pattern ["@{" "}"]) - - )) - -(comment - (def source "let 1 = 0") - (def tokens (-> source s/scan :tokens)) - (def ast (p/apply-parser g/script tokens)) - (println (i/prettify-ast ast)) - (println (-> ast :data first :data first show-pattern)) - ) diff --git a/src/ludus/token.cljc b/src/ludus/token.cljc deleted file mode 100644 index 6638bc0..0000000 --- a/src/ludus/token.cljc +++ /dev/null @@ -1,11 +0,0 @@ -(ns ludus.token) - -(defn token - [type text literal line start source input] - {:type type - :lexeme text - :literal literal - :line line - :source source - :input input - :start start}) diff --git a/src/ludus/web.cljs b/src/ludus/web.cljs deleted file mode 100644 index 0907701..0000000 --- a/src/ludus/web.cljs +++ /dev/null @@ -1,44 +0,0 @@ -(ns ludus.web - (:require - [ludus.core :as core] - [goog.object :as o] - ) - ) - -(defn get-element [id] - (.getElementById (.-document js/window) id)) - -(def canv (get-element "canv")) - -(def code (get-element "code")) - -(def out (get-element "output")) - -(def play (get-element "play")) - -(defn run-code [] - (let [source (.-value code) - result (core/run source)] - (println "Running code:" source) - (o/set out "value" result))) - -(.addEventListener play "click" run-code) - -(defn setup [] - (js/createCanvas 640 240 canv) - (js/background 235) - ) - -(defn draw [] - (if js/mouseIsPressed - (js/fill 255) - (js/fill 155)) - (js/ellipse js/mouseX js/mouseY 80 80)) - -(defn init [] - (doto js/window - (o/set "setup" setup) - (o/set "draw" draw))) - -(o/set js/window "ludus_init" init) - diff --git a/janet/parser.janet b/src/parser.janet similarity index 99% rename from janet/parser.janet rename to src/parser.janet index 5cb4405..6d94c49 100644 --- a/janet/parser.janet +++ b/src/parser.janet @@ -1,8 +1,7 @@ ### A recursive descent parser for Ludus ### We still need to scan some things -(try (os/cd "janet") ([_] nil)) # when in repl to do relative imports -(import ./scanner :as s) +(import /src/scanner :as s) (defmacro declare "Forward-declares a function name, so that it can be called in a mutually recursive manner." diff --git a/janet/prelude.janet b/src/prelude.janet similarity index 88% rename from janet/prelude.janet rename to src/prelude.janet index 04f677d..702c74c 100644 --- a/janet/prelude.janet +++ b/src/prelude.janet @@ -1,10 +1,9 @@ -(try (os/cd "janet") ([_] nil)) -(import /base :as b) -(import /scanner :as s) -(import /parser :as p) -(import /validate :as v) -(import /interpreter :as i) -(import /errors :as e) +(import /src/base :as b) +(import /src/scanner :as s) +(import /src/parser :as p) +(import /src/validate :as v) +(import /src/interpreter :as i) +(import /src/errors :as e) (def pkg (do (def pre-ctx @{:^parent {"base" b/base}}) diff --git a/janet/prelude.test.janet b/src/prelude.test.janet similarity index 100% rename from janet/prelude.test.janet rename to src/prelude.test.janet diff --git a/janet/project.janet b/src/project.janet similarity index 54% rename from janet/project.janet rename to src/project.janet index a43aa16..0b0ac3a 100644 --- a/janet/project.janet +++ b/src/project.janet @@ -2,4 +2,8 @@ :dependencies [ {:url "https://github.com/ianthehenry/judge.git" :tag "v2.8.1"} + {:url "https://github.com/janet-lang/spork"} ]) + +(declare-source + :source ["ludus.janet"]) diff --git a/janet/scanner.janet b/src/scanner.janet similarity index 99% rename from janet/scanner.janet rename to src/scanner.janet index 3cfcd6a..da7323b 100644 --- a/janet/scanner.janet +++ b/src/scanner.janet @@ -341,9 +341,3 @@ (recur (-> scanner (scan-token) (next-token))))) (recur (new-scanner source input))) -# (def source ` -# a :b "c" -# & thing -# `) - -# (pp ((scan source) :tokens)) diff --git a/janet/validate.janet b/src/validate.janet similarity index 100% rename from janet/validate.janet rename to src/validate.janet diff --git a/janet/watchy.fish b/src/watchy.fish similarity index 100% rename from janet/watchy.fish rename to src/watchy.fish diff --git a/test/cases/if.ld b/test/cases/if.ld deleted file mode 100644 index 965f300..0000000 --- a/test/cases/if.ld +++ /dev/null @@ -1,7 +0,0 @@ -& EXPECT (:true, :false, :true, :false) -let true_literal = if true then :true else :false -let false_literal = if false then :true else :false -let truthy = if :truthy then :true else :false -let falsy = if nil then :true else :false - -(true_literal, false_literal, truthy, falsy) diff --git a/test/cases/list_atoms.ld b/test/cases/list_atoms.ld deleted file mode 100644 index 349936a..0000000 --- a/test/cases/list_atoms.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT [:one, 2, "three"] -[:one, 2, "three"] diff --git a/test/cases/single_float.ld b/test/cases/single_float.ld deleted file mode 100644 index 1383d7f..0000000 --- a/test/cases/single_float.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT 12.123 -12.123 diff --git a/test/cases/single_int.ld b/test/cases/single_int.ld deleted file mode 100644 index 46c6857..0000000 --- a/test/cases/single_int.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT 42 -42 diff --git a/test/cases/single_string.ld b/test/cases/single_string.ld deleted file mode 100644 index f06a042..0000000 --- a/test/cases/single_string.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT "foo" -"foo" diff --git a/test/cases/tuple_keywords.ld b/test/cases/tuple_keywords.ld deleted file mode 100644 index 728ddbf..0000000 --- a/test/cases/tuple_keywords.ld +++ /dev/null @@ -1,2 +0,0 @@ -& EXPECT (true, false, nil) -(true, false, nil) diff --git a/test/ludus/core_test.clj b/test/ludus/core_test.clj deleted file mode 100644 index 0cd43ec..0000000 --- a/test/ludus/core_test.clj +++ /dev/null @@ -1,7 +0,0 @@ -(ns ludus.core-test - (:require [clojure.test :refer :all] - [cludus.core :refer :all])) - -(deftest a-test - (testing "FIXME, I fail." - (is (= 0 1)))) diff --git a/test/run_tests.js b/test/run_tests.js deleted file mode 100644 index defb742..0000000 --- a/test/run_tests.js +++ /dev/null @@ -1,30 +0,0 @@ -import {run} from "../target/js/ludus.js" -import * as fs from "node:fs/promises" -import t from "tap" - -const case_path = "./cases" -const files = await fs.readdir(case_path) - -for (const file of files) { - const source = await fs.readFile(`${case_path}/${file}`, {encoding: "utf8"}) - const first_line = source.split("\n")[0] - const expected = first_line.split("EXPECT")[1].trim() - if (expected === "PANIC") expect_panic(file, source) - else expect_result(file, source, expected) -} - -function expect_panic(file, source) { - const result = run(source).errors[0] - t.test(`testing ${file}: EXPECT PANIC`, t => { - t.ok(result) - t.end() - }) -} - -function expect_result(file, source, expected) { - const result = run(source).result - t.test(`testing ${file}: EXPECT ${expected}, GOT ${result}`, t => { - t.equal(expected, result) - t.end() - }) -} diff --git a/tokens b/tokens deleted file mode 100644 index 23d11ef..0000000 --- a/tokens +++ /dev/null @@ -1,47 +0,0 @@ -TOKENS: - -:nil -:true -:false -:word -:keyword -:number -:string - -:as -:cond -:do -:else -:fn -:if -:import -:let -:loop -:ref -:then -:with - -:receive -:spawn -:repeat -:test -:when - -:lparen -:rparen -:lbrace -:rbrace -:lbracket -:rbracket -:semicolon -:comma -:newline -:backslash -:equals -:pipeline -:rarrow -:startdict -:startstruct -:startset -:splat -:eof \ No newline at end of file