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 0000000..4edde6c
Binary files /dev/null and b/build/ludus.jimage differ
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 0000000..542374a
Binary files /dev/null and b/build/out.wasm differ
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