/* Amalgamated build - DO NOT EDIT */ /* Generated 2019-2-20 with janet version 0.4.0-a982f35 */ #define JANET_BUILD "a982f35" #define JANET_AMALG #include "janet.h" /* * Copyright (c) 2019 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 #endif /* Omit docstrings in some builds */ #ifndef JANET_BOOTSTRAP #define JDOC(x) NULL #define JANET_NO_BOOTSTRAP #else #define JDOC(x) x #endif /* Utils */ #define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) 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 janet_buffer_push_types(JanetBuffer *buffer, int types); const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key); Janet janet_dict_get(const JanetKV *buckets, int32_t cap, Janet key); void janet_memempty(JanetKV *mem, int32_t count); void *janet_memalloc_empty(int32_t count); 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); /* Inside the janet core, defining globals is different * at bootstrap time and normal runtime */ #ifdef JANET_BOOTSTRAP #define janet_core_def janet_def #define janet_core_cfuns janet_cfuns #else void janet_core_def(JanetTable *env, const char *name, Janet x, const void *p); void janet_core_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns); #endif /* 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_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 #endif /* * Copyright (c) 2019 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 /* The VM state. Rather than a struct that is passed * around, the vm state is global for simplicity. If * at some point a global state object, or context, * is required to be passed around, this is what would * be in it. However, thread local global variables for interpreter * state should allow easy multi-threading. */ /* How many VM stacks have been entered */ extern JANET_THREAD_LOCAL int janet_vm_stackn; /* The current running fiber on the current thread. * Set and unset by janet_run. */ extern JANET_THREAD_LOCAL JanetFiber *janet_vm_fiber; /* The current pointer to the inner most jmp_buf. The current * return point for panics. */ extern JANET_THREAD_LOCAL jmp_buf *janet_vm_jmp_buf; extern JANET_THREAD_LOCAL Janet *janet_vm_return_reg; /* The global registry for c functions. Used to store meta-data * along with otherwise bare c function pointers. */ extern JANET_THREAD_LOCAL JanetTable *janet_vm_registry; /* Immutable value cache */ extern JANET_THREAD_LOCAL const uint8_t **janet_vm_cache; extern JANET_THREAD_LOCAL uint32_t janet_vm_cache_capacity; extern JANET_THREAD_LOCAL uint32_t janet_vm_cache_count; extern JANET_THREAD_LOCAL uint32_t janet_vm_cache_deleted; /* Garbage collection */ extern JANET_THREAD_LOCAL void *janet_vm_blocks; extern JANET_THREAD_LOCAL uint32_t janet_vm_gc_interval; extern JANET_THREAD_LOCAL uint32_t janet_vm_next_collection; extern JANET_THREAD_LOCAL int janet_vm_gc_suspend; /* GC roots */ extern JANET_THREAD_LOCAL Janet *janet_vm_roots; extern JANET_THREAD_LOCAL uint32_t janet_vm_root_count; extern JANET_THREAD_LOCAL uint32_t janet_vm_root_capacity; #endif /* JANET_STATE_H_defined */ /* * Copyright (c) 2019 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 #endif /* The metadata header associated with an allocated block of memory */ #define janet_gc_header(mem) ((JanetGCMemoryHeader *)(mem) - 1) #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 header struct. Node of a linked list of memory blocks. */ typedef struct JanetGCMemoryHeader JanetGCMemoryHeader; struct JanetGCMemoryHeader { JanetGCMemoryHeader *next; uint32_t flags; }; /* 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 }; /* To allocate collectable memory, one must calk 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 /* * Copyright (c) 2019 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 #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 not garbage collected * and used only from C */ #define janet_v_free(v) (((v) != NULL) ? (free(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_copy(v) (janet_v_copymem((v), sizeof(*(v)))) #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_copymem(void *v, int32_t itemsize); void *janet_v_flattenmem(void *v, int32_t itemsize); #endif /* * Copyright (c) 2019 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 extern JANET_THREAD_LOCAL JanetFiber *janet_vm_fiber; #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); #endif /* * Copyright (c) 2019 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); #endif /* * Copyright (c) 2019 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 #include "regalloc.h" #endif /* 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_GET 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_ORDER_GT 20 #define JANET_FUN_ORDER_LT 21 #define JANET_FUN_ORDER_GTE 22 #define JANET_FUN_ORDER_LTE 23 #define JANET_FUN_ORDER_EQ 24 #define JANET_FUN_ORDER_NEQ 25 #define JANET_FUN_GT 26 #define JANET_FUN_LT 27 #define JANET_FUN_GTE 28 #define JANET_FUN_LTE 29 #define JANET_FUN_EQ 30 #define JANET_FUN_NEQ 31 /* 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 /* Needed for handling single element arrays as global vars. */ /* Used for unquote-splicing */ #define JANET_SLOT_SPLICED 0x200000 #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 /* A symbol and slot pair */ typedef struct SymPair { JanetSlot slot; const uint8_t *sym; int keep; } SymPair; /* A lexical scope during compilation */ struct JanetScope { /* For debugging */ 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; /* Regsiter allocator */ JanetcRegisterAllocator ra; /* Referenced closure environents. 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. */ int32_t *envs; /* Where to add reference to self in constants */ int32_t selfconst; 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; }; #define JANET_FOPTS_TAIL 0x10000 #define JANET_FOPTS_HINT 0x20000 #define JANET_FOPTS_DROP 0x40000 /* 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 load via janetc_toslots. */ void 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); /* 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); #endif /* * Copyright (c) 2019 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); /* Move value from one slot to another. Cannot copy to constant slots. */ void janetc_copy(JanetCompiler *c, JanetSlot dest, JanetSlot src); #endif /* * Copyright (c) 2019 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 #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 /* * Copyright (c) 2019 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 #include "gc.h" #endif /* Create new userdata */ void *janet_abstract(const JanetAbstractType *atype, size_t size) { char *data = janet_gcalloc(JANET_MEMORY_ABSTRACT, sizeof(JanetAbstractHeader) + size); JanetAbstractHeader *header = (JanetAbstractHeader *)data; void *a = data + sizeof(JanetAbstractHeader); header->size = size; header->type = atype; return a; } /* * Copyright (c) 2019 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 #include "gc.h" #include "util.h" #endif #include /* Initializes an array */ JanetArray *janet_array_init(JanetArray *array, int32_t capacity) { Janet *data = NULL; if (capacity > 0) { data = (Janet *) malloc(sizeof(Janet) * capacity); if (NULL == data) { JANET_OUT_OF_MEMORY; } } array->count = 0; array->capacity = capacity; array->data = data; return array; } void janet_array_deinit(JanetArray *array) { free(array->data); } /* Creates a new array */ JanetArray *janet_array(int32_t capacity) { JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); return janet_array_init(array, capacity); } /* 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 = malloc(sizeof(Janet) * n); if (!array->data) { JANET_OUT_OF_MEMORY; } 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; capacity *= growth; newData = realloc(old, capacity * sizeof(Janet)); if (NULL == newData) { JANET_OUT_OF_MEMORY; } 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) { 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 */ static Janet cfun_array_new(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); int32_t cap = janet_getinteger(argv, 0); JanetArray *array = janet_array(cap); return janet_wrap_array(array); } static Janet cfun_array_pop(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetArray *array = janet_getarray(argv, 0); return janet_array_pop(array); } static Janet cfun_array_peek(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetArray *array = janet_getarray(argv, 0); return janet_array_peek(array); } static Janet cfun_array_push(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); JanetArray *array = janet_getarray(argv, 0); int32_t newcount = array->count - 1 + argc; janet_array_ensure(array, newcount, 2); if (argc > 1) memcpy(array->data + array->count, argv + 1, (argc - 1) * sizeof(Janet)); array->count = newcount; return argv[0]; } static Janet cfun_array_ensure(int32_t argc, Janet *argv) { 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]; } static Janet cfun_array_slice(int32_t argc, Janet *argv) { JanetRange range = janet_getslice(argc, argv); JanetView view = janet_getindexed(argv, 0); JanetArray *array = janet_array(range.end - range.start); memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start)); array->count = range.end - range.start; return janet_wrap_array(array); } static Janet cfun_array_concat(int32_t argc, Janet *argv) { 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; const Janet *vals; 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); } static Janet cfun_array_insert(int32_t argc, Janet *argv) { 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); janet_array_ensure(array, array->count + argc - 2, 2); memmove(array->data + at + argc - 2, array->data + at, restsize); memcpy(array->data + at, argv + 2, chunksize); array->count += (argc - 2); return janet_wrap_array(array); } static const JanetReg array_cfuns[] = { { "array/new", cfun_array_new, JDOC("(array/new capacity)\n\n" "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.") }, { "array/pop", cfun_array_pop, JDOC("(array/pop arr)\n\n" "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies " "the input array.") }, { "array/peek", cfun_array_peek, JDOC("(array/peek arr)\n\n" "Returns the last element of the array. Does not modify the array.") }, { "array/push", cfun_array_push, JDOC("(array/push arr x)\n\n" "Insert an element in the end of an array. Modifies the input array and returns it.") }, { "array/ensure", cfun_array_ensure, JDOC("(array/ensure arr capacity)\n\n" "Ensures that the memory backing the array has enough memory for capacity " "items. Capacity must be an integer. 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.") }, { "array/slice", cfun_array_slice, JDOC("(array/slice arrtup [, start=0 [, end=(length arrtup)]])\n\n" "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 " "end of the array. By default, start is 0 and end is the length of the array. " "Returns a new array.") }, { "array/concat", cfun_array_concat, JDOC("(array/concat arr & parts)\n\n" "Concatenates a variadic number of arrays (and tuples) into the first argument " "which must 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.") }, { "array/insert", cfun_array_insert, JDOC("(array/insert arr at & xs)\n\n" "Insert all of xs into array arr at index at. at should be an integer " "0 and the length of the array. A negative value for at will index from " "the end of the array, such that inserting at -1 appends to the array. " "Returns the array.") }, {NULL, NULL, NULL} }; /* Load the array module */ void janet_lib_array(JanetTable *env) { janet_core_cfuns(env, NULL, array_cfuns); } /* * Copyright (c) 2019 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 #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 constants; /* symbol -> constant 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}, {"div", JOP_DIVIDE}, {"divim", JOP_DIVIDE_IMMEDIATE}, {"eq", JOP_EQUALS}, {"eqim", JOP_EQUALS_IMMEDIATE}, {"eqn", JOP_NUMERIC_EQUAL}, {"err", JOP_ERROR}, {"get", JOP_GET}, {"geti", JOP_GET_INDEX}, {"gt", JOP_GREATER_THAN}, {"gten", JOP_NUMERIC_GREATER_THAN_EQUAL}, {"gtim", JOP_GREATER_THAN_IMMEDIATE}, {"gtn", JOP_NUMERIC_GREATER_THAN}, {"jmp", JOP_JUMP}, {"jmpif", JOP_JUMP_IF}, {"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}, {"lten", JOP_NUMERIC_LESS_THAN_EQUAL}, {"ltim", JOP_LESS_THAN_IMMEDIATE}, {"ltn", JOP_NUMERIC_LESS_THAN}, {"mkarr", JOP_MAKE_ARRAY}, {"mkbuf", JOP_MAKE_BUFFER}, {"mkstr", JOP_MAKE_STRING}, {"mkstu", JOP_MAKE_STRUCT}, {"mktab", JOP_MAKE_TABLE}, {"mktup", JOP_MAKE_TUPLE}, {"movf", JOP_MOVE_FAR}, {"movn", JOP_MOVE_NEAR}, {"mul", JOP_MULTIPLY}, {"mulim", JOP_MULTIPLY_IMMEDIATE}, {"noop", JOP_NOOP}, {"push", JOP_PUSH}, {"push2", JOP_PUSH_2}, {"push3", JOP_PUSH_3}, {"pusha", JOP_PUSH_ARRAY}, {"put", JOP_PUT}, {"puti", JOP_PUT_INDEX}, {"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}, {"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}, {"false", JANET_TFLAG_FALSE}, {"fiber", JANET_TFLAG_FIBER}, {"function", JANET_TFLAG_FUNCTION}, {"indexed", JANET_TFLAG_INDEXED}, {"nil", JANET_TFLAG_NIL}, {"number", JANET_TFLAG_NUMBER}, {"string", JANET_TFLAG_STRING}, {"struct", JANET_TFLAG_STRUCT}, {"symbol", JANET_TFLAG_SYMBOL}, {"keyword", JANET_TFLAG_KEYWORD}, {"table", JANET_TFLAG_BOOLEAN}, {"true", JANET_TFLAG_TRUE}, {"tuple", JANET_TFLAG_BOOLEAN} }; /* 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->constants); janet_table_deinit(&a->defs); } /* Throw some kind of assembly error */ static void janet_asm_error(JanetAssembler *a, const char *message) { a->errmessage = janet_formatc("%s, instruction %d", message, a->errindex); longjmp(a->on_error, 1); } #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; longjmp(a->on_error, 1); } /* 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 = 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_CONSTANT: c = &a->constants; 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.constants, 0); janet_table_init(&a.slots, 0); janet_table_init(&a.envs, 0); janet_table_init(&a.defs, 0); /* Set error jump */ if (setjmp(a.on_error)) { if (NULL != a.parent) { janet_asm_deinit(&a); longjmp(a.parent->on_error, 1); } 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_csymbolv("name")); if (!janet_checktype(a.name, JANET_NIL)) { def->name = janet_to_string(a.name); } /* Set function arity */ x = janet_get1(s, janet_csymbolv("arity")); def->arity = janet_checkint(x) ? janet_unwrap_integer(x) : 0; /* Check vararg */ x = janet_get1(s, janet_csymbolv("vararg")); if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_VARARG; /* Check strict arity */ x = janet_get1(s, janet_csymbolv("fix-arity")); if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_FIXARITY; /* Check source */ x = janet_get1(s, janet_csymbolv("source")); if (janet_checktype(x, JANET_STRING)) def->source = janet_unwrap_string(x); /* Create slot aliases */ x = janet_get1(s, janet_csymbolv("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_csymbolv("constants")); if (janet_indexed_view(x, &arr, &count)) { def->constants_length = count; def->constants = malloc(sizeof(Janet) * count); if (NULL == def->constants) { JANET_OUT_OF_MEMORY; } for (i = 0; i < count; i++) { Janet ct = arr[i]; if (janet_checktype(ct, JANET_TUPLE) && janet_tuple_length(janet_unwrap_tuple(ct)) > 1 && janet_checktype(janet_unwrap_tuple(ct)[0], JANET_SYMBOL)) { const Janet *t = janet_unwrap_tuple(ct); int32_t tcount = janet_tuple_length(t); const uint8_t *macro = janet_unwrap_symbol(t[0]); if (0 == janet_cstrcmp(macro, "quote")) { def->constants[i] = t[1]; } else if (tcount == 3 && janet_checktype(t[1], JANET_SYMBOL) && 0 == janet_cstrcmp(macro, "def")) { def->constants[i] = t[2]; janet_table_put(&a.constants, t[1], janet_wrap_integer(i)); } else { janet_asm_errorv(&a, janet_formatc("could not parse constant \"%v\"", ct)); } } else { def->constants[i] = ct; } } } else { def->constants = NULL; def->constants_length = 0; } /* Parse sub funcdefs */ x = janet_get1(s, janet_csymbolv("closures")); 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_csymbolv("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 = 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_csymbolv("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 = malloc(sizeof(int32_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_csymbolv("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 = malloc(sizeof(JanetSourceMapping) * count); 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.start = janet_unwrap_integer(tup[0]); mapping.end = janet_unwrap_integer(tup[1]); def->sourcemap[i] = mapping; } } /* Set environments */ def->environments = realloc(def->environments, def->environments_length * sizeof(int32_t)); /* Verify the func def */ if (janet_verify(def)) { janet_asm_error(&a, "invalid assembly"); } /* 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 Janet tup1(Janet x) { Janet *tup = janet_tuple_begin(1); tup[0] = x; return janet_wrap_tuple(janet_tuple_end(tup)); } static Janet tup2(Janet x, Janet y) { Janet *tup = janet_tuple_begin(2); tup[0] = x; tup[1] = y; return janet_wrap_tuple(janet_tuple_end(tup)); } static 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_wrap_tuple(janet_tuple_end(tup)); } static 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_wrap_tuple(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); #define oparg(shift, mask) ((instr >> ((shift) << 3)) & (mask)) switch (janet_instructions[def->opcode]) { case JINT_0: return tup1(name); case JINT_S: return tup2(name, janet_wrap_integer(oparg(1, 0xFFFFFF))); case JINT_L: return tup2(name, janet_wrap_integer((int32_t)instr >> 8)); case JINT_SS: case JINT_ST: case JINT_SC: case JINT_SU: case JINT_SD: return tup3(name, janet_wrap_integer(oparg(1, 0xFF)), janet_wrap_integer(oparg(2, 0xFFFF))); case JINT_SI: case JINT_SL: return tup3(name, janet_wrap_integer(oparg(1, 0xFF)), janet_wrap_integer((int32_t)instr >> 16)); case JINT_SSS: case JINT_SES: case JINT_SSU: return tup4(name, janet_wrap_integer(oparg(1, 0xFF)), janet_wrap_integer(oparg(2, 0xFF)), janet_wrap_integer(oparg(3, 0xFF))); case JINT_SSI: return tup4(name, janet_wrap_integer(oparg(1, 0xFF)), janet_wrap_integer(oparg(2, 0xFF)), janet_wrap_integer((int32_t)instr >> 24)); } #undef oparg return janet_wrap_nil(); } Janet janet_disasm(JanetFuncDef *def) { int32_t i; JanetArray *bcode = janet_array(def->bytecode_length); JanetArray *constants; JanetTable *ret = janet_table(10); janet_table_put(ret, janet_csymbolv("arity"), janet_wrap_integer(def->arity)); janet_table_put(ret, janet_csymbolv("bytecode"), janet_wrap_array(bcode)); if (NULL != def->source) { janet_table_put(ret, janet_csymbolv("source"), janet_wrap_string(def->source)); } if (def->flags & JANET_FUNCDEF_FLAG_VARARG) { janet_table_put(ret, janet_csymbolv("vararg"), janet_wrap_true()); } if (def->flags & JANET_FUNCDEF_FLAG_FIXARITY) { janet_table_put(ret, janet_csymbolv("fix-arity"), janet_wrap_true()); } if (NULL != def->name) { janet_table_put(ret, janet_csymbolv("name"), janet_wrap_string(def->name)); } /* Add constants */ if (def->constants_length > 0) { constants = janet_array(def->constants_length); janet_table_put(ret, janet_csymbolv("constants"), janet_wrap_array(constants)); for (i = 0; i < def->constants_length; i++) { Janet src = def->constants[i]; Janet dest; if (janet_checktype(src, JANET_TUPLE)) { dest = tup2(janet_csymbolv("quote"), src); } else { dest = src; } constants->data[i] = dest; } constants->count = def->constants_length; } /* Add bytecode */ for (i = 0; i < def->bytecode_length; i++) { bcode->data[i] = janet_asm_decode_instruction(def->bytecode[i]); } bcode->count = def->bytecode_length; /* Add source map */ if (NULL != def->sourcemap) { JanetArray *sourcemap = janet_array(def->bytecode_length); for (i = 0; i < def->bytecode_length; i++) { Janet *t = janet_tuple_begin(2); JanetSourceMapping mapping = def->sourcemap[i]; t[0] = janet_wrap_integer(mapping.start); t[1] = janet_wrap_integer(mapping.end); sourcemap->data[i] = janet_wrap_tuple(janet_tuple_end(t)); } sourcemap->count = def->bytecode_length; janet_table_put(ret, janet_csymbolv("sourcemap"), janet_wrap_array(sourcemap)); } /* Add environments */ if (NULL != def->environments) { JanetArray *envs = janet_array(def->environments_length); for (i = 0; i < def->environments_length; i++) { envs->data[i] = janet_wrap_integer(def->environments[i]); } envs->count = def->environments_length; janet_table_put(ret, janet_csymbolv("environments"), janet_wrap_array(envs)); } /* Add closures */ /* Funcdefs cannot be recursive */ if (NULL != def->defs) { JanetArray *defs = janet_array(def->defs_length); for (i = 0; i < def->defs_length; i++) { defs->data[i] = janet_disasm(def->defs[i]); } defs->count = def->defs_length; janet_table_put(ret, janet_csymbolv("defs"), janet_wrap_array(defs)); } /* Add slotcount */ janet_table_put(ret, janet_csymbolv("slotcount"), janet_wrap_integer(def->slotcount)); return janet_wrap_struct(janet_table_to_struct(ret)); } /* C Function for assembly */ static Janet cfun_asm(int32_t argc, Janet *argv) { janet_arity(argc, 1, 1); JanetAssembleResult res; res = janet_asm(argv[0], 0); if (res.status != JANET_ASSEMBLE_OK) { janet_panics(res.error); } return janet_wrap_function(janet_thunk(res.funcdef)); } static Janet cfun_disasm(int32_t argc, Janet *argv) { janet_arity(argc, 1, 1); JanetFunction *f = janet_getfunction(argv, 0); return janet_disasm(f->def); } static const JanetReg asm_cfuns[] = { { "asm", cfun_asm, JDOC("(asm assembly)\n\n" "Returns a new function that is the compiled result of the assembly.\n" "The syntax for the assembly can be found on the janet wiki. Will throw an\n" "error on invalid assembly.") }, { "disasm", cfun_disasm, JDOC("(disasm func)\n\n" "Returns assembly that could be used be compile the given function.\n" "func must be a function, not a c function. Will throw on error on a badly\n" "typed argument.") }, {NULL, NULL, NULL} }; /* Load the library */ void janet_lib_asm(JanetTable *env) { janet_core_cfuns(env, NULL, asm_cfuns); } #endif /* * Copyright (c) 2019 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 #include "gc.h" #include "util.h" #endif /* Initialize a buffer */ JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { uint8_t *data = NULL; if (capacity > 0) { data = malloc(sizeof(uint8_t) * capacity); if (NULL == data) { JANET_OUT_OF_MEMORY; } } buffer->count = 0; buffer->capacity = capacity; buffer->data = data; return buffer; } /* Deinitialize a buffer (free data memory) */ void janet_buffer_deinit(JanetBuffer *buffer) { 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(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; int64_t big_capacity = capacity * growth; capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity; new_data = realloc(old, 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) { int32_t new_capacity = new_size * 2; uint8_t *new_data = realloc(buffer->data, new_capacity * sizeof(uint8_t)); 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 = 0; while (cstring[len]) ++len; 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) { 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 */ static Janet cfun_buffer_new(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); int32_t cap = janet_getinteger(argv, 0); JanetBuffer *buffer = janet_buffer(cap); return janet_wrap_buffer(buffer); } static Janet cfun_buffer_new_filled(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); int32_t count = janet_getinteger(argv, 0); int32_t byte = 0; if (argc == 2) { byte = janet_getinteger(argv, 1) & 0xFF; } JanetBuffer *buffer = janet_buffer(count); memset(buffer->data, byte, count); buffer->count = count; return janet_wrap_buffer(buffer); } static Janet cfun_buffer_u8(int32_t argc, Janet *argv) { 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]; } static Janet cfun_buffer_word(int32_t argc, Janet *argv) { 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]; } static Janet cfun_buffer_chars(int32_t argc, Janet *argv) { 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); janet_buffer_push_bytes(buffer, view.bytes, view.len); } return argv[0]; } static Janet cfun_buffer_clear(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetBuffer *buffer = janet_getbuffer(argv, 0); buffer->count = 0; return argv[0]; } static Janet cfun_buffer_popn(int32_t argc, Janet *argv) { 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]; } static Janet cfun_buffer_slice(int32_t argc, Janet *argv) { JanetRange range = janet_getslice(argc, argv); JanetByteView view = janet_getbytes(argv, 0); JanetBuffer *buffer = janet_buffer(range.end - range.start); 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; } static Janet cfun_buffer_bitset(int32_t argc, Janet *argv) { int bit; int32_t index; JanetBuffer *buffer; bitloc(argc, argv, &buffer, &index, &bit); buffer->data[index] |= 1 << bit; return argv[0]; } static Janet cfun_buffer_bitclear(int32_t argc, Janet *argv) { int bit; int32_t index; JanetBuffer *buffer; bitloc(argc, argv, &buffer, &index, &bit); buffer->data[index] &= ~(1 << bit); return argv[0]; } static Janet cfun_buffer_bitget(int32_t argc, Janet *argv) { int bit; int32_t index; JanetBuffer *buffer; bitloc(argc, argv, &buffer, &index, &bit); return janet_wrap_boolean(buffer->data[index] & (1 << bit)); } static Janet cfun_buffer_bittoggle(int32_t argc, Janet *argv) { int bit; int32_t index; JanetBuffer *buffer; bitloc(argc, argv, &buffer, &index, &bit); buffer->data[index] ^= (1 << bit); return argv[0]; } static Janet cfun_buffer_blit(int32_t argc, Janet *argv) { janet_arity(argc, 2, 5); JanetBuffer *dest = janet_getbuffer(argv, 0); JanetByteView src = janet_getbytes(argv, 1); int32_t offset_dest = 0; int32_t offset_src = 0; if (argc > 2) offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start"); if (argc > 3) offset_src = janet_gethalfrange(argv, 3, src.len, "src-start"); int32_t length_src; if (argc > 4) { int32_t 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 - offset_src) + length_src; if (last > INT32_MAX) janet_panic("buffer blit out of range"); janet_buffer_ensure(dest, (int32_t) last, 2); if (last > dest->count) dest->count = (int32_t) last; memcpy(dest->data + offset_dest, src.bytes + offset_src, length_src); return argv[0]; } static Janet cfun_buffer_format(int32_t argc, Janet *argv) { 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]; } static const JanetReg buffer_cfuns[] = { { "buffer/new", cfun_buffer_new, JDOC("(buffer/new capacity)\n\n" "Creates a new, empty buffer with enough memory for capacity bytes. " "Returns a new buffer.") }, { "buffer/new-filled", cfun_buffer_new_filled, JDOC("(buffer/new-filled count [, byte=0])\n\n" "Creates a new buffer of length count filled with byte. " "Returns the new buffer.") }, { "buffer/push-byte", cfun_buffer_u8, JDOC("(buffer/push-byte buffer x)\n\n" "Append a byte to a buffer. Will expand the buffer as necessary. " "Returns the modified buffer. Will throw an error if the buffer overflows.") }, { "buffer/push-word", cfun_buffer_word, JDOC("(buffer/push-word buffer x)\n\n" "Append a machine word to a buffer. The 4 bytes of the integer are appended " "in twos complement, big endian order, unsigned. Returns the modified buffer. Will " "throw an error if the buffer overflows.") }, { "buffer/push-string", cfun_buffer_chars, JDOC("(buffer/push-string buffer str)\n\n" "Push a string onto the end of a buffer. Non string values will be converted " "to strings before being pushed. Returns the modified buffer. " "Will throw an error if the buffer overflows.") }, { "buffer/popn", cfun_buffer_popn, JDOC("(buffer/popn buffer n)\n\n" "Removes the last n bytes from the buffer. Returns the modified buffer.") }, { "buffer/clear", cfun_buffer_clear, JDOC("(buffer/clear buffer)\n\n" "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.") }, { "buffer/slice", cfun_buffer_slice, JDOC("(buffer/slice bytes [, start=0 [, end=(length bytes)]])\n\n" "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.") }, { "buffer/bit-set", cfun_buffer_bitset, JDOC("(buffer/bit-set buffer index)\n\n" "Sets the bit at the given bit-index. Returns the buffer.") }, { "buffer/bit-clear", cfun_buffer_bitclear, JDOC("(buffer/bit-clear buffer index)\n\n" "Clears the bit at the given bit-index. Returns the buffer.") }, { "buffer/bit", cfun_buffer_bitget, JDOC("(buffer/bit buffer index)\n\n" "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.") }, { "buffer/bit-toggle", cfun_buffer_bittoggle, JDOC("(buffer/bit-toggle buffer index)\n\n" "Toggles the bit at the given bit index in buffer. Returns the buffer.") }, { "buffer/blit", cfun_buffer_blit, JDOC("(buffer/blit dest src [, dest-start=0 [, src-start=0 [, src-end=-1]]])\n\n" "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 to index from the end of src or dest. Returns dest.") }, { "buffer/format", cfun_buffer_format, JDOC("(buffer/format buffer format & args)\n\n" "Snprintf like functionality for printing values into a buffer. Returns " " the modified buffer.") }, {NULL, NULL, NULL} }; void janet_lib_buffer(JanetTable *env) { janet_core_cfuns(env, NULL, buffer_cfuns); } /* * Copyright (c) 2019 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 #include "gc.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_SSS, /* JOP_SUBTRACT, */ JINT_SSI, /* JOP_MULTIPLY_IMMEDIATE, */ JINT_SSS, /* JOP_MULTIPLY, */ JINT_SSI, /* JOP_DIVIDE_IMMEDIATE, */ JINT_SSS, /* JOP_DIVIDE, */ 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_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_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_TUPLE */ JINT_S, /* JOP_MAKE_STRUCT */ JINT_S, /* JOP_MAKE_TABLE */ JINT_S, /* JOP_MAKE_STRING */ JINT_SSS, /* JOP_NUMERIC_LESS_THAN */ JINT_SSS, /* JOP_NUMERIC_LESS_THAN_EQUAL */ JINT_SSS, /* JOP_NUMERIC_GREATER_THAN */ JINT_SSS, /* JOP_NUMERIC_GREATER_THAN_EQUAL */ JINT_SSS /* JOP_NUMERIC_EQUAL */ }; /* Verify some bytecode */ int32_t 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() { JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); def->environments = NULL; def->constants = NULL; def->bytecode = NULL; def->flags = 0; def->slotcount = 0; def->arity = 0; 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; 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; } /* * Copyright (c) 2019 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 #include "state.h" #include "fiber.h" #endif void janet_panicv(Janet message) { if (janet_vm_return_reg != NULL) { *janet_vm_return_reg = message; longjmp(*janet_vm_jmp_buf, 1); } else { fputs((const char *)janet_formatc("janet top level panic - %v\n", message), stdout); exit(1); } } 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); \ } Janet janet_getmethod(const uint8_t *method, const JanetMethod *methods) { while (methods->name) { if (!janet_cstrcmp(method, methods->name)) return janet_wrap_cfunction(methods->cfun); methods++; } janet_panicf("unknown method %S invoked", method); 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) int janet_getboolean(const Janet *argv, int32_t n) { Janet x = argv[n]; if (janet_checktype(x, JANET_TRUE)) { return 1; } else if (!janet_checktype(x, JANET_FALSE)) { janet_panicf("bad slot #%d, expected boolean, got %v", n, x); } return 0; } int32_t janet_getinteger(const Janet *argv, int32_t n) { Janet x = argv[n]; if (!janet_checkint(x)) { janet_panicf("bad slot #%d, expected integer, got %v", n, x); } return janet_unwrap_integer(x); } int64_t janet_getinteger64(const Janet *argv, int32_t n) { Janet x = argv[n]; if (!janet_checkint64(x)) { janet_panicf("bad slot #%d, expected 64 bit integer, got %v", n, x); } return (int64_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); if (raw < 0) raw += length + 1; if (raw < 0 || raw > length) janet_panicf("%s index %d out of range [0,%d]", which, raw, length); return raw; } int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which) { int32_t raw = janet_getinteger(argv, n); if (raw < 0) raw += length; if (raw < 0 || raw > length) janet_panicf("%s index %d out of range [0,%d)", which, raw, length); return 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]); if (argc == 1) { range.start = 0; range.end = length; } else if (argc == 2) { range.start = janet_gethalfrange(argv, 1, length, "start"); range.end = length; } else { range.start = janet_gethalfrange(argv, 1, length, "start"); range.end = janet_gethalfrange(argv, 2, length, "end"); if (range.end < range.start) range.end = range.start; } return range; } /* * Copyright (c) 2019 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 #include "compile.h" #include "emit.h" #include "vector.h" #endif static int fixarity0(JanetFopts opts, JanetSlot *args) { (void) opts; return janet_v_count(args) == 0; } static int fixarity1(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 a series of instructions instead of a function call to a math op */ static JanetSlot opreduce( JanetFopts opts, JanetSlot *args, int op, Janet nullary) { JanetCompiler *c = opts.compiler; int32_t i, len; len = janet_v_count(args); JanetSlot t; if (len == 0) { return janetc_cslot(nullary); } else if (len == 1) { t = janetc_gettarget(opts); janetc_emit_sss(c, op, t, janetc_cslot(nullary), args[0], 1); return t; } t = janetc_gettarget(opts); janetc_emit_sss(c, op, t, args[0], args[1], 1); for (i = 2; i < len; i++) janetc_emit_sss(c, op, t, t, args[i], 1); return t; } /* Function optimizers */ 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; janetc_emit(opts.compiler, JOP_SIGNAL | (2 << 24)); return janetc_cslot(janet_wrap_nil()); } static JanetSlot do_get(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_GET, 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) { return genericSSI(opts, JOP_SIGNAL, args[0], 3); } static JanetSlot do_resume(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_RESUME, 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, janet_wrap_integer(0)); } static JanetSlot do_sub(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_SUBTRACT, janet_wrap_integer(0)); } static JanetSlot do_mul(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_MULTIPLY, janet_wrap_integer(1)); } static JanetSlot do_div(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_DIVIDE, janet_wrap_integer(1)); } static JanetSlot do_band(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_BAND, janet_wrap_integer(-1)); } static JanetSlot do_bor(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_BOR, janet_wrap_integer(0)); } static JanetSlot do_bxor(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_BXOR, janet_wrap_integer(0)); } static JanetSlot do_lshift(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_SHIFT_LEFT, janet_wrap_integer(1)); } static JanetSlot do_rshift(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_SHIFT_RIGHT, janet_wrap_integer(1)); } static JanetSlot do_rshiftu(JanetFopts opts, JanetSlot *args) { return opreduce(opts, args, JOP_SHIFT_RIGHT, 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 invert) { JanetCompiler *c = opts.compiler; int32_t i, len; 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++) { janetc_emit_sss(c, op, t, args[i - 1], args[i], 1); if (i != (len - 1)) { int32_t label = janetc_emit_si(c, JOP_JUMP_IF_NOT, t, 0, 1); janet_v_push(labels, label); } } int32_t end = janet_v_count(c->buffer); if (invert) { janetc_emit_si(c, JOP_JUMP_IF, t, 3, 0); janetc_emit_s(c, JOP_LOAD_TRUE, t, 1); janetc_emit(c, JOP_JUMP | (2 << 8)); janetc_emit_s(c, JOP_LOAD_FALSE, t, 1); } 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_order_gt(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_GREATER_THAN, 0); } static JanetSlot do_order_lt(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_LESS_THAN, 0); } static JanetSlot do_order_gte(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_LESS_THAN, 1); } static JanetSlot do_order_lte(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_GREATER_THAN, 1); } static JanetSlot do_order_eq(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_EQUALS, 0); } static JanetSlot do_order_neq(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_EQUALS, 1); } static JanetSlot do_gt(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_GREATER_THAN, 0); } static JanetSlot do_lt(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_LESS_THAN, 0); } static JanetSlot do_gte(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_GREATER_THAN_EQUAL, 0); } static JanetSlot do_lte(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_LESS_THAN_EQUAL, 0); } static JanetSlot do_eq(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_EQUAL, 0); } static JanetSlot do_neq(JanetFopts opts, JanetSlot *args) { return compreduce(opts, args, JOP_NUMERIC_EQUAL, 1); } /* Arranged by tag */ static const JanetFunOptimizer optimizers[] = { {fixarity0, do_debug}, {fixarity1, do_error}, {minarity2, do_apply}, {fixarity1, do_yield}, {fixarity2, do_resume}, {fixarity2, do_get}, {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_order_gt}, {NULL, do_order_lt}, {NULL, do_order_gte}, {NULL, do_order_lte}, {NULL, do_order_eq}, {NULL, do_order_neq}, {NULL, do_gt}, {NULL, do_lt}, {NULL, do_gte}, {NULL, do_lte}, {NULL, do_eq}, {NULL, do_neq} }; 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; } /* * Copyright (c) 2019 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 #include "compile.h" #include "emit.h" #include "vector.h" #include "util.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)); } /* 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; sp.sym = sym; sp.slot = s; sp.keep = 0; sp.slot.flags |= JANET_SLOT_NAMED; 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.selfconst = -1; scope.bytecode_start = janet_v_count(c->buffer); scope.flags = flags; scope.parent = c->scope; /* 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 */ for (int32_t i = 0; i < janet_v_count(oldscope->syms); i++) { SymPair pair = oldscope->syms[i]; if (pair.keep) { /* The variable should not be lexically accessible */ pair.sym = NULL; janet_v_push(newscope->syms, pair); janetc_regalloc_touch(&newscope->ra, pair.slot.index); } } } /* 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); /* 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); } } /* 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 */ { Janet check; JanetBindingType btype = janet_resolve(c->env, sym, &check); switch (btype) { default: case JANET_BINDING_NONE: janetc_error(c, janet_formatc("unknown symbol %q", 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 */ return janetc_cslot(check); case JANET_BINDING_VAR: { JanetSlot ret = janetc_cslot(check); /* TODO save type info */ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; ret.flags &= ~JANET_SLOT_CONSTANT; 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 */ pair->keep = 1; while (scope && !(scope->flags & JANET_SCOPE_FUNCTION)) scope = scope->parent; janet_assert(scope, "invalid scopes"); scope->flags |= JANET_SCOPE_ENV; 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) { scopefound = 1; envindex = j; break; } } /* Add the environment if it is not already referenced */ if (!scopefound) { len = janet_v_count(scope->envs); janet_v_push(scope->envs, envindex); 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); 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); const JanetKV *kvs = NULL; int32_t cap, i, len; janet_dictionary_view(ds, &kvs, &len, &cap); for (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 load via janetc_toslots. */ void janetc_pushslots(JanetCompiler *c, JanetSlot *slots) { int32_t i; int32_t count = janet_v_count(slots); for (i = 0; i < count;) { if (slots[i].flags & JANET_SLOT_SPLICED) { janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i], 0); i++; } else if (i + 1 == count) { janetc_emit_s(c, JOP_PUSH, slots[i], 0); i++; } 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; } else if (i + 2 == count) { janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0); i += 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; } else { janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i + 1], slots[i + 2], 0); i += 3; } } } /* 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_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) { janetc_pushslots(c, slots); 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; 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_start(form) >= 0) { c->current_mapping.start = janet_tuple_sm_start(form); c->current_mapping.end = janet_tuple_sm_end(form); } 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 || !janet_checktype(macroval, JANET_FUNCTION)) return 0; /* Evaluate macro */ JanetFiber *fiberp; JanetFunction *macro = janet_unwrap_function(macroval); int lock = janet_gclock(); JanetSignal status = janet_pcall( macro, janet_tuple_length(form) - 1, form + 1, &x, &fiberp); janet_gcunlock(lock); if (status != JANET_SIGNAL_OK) { const uint8_t *es = janet_formatc("(macro) %V", x); c->result.macrofiber = fiberp; janetc_error(c, es); } else { *out = x; } 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(x); } 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; } /* Compile a 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_v_flatten(scope->envs); 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) * def->bytecode_length; def->bytecode = malloc(s); if (NULL == def->bytecode) { JANET_OUT_OF_MEMORY; } memcpy(def->bytecode, c->buffer + scope->bytecode_start, s); janet_v__cnt(c->buffer) = scope->bytecode_start; if (NULL != c->mapbuffer) { size_t s = sizeof(JanetSourceMapping) * def->bytecode_length; def->sourcemap = malloc(s); if (NULL == def->sourcemap) { JANET_OUT_OF_MEMORY; } 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->flags = 0; if (scope->flags & JANET_SCOPE_ENV) { def->flags |= JANET_FUNCDEF_FLAG_NEEDSENV; } /* Pop the scope */ janetc_popscope(c); return def; } /* Initialize a compiler */ static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where) { c->scope = NULL; c->buffer = NULL; c->mapbuffer = NULL; c->recursion_guard = JANET_RECURSION_GUARD; c->env = env; c->source = where; c->current_mapping.start = -1; c->current_mapping.end = -1; /* Init result */ c->result.error = NULL; c->result.status = JANET_COMPILE_OK; c->result.funcdef = NULL; c->result.macrofiber = NULL; c->result.error_mapping.start = -1; c->result.error_mapping.end = -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(Janet source, JanetTable *env, const uint8_t *where) { JanetCompiler c; JanetScope rootscope; JanetFopts fopts; janetc_init(&c, env, where); /* 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"); c.result.funcdef = def; } else { c.result.error_mapping = c.current_mapping; janetc_popscope(&c); } janetc_deinit(&c); return c.result; } /* C Function for compiling */ static Janet cfun(int32_t argc, Janet *argv) { janet_arity(argc, 2, 3); JanetTable *env = janet_gettable(argv, 1); const uint8_t *source = NULL; if (argc == 3) { source = janet_getstring(argv, 2); } JanetCompileResult res = janet_compile(argv[0], env, source); 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)); janet_table_put(t, janet_ckeywordv("start"), janet_wrap_integer(res.error_mapping.start)); janet_table_put(t, janet_ckeywordv("end"), janet_wrap_integer(res.error_mapping.end)); if (res.macrofiber) { janet_table_put(t, janet_ckeywordv("fiber"), janet_wrap_fiber(res.macrofiber)); } return janet_wrap_table(t); } } static const JanetReg compile_cfuns[] = { { "compile", cfun, JDOC("(compile ast env [, source])\n\n" "Compiles an Abstract Syntax Tree (ast) into a janet function. " "Pair the compile function with parsing functionality to implement " "eval. Returns a janet function and does not modify ast. Throws an " "error if the ast cannot be compiled.") }, {NULL, NULL, NULL} }; void janet_lib_compile(JanetTable *env) { janet_core_cfuns(env, NULL, compile_cfuns); } /* * Copyright (c) 2019 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 #include "compile.h" #include "state.h" #include "util.h" #endif /* Generated bytes */ #ifdef JANET_BOOTSTRAP extern const unsigned char *janet_gen_core; extern int32_t janet_gen_core_size; #else extern const unsigned char *janet_core_image; extern size_t janet_core_image_size; #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, 0) #define error_clib() "dynamic libraries not supported" #elif defined(JANET_WINDOWS) #include typedef HINSTANCE Clib; #define load_clib(name) LoadLibrary((name)) #define symbol_clib(lib, sym) GetProcAddress((lib), (sym)) #define error_clib() "could not load dynamic library" #else #include typedef void *Clib; #define load_clib(name) dlopen((name), RTLD_NOW) #define symbol_clib(lib, sym) dlsym((lib), (sym)) #define error_clib() dlerror() #endif JanetModule janet_native(const char *name, const uint8_t **error) { Clib lib = load_clib(name); JanetModule init; if (!lib) { *error = janet_cstring(error_clib()); return NULL; } init = (JanetModule) symbol_clib(lib, "_janet_init"); if (!init) { *error = janet_cstring("could not find _janet_init symbol"); return NULL; } return init; } static Janet janet_core_native(int32_t argc, Janet *argv) { 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); return janet_wrap_table(env); } static Janet janet_core_print(int32_t argc, Janet *argv) { for (int32_t i = 0; i < argc; ++i) { int32_t j, len; const uint8_t *vstr = janet_to_string(argv[i]); len = janet_string_length(vstr); for (j = 0; j < len; ++j) { putc(vstr[j], stdout); } } putc('\n', stdout); return janet_wrap_nil(); } static Janet janet_core_describe(int32_t argc, Janet *argv) { 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); } static Janet janet_core_string(int32_t argc, Janet *argv) { 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); } static Janet janet_core_symbol(int32_t argc, Janet *argv) { 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); } static Janet janet_core_keyword(int32_t argc, Janet *argv) { 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); } static Janet janet_core_buffer(int32_t argc, Janet *argv) { 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); } static Janet janet_core_is_abstract(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); return janet_wrap_boolean(janet_checktype(argv[0], JANET_ABSTRACT)); } static Janet janet_core_scannumber(int32_t argc, Janet *argv) { double number; janet_fixarity(argc, 1); JanetByteView view = janet_getbytes(argv, 0); if (janet_scan_number(view.bytes, view.len, &number)) return janet_wrap_nil(); return janet_wrap_number(number); } static Janet janet_core_tuple(int32_t argc, Janet *argv) { return janet_wrap_tuple(janet_tuple_n(argv, argc)); } static Janet janet_core_array(int32_t argc, Janet *argv) { JanetArray *array = janet_array(argc); array->count = argc; memcpy(array->data, argv, argc * sizeof(Janet)); return janet_wrap_array(array); } static Janet janet_core_table(int32_t argc, Janet *argv) { 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); } static Janet janet_core_struct(int32_t argc, Janet *argv) { 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)); } static Janet janet_core_gensym(int32_t argc, Janet *argv) { (void) argv; janet_fixarity(argc, 0); return janet_wrap_symbol(janet_symbol_gen()); } static Janet janet_core_gccollect(int32_t argc, Janet *argv) { (void) argv; (void) argc; janet_collect(); return janet_wrap_nil(); } static Janet janet_core_gcsetinterval(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); int32_t val = janet_getinteger(argv, 0); if (val < 0) janet_panic("expected non-negative integer"); janet_vm_gc_interval = val; return janet_wrap_nil(); } static Janet janet_core_gcinterval(int32_t argc, Janet *argv) { (void) argv; janet_fixarity(argc, 0); return janet_wrap_number(janet_vm_gc_interval); } static Janet janet_core_type(int32_t argc, Janet *argv) { 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]); } } static Janet janet_core_next(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); JanetDictView view = janet_getdictionary(argv, 0); const JanetKV *end = view.kvs + view.cap; const JanetKV *kv = janet_checktype(argv[1], JANET_NIL) ? view.kvs : janet_dict_find(view.kvs, view.cap, argv[1]) + 1; while (kv < end) { if (!janet_checktype(kv->key, JANET_NIL)) return kv->key; kv++; } return janet_wrap_nil(); } static Janet janet_core_hash(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); return janet_wrap_number(janet_hash(argv[0])); } static const JanetReg corelib_cfuns[] = { { "native", janet_core_native, JDOC("(native path [,env])\n\n" "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.") }, { "print", janet_core_print, JDOC("(print & xs)\n\n" "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. Returns nil.") }, { "describe", janet_core_describe, JDOC("(describe x)\n\n" "Returns a string that is a human readable description of a value x.") }, { "string", janet_core_string, JDOC("(string & parts)\n\n" "Creates a string by concatenating values together. Values are " "converted to bytes via describe if they are not byte sequences. " "Returns the new string.") }, { "symbol", janet_core_symbol, JDOC("(symbol & xs)\n\n" "Creates a symbol by concatenating values together. Values are " "converted to bytes via describe if they are not byte sequences. Returns " "the new symbol.") }, { "keyword", janet_core_keyword, JDOC("(keyword & xs)\n\n" "Creates a keyword by concatenating values together. Values are " "converted to bytes via describe if they are not byte sequences. Returns " "the new keyword.") }, { "buffer", janet_core_buffer, JDOC("(buffer & xs)\n\n" "Creates a new buffer by concatenating values together. Values are " "converted to bytes via describe if they are not byte sequences. Returns " "the new buffer.") }, { "abstract?", janet_core_is_abstract, JDOC("(abstract? x)\n\n" "Check if x is an abstract type.") }, { "table", janet_core_table, JDOC("(table & kvs)\n\n" "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.") }, { "array", janet_core_array, JDOC("(array & items)\n\n" "Create a new array that contains items. Returns the new array.") }, { "scan-number", janet_core_scannumber, JDOC("(scan-number str)\n\n" "Parse a number from a byte sequence an return that number, either and 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.") }, { "tuple", janet_core_tuple, JDOC("(tuple & items)\n\n" "Creates a new tuple that contains items. Returns the new tuple.") }, { "struct", janet_core_struct, JDOC("(struct & kvs)\n\n" "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.") }, { "gensym", janet_core_gensym, JDOC("(gensym)\n\n" "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.") }, { "gccollect", janet_core_gccollect, JDOC("(gccollect)\n\n" "Run garbage collection. You should probably not call this manually.") }, { "gcsetinterval", janet_core_gcsetinterval, JDOC("(gcsetinterval interval)\n\n" "Set an integer number of bytes to allocate before running garbage collection. " "Low valuesi for interval will be slower but use less memory. " "High values will be faster but use more memory.") }, { "gcinterval", janet_core_gcinterval, JDOC("(gcinterval)\n\n" "Returns the integer number of bytes to allocate before running an iteration " "of garbage collection.") }, { "type", janet_core_type, JDOC("(type x)\n\n" "Returns the type of x as a keyword symbol. x is one of\n" "\t:nil\n" "\t:boolean\n" "\t:integer\n" "\t:real\n" "\t:array\n" "\t:tuple\n" "\t:table\n" "\t:struct\n" "\t:string\n" "\t:buffer\n" "\t:symbol\n" "\t:keyword\n" "\t:function\n" "\t:cfunction\n\n" "or another symbol for an abstract type.") }, { "next", janet_core_next, JDOC("(next dict key)\n\n" "Gets the next key in a struct or table. 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 they 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. ") }, { "hash", janet_core_hash, JDOC("(hash value)\n\n" "Gets a hash value for any janet value. The hash is an integer can be used " "as a cheap hash function for all janet objects. If two values are strictly equal, " "then they will have the same hash value.") }, {NULL, NULL, NULL} }; #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 slots, const uint32_t *bytecode, size_t bytecode_size, const char *doc) { JanetFuncDef *def = janet_funcdef_alloc(); def->arity = arity; def->flags = flags; def->slotcount = slots; def->bytecode = 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(env, name, janet_wrap_function(janet_thunk(def)), doc); } /* Macros for easier inline janet 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_GET, 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, 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_GET, 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, 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_GET, 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, 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_NIL }; 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 get_asm[] = { JOP_GET | (1 << 24), JOP_RETURN }; 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 }; #endif /* ifndef JANET_NO_BOOTSTRAP */ JanetTable *janet_core_env(void) { JanetTable *env = janet_table(0); janet_core_cfuns(env, NULL, corelib_cfuns); #ifdef JANET_BOOTSTRAP janet_quick_asm(env, JANET_FUN_YIELD | JANET_FUNCDEF_FLAG_FIXARITY, "debug", 0, 1, debug_asm, sizeof(debug_asm), JDOC("(debug)\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 nil.")); janet_quick_asm(env, JANET_FUN_ERROR | JANET_FUNCDEF_FLAG_FIXARITY, "error", 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, 2, yield_asm, sizeof(yield_asm), JDOC("(yield 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_RESUME, "resume", 2, 2, resume_asm, sizeof(resume_asm), JDOC("(resume fiber [,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_GET | JANET_FUNCDEF_FLAG_FIXARITY, "get", 2, 2, get_asm, sizeof(get_asm), JDOC("(get ds key)\n\n" "Get a value from any associative data structure. Arrays, tuples, tables, structs, strings, " "symbols, and buffers are all associative and can be used with get. Order structures, name " "arrays, tuples, strings, buffers, and symbols must use integer keys. Structs and tables can " "take any value as a key except nil and return a value except nil. Byte sequences will return " "integer representations of bytes as result of a get call.")); janet_quick_asm(env, JANET_FUN_PUT | JANET_FUNCDEF_FLAG_FIXARITY, "put", 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 | JANET_FUNCDEF_FLAG_FIXARITY, "length", 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 | JANET_FUNCDEF_FLAG_FIXARITY, "bnot", 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. Division by two integers uses truncating division.")); 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_ORDER_GT, "order>", 0, JOP_GREATER_THAN, JDOC("(order> & xs)\n\n" "Check if xs is strictly descending according to a total order " "over all values. Returns a boolean.")); templatize_comparator(env, JANET_FUN_ORDER_LT, "order<", 0, JOP_LESS_THAN, JDOC("(order< & xs)\n\n" "Check if xs is strictly increasing according to a total order " "over all values. Returns a boolean.")); templatize_comparator(env, JANET_FUN_ORDER_GTE, "order>=", 1, JOP_LESS_THAN, JDOC("(order>= & xs)\n\n" "Check if xs is not increasing according to a total order " "over all values. Returns a boolean.")); templatize_comparator(env, JANET_FUN_ORDER_LTE, "order<=", 1, JOP_GREATER_THAN, JDOC("(order<= & xs)\n\n" "Check if xs is not decreasing according to a total order " "over all values. Returns a boolean.")); templatize_comparator(env, JANET_FUN_ORDER_EQ, "=", 0, JOP_EQUALS, JDOC("(= & xs)\n\n" "Returns true if all values in xs are the same, false otherwise.")); templatize_comparator(env, JANET_FUN_ORDER_NEQ, "not=", 1, JOP_EQUALS, JDOC("(not= & xs)\n\n" "Return true if any values in xs are not equal, otherwise false.")); templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_NUMERIC_GREATER_THAN, JDOC("(> & xs)\n\n" "Check if xs is in numerically descending order. Returns a boolean.")); templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_NUMERIC_LESS_THAN, JDOC("(< & xs)\n\n" "Check if xs is in numerically ascending order. Returns a boolean.")); templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_NUMERIC_GREATER_THAN_EQUAL, JDOC("(>= & xs)\n\n" "Check if xs is in numerically non-ascending order. Returns a boolean.")); templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_NUMERIC_LESS_THAN_EQUAL, JDOC("(<= & xs)\n\n" "Check if xs is in numerically non-descending order. Returns a boolean.")); templatize_comparator(env, JANET_FUN_EQ, "==", 0, JOP_NUMERIC_EQUAL, JDOC("(== & xs)\n\n" "Check if all values in xs are numerically equal (4.0 == 4). Returns a boolean.")); templatize_comparator(env, JANET_FUN_NEQ, "not==", 1, JOP_NUMERIC_EQUAL, JDOC("(not== & xs)\n\n" "Check if any values in xs are not numerically equal (3.0 not== 4). 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.")); /* Allow references to the environment */ janet_def(env, "_env", janet_wrap_table(env), JDOC("The environment table for the current scope.")); /* Set as gc root */ janet_gcroot(janet_wrap_table(env)); #endif /* Load auxiliary envs */ 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_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_BOOTSTRAP /* Run bootstrap source */ janet_dobytes(env, janet_gen_core, janet_gen_core_size, "core.janet", NULL); #else /* Unmarshal from core image */ Janet marsh_out; int status = janet_unmarshal( janet_core_image, janet_core_image_size, 0, &marsh_out, env, NULL); if (status) { printf("error unmarshaling core image\n"); exit(1); } janet_gcroot(marsh_out); env = janet_unwrap_table(marsh_out); #endif return env; } /* * Copyright (c) 2019 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 #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 offset) { /* Scan the heap for right func def */ JanetGCMemoryHeader *current = janet_vm_blocks; /* Keep track of the best source mapping we have seen so far */ int32_t besti = -1; int32_t best_range = INT32_MAX; JanetFuncDef *best_def = NULL; while (NULL != current) { if ((current->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_FUNCDEF) { JanetFuncDef *def = (JanetFuncDef *)(current + 1); if (def->sourcemap && def->source && !janet_string_compare(source, def->source)) { /* Correct source file, check mappings. The chosen * pc index is the first match with the smallest range. */ int32_t i; for (i = 0; i < def->bytecode_length; i++) { int32_t start = def->sourcemap[i].start; int32_t end = def->sourcemap[i].end; if (end - start < best_range && start <= offset && end >= offset) { best_range = end - start; besti = i; best_def = def; } } } } current = current->next; } if (best_def) { *def_out = best_def; *pc_out = besti; } else { janet_panic("could not find breakpoint"); } } /* Error reporting. This can be emulated from within Janet, but for * consitency with the top level code it is defined once. */ void janet_stacktrace(JanetFiber *fiber, Janet err) { int32_t fi; const char *errstr = (const char *)janet_to_string(err); JanetFiber **fibers = NULL; int wrote_error = 0; 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) { 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); const char *prefix = status == JANET_STATUS_ERROR ? "" : "status "; fprintf(stderr, "%s%s: %s\n", prefix, janet_status_names[status], errstr); wrote_error = 1; } fprintf(stderr, " in"); if (frame->func) { def = frame->func->def; fprintf(stderr, " %s", def->name ? (const char *)def->name : ""); if (def->source) { fprintf(stderr, " [%s]", (const char *)def->source); } } else { JanetCFunction cfun = (JanetCFunction)(frame->pc); if (cfun) { Janet name = janet_table_get(janet_vm_registry, janet_wrap_cfunction(cfun)); if (!janet_checktype(name, JANET_NIL)) fprintf(stderr, " %s", (const char *)janet_to_string(name)); else fprintf(stderr, " "); } } if (frame->flags & JANET_STACKFRAME_TAILCALL) fprintf(stderr, " (tailcall)"); if (frame->func && frame->pc) { int32_t off = (int32_t)(frame->pc - def->bytecode); if (def->sourcemap) { JanetSourceMapping mapping = def->sourcemap[off]; fprintf(stderr, " at (%d:%d)", mapping.start, mapping.end); } else { fprintf(stderr, " pc=%d", off); } } fprintf(stderr, "\n"); } } 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, 2); const uint8_t *source = janet_getstring(argv, 0); int32_t source_offset = janet_getinteger(argv, 1); janet_debug_find(def, bytecode_offset, source, source_offset); } /* 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; } static Janet cfun_debug_break(int32_t argc, Janet *argv) { JanetFuncDef *def; int32_t offset; helper_find(argc, argv, &def, &offset); janet_debug_break(def, offset); return janet_wrap_nil(); } static Janet cfun_debug_unbreak(int32_t argc, Janet *argv) { JanetFuncDef *def; int32_t offset; helper_find(argc, argv, &def, &offset); janet_debug_unbreak(def, offset); return janet_wrap_nil(); } static Janet cfun_debug_fbreak(int32_t argc, Janet *argv) { JanetFuncDef *def; int32_t offset; helper_find_fun(argc, argv, &def, &offset); janet_debug_break(def, offset); return janet_wrap_nil(); } static Janet cfun_debug_unfbreak(int32_t argc, Janet *argv) { JanetFuncDef *def; int32_t offset; helper_find_fun(argc, argv, &def, &offset); janet_debug_unbreak(def, offset); return janet_wrap_nil(); } static Janet cfun_debug_lineage(int32_t argc, Janet *argv) { 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) { Janet name = janet_table_get(janet_vm_registry, janet_wrap_cfunction(cfun)); if (!janet_checktype(name, JANET_NIL)) { janet_table_put(t, janet_ckeywordv("name"), name); } } 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; 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-start"), janet_wrap_integer(mapping.start)); janet_table_put(t, janet_ckeywordv("source-end"), janet_wrap_integer(mapping.end)); } if (def->source) { janet_table_put(t, janet_ckeywordv("source"), janet_wrap_string(def->source)); } /* Add stack arguments */ slots = janet_array(def->slotcount); memcpy(slots->data, stack, sizeof(Janet) * def->slotcount); slots->count = def->slotcount; janet_table_put(t, janet_ckeywordv("slots"), janet_wrap_array(slots)); } return janet_wrap_table(t); } static Janet cfun_debug_stack(int32_t argc, Janet *argv) { 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); } static Janet cfun_debug_stacktrace(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); JanetFiber *fiber = janet_getfiber(argv, 0); janet_stacktrace(fiber, argv[1]); return argv[0]; } static Janet cfun_debug_argstack(int32_t argc, Janet *argv) { 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); } static const JanetReg debug_cfuns[] = { { "debug/break", cfun_debug_break, JDOC("(debug/break source byte-offset)\n\n" "Sets a breakpoint with source a key at a given byte offset. An offset " "of 0 is the first byte in a file. Will throw an error if the breakpoint location " "cannot be found. For example\n\n" "\t(debug/break \"core.janet\" 1000)\n\n" "wil set a breakpoint at the 1000th byte of the file core.janet.") }, { "debug/unbreak", cfun_debug_unbreak, JDOC("(debug/unbreak source byte-offset)\n\n" "Remove a breakpoint with a source key at a given byte offset. An offset " "of 0 is the first byte in a file. Will throw an error if the breakpoint " "cannot be found.") }, { "debug/fbreak", cfun_debug_fbreak, JDOC("(debug/fbreak fun [,pc=0])\n\n" "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.") }, { "debug/unfbreak", cfun_debug_unfbreak, JDOC("(debug/unfbreak fun [,pc=0])\n\n" "Unset a breakpoint set with debug/fbreak.") }, { "debug/arg-stack", cfun_debug_argstack, JDOC("(debug/arg-stack fiber)\n\n" "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.") }, { "debug/stack", cfun_debug_stack, JDOC("(debug/stack fib)\n\n" "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" "\t:c - true if the stack frame is a c function invocation\n" "\t:column - the current source column of the stack frame\n" "\t:function - the function that the stack frame represents\n" "\t:line - the current source line of the stack frame\n" "\t:name - the human friendly name of the function\n" "\t:pc - integer indicating the location of the program counter\n" "\t:source - string with the file path or other identifier for the source code\n" "\t:slots - array of all values in each slot\n" "\t:tail - boolean indicating a tail call") }, { "debug/stacktrace", cfun_debug_stacktrace, JDOC("(debug/stacktrace fiber err)\n\n" "Prints a nice looking stacktrace for a fiber. The error message " "err must be passed to the function as fiber's do not keep track of " "the last error they have thrown. Returns the fiber.") }, { "debug/lineage", cfun_debug_lineage, JDOC("(debug/lineage fib)\n\n" "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.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_debug(JanetTable *env) { janet_core_cfuns(env, NULL, debug_cfuns); } /* * Copyright (c) 2019 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 #include "emit.h" #include "vector.h" #include "regalloc.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 */ 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_TRUE: janetc_emit(c, (reg << 8) | JOP_LOAD_TRUE); break; case JANET_FALSE: janetc_emit(c, (reg << 8) | JOP_LOAD_FALSE); break; case JANET_NUMBER: { double dval = janet_unwrap_number(k); int32_t i = (int32_t) dval; if (dval != i || !(dval >= INT16_MIN && dval <= INT16_MAX)) goto do_constant; janetc_emit(c, (i << 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 > 0xFF || src.index != dest) { 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) { 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 */ static 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 near = janetc_allocnear(c, JANETC_REGTEMP_3); janetc_movenear(c, near, src); janetc_moveback(c, dest, near); /* Cleanup */ janetc_regalloc_freetemp(&c->scope->ra, near, 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) | (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) | (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) | (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; } /* * Copyright (c) 2019 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 #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_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 = malloc(sizeof(Janet) * capacity); if (NULL == data) { JANET_OUT_OF_MEMORY; } 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); } memcpy(fiber->data + fiber->stacktop, argv, argc * sizeof(Janet)); fiber->stacktop = newstacktop; } if (janet_fiber_funcframe(fiber, callee)) return NULL; janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE; 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); } /* Ensure that the fiber has enough extra capacity */ void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) { Janet *newData = realloc(fiber->data, sizeof(Janet) * n); if (NULL == newData) { JANET_OUT_OF_MEMORY; } fiber->data = newData; fiber->capacity = n; } /* Push a value on the next stack frame */ void janet_fiber_push(JanetFiber *fiber, Janet x) { if (fiber->stacktop >= fiber->capacity) { janet_fiber_setcapacity(fiber, 2 * 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) { int32_t newtop = fiber->stacktop + 2; if (newtop > fiber->capacity) { janet_fiber_setcapacity(fiber, 2 * 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) { int32_t newtop = fiber->stacktop + 3; if (newtop > fiber->capacity) { janet_fiber_setcapacity(fiber, 2 * 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) { int32_t newtop = fiber->stacktop + n; if (newtop > fiber->capacity) { janet_fiber_setcapacity(fiber, 2 * newtop); } memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet)); fiber->stacktop = newtop; } /* 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 (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) { if (func->def->arity != next_arity) { return 1; } } if (fiber->capacity < nextstacktop) { janet_fiber_setcapacity(fiber, 2 * nextstacktop); } /* 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; if (tuplehead >= oldtop) { fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(NULL, 0)); } else { fiber->data[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) { size_t s = sizeof(Janet) * env->length; Janet *vmem = malloc(s); if (NULL == vmem) { JANET_OUT_OF_MEMORY; } memcpy(vmem, env->as.fiber->data + env->offset, s); env->offset = 0; env->as.values = vmem; } } /* 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 (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) { if (func->def->arity != next_arity) { return 1; } } if (fiber->capacity < nextstacktop) { janet_fiber_setcapacity(fiber, 2 * nextstacktop); } 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; 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] = janet_wrap_tuple(janet_tuple_n(NULL, 0)); } else { fiber->data[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); } /* 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. Returns the new stack frame, or * NULL if there are no more frames */ 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; } /* CFuns */ static Janet cfun_fiber_new(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); JanetFunction *func = janet_getfunction(argv, 0); JanetFiber *fiber; if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) { if (func->def->arity != 0) { janet_panic("expected nullary function in fiber constructor"); } } fiber = janet_fiber(func, 64, 0, NULL); if (argc == 2) { int32_t i; JanetByteView view = janet_getbytes(argv, 1); fiber->flags = 0; 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, d, e, u, or y", 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 '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; } } } } return janet_wrap_fiber(fiber); } static Janet cfun_fiber_status(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetFiber *fiber = janet_getfiber(argv, 0); uint32_t s = (fiber->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; return janet_ckeywordv(janet_status_names[s]); } static Janet cfun_fiber_current(int32_t argc, Janet *argv) { (void) argv; janet_fixarity(argc, 0); return janet_wrap_fiber(janet_vm_fiber); } static Janet cfun_fiber_maxstack(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetFiber *fiber = janet_getfiber(argv, 0); return janet_wrap_integer(fiber->maxstack); } static Janet cfun_fiber_setmaxstack(int32_t argc, Janet *argv) { 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]; } static const JanetReg fiber_cfuns[] = { { "fiber/new", cfun_fiber_new, JDOC("(fiber/new func [,sigmask])\n\n" "Create a new fiber with function body func. Can optionally " "take a set of signals to block from the current parent fiber " "when called. The mask is specified as a keyword where each character " "is used to indicate a signal to block. The default sigmask is :y. " "For example, \n\n" "\t(fiber/new myfun :e123)\n\n" "blocks error signals and user signals 1, 2 and 3. The signals are " "as follows: \n\n" "\ta - block all signals\n" "\td - block debug signals\n" "\te - block error signals\n" "\tu - block user signals\n" "\ty - block yield signals\n" "\t0-9 - block a specific user signal") }, { "fiber/status", cfun_fiber_status, JDOC("(fiber/status fib)\n\n" "Get the status of a fiber. The status will be one of:\n\n" "\t:dead - the fiber has finished\n" "\t:error - the fiber has errored out\n" "\t:debug - the fiber is suspended in debug mode\n" "\t:pending - the fiber has been yielded\n" "\t:user(0-9) - the fiber is suspended by a user signal\n" "\t:alive - the fiber is currently running and cannot be resumed\n" "\t:new - the fiber has just been created and not yet run") }, { "fiber/current", cfun_fiber_current, JDOC("(fiber/current)\n\n" "Returns the currently running fiber.") }, { "fiber/maxstack", cfun_fiber_maxstack, JDOC("(fiber/maxstack fib)\n\n" "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. ") }, { "fiber/setmaxstack", cfun_fiber_setmaxstack, JDOC("(fiber/setmaxstack fib maxstack)\n\n" "Sets the maximum stack size in janet values for a fiber. By default, the " "maximum stack size is usually 8192.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_fiber(JanetTable *env) { janet_core_cfuns(env, NULL, fiber_cfuns); } /* * Copyright (c) 2019 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 #include "state.h" #include "symcache.h" #include "gc.h" #endif /* GC State */ JANET_THREAD_LOCAL void *janet_vm_blocks; JANET_THREAD_LOCAL uint32_t janet_vm_gc_interval; JANET_THREAD_LOCAL uint32_t janet_vm_next_collection; JANET_THREAD_LOCAL int janet_vm_gc_suspend = 0; /* Roots */ JANET_THREAD_LOCAL Janet *janet_vm_roots; JANET_THREAD_LOCAL uint32_t janet_vm_root_count; JANET_THREAD_LOCAL uint32_t janet_vm_root_capacity; /* 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 */ static JANET_THREAD_LOCAL uint32_t depth = JANET_RECURSION_GUARD; static JANET_THREAD_LOCAL uint32_t orig_rootcount; /* 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_raw(str)); } static void janet_mark_buffer(JanetBuffer *buffer) { janet_gc_mark(buffer); } static void janet_mark_abstract(void *adata) { if (janet_gc_reachable(janet_abstract_header(adata))) return; janet_gc_mark(janet_abstract_header(adata)); if (janet_abstract_header(adata)->type->gcmark) { janet_abstract_header(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) { 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_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); 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); janet_mark_kvs(table->data, table->capacity); if (table->proto) { table = table->proto; goto recur; } } static void janet_mark_struct(const JanetKV *st) { if (janet_gc_reachable(janet_struct_raw(st))) return; janet_gc_mark(janet_struct_raw(st)); janet_mark_kvs(st, janet_struct_capacity(st)); } static void janet_mark_tuple(const Janet *tuple) { if (janet_gc_reachable(janet_tuple_raw(tuple))) return; janet_gc_mark(janet_tuple_raw(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 (env->offset) { /* 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); } static void janet_mark_function(JanetFunction *func) { int32_t i; int32_t numenvs; if (janet_gc_reachable(func)) return; janet_gc_mark(func); 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); /* 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; } /* Explicit tail recursion */ if (fiber->child) { fiber = fiber->child; goto recur; } } /* Deinitialize a block of memory */ static void janet_deinit_block(JanetGCMemoryHeader *block) { void *mem = ((char *)(block + 1)); JanetAbstractHeader *h = (JanetAbstractHeader *)mem; switch (block->flags & JANET_MEM_TYPEBITS) { default: case JANET_MEMORY_FUNCTION: break; /* Do nothing for non gc types */ case JANET_MEMORY_SYMBOL: janet_symbol_deinit((const uint8_t *)mem + 2 * sizeof(int32_t)); break; case JANET_MEMORY_ARRAY: janet_array_deinit((JanetArray *) mem); break; case JANET_MEMORY_TABLE: janet_table_deinit((JanetTable *) mem); break; case JANET_MEMORY_FIBER: free(((JanetFiber *)mem)->data); break; case JANET_MEMORY_BUFFER: janet_buffer_deinit((JanetBuffer *) mem); break; case JANET_MEMORY_ABSTRACT: if (h->type->gc) { janet_assert(!h->type->gc((void *)(h + 1), h->size), "finalizer failed"); } break; case JANET_MEMORY_FUNCENV: { JanetFuncEnv *env = (JanetFuncEnv *)mem; if (0 == env->offset) free(env->as.values); } break; case JANET_MEMORY_FUNCDEF: { JanetFuncDef *def = (JanetFuncDef *)mem; /* TODO - get this all with one alloc and one free */ free(def->defs); free(def->environments); free(def->constants); free(def->bytecode); free(def->sourcemap); } break; } } /* 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() { JanetGCMemoryHeader *previous = NULL; JanetGCMemoryHeader *current = janet_vm_blocks; JanetGCMemoryHeader *next; while (NULL != current) { next = current->next; if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) { previous = current; current->flags &= ~JANET_MEM_REACHABLE; } else { janet_deinit_block(current); if (NULL != previous) { previous->next = next; } else { janet_vm_blocks = next; } free(current); } current = next; } } /* Allocate some memory that is tracked for garbage collection */ void *janet_gcalloc(enum JanetMemoryType type, size_t size) { JanetGCMemoryHeader *mdata; size_t total = size + sizeof(JanetGCMemoryHeader); /* Make sure everything is inited */ janet_assert(NULL != janet_vm_cache, "please initialize janet before use"); void *mem = malloc(total); /* Check for bad malloc */ if (NULL == mem) { JANET_OUT_OF_MEMORY; } mdata = (JanetGCMemoryHeader *)mem; /* Configure block */ mdata->flags = type; /* Prepend block to heap list */ janet_vm_next_collection += (int32_t) size; mdata->next = janet_vm_blocks; janet_vm_blocks = mdata; return (char *) mem + sizeof(JanetGCMemoryHeader); } /* Run garbage collection */ void janet_collect(void) { uint32_t i; if (janet_vm_gc_suspend) return; depth = JANET_RECURSION_GUARD; orig_rootcount = janet_vm_root_count; 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_sweep(); janet_vm_next_collection = 0; } /* 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) { uint32_t newcount = janet_vm_root_count + 1; if (newcount > janet_vm_root_capacity) { uint32_t newcap = 2 * newcount; janet_vm_roots = 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_TRUE: case JANET_FALSE: 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; Janet *v = janet_vm_roots; /* Search from top to bottom as access is most likely LIFO */ for (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; Janet *v = janet_vm_roots; int ret = 0; /* Search from top to bottom as access is most likely LIFO */ for (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) { JanetGCMemoryHeader *current = janet_vm_blocks; while (NULL != current) { janet_deinit_block(current); JanetGCMemoryHeader *next = current->next; free(current); current = next; } janet_vm_blocks = NULL; } /* Primitives for suspending GC. */ int janet_gclock(void) { return janet_vm_gc_suspend++; } void janet_gcunlock(int handle) { janet_vm_gc_suspend = handle; } /* * Copyright (c) 2019 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. */ /* Compiler feature test macros for things */ #define _DEFAULT_SOURCE #define _BSD_SOURCE #include #include #ifndef JANET_AMALG #include #include "util.h" #endif #define IO_WRITE 1 #define IO_READ 2 #define IO_APPEND 4 #define IO_UPDATE 8 #define IO_NOT_CLOSEABLE 16 #define IO_CLOSED 32 #define IO_BINARY 64 #define IO_SERIALIZABLE 128 #define IO_PIPED 256 typedef struct IOFile IOFile; struct IOFile { FILE *file; int flags; }; static int cfun_io_gc(void *p, size_t len); static Janet io_file_get(void *p, Janet); JanetAbstractType cfun_io_filetype = { "core/file", cfun_io_gc, NULL, io_file_get, NULL }; /* Check arguments to fopen */ static int checkflags(const uint8_t *str) { int flags = 0; int32_t i; int32_t len = janet_string_length(str); if (!len || len > 3) janet_panic("file mode must have a length between 1 and 3"); switch (*str) { default: janet_panicf("invalid flag %c, expected w, a, or r", *str); break; case 'w': flags |= IO_WRITE; break; case 'a': flags |= IO_APPEND; break; case 'r': flags |= IO_READ; break; } for (i = 1; i < len; i++) { switch (str[i]) { default: janet_panicf("invalid flag %c, expected + or b", str[i]); break; case '+': if (flags & IO_UPDATE) return -1; flags |= IO_UPDATE; break; case 'b': if (flags & IO_BINARY) return -1; flags |= IO_BINARY; break; } } return flags; } static Janet makef(FILE *f, int flags) { IOFile *iof = (IOFile *) janet_abstract(&cfun_io_filetype, sizeof(IOFile)); iof->file = f; iof->flags = flags; return janet_wrap_abstract(iof); } /* Open a process */ #ifdef __EMSCRIPTEN__ static Janet cfun_io_popen(int32_t argc, Janet *argv) { (void) argc; (void) argv; janet_panic("not implemented on this platform"); return janet_wrap_nil(); } #else static Janet cfun_io_popen(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); const uint8_t *fname = janet_getstring(argv, 0); const uint8_t *fmode = NULL; int flags; if (argc == 2) { fmode = janet_getkeyword(argv, 1); if (janet_string_length(fmode) != 1 || !(fmode[0] == 'r' || fmode[0] == 'w')) { janet_panicf("invalid file mode :%S, expected :r or :w", fmode); } flags = IO_PIPED | (fmode[0] == 'r' ? IO_READ : IO_WRITE); } else { fmode = (const uint8_t *)"r"; flags = IO_PIPED | IO_READ; } #ifdef JANET_WINDOWS #define popen _popen #endif FILE *f = popen((const char *)fname, (const char *)fmode); if (!f) { return janet_wrap_nil(); } return makef(f, flags); } #endif static Janet cfun_io_fopen(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); const uint8_t *fname = janet_getstring(argv, 0); const uint8_t *fmode; int flags; if (argc == 2) { fmode = janet_getkeyword(argv, 1); flags = checkflags(fmode); } else { fmode = (const uint8_t *)"r"; flags = IO_READ; } FILE *f = fopen((const char *)fname, (const char *)fmode); return f ? makef(f, flags) : janet_wrap_nil(); } /* Read up to n bytes into buffer. Return error string if error. */ static void read_chunk(IOFile *iof, JanetBuffer *buffer, int32_t nBytesMax) { if (!(iof->flags & (IO_READ | IO_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 */ static Janet cfun_io_fread(int32_t argc, Janet *argv) { janet_arity(argc, 2, 3); IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); if (iof->flags & IO_CLOSED) janet_panic("file is closed"); JanetBuffer *buffer; if (argc == 2) { buffer = janet_buffer(0); } else { buffer = janet_getbuffer(argv, 2); } if (janet_checktype(argv[1], JANET_KEYWORD)) { const uint8_t *sym = janet_unwrap_keyword(argv[1]); if (!janet_cstrcmp(sym, "all")) { /* Read whole file */ int status = fseek(iof->file, 0, SEEK_SET); if (status) { /* backwards fseek did not work (stream like popen) */ int32_t sizeBefore; do { sizeBefore = buffer->count; read_chunk(iof, buffer, 1024); } while (sizeBefore < buffer->count); } else { fseek(iof->file, 0, SEEK_END); long fsize = ftell(iof->file); if (fsize < 0) { janet_panicf("could not get file size of %v", argv[0]); } fseek(iof->file, 0, SEEK_SET); read_chunk(iof, buffer, (int32_t) fsize); } } 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); } return janet_wrap_buffer(buffer); } /* Write bytes to a file */ static Janet cfun_io_fwrite(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); if (iof->flags & IO_CLOSED) janet_panic("file is closed"); if (!(iof->flags & (IO_WRITE | IO_APPEND | IO_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]; } /* Flush the bytes in the file */ static Janet cfun_io_fflush(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); if (iof->flags & IO_CLOSED) janet_panic("file is closed"); if (!(iof->flags & (IO_WRITE | IO_APPEND | IO_UPDATE))) janet_panic("file is not writeable"); if (fflush(iof->file)) janet_panic("could not flush file"); return argv[0]; } /* Cleanup a file */ static int cfun_io_gc(void *p, size_t len) { (void) len; IOFile *iof = (IOFile *)p; if (!(iof->flags & (IO_NOT_CLOSEABLE | IO_CLOSED))) { return fclose(iof->file); } return 0; } /* Close a file */ static Janet cfun_io_fclose(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); if (iof->flags & IO_CLOSED) janet_panic("file is closed"); if (iof->flags & (IO_NOT_CLOSEABLE)) janet_panic("file not closable"); if (iof->flags & IO_PIPED) { #ifdef JANET_WINDOWS #define pclose _pclose #endif if (pclose(iof->file)) janet_panic("could not close file"); } else { if (fclose(iof->file)) janet_panic("could not close file"); } iof->flags |= IO_CLOSED; return argv[0]; } /* Seek a file */ static Janet cfun_io_fseek(int32_t argc, Janet *argv) { janet_arity(argc, 2, 3); IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); if (iof->flags & IO_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]; } static JanetMethod io_file_methods[] = { {"close", cfun_io_fclose}, {"read", cfun_io_fread}, {"write", cfun_io_fwrite}, {"flush", cfun_io_fflush}, {"seek", cfun_io_fseek}, {NULL, NULL} }; static Janet io_file_get(void *p, Janet key) { (void) p; if (!janet_checktype(key, JANET_KEYWORD)) janet_panicf("expected keyword, got %v", key); return janet_getmethod(janet_unwrap_keyword(key), io_file_methods); } static const JanetReg io_cfuns[] = { { "file/open", cfun_io_fopen, JDOC("(file/open path [,mode])\n\n" "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" "\tr - allow reading from the file\n" "\tw - allow writing to the file\n" "\ta - append to the file\n" "\tb - open the file in binary mode (rather than text mode)\n" "\t+ - append to the file instead of overwriting it") }, { "file/close", cfun_io_fclose, JDOC("(file/close f)\n\n" "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.") }, { "file/read", cfun_io_fread, JDOC("(file/read f what [,buf])\n\n" "Read a number of bytes from a file into a buffer. A buffer can " "be provided as an optional fourth 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" "\t:all - read the whole file\n" "\t:line - read up to and including the next newline character\n" "\tn (integer) - read up to n bytes from the file") }, { "file/write", cfun_io_fwrite, JDOC("(file/write f bytes)\n\n" "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the " "file.") }, { "file/flush", cfun_io_fflush, JDOC("(file/flush f)\n\n" "Flush any buffered bytes to the file system. In most files, writes are " "buffered for efficiency reasons. Returns the file handle.") }, { "file/seek", cfun_io_fseek, JDOC("(file/seek f [,whence [,n]])\n\n" "Jump to a relative location in the file. 'whence' must be one of\n\n" "\t:cur - jump relative to the current file location\n" "\t:set - jump relative to the beginning of the file\n" "\t: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 the 4GB. Returns the file handle.") }, { "file/popen", cfun_io_popen, JDOC("(file/popen path [,mode])\n\n" "Open a file that is backed by a process. The file must be opened in either " "the :r (read) or the :w (write) mode. In :r mode, the stdout of the " "process can be read from the file. In :w mode, the stdin of the process " "can be written to. Returns the new file.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_io(JanetTable *env) { janet_core_cfuns(env, NULL, io_cfuns); /* stdout */ janet_core_def(env, "stdout", makef(stdout, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE), JDOC("The standard output file.")); /* stderr */ janet_core_def(env, "stderr", makef(stderr, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE), JDOC("The standard error file.")); /* stdin */ janet_core_def(env, "stdin", makef(stdin, IO_READ | IO_NOT_CLOSEABLE | IO_SERIALIZABLE), JDOC("The standard input file.")); } /* * Copyright (c) 2019 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 #include "state.h" #include "vector.h" #include "gc.h" #include "fiber.h" #include "util.h" #endif typedef struct { jmp_buf err; Janet current; JanetBuffer *buf; JanetTable seen; JanetTable *rreg; JanetFuncEnv **seen_envs; JanetFuncDef **seen_defs; int32_t nextid; } MarshalState; enum { MR_OK, MR_STACKOVERFLOW, MR_NYI, MR_NRV, MR_C_STACKFRAME, MR_OVERFLOW, MR_LIVEFIBER } MarshalResult; const char *mr_strings[] = { "", "stack overflow", "type NYI", "no registry value", "fiber has c stack frame", "buffer overflow", "alive fiber" }; /* Lead bytes in marshaling protocol */ enum { LB_REAL = 200, LB_NIL, LB_FALSE, LB_TRUE, LB_FIBER, LB_INTEGER, LB_STRING, LB_SYMBOL, LB_KEYWORD, LB_ARRAY, LB_TUPLE, LB_TABLE, LB_TABLE_PROTO, LB_STRUCT, LB_BUFFER, LB_FUNCTION, LB_REGISTRY, LB_ABSTRACT, LB_REFERENCE, LB_FUNCENV_REF, LB_FUNCDEF_REF } 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(); } } /* Make a forward lookup table from an environment (for unmarshaling) */ JanetTable *janet_env_lookup(JanetTable *env) { JanetTable *renv = janet_table(env->count); while (env) { for (int32_t i = 0; i < env->capacity; i++) { if (janet_checktype(env->data[i].key, JANET_SYMBOL)) { janet_table_put(renv, env->data[i].key, entry_getval(env->data[i].value)); } } env = env->proto; } 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); } /* 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); /* Marshal a function env */ static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags) { if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) longjmp(st->err, MR_STACKOVERFLOW); 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_v_push(st->seen_envs, env); pushint(st, env->offset); pushint(st, env->length); if (env->offset) { /* 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); } } /* Add function flags to janet functions */ static void janet_func_addflags(JanetFuncDef *def) { if (def->name) def->flags |= JANET_FUNCDEF_FLAG_HASNAME; if (def->source) def->flags |= JANET_FUNCDEF_FLAG_HASSOURCE; if (def->defs) def->flags |= JANET_FUNCDEF_FLAG_HASDEFS; if (def->environments) def->flags |= JANET_FUNCDEF_FLAG_HASENVS; if (def->sourcemap) def->flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP; } /* Marshal a function def */ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) { if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) longjmp(st->err, MR_STACKOVERFLOW); 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; } } janet_func_addflags(def); /* 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->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_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); /* marshal the bytecode */ for (int32_t i = 0; i < def->bytecode_length; i++) { pushbyte(st, def->bytecode[i] & 0xFF); pushbyte(st, (def->bytecode[i] >> 8) & 0xFF); pushbyte(st, (def->bytecode[i] >> 16) & 0xFF); pushbyte(st, (def->bytecode[i] >> 24) & 0xFF); } /* 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); /* 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.start - current); pushint(st, map.end - map.start); current = map.end; } } } #define JANET_FIBER_FLAG_HASCHILD (1 << 29) #define JANET_STACKFRAME_HASENV (1 << 30) /* Marshal a fiber */ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) { int32_t fflags = fiber->flags; if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) longjmp(st->err, MR_STACKOVERFLOW); if (fiber->child) fflags |= JANET_FIBER_FLAG_HASCHILD; if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) longjmp(st->err, MR_LIVEFIBER); 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) longjmp(st->err, MR_C_STACKFRAME); 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->child) marshal_one(st, janet_wrap_fiber(fiber->child), flags + 1); } /* 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) { Janet parent = st->current; JanetType type = janet_type(x); st->current = x; if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) longjmp(st->err, MR_STACKOVERFLOW); /* Check simple primitives (non reference types, no benefit from memoization) */ switch (type) { default: break; case JANET_NIL: case JANET_FALSE: case JANET_TRUE: pushbyte(st, 200 + type); goto done; case JANET_NUMBER: { double xval = janet_unwrap_number(x); if (janet_checkintrange(xval)) { pushint(st, (int32_t) xval); goto done; } break; } } #define MARK_SEEN() \ janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)) /* Check reference and registry value */ { Janet check = janet_table_get(&st->seen, x); if (janet_checkint(check)) { pushbyte(st, LB_REFERENCE); pushint(st, janet_unwrap_integer(check)); goto done; } 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)); goto done; } } } /* 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(); } goto done; 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); } goto done; case JANET_BUFFER: { JanetBuffer *buffer = janet_unwrap_buffer(x); /* Record reference */ MARK_SEEN(); pushbyte(st, LB_BUFFER); pushint(st, buffer->count); pushbytes(st, buffer->data, buffer->count); } goto done; 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); } goto done; 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); 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(); } goto done; 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); } } goto done; case JANET_STRUCT: { int32_t count; const JanetKV *struct_ = janet_unwrap_struct(x); count = janet_struct_length(struct_); pushbyte(st, LB_STRUCT); pushint(st, count); 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(); } goto done; case JANET_ABSTRACT: case JANET_CFUNCTION: goto noregval; case JANET_FUNCTION: { pushbyte(st, LB_FUNCTION); JanetFunction *func = janet_unwrap_function(x); marshal_one_def(st, func->def, flags); /* Mark seen after reading def, but before envs */ MARK_SEEN(); for (int32_t i = 0; i < func->def->environments_length; i++) marshal_one_env(st, func->envs[i], flags + 1); } goto done; case JANET_FIBER: { MARK_SEEN(); pushbyte(st, LB_FIBER); marshal_one_fiber(st, janet_unwrap_fiber(x), flags + 1); } goto done; default: goto nyi; } #undef MARK_SEEN done: st->current = parent; return; /* Errors */ nyi: longjmp(st->err, MR_NYI); noregval: longjmp(st->err, MR_NRV); } int janet_marshal( JanetBuffer *buf, Janet x, Janet *errval, JanetTable *rreg, int flags) { int status; MarshalState st; st.buf = buf; st.nextid = 0; st.seen_defs = NULL; st.seen_envs = NULL; st.rreg = rreg; st.current = x; janet_table_init(&st.seen, 0); if (!(status = setjmp(st.err))) marshal_one(&st, x, flags); if (status && errval) *errval = st.current; janet_table_deinit(&st.seen); janet_v_free(st.seen_envs); janet_v_free(st.seen_defs); return status; } typedef struct { jmp_buf err; JanetArray lookup; JanetTable *reg; JanetFuncEnv **lookup_envs; JanetFuncDef **lookup_defs; const uint8_t *end; } UnmarshalState; enum { UMR_OK, UMR_STACKOVERFLOW, UMR_EOS, UMR_UNKNOWN, UMR_EXPECTED_INTEGER, UMR_EXPECTED_TABLE, UMR_EXPECTED_FIBER, UMR_EXPECTED_STRING, UMR_INVALID_REFERENCE, UMR_INVALID_BYTECODE, UMR_INVALID_FIBER } UnmarshalResult; const char *umr_strings[] = { "", "stack overflow", "unexpected end of source", "unmarshal error", "expected integer", "expected table", "expected fiber", "expected string", "invalid reference", "invalid bytecode", "invalid fiber" }; /* 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; if (data >= st->end) longjmp(st->err, UMR_EOS); if (*data < 128) { ret = *data++; } else if (*data < 192) { if (data + 2 > st->end) longjmp(st->err, UMR_EOS); ret = ((data[0] & 0x3F) << 8) + data[1]; ret = ((ret << 18) >> 18); data += 2; } else if (*data == LB_INTEGER) { if (data + 5 > st->end) longjmp(st->err, UMR_EOS); ret = ((int32_t)(data[1]) << 24) | ((int32_t)(data[2]) << 16) | ((int32_t)(data[3]) << 8) | (int32_t)(data[4]); data += 5; } else { longjmp(st->err, UMR_EXPECTED_INTEGER); } *atdata = data; return ret; } /* 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) { const uint8_t *end = st->end; if (data >= end) longjmp(st->err, UMR_EOS); if (*data == LB_FUNCENV_REF) { data++; int32_t index = readint(st, &data); if (index < 0 || index >= janet_v_count(st->lookup_envs)) longjmp(st->err, UMR_INVALID_REFERENCE); *out = st->lookup_envs[index]; } else { JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); env->length = 0; env->offset = 0; janet_v_push(st->lookup_envs, env); int32_t offset = readint(st, &data); int32_t length = readint(st, &data); if (offset) { Janet fiberv; /* On stack variant */ data = unmarshal_one(st, data, &fiberv, flags); if (!janet_checktype(fiberv, JANET_FIBER)) longjmp(st->err, UMR_EXPECTED_FIBER); env->as.fiber = janet_unwrap_fiber(fiberv); /* Unmarshalling fiber may set values */ if (env->offset != 0 && env->offset != offset) longjmp(st->err, UMR_UNKNOWN); if (env->length != 0 && env->length != length) longjmp(st->err, UMR_UNKNOWN); } else { /* Off stack variant */ env->as.values = malloc(sizeof(Janet) * length); if (!env->as.values) { JANET_OUT_OF_MEMORY; } for (int32_t i = 0; i < length; i++) data = unmarshal_one(st, data, env->as.values + i, flags); } env->offset = offset; env->length = length; *out = env; } return data; } /* Unmarshal a funcdef */ static const uint8_t *unmarshal_one_def( UnmarshalState *st, const uint8_t *data, JanetFuncDef **out, int flags) { const uint8_t *end = st->end; if (data >= end) longjmp(st->err, UMR_EOS); if (*data == LB_FUNCDEF_REF) { data++; int32_t index = readint(st, &data); if (index < 0 || index >= janet_v_count(st->lookup_defs)) longjmp(st->err, UMR_INVALID_REFERENCE); *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; 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; /* Read flags and other fixed values */ def->flags = readint(st, &data); def->slotcount = readint(st, &data); def->arity = readint(st, &data); /* Read some lengths */ constants_length = readint(st, &data); bytecode_length = readint(st, &data); if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) environments_length = readint(st, &data); if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) defs_length = readint(st, &data); /* Check name and source (optional) */ if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { Janet x; data = unmarshal_one(st, data, &x, flags + 1); if (!janet_checktype(x, JANET_STRING)) longjmp(st->err, UMR_EXPECTED_STRING); def->name = janet_unwrap_string(x); } if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { Janet x; data = unmarshal_one(st, data, &x, flags + 1); if (!janet_checktype(x, JANET_STRING)) longjmp(st->err, UMR_EXPECTED_STRING); def->source = janet_unwrap_string(x); } /* Unmarshal constants */ if (constants_length) { def->constants = 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 bytecode */ def->bytecode = malloc(sizeof(uint32_t) * bytecode_length); if (!def->bytecode) { JANET_OUT_OF_MEMORY; } for (int32_t i = 0; i < bytecode_length; i++) { if (data + 4 > end) longjmp(st->err, UMR_EOS); def->bytecode[i] = (uint32_t)(data[0]) | ((uint32_t)(data[1]) << 8) | ((uint32_t)(data[2]) << 16) | ((uint32_t)(data[3]) << 24); data += 4; } def->bytecode_length = bytecode_length; /* Unmarshal environments */ if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { def->environments = calloc(1, sizeof(int32_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 = calloc(1, sizeof(JanetFuncDef *) * 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 = malloc(sizeof(JanetSourceMapping) * 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].start = current; current += readint(st, &data); def->sourcemap[i].end = current; } } else { def->sourcemap = NULL; } /* Validate */ if (janet_verify(def)) longjmp(st->err, UMR_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 */ 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; /* Set frame later so fiber can be GCed at anytime if unmarshalling fails */ int32_t frame = 0; int32_t stack = 0; int32_t stacktop = 0; /* Read ints */ fiber->flags = readint(st, &data); frame = readint(st, &data); fiber->stackstart = readint(st, &data); fiber->stacktop = readint(st, &data); fiber->maxstack = readint(st, &data); /* Check for bad flags and ints */ if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber->stackstart || fiber->stackstart > fiber->stacktop || fiber->stacktop > fiber->maxstack) { goto error; } /* Allocate stack memory */ fiber->capacity = fiber->stacktop + 10; fiber->data = malloc(sizeof(Janet) * fiber->capacity); if (!fiber->data) { JANET_OUT_OF_MEMORY; } /* get frames */ stack = frame; 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 = readint(st, &data); int32_t pcdiff = readint(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); if (!janet_checktype(funcv, JANET_FUNCTION)) { goto error; } func = janet_unwrap_function(funcv); def = func->def; /* Check env */ if (frameflags & JANET_STACKFRAME_HASENV) { frameflags &= ~JANET_STACKFRAME_HASENV; int32_t offset = stack; int32_t length = stacktop - stack; data = unmarshal_one_env(st, data, &env, flags + 1); if (env->offset != 0 && env->offset != offset) goto error; if (env->length != 0 && env->length != offset) goto error; env->offset = offset; env->length = length; } /* Error checking */ int32_t expected_framesize = def->slotcount; if (expected_framesize != stacktop - stack) goto error; if (pcdiff < 0 || pcdiff >= def->bytecode_length) goto error; if ((int32_t)(prevframe + JANET_FRAME_SIZE) > stack) goto error; /* 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) goto error; /* 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); if (!janet_checktype(fiberv, JANET_FIBER)) longjmp(st->err, UMR_EXPECTED_FIBER); fiber->child = janet_unwrap_fiber(fiberv); } /* Return data */ fiber->frame = frame; *out = fiber; return data; error: longjmp(st->err, UMR_INVALID_FIBER); return NULL; } static const uint8_t *unmarshal_one( UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { const uint8_t *end = st->end; uint8_t lead; if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) { longjmp(st->err, UMR_STACKOVERFLOW); } #define EXTRA(N) if (data + N > end) longjmp(st->err, UMR_EOS) EXTRA(1); lead = data[0]; if (lead < 200) { *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 */ EXTRA(5); *out = janet_wrap_integer( (data[4]) | (data[3] << 8) | (data[2] << 16) | (data[1] << 24)); return data + 5; case LB_REAL: /* Real */ { union { double d; uint8_t bytes[8]; } u; EXTRA(9); #ifdef JANET_BIG_ENDIAN u.bytes[0] = data[8]; u.bytes[1] = data[7]; u.bytes[2] = data[6]; u.bytes[5] = 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(u.d); janet_array_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 = readint(st, &data); EXTRA(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; memcpy(buffer->data, data, len); *out = janet_wrap_buffer(buffer); } janet_array_push(&st->lookup, *out); return data + len; } case LB_FIBER: { JanetFiber *fiber; data = unmarshal_one_fiber(st, data + 1, &fiber, flags); *out = janet_wrap_fiber(fiber); return data; } case LB_FUNCTION: { JanetFunction *func; JanetFuncDef *def; data = unmarshal_one_def(st, data + 1, &def, flags + 1); func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + def->environments_length * sizeof(JanetFuncEnv)); func->def = def; *out = janet_wrap_function(func); janet_array_push(&st->lookup, *out); for (int32_t i = 0; i < def->environments_length; i++) { data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); } return data; } case LB_REFERENCE: case LB_ARRAY: case LB_TUPLE: case LB_STRUCT: case LB_TABLE: case LB_TABLE_PROTO: /* Things that open with integers */ { data++; int32_t len = readint(st, &data); if (lead == LB_ARRAY) { /* Array */ JanetArray *array = janet_array(len); array->count = len; *out = janet_wrap_array(array); janet_array_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; 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_array_push(&st->lookup, *out); } else if (lead == LB_STRUCT) { /* Struct */ JanetKV *struct_ = janet_struct_begin(len); 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_array_push(&st->lookup, *out); } else if (lead == LB_REFERENCE) { if (len < 0 || len >= st->lookup.count) longjmp(st->err, UMR_INVALID_REFERENCE); *out = st->lookup.data[len]; } else { /* Table */ JanetTable *t = janet_table(len); *out = janet_wrap_table(t); janet_array_push(&st->lookup, *out); if (lead == LB_TABLE_PROTO) { Janet proto; data = unmarshal_one(st, data, &proto, flags + 1); if (!janet_checktype(proto, JANET_TABLE)) longjmp(st->err, UMR_EXPECTED_TABLE); 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; } default: longjmp(st->err, UMR_UNKNOWN); return NULL; } #undef EXTRA } int janet_unmarshal( const uint8_t *bytes, size_t len, int flags, Janet *out, JanetTable *reg, const uint8_t **next) { int status; /* Avoid longjmp clobber warning in GCC */ UnmarshalState st; st.end = bytes + len; st.lookup_defs = NULL; st.lookup_envs = NULL; st.reg = reg; janet_array_init(&st.lookup, 0); if (!(status = setjmp(st.err))) { const uint8_t *nextbytes = unmarshal_one(&st, bytes, out, flags); if (next) *next = nextbytes; } janet_array_deinit(&st.lookup); janet_v_free(st.lookup_defs); janet_v_free(st.lookup_envs); return status; } /* C functions */ static Janet cfun_env_lookup(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetTable *env = janet_gettable(argv, 0); return janet_wrap_table(janet_env_lookup(env)); } static Janet cfun_marshal(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); JanetBuffer *buffer; JanetTable *rreg = NULL; Janet err_param = janet_wrap_nil(); int status; if (argc > 1) { rreg = janet_gettable(argv, 1); } if (argc > 2) { buffer = janet_getbuffer(argv, 2); } else { buffer = janet_buffer(10); } status = janet_marshal(buffer, argv[0], &err_param, rreg, 0); if (status) janet_panicf("%s for %V", mr_strings[status], err_param); return janet_wrap_buffer(buffer); } static Janet cfun_unmarshal(int32_t argc, Janet *argv) { janet_arity(argc, 1, 2); JanetByteView view = janet_getbytes(argv, 0); JanetTable *reg = NULL; Janet ret; int status; if (argc > 1) { reg = janet_gettable(argv, 1); } status = janet_unmarshal(view.bytes, (size_t) view.len, 0, &ret, reg, NULL); if (status) { janet_panic(umr_strings[status]); } return ret; } static const JanetReg marsh_cfuns[] = { { "marshal", cfun_marshal, JDOC("(marshal x [,reverse-lookup [,buffer]])\n\n" "Marshal a janet value into a buffer and return the buffer. The buffer " "can the 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 janet value when " "unmarshalling.") }, { "unmarshal", cfun_unmarshal, JDOC("(unmarshal buffer [,lookup])\n\n" "Unmarshal a janet 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.") }, { "env-lookup", cfun_env_lookup, JDOC("(env-lookup env)\n\n" "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.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_marsh(JanetTable *env) { janet_core_cfuns(env, NULL, marsh_cfuns); } /* * Copyright (c) 2019 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. */ #include #ifndef JANET_AMALG #include #include "util.h" #endif /* Get a random number */ static Janet janet_rand(int32_t argc, Janet *argv) { (void) argv; janet_fixarity(argc, 0); double r = (rand() % RAND_MAX) / ((double) RAND_MAX); return janet_wrap_number(r); } /* Seed the random number generator */ static Janet janet_srand(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); int32_t x = janet_getinteger(argv, 0); srand((unsigned) x); return janet_wrap_nil(); } static Janet janet_remainder(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); double x = janet_getnumber(argv, 0); double y = janet_getnumber(argv, 1); return janet_wrap_number(fmod(x, y)); } #define JANET_DEFINE_MATHOP(name, fop)\ static Janet janet_##name(int32_t argc, Janet *argv) {\ janet_fixarity(argc, 1); \ double x = janet_getnumber(argv, 0); \ return janet_wrap_number(fop(x)); \ } JANET_DEFINE_MATHOP(acos, acos) JANET_DEFINE_MATHOP(asin, asin) JANET_DEFINE_MATHOP(atan, atan) JANET_DEFINE_MATHOP(cos, cos) JANET_DEFINE_MATHOP(cosh, cosh) JANET_DEFINE_MATHOP(sin, sin) JANET_DEFINE_MATHOP(sinh, sinh) JANET_DEFINE_MATHOP(tan, tan) JANET_DEFINE_MATHOP(tanh, tanh) JANET_DEFINE_MATHOP(exp, exp) JANET_DEFINE_MATHOP(log, log) JANET_DEFINE_MATHOP(log10, log10) JANET_DEFINE_MATHOP(sqrt, sqrt) JANET_DEFINE_MATHOP(ceil, ceil) JANET_DEFINE_MATHOP(fabs, fabs) JANET_DEFINE_MATHOP(floor, floor) #define JANET_DEFINE_MATH2OP(name, fop)\ static Janet janet_##name(int32_t argc, Janet *argv) {\ 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) JANET_DEFINE_MATH2OP(pow, pow) static Janet janet_not(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); return janet_wrap_boolean(!janet_truthy(argv[0])); } static const JanetReg math_cfuns[] = { { "%", janet_remainder, JDOC("(% dividend divisor)\n\n" "Returns the remainder of dividend / divisor.") }, { "not", janet_not, JDOC("(not x)\n\nReturns the boolean inverse of x.") }, { "math/random", janet_rand, JDOC("(math/random)\n\n" "Returns a uniformly distributed random number between 0 and 1.") }, { "math/seedrandom", janet_srand, JDOC("(math/seedrandom seed)\n\n" "Set the seed for the random number generator. 'seed' should be an " "an integer.") }, { "math/cos", janet_cos, JDOC("(math/cos x)\n\n" "Returns the cosine of x.") }, { "math/sin", janet_sin, JDOC("(math/sin x)\n\n" "Returns the sine of x.") }, { "math/tan", janet_tan, JDOC("(math/tan x)\n\n" "Returns the tangent of x.") }, { "math/acos", janet_acos, JDOC("(math/acos x)\n\n" "Returns the arccosine of x.") }, { "math/asin", janet_asin, JDOC("(math/asin x)\n\n" "Returns the arcsine of x.") }, { "math/atan", janet_atan, JDOC("(math/atan x)\n\n" "Returns the arctangent of x.") }, { "math/exp", janet_exp, JDOC("(math/exp x)\n\n" "Returns e to the power of x.") }, { "math/log", janet_log, JDOC("(math/log x)\n\n" "Returns log base 2 of x.") }, { "math/log10", janet_log10, JDOC("(math/log10 x)\n\n" "Returns log base 10 of x.") }, { "math/sqrt", janet_sqrt, JDOC("(math/sqrt x)\n\n" "Returns the square root of x.") }, { "math/floor", janet_floor, JDOC("(math/floor x)\n\n" "Returns the largest integer value number that is not greater than x.") }, { "math/ceil", janet_ceil, JDOC("(math/ceil x)\n\n" "Returns the smallest integer value number that is not less than x.") }, { "math/pow", janet_pow, JDOC("(math/pow a x)\n\n" "Return a to the power of x.") }, { "math/abs", janet_fabs, JDOC("(math/abs x)\n\n" "Return the absolute value of x.") }, { "math/sinh", janet_sinh, JDOC("(math/sinh x)\n\n" "Return the hyperbolic sine of x.") }, { "math/cosh", janet_cosh, JDOC("(math/cosh x)\n\n" "Return the hyperbolic cosine of x.") }, { "math/tanh", janet_tanh, JDOC("(math/tanh x)\n\n" "Return the hyperbolic tangent of x.") }, { "math/atan2", janet_atan2, JDOC("(math/atan2 y x)\n\n" "Return the arctangent of y/x. Works even when x is 0.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_math(JanetTable *env) { janet_core_cfuns(env, NULL, math_cfuns); #ifdef JANET_BOOTSTRAP janet_def(env, "math/pi", janet_wrap_number(3.1415926535897931), JDOC("The value pi.")); janet_def(env, "math/e", janet_wrap_number(2.7182818284590451), JDOC("The base of the natural log.")); janet_def(env, "math/inf", janet_wrap_number(INFINITY), JDOC("The number representing positive infinity")); #endif } /* * Copyright (c) 2019 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 #include "util.h" #endif #include #include #ifdef JANET_WINDOWS #include #include #else #include #include #include #include #endif /* For macos */ #ifdef __MACH__ #include #include #endif static Janet os_which(int32_t argc, Janet *argv) { janet_fixarity(argc, 0); (void) argv; #ifdef JANET_WINDOWS return janet_ckeywordv("windows"); #elif __APPLE__ return janet_ckeywordv("macos"); #elif defined(__EMSCRIPTEN__) return janet_ckeywordv("web"); #else return janet_ckeywordv("posix"); #endif } #ifdef JANET_WINDOWS static Janet os_execute(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); JanetBuffer *buffer = janet_buffer(10); for (int32_t i = 0; i < argc; i++) { const uint8_t *argstring = janet_getstring(argv, i); janet_buffer_push_bytes(buffer, argstring, janet_string_length(argstring)); if (i != argc - 1) { janet_buffer_push_u8(buffer, ' '); } } janet_buffer_push_u8(buffer, 0); /* Convert to wide chars */ wchar_t *sys_str = malloc(buffer->count * sizeof(wchar_t)); if (NULL == sys_str) { JANET_OUT_OF_MEMORY; } int nwritten = MultiByteToWideChar( CP_UTF8, MB_PRECOMPOSED, buffer->data, buffer->count, sys_str, buffer->count); if (nwritten == 0) { free(sys_str); janet_panic("could not create process"); } STARTUPINFO si; PROCESS_INFORMATION pi; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); ZeroMemory(&pi, sizeof(pi)); // Start the child process. if (!CreateProcess(NULL, (LPSTR) sys_str, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { free(sys_str); janet_panic("could not create process"); } free(sys_str); // Wait until child process exits. WaitForSingleObject(pi.hProcess, INFINITE); // Close process and thread handles. WORD status; GetExitCodeProcess(pi.hProcess, (LPDWORD)&status); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); return janet_wrap_integer(status); } #else static Janet os_execute(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); const uint8_t **child_argv = malloc(sizeof(uint8_t *) * (argc + 1)); if (NULL == child_argv) { JANET_OUT_OF_MEMORY; } for (int32_t i = 0; i < argc; i++) { child_argv[i] = janet_getstring(argv, i); } child_argv[argc] = NULL; /* Fork child process */ pid_t pid = fork(); if (pid < 0) { janet_panic("failed to execute"); } else if (pid == 0) { if (-1 == execve((const char *)child_argv[0], (char **)child_argv, NULL)) { exit(1); } } int status; waitpid(pid, &status, 0); return janet_wrap_integer(status); } #endif static Janet os_shell(int32_t argc, Janet *argv) { janet_arity(argc, 0, 1); const char *cmd = argc ? (const char *)janet_getstring(argv, 0) : NULL; int stat = system(cmd); return argc ? janet_wrap_integer(stat) : janet_wrap_boolean(stat); } static Janet os_getenv(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); const uint8_t *k = janet_getstring(argv, 0); const char *cstr = (const char *) k; const char *res = getenv(cstr); return (res && cstr) ? janet_cstringv(res) : janet_wrap_nil(); } static Janet os_setenv(int32_t argc, Janet *argv) { #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_arity(argc, 1, 2); const uint8_t *k = janet_getstring(argv, 0); const char *ks = (const char *) k; if (argc == 1 || janet_checktype(argv[1], JANET_NIL)) { UNSETENV(ks); } else { const uint8_t *v = janet_getstring(argv, 1); SETENV(ks, (const char *)v); } return janet_wrap_nil(); } static Janet os_exit(int32_t argc, Janet *argv) { janet_arity(argc, 0, 1); if (argc == 0) { exit(EXIT_SUCCESS); } else if (janet_checkint(argv[0])) { exit(janet_unwrap_integer(argv[0])); } else { exit(EXIT_FAILURE); } return janet_wrap_nil(); } static Janet os_time(int32_t argc, Janet *argv) { janet_fixarity(argc, 0); (void) argv; double dtime = (double)(time(NULL)); return janet_wrap_number(dtime); } /* Clock shims */ #ifdef JANET_WINDOWS static int gettime(struct timespec *spec) { int64_t wintime = 0LL; GetSystemTimeAsFileTime((FILETIME *)&wintime); /* Windows epoch is January 1, 1601 apparently*/ wintime -= 116444736000000000LL; spec->tv_sec = wintime / 10000000LL; /* Resolution is 100 nanoseconds. */ spec->tv_nsec = wintime % 10000000LL * 100; return 0; } #elif defined(__MACH__) static int gettime(struct timespec *spec) { 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; return 0; } #else #define gettime(TV) clock_gettime(CLOCK_MONOTONIC, (TV)) #endif static Janet os_clock(int32_t argc, Janet *argv) { janet_fixarity(argc, 0); (void) argv; struct timespec tv; if (gettime(&tv)) janet_panic("could not get time"); double dtime = tv.tv_sec + (tv.tv_nsec / 1E9); return janet_wrap_number(dtime); } static Janet os_sleep(int32_t argc, Janet *argv) { 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 struct timespec ts; ts.tv_sec = (time_t) delay; ts.tv_nsec = (delay <= UINT32_MAX) ? (long)((delay - ((uint32_t)delay)) * 1000000000) : 0; nanosleep(&ts, NULL); #endif return janet_wrap_nil(); } static Janet os_cwd(int32_t argc, Janet *argv) { 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); } static Janet os_date(int32_t argc, Janet *argv) { janet_arity(argc, 0, 1); (void) argv; time_t t; struct tm *t_info; if (argc) { t = (time_t) janet_getinteger64(argv, 0); } else { time(&t); } t_info = localtime(&t); 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)); } static const JanetReg os_cfuns[] = { { "os/which", os_which, JDOC("(os/which)\n\n" "Check the current operating system. Returns one of:\n\n" "\t:windows - Microsoft Windows\n" "\t:macos - Apple macos\n" "\t:posix - A POSIX compatible system (default)") }, { "os/execute", os_execute, JDOC("(os/execute program & args)\n\n" "Execute a program on the system and pass it string arguments. Returns " "the exit status of the program.") }, { "os/shell", os_shell, JDOC("(os/shell str)\n\n" "Pass a command string str directly to the system shell.") }, { "os/exit", os_exit, JDOC("(os/exit x)\n\n" "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.") }, { "os/getenv", os_getenv, JDOC("(os/getenv variable)\n\n" "Get the string value of an environment variable.") }, { "os/setenv", os_setenv, JDOC("(os/setenv variable value)\n\n" "Set an environment variable.") }, { "os/time", os_time, JDOC("(os/time)\n\n" "Get the current time expressed as the number of seconds since " "January 1, 1970, the Unix epoch. Returns a real number.") }, { "os/clock", os_clock, JDOC("(os/clock)\n\n" "Return the number of seconds since some fixed point in time. The clock " "is guaranteed to be non decreasing in real time.") }, { "os/sleep", os_sleep, JDOC("(os/sleep nsec)\n\n" "Suspend the program for nsec seconds. 'nsec' can be a real number. Returns " "nil.") }, { "os/cwd", os_cwd, JDOC("(os/cwd)\n\n" "Returns the current working directory.") }, { "os/date", os_date, JDOC("(os/date [,time])\n\n" "Returns the given time as a date struct, or the current time if no time is given. " "Returns a struct with following key values. Note that all numbers are 0-indexed.\n\n" "\t:seconds - number of seconds [0-61]\n" "\t:minutes - number of minutes [0-59]\n" "\t:seconds - number of hours [0-23]\n" "\t:month-day - day of month [0-30]\n" "\t:month - month of year [0, 11]\n" "\t:year - years since year 0 (e.g. 2019)\n" "\t:week-day - day of the week [0-6]\n" "\t:year-day - day of the year [0-365]\n" "\t:dst - If Day Light Savings is in effect") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_os(JanetTable *env) { janet_core_cfuns(env, NULL, os_cfuns); } /* * Copyright (c) 2019 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 #include "util.h" #endif /* Check if a character is whitespace */ static int is_whitespace(uint8_t c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\0' || c == '\f'; } /* Code generated by tools/symcharsgen.c. * The table contains 256 bits, where each bit is 1 * if the corresponding ascci 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, 0x17fffffe, 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 !$&*+-./:<=>@\^_~| */ static int is_symbol_char(uint8_t c) { return symchars[c >> 5] & (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). */ static int 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 start; 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 = 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 static void pushstate(JanetParser *p, Consumer consumer, int flags) { JanetParseState s; s.counter = 0; s.argn = 0; s.flags = flags; s.consumer = consumer; s.start = p->offset; _pushstate(p, s); } static void popstate(JanetParser *p, Janet val) { for (;;) { JanetParseState top = p->states[--p->statecount]; JanetParseState *newtop = p->states + p->statecount - 1; if (newtop->flags & PFLAG_CONTAINER) { /* Source mapping info */ if (janet_checktype(val, JANET_TUPLE)) { janet_tuple_sm_start(janet_unwrap_tuple(val)) = (int32_t) top.start; janet_tuple_sm_end(janet_unwrap_tuple(val)) = (int32_t) p->offset; } newtop->argn++; /* Keep track of number of values in the root state */ if (p->statecount == 1) p->pending++; 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 == '~') ? "quasiquote" : ""; t[0] = janet_csymbolv(which); t[1] = val; /* Quote source mapping info */ janet_tuple_sm_start(t) = (int32_t) newtop->start; janet_tuple_sm_end(t) = (int32_t) p->offset; val = janet_wrap_tuple(janet_tuple_end(t)); } else { return; } } } static int checkescape(uint8_t c) { switch (c) { default: return -1; case 'x': 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 'e': return 27; case '"': return '"'; case '\\': return '\\'; } } /* Forward declare */ static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c); 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, (state->argn & 0xFF)); 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 { push_buf(p, (uint8_t) e); state->consumer = stringchar; } return 1; } static int stringend(JanetParser *p, JanetParseState *state) { Janet ret; if (state->flags & PFLAG_BUFFER) { JanetBuffer *b = janet_buffer((int32_t)p->bufcount); janet_buffer_push_bytes(b, p->buf, (int32_t)p->bufcount); ret = janet_wrap_buffer(b); } else { ret = janet_wrap_string(janet_string(p->buf, (int32_t)p->bufcount)); } 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') 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 (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] == ':') { 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 (p->buf) { 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) || valid_utf8(p->buf, blen); if (!valid) { p->error = "invalid utf-8 in symbol"; return 0; } ret = janet_symbolv(p->buf, blen); } } else { p->error = "empty symbol invalid"; return 0; } 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--; 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 (int32_t i = state->argn; i > 0; i -= 2) { Janet value = p->args[--p->argcount]; Janet key = p->args[--p->argcount]; janet_struct_put(st, key, value); } return janet_wrap_struct(janet_struct_end(st)); } static Janet close_table(JanetParser *p, JanetParseState *state) { JanetTable *table = janet_table(state->argn >> 1); for (int32_t i = state->argn; i > 0; i -= 2) { Janet value = p->args[--p->argcount]; Janet key = p->args[--p->argcount]; janet_table_put(table, key, value); } 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 ampersand(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, 0); push_buf(p, '@'); /* Push the leading ampersand 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 (!is_symbol_char(c)) { p->error = "unexpected character"; return 1; } pushstate(p, tokenchar, 0); return 0; case '\'': case ',': case ';': case '~': pushstate(p, root, PFLAG_READERMAC | c); return 1; case '"': pushstate(p, stringchar, PFLAG_STRING); return 1; case '#': pushstate(p, comment, 0); return 1; case '@': pushstate(p, ampersand, 0); return 1; case '`': pushstate(p, longstring, PFLAG_LONGSTRING); return 1; case ')': case ']': case '}': { Janet ds; if (p->statecount == 1) { p->error = "unexpected 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 { p->error = "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; } } int janet_parser_consume(JanetParser *parser, uint8_t c) { int consumed = 0; if (parser->error) return 0; parser->offset++; while (!consumed && !parser->error) { JanetParseState *state = parser->states + parser->statecount - 1; consumed = state->consumer(parser, state, c); } parser->lookback = c; return 1; } enum JanetParserStatus janet_parser_status(JanetParser *parser) { if (parser->error) return JANET_PARSE_ERROR; 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; 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 = parser->args[0]; for (i = 1; i < parser->argcount; i++) { parser->args[i - 1] = parser->args[i]; } parser->pending--; parser->argcount--; 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->offset = 0; parser->pending = 0; pushstate(parser, root, PFLAG_CONTAINER); } void janet_parser_deinit(JanetParser *parser) { free(parser->args); free(parser->buf); free(parser->states); } /* 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]); } return 0; } static int parsergc(void *p, size_t size) { JanetParser *parser = (JanetParser *)p; (void) size; janet_parser_deinit(parser); return 0; } static Janet parserget(void *p, Janet key); static JanetAbstractType janet_parse_parsertype = { "core/parser", parsergc, parsermark, parserget, NULL }; /* C Function parser */ static Janet cfun_parse_parser(int32_t argc, Janet *argv) { (void) argv; janet_fixarity(argc, 0); JanetParser *p = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser)); janet_parser_init(p); return janet_wrap_abstract(p); } static Janet cfun_parse_consume(int32_t argc, Janet *argv) { janet_arity(argc, 2, 3); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); 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); } static Janet cfun_parse_insert(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParseState *s = p->states + p->statecount - 1; if (s->consumer == tokenchar) { janet_parser_consume(p, ' '); p->offset--; s = p->states + p->statecount - 1; } if (s->flags & PFLAG_CONTAINER) { s->argn++; if (p->statecount == 1) p->pending++; 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 > p->bufcount + slen) { size_t newcap = 2 * newcount; p->buf = realloc(p->buf, newcap); if (p->buf == NULL) { JANET_OUT_OF_MEMORY; } p->bufcap = newcap; } memcpy(p->buf + p->bufcount, str, slen); p->bufcount = newcount; } else { janet_panic("cannot insert value into parser"); } return argv[0]; } static Janet cfun_parse_has_more(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); return janet_wrap_boolean(janet_parser_has_more(p)); } static Janet cfun_parse_byte(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); int32_t i = janet_getinteger(argv, 1); janet_parser_consume(p, 0xFF & i); return argv[0]; } static Janet cfun_parse_status(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); 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; } return janet_ckeywordv(stat); } static Janet cfun_parse_error(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); const char *err = janet_parser_error(p); if (err) return janet_cstringv(err); return janet_wrap_nil(); } static Janet cfun_parse_produce(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); return janet_parser_produce(p); } static Janet cfun_parse_flush(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); janet_parser_flush(p); return argv[0]; } static Janet cfun_parse_where(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); return janet_wrap_integer(p->offset); } static Janet cfun_parse_state(int32_t argc, Janet *argv) { size_t i; const uint8_t *str; size_t oldcount; janet_fixarity(argc, 1); JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); 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, '`'); } } } str = janet_string(p->buf + oldcount, (int32_t)(p->bufcount - oldcount)); p->bufcount = oldcount; return janet_wrap_string(str); } static const JanetMethod parser_methods[] = { {"byte", cfun_parse_byte}, {"consume", cfun_parse_consume}, {"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 Janet parserget(void *p, Janet key) { (void) p; if (!janet_checktype(key, JANET_KEYWORD)) janet_panicf("expected keyword method"); return janet_getmethod(janet_unwrap_keyword(key), parser_methods); } static const JanetReg parse_cfuns[] = { { "parser/new", cfun_parse_parser, JDOC("(parser/new)\n\n" "Creates and returns a new parser object. Parsers are state machines " "that can receive bytes, and generate a stream of janet values. ") }, { "parser/has-more", cfun_parse_has_more, JDOC("(parser/has-more parser)\n\n" "Check if the parser has more values in the value queue.") }, { "parser/produce", cfun_parse_produce, JDOC("(parser/produce parser)\n\n" "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.") }, { "parser/consume", cfun_parse_consume, JDOC("(parser/consume parser bytes [, index])\n\n" "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.") }, { "parser/byte", cfun_parse_byte, JDOC("(parser/byte parser b)\n\n" "Input a single byte into the parser byte stream. Returns the parser.") }, { "parser/error", cfun_parse_error, JDOC("(parser/error parser)\n\n" "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.") }, { "parser/status", cfun_parse_status, JDOC("(parser/status parser)\n\n" "Gets the current status of the parser state machine. The status will " "be one of:\n\n" "\t:pending - a value is being parsed.\n" "\t:error - a parsing error was encountered.\n" "\t:root - the parser can either read more values or safely terminate.") }, { "parser/flush", cfun_parse_flush, JDOC("(parser/flush parser)\n\n" "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.") }, { "parser/state", cfun_parse_state, JDOC("(parser/state parser)\n\n" "Returns a string representation of the internal state of the parser. " "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.") }, { "parser/where", cfun_parse_where, JDOC("(parser/where parser)\n\n" "Returns the current line number and column number of the parser's location " "in the byte stream as a tuple (line, column). Lines and columns are counted from " "1, (the first byte is line 1, column 1) and a newline is considered ASCII 0x0A.") }, { "parser/insert", cfun_parse_insert, JDOC("(parser/insert parser value)\n\n" "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.") }, {NULL, NULL, NULL} }; /* Load the library */ void janet_lib_parse(JanetTable *env) { janet_core_cfuns(env, NULL, parse_cfuns); } /* * Copyright (c) 2019 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 #include #include "util.h" #include "vector.h" #include "util.h" #endif #ifdef JANET_PEG /* * Runtime */ /* 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] */ } Opcode; /* Hold captured patterns and match state */ typedef struct { const uint8_t *text_start; const uint8_t *text_end; const uint32_t *bytecode; const Janet *constants; JanetArray *captures; JanetBuffer *scratch; JanetBuffer *tags; const Janet *extrav; int32_t extrac; int32_t depth; enum { PEG_MODE_NORMAL, PEG_MODE_ACCUMULATE, PEG_MODE_NOCAPTURE } 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 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; 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.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 || (tag && s->mode == PEG_MODE_ACCUMULATE)) { janet_array_push(s->captures, capture); janet_buffer_push_u8(s->tags, tag); } } /* 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. If s->mode was PEG_MODE_NOCAPTURE, captures MUST * not be changed, though. */ static const uint8_t *peg_rule( PegState *s, const uint32_t *rule, const uint8_t *text) { tail: switch (*rule & 0x1F) { 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: { uint32_t word = rule[1 + (text[0] >> 5)]; uint32_t mask = (uint32_t)1 << (text[0] & 0x1F); return (text < s->text_end && (word & mask)) ? text + 1 : NULL; } case RULE_LOOK: { text += ((int32_t *)rule)[1]; if (text < s->text_start || text > s->text_end) return NULL; int oldmode = s->mode; s->mode = PEG_MODE_NOCAPTURE; down1(s); const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text); up1(s); s->mode = oldmode; 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: case RULE_IFNOT: { const uint32_t *rule_a = s->bytecode + rule[1]; const uint32_t *rule_b = s->bytecode + rule[2]; int oldmode = s->mode; s->mode = PEG_MODE_NOCAPTURE; down1(s); const uint8_t *result = peg_rule(s, rule_a, text); up1(s); s->mode = oldmode; if (rule[0] == RULE_IF ? !result : !!result) return NULL; rule = rule_b; goto tail; } case RULE_NOT: { const uint32_t *rule_a = s->bytecode + rule[1]; int oldmode = s->mode; s->mode = PEG_MODE_NOCAPTURE; down1(s); const uint8_t *result = peg_rule(s, rule_a, text); up1(s); s->mode = oldmode; return (result) ? NULL : 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->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_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: { uint32_t tag = rule[2]; if (!tag && s->mode == PEG_MODE_NOCAPTURE) { rule = s->bytecode + rule[1]; goto tail; } 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 (!tag && s->mode == PEG_MODE_ACCUMULATE) { janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text)); } else { pushcap(s, janet_stringv(text, (int32_t)(result - text)), tag); } return result; } case RULE_ACCUMULATE: { uint32_t tag = rule[2]; int oldmode = s->mode; /* No capture mode, skip captures. Accumulate inside accumulate also does nothing. */ if (!tag && oldmode != PEG_MODE_NORMAL) { 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(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; if (!tag && oldmode == PEG_MODE_NOCAPTURE) { rule = s->bytecode + rule[1]; goto tail; } 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); memcpy(sub_captures->data, s->captures->data + cs.cap, sizeof(Janet) * num_sub_captures); sub_captures->count = num_sub_captures; cap_load(s, cs); pushcap(s, janet_wrap_array(sub_captures), tag); return result; } case RULE_REPLACE: case RULE_MATCHTIME: { uint32_t tag = rule[3]; int oldmode = s->mode; if (!tag && rule[0] == RULE_REPLACE && oldmode == PEG_MODE_NOCAPTURE) { rule = s->bytecode + rule[1]; goto tail; } 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 constant = s->constants[rule[2]]; switch (janet_type(constant)) { default: cap = constant; break; case JANET_STRUCT: cap = janet_struct_get(janet_unwrap_struct(constant), s->captures->data[s->captures->count - 1]); break; case JANET_TABLE: 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(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); int32_t end = (int32_t)(result - s->text_start); janet_panicf("match error in range (%d:%d)", start, end); } return NULL; } } } /* * Compilation */ typedef struct { JanetTable *grammar; JanetTable *memoized; JanetTable *tags; Janet *constants; uint32_t *bytecode; Janet form; int depth; uint32_t nexttag; } 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); } 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_panicf(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_panicf(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_panicf(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_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); } /* 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) { spec_onerule(b, argc, argv, RULE_ERROR); } 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_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; emit_2(r, RULE_GETTAG, search, tag); } static void spec_position(Builder *b, int32_t argc, const Janet *argv) { 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, RULE_POSITION, tag); } 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|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); } /* 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}, {"backref", spec_reference}, {"between", spec_between}, {"capture", spec_capture}, {"choice", spec_choice}, {"cmt", spec_matchtime}, {"constant", spec_constant}, {"drop", spec_drop}, {"error", spec_error}, {"group", spec_group}, {"if", spec_if}, {"if-not", spec_ifnot}, {"look", spec_look}, {"not", spec_not}, {"opt", spec_opt}, {"position", spec_position}, {"quote", spec_capture}, {"range", spec_range}, {"replace", spec_replace}, {"sequence", spec_sequence}, {"set", spec_set}, {"some", spec_some}, }; /* Compile a janet value into a rule and return the rule index. */ static uint32_t peg_compile1(Builder *b, Janet peg) { /* Check for already compiled rules */ Janet check = janet_table_get(b->memoized, peg); if (!janet_checktype(check, JANET_NIL)) { uint32_t rule = (uint32_t) janet_unwrap_number(check); return rule; } /* Keep track of the form being compiled for error purposes */ Janet old_form = b->form; b->form = peg; /* 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); if (!janet_checktype(peg, JANET_KEYWORD) && !janet_checktype(peg, JANET_STRUCT)) { janet_table_put(b->memoized, peg, janet_wrap_number(rule)); } switch (janet_type(peg)) { default: peg_panicf(b, "unexpected peg source"); return 0; 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_KEYWORD: { Janet check = janet_table_get(b->grammar, peg); if (janet_checktype(check, JANET_NIL)) peg_panicf(b, "unknown rule"); rule = peg_compile1(b, check); break; } case JANET_STRUCT: { JanetTable *grammar = janet_struct_to_table(janet_unwrap_struct(peg)); grammar->proto = b->grammar; b->grammar = grammar; Janet main_rule = janet_table_get(grammar, janet_ckeywordv("main")); if (janet_checktype(main_rule, JANET_NIL)) peg_panicf(b, "grammar requires :main rule"); rule = peg_compile1(b, main_rule); b->grammar = grammar->proto; 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_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) peg_panicf(b, "unknown special %S", sym); sp->special(b, len - 1, tup + 1); break; } } /* Increase depth again */ b->depth++; b->form = old_form; return rule; } /* * Post-Compilation */ typedef struct { uint32_t *bytecode; Janet *constants; uint32_t num_constants; } Peg; static int peg_mark(void *p, size_t size) { (void) size; Peg *peg = (Peg *)p; for (uint32_t i = 0; i < peg->num_constants; i++) janet_mark(peg->constants[i]); return 0; } static JanetAbstractType peg_type = { "core/peg", NULL, peg_mark, NULL, NULL }; /* Convert Builder to Peg (Janet Abstract Value) */ static Peg *make_peg(Builder *b) { size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t); size_t constants_size = janet_v_count(b->constants) * sizeof(Janet); size_t total_size = bytecode_size + constants_size + sizeof(Peg); char *mem = janet_abstract(&peg_type, total_size); Peg *peg = (Peg *)mem; peg->bytecode = (uint32_t *)(mem + sizeof(Peg)); peg->constants = (Janet *)(mem + sizeof(Peg) + bytecode_size); peg->num_constants = janet_v_count(b->constants); memcpy(peg->bytecode, b->bytecode, bytecode_size); memcpy(peg->constants, b->constants, constants_size); return peg; } /* Compiler entry point */ static Peg *compile_peg(Janet x) { Builder builder; builder.grammar = janet_table(0); builder.memoized = janet_table(0); builder.tags = janet_table(0); builder.constants = NULL; builder.bytecode = NULL; builder.nexttag = 1; builder.form = x; builder.depth = JANET_RECURSION_GUARD; peg_compile1(&builder, x); Peg *peg = make_peg(&builder); builder_cleanup(&builder); return peg; } /* * C Functions */ static Janet cfun_peg_compile(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); Peg *peg = compile_peg(argv[0]); return janet_wrap_abstract(peg); } static Janet cfun_peg_match(int32_t argc, Janet *argv) { janet_arity(argc, 2, -1); Peg *peg; if (janet_checktype(argv[0], JANET_ABSTRACT) && janet_abstract_type(janet_unwrap_abstract(argv[0])) == &peg_type) { peg = janet_unwrap_abstract(argv[0]); } else { peg = compile_peg(argv[0]); } JanetByteView bytes = janet_getbytes(argv, 1); int32_t start; PegState s; if (argc > 2) { start = janet_gethalfrange(argv, 2, bytes.len, "offset"); s.extrac = argc - 3; s.extrav = argv + 3; } else { start = 0; s.extrac = 0; s.extrav = NULL; } s.mode = PEG_MODE_NORMAL; s.text_start = bytes.bytes; s.text_end = bytes.bytes + bytes.len; s.depth = JANET_RECURSION_GUARD; s.captures = janet_array(0); s.scratch = janet_buffer(10); s.tags = janet_buffer(10); s.constants = peg->constants; s.bytecode = peg->bytecode; const uint8_t *result = peg_rule(&s, s.bytecode, bytes.bytes + start); return result ? janet_wrap_array(s.captures) : janet_wrap_nil(); } static const JanetReg peg_cfuns[] = { { "peg/compile", cfun_peg_compile, JDOC("(peg/compile peg)\n\n" "Compiles a peg source data structure into a . This will speed up matching " "if the same peg will be used multiple times.") }, { "peg/match", cfun_peg_match, JDOC("(peg/match peg text [,start=0])\n\n" "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 are very " "similar to those defined by LPeg, and have similar capabilities.") }, {NULL, NULL, NULL} }; /* Load the peg module */ void janet_lib_peg(JanetTable *env) { janet_core_cfuns(env, NULL, peg_cfuns); } #endif /* ifdef JANET_PEG */ /* * Copyright (c) 2019 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. */ #include #include #ifndef JANET_AMALG #include #include "util.h" #include "state.h" #endif /* Implements a pretty printer for Janet. The pretty printer * is farily simple and not that flexible, but fast. */ /* Temporary buffer size */ #define BUFSIZE 64 static void number_to_string_b(JanetBuffer *buffer, double x) { janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); int count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, "%g", 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; title[i] && i < 32; ++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 } #undef HEX #undef BUFSIZE 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 '\\': janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); break; default: if (c < 32 || c > 127) { 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) { janet_buffer_push_u8(buffer, '@'); janet_escape_string_impl(buffer, bx->data, bx->count); } void janet_description_b(JanetBuffer *buffer, Janet x) { switch (janet_type(x)) { case JANET_NIL: janet_buffer_push_cstring(buffer, "nil"); return; case JANET_TRUE: janet_buffer_push_cstring(buffer, "true"); return; case JANET_FALSE: janet_buffer_push_cstring(buffer, "false"); return; case JANET_NUMBER: number_to_string_b(buffer, janet_unwrap_number(x)); return; case JANET_KEYWORD: janet_buffer_push_u8(buffer, ':'); /* fallthrough */ case JANET_SYMBOL: janet_buffer_push_bytes(buffer, janet_unwrap_string(x), janet_string_length(janet_unwrap_string(x))); return; case JANET_STRING: janet_escape_string_b(buffer, janet_unwrap_string(x)); return; case JANET_BUFFER: janet_escape_buffer_b(buffer, janet_unwrap_buffer(x)); return; case JANET_ABSTRACT: { const char *n = janet_abstract_type(janet_unwrap_abstract(x))->name; string_description_b(buffer, n, janet_unwrap_abstract(x)); return; } case JANET_CFUNCTION: { Janet check = janet_table_get(janet_vm_registry, x); if (janet_checktype(check, JANET_SYMBOL)) { janet_buffer_push_cstring(buffer, "'); break; } goto fallthrough; } case JANET_FUNCTION: { JanetFunction *fun = janet_unwrap_function(x); JanetFuncDef *def = fun->def; 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; } } void janet_to_string_b(JanetBuffer *buffer, Janet x) { switch (janet_type(x)) { default: janet_description_b(buffer, x); break; case JANET_BUFFER: janet_buffer_push_bytes(buffer, janet_unwrap_buffer(x)->data, janet_unwrap_buffer(x)->count); 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; } } 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; JanetTable seen; }; static void print_newline(struct pretty *S, int just_a_space) { int i; if (just_a_space) { 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, ' '); } } /* 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_TRUE: case JANET_FALSE: break; default: { Janet seenid = janet_table_get(&S->seen, x); if (janet_checktype(seenid, JANET_NUMBER)) { janet_buffer_push_cstring(S->buffer, "buffer, janet_unwrap_integer(seenid)); janet_buffer_push_u8(S->buffer, '>'); return; } else { janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count)); break; } } } switch (janet_type(x)) { default: janet_description_b(S->buffer, x); break; case JANET_ARRAY: case JANET_TUPLE: { int32_t i, len; const Janet *arr; 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 && len >= 5) janet_buffer_push_u8(S->buffer, ' '); if (is_dict_value && len >= 5) print_newline(S, 0); for (i = 0; i < len; i++) { if (i) print_newline(S, len < 5); 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); janet_buffer_push_cstring(S->buffer, istable ? "@" : "{"); /* For object-like tables, print class name */ if (istable) { JanetTable *t = janet_unwrap_table(x); JanetTable *proto = t->proto; if (NULL != proto) { Janet name = janet_table_get(proto, janet_csymbolv(":name")); if (janet_checktype(name, JANET_SYMBOL)) { const uint8_t *sym = janet_unwrap_symbol(name); janet_buffer_push_bytes(S->buffer, sym, janet_string_length(sym)); } } 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, len, cap; int first_kv_pair = 1; const JanetKV *kvs; janet_dictionary_view(x, &kvs, &len, &cap); if (!istable && len >= 4) janet_buffer_push_u8(S->buffer, ' '); if (is_dict_value && len >= 5) print_newline(S, 0); for (i = 0; i < cap; i++) { if (!janet_checktype(kvs[i].key, JANET_NIL)) { if (first_kv_pair) { first_kv_pair = 0; } else { print_newline(S, len < 4); } janet_pretty_one(S, kvs[i].key, 0); janet_buffer_push_u8(S->buffer, ' '); janet_pretty_one(S, kvs[i].value, 1); } } } S->indent -= 2; S->depth++; janet_buffer_push_u8(S->buffer, '}'); break; } } /* Remove from seen */ janet_table_remove(&S->seen, x); return; } /* 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, Janet x) { struct pretty S; if (NULL == buffer) { buffer = janet_buffer(0); } S.buffer = buffer; S.depth = depth; S.indent = 0; janet_table_init(&S.seen, 10); janet_pretty_one(&S, x, 0); janet_table_deinit(&S.seen); return S.buffer; } 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_u8(buffer, '|'); } janet_buffer_push_cstring(buffer, janet_type_names[i]); } i++; types >>= 1; } } /* 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; int32_t len = 0; int32_t i; const uint8_t *ret; JanetBuffer buffer; JanetBuffer *bufp = &buffer; /* Calculate length */ while (format[len]) len++; /* Initialize buffer */ janet_buffer_init(bufp, len); /* Start args */ va_start(args, format); /* Iterate length */ for (i = 0; i < len; i++) { uint8_t c = format[i]; switch (c) { default: janet_buffer_push_u8(bufp, c); break; case '%': { if (i + 1 >= len) break; switch (format[++i]) { default: janet_buffer_push_u8(bufp, format[i]); break; case 'f': number_to_string_b(bufp, va_arg(args, double)); break; case 'd': integer_to_string_b(bufp, va_arg(args, long)); break; case 'S': { const uint8_t *str = va_arg(args, const uint8_t *); janet_buffer_push_bytes(bufp, str, janet_string_length(str)); break; } case 's': janet_buffer_push_cstring(bufp, va_arg(args, const char *)); break; case 'c': janet_buffer_push_u8(bufp, (uint8_t) va_arg(args, long)); break; case 'q': { const uint8_t *str = va_arg(args, const uint8_t *); janet_escape_string_b(bufp, str); break; } case 't': { janet_buffer_push_cstring(bufp, typestr(va_arg(args, Janet))); break; } case 'T': { int types = va_arg(args, long); pushtypes(bufp, types); break; } case 'V': { janet_to_string_b(bufp, va_arg(args, Janet)); break; } case 'v': { janet_description_b(bufp, va_arg(args, Janet)); break; } case 'p': { janet_pretty(bufp, 4, va_arg(args, Janet)); } } } } } va_end(args); ret = janet_string(buffer.data, buffer.count); janet_buffer_deinit(&buffer); return ret; } /* * code adapted from lua/lstrlib.c http://lua.org */ #define MAX_ITEM 256 #define FMT_FLAGS "-+ #0" #define MAX_FORMAT 32 static const char *scanformat( const char *strfrmt, char *form, char width[3], char precision[3]) { const char *p = 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) / sizeof(char)) 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)"); *(form++) = '%'; memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char)); form += (p - strfrmt) + 1; *form = '\0'; return p; } /* 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; 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 'o': case 'u': case 'x': case 'X': { int32_t n = janet_getinteger(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': { const uint8_t *s = janet_getstring(argv, arg); size_t l = janet_string_length(s); if (form[2] == '\0') janet_buffer_push_bytes(b, s, l); else { if (l != 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 'p': { /* janet pretty , precision = depth */ int depth = atoi(precision); if (depth < 1) depth = 4; janet_pretty(b, depth, argv[arg]); break; } default: { /* also treat cases 'nLlh' */ janet_panicf("invalid conversion '%s' to 'format'", form); } } if (nb >= MAX_ITEM) janet_panicf("format buffer overflow", form); if (nb > 0) janet_buffer_push_bytes(b, (uint8_t *) item, nb); } } } /* * Copyright (c) 2019 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 #include "regalloc.h" #endif 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) { 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) * dest->capacity; dest->chunks = malloc(size); dest->regtemps = 0; if (!dest->chunks) { JANET_OUT_OF_MEMORY; } memcpy(dest->chunks, src->chunks, size); } /* 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 = realloc(ra->chunks, 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); } /* 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); } /* * Copyright (c) 2019 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 #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; int32_t index = 0; int dudeol = 0; int done = 0; Janet ret = janet_wrap_nil(); 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 (!errflags && !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); JanetFiber *fiber = janet_fiber(f, 64, 0, NULL); JanetSignal status = janet_continue(fiber, janet_wrap_nil(), &ret); if (status != JANET_SIGNAL_OK) { janet_stacktrace(fiber, ret); errflags |= 0x01; } } else { fprintf(stderr, "compile error in %s: %s\n", sourcePath, (const char *)cres.error); errflags |= 0x02; } } /* Dispatch based on parse state */ switch (janet_parser_status(&parser)) { case JANET_PARSE_ERROR: errflags |= 0x04; fprintf(stderr, "parse error in %s: %s\n", sourcePath, janet_parser_error(&parser)); break; case JANET_PARSE_PENDING: if (index >= len) { if (dudeol) { errflags |= 0x04; fprintf(stderr, "internal parse error in %s: unexpected end of source\n", sourcePath); } else { dudeol = 1; janet_parser_consume(&parser, '\n'); } } else { janet_parser_consume(&parser, bytes[index++]); } break; case JANET_PARSE_ROOT: if (index >= len) { done = 1; } else { janet_parser_consume(&parser, bytes[index++]); } break; } } janet_parser_deinit(&parser); if (where) janet_gcunroot(janet_wrap_string(where)); 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); } /* * Copyright (c) 2019 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 #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"); 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 (argn != 1) { janetc_cerror(opts.compiler, "expected 1 argument"); 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) { JanetSlot *slots = NULL; 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")) return janetc_value(janetc_fopts_default(opts.compiler), tup[1]); } for (i = 0; i < len; i++) janet_v_push(slots, quasiquote(opts, tup[i])); return qq_slots(opts, slots, 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(opts, array->data[i])); return qq_slots(opts, slots, JOP_MAKE_ARRAY); } case JANET_TABLE: case JANET_STRUCT: { const JanetKV *kv = NULL, *kvs = NULL; int32_t len, cap; janet_dictionary_view(x, &kvs, &len, &cap); while ((kv = janet_dictionary_next(kvs, cap, kv))) { JanetSlot key = quasiquote(opts, kv->key); JanetSlot value = quasiquote(opts, kv->value); 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"); return janetc_cslot(janet_wrap_nil()); } return quasiquote(opts, argv[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()); } /* Preform 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_cerror(c, "unexpected type in destructuring"); 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 i, len; const Janet *values; janet_indexed_view(left, &values, &len); for (i = 0; i < len; i++) { JanetSlot nextright = janetc_farslot(c); Janet subval = values[i]; 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_GET, 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 i, cap, len; janet_dictionary_view(left, &kvs, &len, &cap); for (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_GET, 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] = janet_wrap_string(c->source); tup[1] = janet_wrap_integer(c->current_mapping.start); tup[2] = janet_wrap_integer(c->current_mapping.end); 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"); 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, int32_t argn, const Janet *argv) { int32_t i; JanetTable *tab = janet_table(2); for (i = 1; i < argn - 1; i++) { Janet attr = argv[i]; switch (janet_type(attr)) { default: janetc_cerror(c, "could not add metadata to binding"); 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; } } return tab; } static JanetSlot dohead(JanetCompiler *c, JanetFopts opts, Janet *head, int32_t argn, const Janet *argv) { JanetFopts subopts = janetc_fopts_default(c); JanetSlot ret; if (argn < 2) { janetc_cerror(c, "expected at least 2 arguments"); return janetc_cslot(janet_wrap_nil()); } *head = argv[0]; subopts.flags = opts.flags & ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); subopts.hint = opts.hint; ret = janetc_value(subopts, argv[argn - 1]); return ret; } /* 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; 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 *attr) { if (c->scope->flags & JANET_SCOPE_TOP) { /* Global var, generate var */ JanetSlot refslot; JanetTable *reftab = janet_table(1); reftab->proto = attr; JanetArray *ref = janet_array(1); janet_array_push(ref, janet_wrap_nil()); janet_table_put(reftab, janet_ckeywordv("ref"), janet_wrap_array(ref)); janet_table_put(reftab, janet_ckeywordv("source-map"), janet_wrap_tuple(janetc_make_sourcemap(c))); janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(reftab)); 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; Janet head; JanetSlot ret = dohead(c, opts, &head, argn, argv); if (c->result.status == JANET_COMPILE_ERROR) return janetc_cslot(janet_wrap_nil()); destructure(c, argv[0], ret, varleaf, handleattr(c, argn, argv)); return ret; } static int defleaf( JanetCompiler *c, const uint8_t *sym, JanetSlot s, JanetTable *attr) { if (c->scope->flags & JANET_SCOPE_TOP) { JanetTable *tab = janet_table(2); janet_table_put(tab, janet_ckeywordv("source-map"), janet_wrap_tuple(janetc_make_sourcemap(c))); tab->proto = attr; JanetSlot valsym = janetc_cslot(janet_ckeywordv("value")); JanetSlot tabslot = janetc_cslot(janet_wrap_table(tab)); /* Add env entry to env */ janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(tab)); /* Put value in table when evaulated */ janetc_emit_sss(c, JOP_PUT, tabslot, valsym, s, 0); return 1; } else { return namelocal(c, sym, 0, s); } } static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) { JanetCompiler *c = opts.compiler; Janet head; opts.flags &= ~JANET_FOPTS_HINT; JanetSlot ret = dohead(c, opts, &head, argn, argv); if (c->result.status == JANET_COMPILE_ERROR) return janetc_cslot(janet_wrap_nil()); destructure(c, argv[0], ret, defleaf, handleattr(c, argn, argv)); return ret; } /* * :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; 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; /* Set target for compilation */ target = (drop || tail) ? janetc_cslot(janet_wrap_nil()) : janetc_gettarget(opts); /* Compile condition */ janetc_scope(&condscope, c, 0, "if"); cond = janetc_value(condopts, argv[0]); /* Check constant condition. */ /* TODO: Use type info for more short circuits */ if (cond.flags & JANET_SLOT_CONSTANT) { if (!janet_truthy(cond.constant)) { /* 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); janetc_throwaway(bodyopts, falsebody); janetc_popscope(c); return target; } /* Compile jump to right */ labeljr = janetc_emit_si(c, JOP_JUMP_IF_NOT, 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) 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; } ret = janetc_value(subopts, argv[i]); if (i != argn - 1) { janetc_freeslot(c, ret); } } janetc_popscope_keepslot(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; } /* * :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; if (argn < 2) { janetc_cerror(c, "expected at least 2 arguments"); return janetc_cslot(janet_wrap_nil()); } labelwt = janet_v_count(c->buffer); janetc_scope(&tempscope, c, 0, "while"); /* Compile condition */ cond = janetc_value(subopts, argv[0]); /* Check for constant condition */ if (cond.flags & JANET_SLOT_CONSTANT) { /* Loop never executes */ if (!janet_truthy(cond.constant)) { 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, JOP_JUMP_IF_NOT, 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) { tempscope.flags |= JANET_SCOPE_UNUSED; janetc_popscope(c); janet_v__cnt(c->buffer) = labelwt; janet_v__cnt(c->mapbuffer) = labelwt; janetc_scope(&tempscope, c, JANET_SCOPE_FUNCTION, "while-iife"); /* Recompile in the function scope */ cond = janetc_value(subopts, argv[0]); if (!(cond.flags & JANET_SLOT_CONSTANT)) { /* If not an infinite loop, return nil when condition false */ janetc_emit_si(c, JOP_JUMP_IF, 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)); /* Compile function */ JanetFuncDef *def = janetc_pop_funcdef(c); def->name = janet_cstring("_while"); 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_free(&c->scope->ra, cloreg); 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] |= (labeld - labelc) << 16; c->buffer[labeljt] |= (labelwt - labeljt) << 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, defindex, i; JanetFopts subopts = janetc_fopts_default(c); const Janet *params; const char *errmsg = NULL; /* Function flags */ int vararg = 0; int fixarity = 1; int selfref = 0; int seenamp = 0; /* Begin function */ c->scope->flags |= JANET_SCOPE_CLOSURE; janetc_scope(&fnscope, c, JANET_SCOPE_FUNCTION, "function"); if (argn < 2) { errmsg = "expected at least 2 arguments 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; } /* 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 (janet_checktype(param, JANET_SYMBOL)) { /* Check for varargs and unfixed arity */ if ((!seenamp) && (0 == janet_cstrcmp(janet_unwrap_symbol(param), "&"))) { seenamp = 1; fixarity = 0; if (i == paramcount - 1) { arity--; } else if (i == paramcount - 2) { vararg = 1; arity -= 2; } else { errmsg = "variable argument symbol in unexpected location"; goto error; } } else { janetc_nameslot(c, janet_unwrap_symbol(param), janetc_farslot(c)); } } else { destructure(c, param, janetc_farslot(c), defleaf, NULL); } } /* Check for self ref */ if (selfref) { JanetSlot slot = janetc_farslot(c); slot.flags = JANET_SLOT_NAMED | JANET_FUNCTION; janetc_emit_s(c, JOP_LOAD_SELF, slot, 1); janetc_nameslot(c, janet_unwrap_symbol(head), 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; if (fixarity) def->flags |= JANET_FUNCDEF_FLAG_FIXARITY; if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG; if (selfref) def->name = janet_unwrap_symbol(head); 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[] = { {"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}, {"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); } /* * Copyright (c) 2019 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. */ #include #ifndef JANET_AMALG #include #include "gc.h" #include "util.h" #include "state.h" #endif /* Begin building a string */ uint8_t *janet_string_begin(int32_t length) { char *data = janet_gcalloc(JANET_MEMORY_STRING, 2 * sizeof(int32_t) + length + 1); uint8_t *str = (uint8_t *)(data + 2 * sizeof(int32_t)); janet_string_length(str) = length; str[length] = 0; return str; } /* 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) { int32_t hash = janet_string_calchash(buf, len); char *data = janet_gcalloc(JANET_MEMORY_STRING, 2 * sizeof(int32_t) + len + 1); uint8_t *str = (uint8_t *)(data + 2 * sizeof(int32_t)); memcpy(str, buf, len); str[len] = 0; janet_string_length(str) = len; janet_string_hash(str) = hash; return str; } /* 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; 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) { int32_t *lookup = 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) { 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 */ static Janet cfun_string_slice(int32_t argc, Janet *argv) { JanetRange range = janet_getslice(argc, argv); JanetByteView view = janet_getbytes(argv, 0); return janet_stringv(view.bytes + range.start, range.end - range.start); } static Janet cfun_string_repeat(int32_t argc, Janet *argv) { 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; uint8_t *p = newbuf; for (p = newbuf; p < end; p += view.len) { memcpy(p, view.bytes, view.len); } return janet_wrap_string(janet_string_end(newbuf)); } static Janet cfun_string_bytes(int32_t argc, Janet *argv) { 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)); } static Janet cfun_string_frombytes(int32_t argc, Janet *argv) { 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)); } static Janet cfun_string_asciilower(int32_t argc, Janet *argv) { 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)); } static Janet cfun_string_asciiupper(int32_t argc, Janet *argv) { 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)); } static Janet cfun_string_reverse(int32_t argc, Janet *argv) { 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; } static Janet cfun_string_find(int32_t argc, Janet *argv) { 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); } static Janet cfun_string_findall(int32_t argc, Janet *argv) { 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; const uint8_t *subst; int32_t substlen; }; static void replacesetup(int32_t argc, Janet *argv, struct replace_state *s) { janet_arity(argc, 3, 4); JanetByteView pat = janet_getbytes(argv, 0); JanetByteView subst = janet_getbytes(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.bytes; s->substlen = subst.len; } static Janet cfun_string_replace(int32_t argc, Janet *argv) { 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); } buf = janet_string_begin(s.kmp.textlen - s.kmp.patlen + s.substlen); memcpy(buf, s.kmp.text, result); memcpy(buf + result, s.subst, s.substlen); memcpy(buf + result + s.substlen, 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)); } static Janet cfun_string_replaceall(int32_t argc, Janet *argv) { 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) { janet_buffer_push_bytes(&b, s.kmp.text + lastindex, result - lastindex); janet_buffer_push_bytes(&b, s.subst, s.substlen); 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); } static Janet cfun_string_split(int32_t argc, Janet *argv) { 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; } { 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); } static Janet cfun_string_checkset(int32_t argc, Janet *argv) { uint32_t bitset[8] = {0, 0, 0, 0, 0, 0, 0, 0}; janet_arity(argc, 2, 3); 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] & 7); bitset[index] |= mask; } if (argc == 3) { if (janet_getboolean(argv, 2)) { for (int i = 0; i < 8; i++) bitset[i] = ~bitset[i]; } } /* Check set */ for (int32_t i = 0; i < str.len; i++) { int index = str.bytes[i] >> 5; uint32_t mask = 1 << (str.bytes[i] & 7); if (!(bitset[index] & mask)) { return janet_wrap_false(); } } return janet_wrap_true(); } static Janet cfun_string_join(int32_t argc, Janet *argv) { 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) { memcpy(out, joiner.bytes, joiner.len); out += joiner.len; } janet_bytes_view(parts.items[i], &chunk, &chunklen); memcpy(out, chunk, chunklen); out += chunklen; } return janet_wrap_string(janet_string_end(buf)); } static Janet cfun_string_format(int32_t argc, Janet *argv) { 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 const JanetReg string_cfuns[] = { { "string/slice", cfun_string_slice, JDOC("(string/slice bytes [,start=0 [,end=(length str)]])\n\n" "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.") }, { "string/repeat", cfun_string_repeat, JDOC("(string/repeat bytes n)\n\n" "Returns a string that is n copies of bytes concatenated.") }, { "string/bytes", cfun_string_bytes, JDOC("(string/bytes str)\n\n" "Returns an array of integers that are the byte values of the string.") }, { "string/from-bytes", cfun_string_frombytes, JDOC("(string/from-bytes byte-array)\n\n" "Creates a string from an array of integers with byte values. All integers " "will be coerced to the range of 1 byte 0-255.") }, { "string/ascii-lower", cfun_string_asciilower, JDOC("(string/ascii-lower str)\n\n" "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.") }, { "string/ascii-upper", cfun_string_asciiupper, JDOC("(string/ascii-upper str)\n\n" "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.") }, { "string/reverse", cfun_string_reverse, JDOC("(string/reverse str)\n\n" "Returns a string that is the reversed version of str.") }, { "string/find", cfun_string_find, JDOC("(string/find patt str)\n\n" "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.") }, { "string/find-all", cfun_string_findall, JDOC("(string/find patt str)\n\n" "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 not counted, meaning a byte in string " "will only contribute to finding at most on occurrence of pattern. If no " "occurrences are found, will return an empty array.") }, { "string/replace", cfun_string_replace, JDOC("(string/replace patt subst str)\n\n" "Replace the first occurrence of patt with subst in the string str. " "Will return the new string if patt is found, otherwise returns str.") }, { "string/replace-all", cfun_string_replaceall, JDOC("(string/replace-all patt subst str)\n\n" "Replace all instances of patt with subst in the string str. " "Will return the new string if patt is found, otherwise returns str.") }, { "string/split", cfun_string_split, JDOC("(string/split delim str)\n\n" "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.") }, { "string/check-set", cfun_string_checkset, JDOC("(string/check-set set str)\n\n" "Checks if any of the bytes in the string set appear in the string str. " "Returns true if some bytes in set do appear in str, false if no bytes do.") }, { "string/join", cfun_string_join, JDOC("(string/join parts [,sep])\n\n" "Joins an array of strings into one string, optionally separated by " "a separator string sep.") }, { "string/format", cfun_string_format, JDOC("(string/format format & values)\n\n" "Similar to snprintf, but specialized for operating with janet. Returns " "a new string.") }, {NULL, NULL, NULL} }; /* Module entry point */ void janet_lib_string(JanetTable *env) { janet_core_cfuns(env, NULL, string_cfuns); } /* * Copyright (c) 2019 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'. */ #include #include #ifndef JANET_AMALG #include #endif /* 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 = realloc(mant->digits, 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) */ static double convert( int negative, struct BigNat *mant, int32_t base, int32_t exponent) { int32_t exponent2 = 0; /* Short circuit zero and huge numbers */ if (mant->n == 0 && mant->first_digit == 0) return negative ? -0.0 : 0.0; if (exponent > 1023) return negative ? -INFINITY : INFINITY; /* 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, set *err to 1 and return 0. */ int janet_scan_number( const uint8_t *str, int32_t len, double *out) { const uint8_t *end = str + len; int seenadigit = 0; int ex = 0; int base = 10; 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 (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; } /* Skip leading zeros */ while (str < end && (*str == '0' || *str == '.')) { if (seenpoint) ex--; if (*str == '.') { if (seenpoint) goto error; seenpoint = 1; } 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; int 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 && ee < (INT32_MAX / 40)) { int digit = digit_lookup[*str & 0x7F]; if (*str > 127 || digit >= base) goto error; ee = base * ee + digit; str++; seenadigit = 1; } if (eneg) ex -= ee; else ex += ee; } if (!seenadigit) goto error; *out = convert(neg, &mant, base, ex); free(mant.digits); return 0; error: free(mant.digits); return 1; } /* * Copyright (c) 2019 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 #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 s = sizeof(int32_t) * 4 + (capacity * sizeof(JanetKV)); char *data = janet_gcalloc(JANET_MEMORY_STRUCT, s); JanetKV *st = (JanetKV *)(data + 4 * sizeof(int32_t)); janet_memempty(st, capacity); janet_struct_length(st) = count; janet_struct_capacity(st) = capacity; janet_struct_hash(st) = 0; return st; } /* Find an item in a struct. 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(JanetKV *st, Janet key, Janet value) { 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) { /* A key was added to the struct more than once */ return; } } } /* 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); } } st = newst; } janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); return (const JanetKV *)st; } /* Get an item from a struct */ Janet janet_struct_get(const JanetKV *st, Janet key) { const JanetKV *kv = janet_struct_find(st, key); return kv ? kv->value : 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; } /* Check if two structs are equal */ int janet_struct_equal(const JanetKV *lhs, const JanetKV *rhs) { int32_t index; 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 0; if (lhash != rhash) return 0; for (index = 0; index < llen; index++) { const JanetKV *l = lhs + index; const JanetKV *r = rhs + index; if (!janet_equals(l->key, r->key)) return 0; if (!janet_equals(l->value, r->value)) return 0; } return 1; } /* Compare structs */ int janet_struct_compare(const JanetKV *lhs, const JanetKV *rhs) { int32_t i; int32_t lhash = janet_struct_hash(lhs); int32_t rhash = janet_struct_hash(rhs); int32_t llen = janet_struct_capacity(lhs); int32_t rlen = janet_struct_capacity(rhs); if (llen < rlen) return -1; if (llen > rlen) return 1; if (lhash < rhash) return -1; if (lhash > rhash) return 1; for (i = 0; i < llen; ++i) { const JanetKV *l = lhs + i; const JanetKV *r = rhs + i; int comp = janet_compare(l->key, r->key); if (comp != 0) return comp; comp = janet_compare(l->value, r->value); if (comp != 0) return comp; } return 0; } /* * Copyright (c) 2019 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 #include "state.h" #include "gc.h" #include "util.h" #include "symcache.h" #endif /* Cache state */ JANET_THREAD_LOCAL const uint8_t **janet_vm_cache = NULL; JANET_THREAD_LOCAL uint32_t janet_vm_cache_capacity = 0; JANET_THREAD_LOCAL uint32_t janet_vm_cache_count = 0; JANET_THREAD_LOCAL uint32_t janet_vm_cache_deleted = 0; /* Initialize the cache (allocate cache memory) */ void janet_symcache_init() { janet_vm_cache_capacity = 1024; janet_vm_cache = calloc(1, janet_vm_cache_capacity * sizeof(const uint8_t **)); if (NULL == janet_vm_cache) { JANET_OUT_OF_MEMORY; } janet_vm_cache_count = 0; janet_vm_cache_deleted = 0; } /* Deinitialize the cache (free the cache memory) */ void janet_symcache_deinit() { 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; 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 = calloc(1, 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 */ 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; newstr = (uint8_t *) janet_gcalloc(JANET_MEMORY_SYMBOL, 2 * sizeof(int32_t) + len + 1) + (2 * sizeof(int32_t)); janet_string_hash(newstr) = hash; janet_string_length(newstr) = len; 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) { int32_t len = 0; while (cstr[len]) len++; return janet_symbol((const uint8_t *)cstr, len); } /* Store counter for genysm to avoid quadratic behavior */ JANET_THREAD_LOCAL uint8_t gensym_counter[8] = {'_', '0', '0', '0', '0', '0', '0', 0}; /* Increment the gensym buffer */ static void inc_gensym(void) { for (int i = sizeof(gensym_counter) - 2; i; i--) { if (gensym_counter[i] == '9') { gensym_counter[i] = 'a'; break; } else if (gensym_counter[i] == 'z') { gensym_counter[i] = 'A'; break; } else if (gensym_counter[i] == 'Z') { gensym_counter[i] = '0'; } else { 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( gensym_counter, sizeof(gensym_counter) - 1); bucket = janet_symcache_findmem( gensym_counter, sizeof(gensym_counter) - 1, hash, &status); } while (status && (inc_gensym(), 1)); sym = (uint8_t *) janet_gcalloc( JANET_MEMORY_SYMBOL, 2 * sizeof(int32_t) + sizeof(gensym_counter)) + (2 * sizeof(int32_t)); memcpy(sym, gensym_counter, sizeof(gensym_counter)); janet_string_length(sym) = sizeof(gensym_counter) - 1; janet_string_hash(sym) = hash; janet_symcache_put((const uint8_t *)sym, bucket); return (const uint8_t *)sym; } /* * Copyright (c) 2019 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 #include "gc.h" #include "util.h" #include #endif /* Initialize a table */ JanetTable *janet_table_init(JanetTable *table, int32_t capacity) { JanetKV *data; capacity = janet_tablen(capacity); if (capacity) { 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; } /* Deinitialize a table */ void janet_table_deinit(JanetTable *table) { 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(table, capacity); } /* 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 = (JanetKV *) janet_memalloc_empty(size); if (NULL == newdata) { JANET_OUT_OF_MEMORY; } int32_t i, oldcapacity; oldcapacity = t->capacity; t->data = newdata; t->capacity = size; t->deleted = 0; for (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; } } free(olddata); } /* Get a value out of the table */ Janet janet_table_get(JanetTable *t, Janet key) { JanetKV *bucket = janet_table_find(t, key); if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) return bucket->value; /* Check prototypes */ { int i; for (i = JANET_MAX_PROTO_DEPTH, t = t->proto; t && i; t = t->proto, --i) { 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. 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->key; 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_FALSE)) --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; } /* 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); } /* 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 other 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)); } /* C Functions */ static Janet cfun_table_new(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); int32_t cap = janet_getinteger(argv, 0); return janet_wrap_table(janet_table(cap)); } static Janet cfun_table_getproto(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetTable *t = janet_gettable(argv, 0); return t->proto ? janet_wrap_table(t->proto) : janet_wrap_nil(); } static Janet cfun_table_setproto(int32_t argc, Janet *argv) { 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]; } static Janet cfun_table_tostruct(int32_t argc, Janet *argv) { janet_fixarity(argc, 1); JanetTable *t = janet_gettable(argv, 0); return janet_wrap_struct(janet_table_to_struct(t)); } static Janet cfun_table_rawget(int32_t argc, Janet *argv) { janet_fixarity(argc, 2); JanetTable *table = janet_gettable(argv, 0); return janet_table_rawget(table, argv[1]); } static const JanetReg table_cfuns[] = { { "table/new", cfun_table_new, JDOC("(table/new capacity)\n\n" "Creates a new empty table with pre-allocated memory " "for capacity entries. This means that if one knows the number of " "entries going to go in a table on creation, extra memory allocation " "can be avoided. Returns the new table.") }, { "table/to-struct", cfun_table_tostruct, JDOC("(table/to-struct tab)\n\n" "Convert a table to a struct. Returns a new struct. This function " "does not take into account prototype tables.") }, { "table/getproto", cfun_table_getproto, JDOC("(table/getproto tab)\n\n" "Get the prototype table of a table. Returns nil if a table " "has no prototype, otherwise returns the prototype.") }, { "table/setproto", cfun_table_setproto, JDOC("(table/setproto tab proto)\n\n" "Set the prototype of a table. Returns the original table tab.") }, { "table/rawget", cfun_table_rawget, JDOC("(table/rawget tab key)\n\n" "Gets a value from a table without looking at the prototype table. " "If a table tab does not contain t directly, the function will return " "nil without checking the prototype. Returns the value in the table.") }, {NULL, NULL, NULL} }; /* Load the table module */ void janet_lib_table(JanetTable *env) { janet_core_cfuns(env, NULL, table_cfuns); } /* * Copyright (c) 2019 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 #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) { char *data = janet_gcalloc(JANET_MEMORY_TUPLE, 5 * sizeof(int32_t) + length * sizeof(Janet)); Janet *tuple = (Janet *)(data + (5 * sizeof(int32_t))); janet_tuple_length(tuple) = length; janet_tuple_sm_start(tuple) = -1; janet_tuple_sm_end(tuple) = -1; janet_tuple_flag(tuple) = 0; return tuple; } /* 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); memcpy(t, values, sizeof(Janet) * n); return janet_tuple_end(t); } /* Check if two tuples are equal */ int janet_tuple_equal(const Janet *lhs, const Janet *rhs) { int32_t index; int32_t llen = janet_tuple_length(lhs); int32_t rlen = janet_tuple_length(rhs); int32_t lhash = janet_tuple_hash(lhs); int32_t rhash = janet_tuple_hash(rhs); if (lhash == 0) lhash = janet_tuple_hash(lhs) = janet_array_calchash(lhs, llen); if (rhash == 0) rhash = janet_tuple_hash(rhs) = janet_array_calchash(rhs, rlen); if (lhash != rhash) return 0; if (llen != rlen) return 0; for (index = 0; index < llen; index++) { if (!janet_equals(lhs[index], rhs[index])) return 0; } return 1; } /* Compare tuples */ int janet_tuple_compare(const Janet *lhs, const Janet *rhs) { int32_t i; int32_t llen = janet_tuple_length(lhs); int32_t rlen = janet_tuple_length(rhs); int32_t count = llen < rlen ? llen : rlen; for (i = 0; i < count; ++i) { int comp = janet_compare(lhs[i], rhs[i]); if (comp != 0) return comp; } if (llen < rlen) return -1; else if (llen > rlen) return 1; return 0; } /* C Functions */ static Janet cfun_tuple_brackets(int32_t argc, Janet *argv) { const Janet *tup = janet_tuple_n(argv, argc); janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; return janet_wrap_tuple(tup); } static Janet cfun_tuple_slice(int32_t argc, Janet *argv) { JanetRange range = janet_getslice(argc, argv); JanetView view = janet_getindexed(argv, 0); return janet_wrap_tuple(janet_tuple_n(view.items + range.start, range.end - range.start)); } static Janet cfun_tuple_prepend(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); JanetView view = janet_getindexed(argv, 0); Janet *n = janet_tuple_begin(view.len - 1 + argc); memcpy(n - 1 + argc, view.items, sizeof(Janet) * view.len); for (int32_t i = 1; i < argc; i++) { n[argc - i - 1] = argv[i]; } return janet_wrap_tuple(janet_tuple_end(n)); } static Janet cfun_tuple_append(int32_t argc, Janet *argv) { janet_arity(argc, 1, -1); JanetView view = janet_getindexed(argv, 0); Janet *n = janet_tuple_begin(view.len - 1 + argc); memcpy(n, view.items, sizeof(Janet) * view.len); memcpy(n + view.len, argv + 1, sizeof(Janet) * (argc - 1)); return janet_wrap_tuple(janet_tuple_end(n)); } static Janet cfun_tuple_type(int32_t argc, Janet *argv) { 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"); } } static const JanetReg tuple_cfuns[] = { { "tuple/brackets", cfun_tuple_brackets, JDOC("(tuple/brackets & xs)\n\n" "Creates a new bracketed tuple containing the elements xs.") }, { "tuple/slice", cfun_tuple_slice, JDOC("(tuple/slice arrtup [,start=0 [,end=(length arrtup)]])\n\n" "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." "Returns the new tuple.") }, { "tuple/append", cfun_tuple_append, JDOC("(tuple/append tup & items)\n\n" "Returns a new tuple that is the result of appending " "each element in items to tup.") }, { "tuple/prepend", cfun_tuple_prepend, JDOC("(tuple/prepend tup & items)\n\n" "Prepends each element in items to tuple and " "returns a new tuple. Items are prepended such that the " "last element in items is the first element in the new tuple.") }, { "tuple/type", cfun_tuple_type, JDOC("(tuple/type tup)\n\n" "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.") }, {NULL, NULL, NULL} }; /* Load the tuple module */ void janet_lib_tuple(JanetTable *env) { janet_core_cfuns(env, NULL, tuple_cfuns); } /* * Copyright (c) 2019 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. */ #include #ifndef JANET_AMALG #include #include "util.h" #include "state.h" #include "gc.h" #endif /* 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", "boolean", "fiber", "string", "symbol", "keyword", "array", "tuple", "table", "struct", "buffer", "function", "cfunction", "abstract" }; const char *const janet_signal_names[14] = { "ok", "error", "debug", "yield", "user0", "user1", "user2", "user3", "user4", "user5", "user6", "user7", "user8", "user9" }; const char *const janet_status_names[16] = { "dead", "error", "debug", "pending", "user0", "user1", "user2", "user3", "user4", "user5", "user6", "user7", "user8", "user9", "new", "alive" }; /* Calculate hash for string */ int32_t janet_string_calchash(const uint8_t *str, int32_t len) { const uint8_t *end = str + len; uint32_t hash = 5381; while (str < end) hash = (hash << 5) + hash + *str++; return (int32_t) hash; } /* 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 = 5381; while (array < end) hash = (hash << 5) + 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 = 5381; while (kvs < end) { hash = (hash << 5) + hash + janet_hash(kvs->key); hash = (hash << 5) + 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) { n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; return n + 1; } /* 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; } /* Register a value in the global registry */ void janet_register(const char *name, JanetCFunction cfun) { Janet key = janet_wrap_cfunction(cfun); Janet value = janet_csymbolv(name); janet_table_put(janet_vm_registry, key, value); } /* Add a def to an environment */ void janet_def(JanetTable *env, const char *name, Janet val, const char *doc) { JanetTable *subt = janet_table(2); janet_table_put(subt, janet_ckeywordv("value"), val); if (doc) janet_table_put(subt, janet_ckeywordv("doc"), janet_cstringv(doc)); janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt)); } /* Add a var to the environment */ void janet_var(JanetTable *env, const char *name, Janet val, const char *doc) { 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)); if (doc) janet_table_put(subt, janet_ckeywordv("doc"), janet_cstringv(doc)); janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt)); } /* Load many cfunctions at once */ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) { while (cfuns->name) { Janet name = janet_csymbolv(cfuns->name); Janet longname = name; if (regprefix) { int32_t reglen = 0; int32_t nmlen = 0; while (regprefix[reglen]) reglen++; while (cfuns->name[nmlen]) nmlen++; uint8_t *longname_buffer = janet_string_begin(reglen + 1 + nmlen); memcpy(longname_buffer, regprefix, reglen); longname_buffer[reglen] = '/'; memcpy(longname_buffer + reglen + 1, cfuns->name, nmlen); longname = janet_wrap_symbol(janet_string_end(longname_buffer)); } Janet fun = janet_wrap_cfunction(cfuns->cfun); janet_def(env, cfuns->name, fun, cfuns->documentation); janet_table_put(janet_vm_registry, fun, longname); cfuns++; } } #ifndef JANET_BOOTSTRAP void janet_core_def(JanetTable *env, const char *name, Janet x, const void *p) { (void) p; janet_table_put(env, janet_csymbolv(name), x); } void janet_core_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) { (void) regprefix; while (cfuns->name) { Janet name = janet_csymbolv(cfuns->name); Janet fun = janet_wrap_cfunction(cfuns->cfun); janet_core_def(env, cfuns->name, fun, cfuns->documentation); janet_table_put(janet_vm_registry, fun, name); cfuns++; } } #endif /* Resolve a symbol in the environment */ JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { Janet ref; JanetTable *entry_table; Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); if (!janet_checktype(entry, JANET_TABLE)) return JANET_BINDING_NONE; entry_table = janet_unwrap_table(entry); if (!janet_checktype( janet_table_get(entry_table, janet_ckeywordv("macro")), JANET_NIL)) { *out = janet_table_get(entry_table, janet_ckeywordv("value")); return JANET_BINDING_MACRO; } ref = janet_table_get(entry_table, janet_ckeywordv("ref")); if (janet_checktype(ref, JANET_ARRAY)) { *out = ref; return JANET_BINDING_VAR; } *out = janet_table_get(entry_table, janet_ckeywordv("value")); return JANET_BINDING_DEF; } /* 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) { if (janet_checktype(str, JANET_STRING) || janet_checktype(str, JANET_SYMBOL) || janet_checktype(str, JANET_KEYWORD)) { *data = janet_unwrap_string(str); *len = janet_string_length(janet_unwrap_string(str)); return 1; } else if (janet_checktype(str, JANET_BUFFER)) { *data = janet_unwrap_buffer(str)->data; *len = janet_unwrap_buffer(str)->count; 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_checkint64(Janet x) { if (!janet_checktype(x, JANET_NUMBER)) return 0; double dval = janet_unwrap_number(x); return janet_checkint64range(dval); } /* Useful for inspecting values while debugging */ void janet_inspect(Janet x) { printf("\n"); } /* * Copyright (c) 2019 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 #endif /* * Define a number of functions that can be used internally on ANY Janet. */ /* Check if two values are equal. This is strict equality with no conversion. */ int janet_equals(Janet x, Janet y) { int result = 0; if (janet_type(x) != janet_type(y)) { result = 0; } else { switch (janet_type(x)) { case JANET_NIL: case JANET_TRUE: case JANET_FALSE: result = 1; break; case JANET_NUMBER: result = (janet_unwrap_number(x) == janet_unwrap_number(y)); break; case JANET_STRING: result = janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); break; case JANET_TUPLE: result = janet_tuple_equal(janet_unwrap_tuple(x), janet_unwrap_tuple(y)); break; case JANET_STRUCT: result = janet_struct_equal(janet_unwrap_struct(x), janet_unwrap_struct(y)); break; default: /* compare pointers */ result = (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)); break; } } return result; } /* 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_FALSE: hash = 1; break; case JANET_TRUE: hash = 2; 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)); break; case JANET_STRUCT: hash = janet_struct_hash(janet_unwrap_struct(x)); break; default: /* TODO - test performance with different hash functions */ if (sizeof(double) == sizeof(void *)) { /* Assuming 8 byte pointer */ uint64_t i = janet_u64(x); hash = (int32_t)(i & 0xFFFFFFFF); /* Get a bit more entropy by shifting the low bits out */ hash >>= 3; hash ^= (int32_t)(i >> 32); } else { /* Assuming 4 byte pointer (or smaller) */ hash = (int32_t)((char *)janet_unwrap_pointer(x) - (char *)0); hash >>= 2; } 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. */ int janet_compare(Janet x, Janet y) { if (janet_type(x) == janet_type(y)) { switch (janet_type(x)) { case JANET_NIL: case JANET_FALSE: case JANET_TRUE: return 0; case JANET_NUMBER: /* Check for NaNs to ensure total order */ if (janet_unwrap_number(x) != janet_unwrap_number(x)) return janet_unwrap_number(y) != janet_unwrap_number(y) ? 0 : -1; if (janet_unwrap_number(y) != janet_unwrap_number(y)) return 1; if (janet_unwrap_number(x) == janet_unwrap_number(y)) { return 0; } else { return janet_unwrap_number(x) > janet_unwrap_number(y) ? 1 : -1; } case JANET_STRING: case JANET_SYMBOL: case JANET_KEYWORD: return janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); case JANET_TUPLE: return janet_tuple_compare(janet_unwrap_tuple(x), janet_unwrap_tuple(y)); case JANET_STRUCT: return janet_struct_compare(janet_unwrap_struct(x), janet_unwrap_struct(y)); default: if (janet_unwrap_string(x) == janet_unwrap_string(y)) { return 0; } else { return janet_unwrap_string(x) > janet_unwrap_string(y) ? 1 : -1; } } } return (janet_type(x) < janet_type(y)) ? -1 : 1; } /* Gets a value and returns. Can panic. */ Janet janet_get(Janet ds, Janet key) { Janet value; switch (janet_type(ds)) { default: janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds); value = janet_wrap_nil(); 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; if (!janet_checkint(key)) janet_panic("expected integer key"); index = janet_unwrap_integer(key); if (index < 0 || index >= array->count) { value = janet_wrap_nil(); } else { value = array->data[index]; } break; } case JANET_TUPLE: { const Janet *tuple = janet_unwrap_tuple(ds); int32_t index; if (!janet_checkint(key)) janet_panic("expected integer key"); index = janet_unwrap_integer(key); if (index < 0 || index >= janet_tuple_length(tuple)) { value = janet_wrap_nil(); } else { value = tuple[index]; } break; } case JANET_BUFFER: { JanetBuffer *buffer = janet_unwrap_buffer(ds); int32_t index; if (!janet_checkint(key)) janet_panic("expected integer key"); index = janet_unwrap_integer(key); if (index < 0 || index >= buffer->count) { value = janet_wrap_nil(); } else { 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; if (!janet_checkint(key)) janet_panic("expected integer key"); index = janet_unwrap_integer(key); if (index < 0 || index >= janet_string_length(str)) { value = janet_wrap_nil(); } else { value = janet_wrap_integer(str[index]); } break; } case JANET_ABSTRACT: { JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); if (type->get) { value = (type->get)(janet_unwrap_abstract(ds), key); } else { janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds); value = janet_wrap_nil(); } break; } } return value; } 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); value = janet_wrap_nil(); 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) { value = (type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index)); } else { janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds); 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); return 0; 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; } } 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); break; 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] = janet_unwrap_integer(value); 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 %T ", JANET_TFLAG_LENGTHABLE, ds); } break; } } } void janet_put(Janet ds, Janet key, Janet value) { switch (janet_type(ds)) { default: janet_panicf("expected %T, got %v", JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); break; case JANET_ARRAY: { int32_t index; JanetArray *array = janet_unwrap_array(ds); if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key); index = janet_unwrap_integer(key); if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key); if (index >= array->count) { janet_array_setcount(array, index + 1); } array->data[index] = value; break; } case JANET_BUFFER: { int32_t index; JanetBuffer *buffer = janet_unwrap_buffer(ds); if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key); index = janet_unwrap_integer(key); if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key); 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 %T ", JANET_TFLAG_LENGTHABLE, ds); } break; } } } /* * Copyright (c) 2019 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 "vector.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; int32_t *p = (int32_t *) realloc(v ? janet_v__raw(v) : 0, itemsize * m + sizeof(int32_t) * 2); if (NULL != p) { if (!v) p[1] = 0; p[0] = m; return p + 2; } else { { JANET_OUT_OF_MEMORY; } return (void *)(2 * sizeof(int32_t)); } } /* Convert a buffer to normal allocated memory (forget capacity) */ void *janet_v_flattenmem(void *v, int32_t itemsize) { int32_t *p; int32_t sizen; if (NULL == v) return NULL; sizen = itemsize * janet_v__cnt(v); p = malloc(sizen); if (NULL != p) { memcpy(p, v, sizen); return p; } else { { JANET_OUT_OF_MEMORY; } return NULL; } } /* * Copyright (c) 2019 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 #include "state.h" #include "fiber.h" #include "gc.h" #include "symcache.h" #include "util.h" #endif /* VM state */ JANET_THREAD_LOCAL JanetTable *janet_vm_registry; JANET_THREAD_LOCAL int janet_vm_stackn = 0; JANET_THREAD_LOCAL JanetFiber *janet_vm_fiber = NULL; JANET_THREAD_LOCAL Janet *janet_vm_return_reg = NULL; JANET_THREAD_LOCAL jmp_buf *janet_vm_jmp_buf = NULL; /* 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. */ #ifdef ____GNUC__ #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] 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, &&label_JOP_MULTIPLY_IMMEDIATE, &&label_JOP_MULTIPLY, &&label_JOP_DIVIDE_IMMEDIATE, &&label_JOP_DIVIDE, &&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_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_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_NUMERIC_LESS_THAN, &&label_JOP_NUMERIC_LESS_THAN_EQUAL, &&label_JOP_NUMERIC_GREATER_THAN, &&label_JOP_NUMERIC_GREATER_THAN_EQUAL, &&label_JOP_NUMERIC_EQUAL, &&label_unknown_op }; #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 { \ vm_commit(); \ 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 %t", (1 << (T)), (X)); \ } \ } while (0) #define vm_assert_types(X, TS) do { \ if (!(janet_checktypes((X), (TS)))) { \ vm_commit(); \ janet_panicf("expected %T, got %t", (TS), (X)); \ } \ } while (0) /* Templates for certain patterns in opcodes */ #define vm_binop_immediate(op)\ {\ Janet op1 = stack[B];\ vm_assert_type(op1, JANET_NUMBER);\ double x1 = janet_unwrap_number(op1);\ stack[A] = janet_wrap_number(x1 op CS);\ vm_pcnext();\ } #define _vm_bitop_immediate(op, type1)\ {\ Janet op1 = stack[B];\ vm_assert_type(op1, JANET_NUMBER);\ type1 x1 = (type1) janet_unwrap_integer(op1);\ stack[A] = janet_wrap_integer(x1 op CS);\ vm_pcnext();\ } #define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t); #define vm_bitopu_immediate(op) _vm_bitop_immediate(op, uint32_t); #define _vm_binop(op, wrap)\ {\ Janet op1 = stack[B];\ Janet op2 = stack[C];\ vm_assert_type(op1, JANET_NUMBER);\ vm_assert_type(op2, JANET_NUMBER);\ double x1 = janet_unwrap_number(op1);\ double x2 = janet_unwrap_number(op2);\ stack[A] = wrap(x1 op x2);\ vm_pcnext();\ } #define vm_binop(op) _vm_binop(op, janet_wrap_number) #define vm_numcomp(op) _vm_binop(op, janet_wrap_boolean) #define _vm_bitop(op, type1)\ {\ Janet op1 = stack[B];\ Janet op2 = stack[C];\ vm_assert_type(op1, JANET_NUMBER);\ vm_assert_type(op2, JANET_NUMBER);\ type1 x1 = (type1) janet_unwrap_integer(op1);\ int32_t x2 = janet_unwrap_integer(op2);\ stack[A] = janet_wrap_integer(x1 op x2);\ vm_pcnext();\ } #define vm_bitop(op) _vm_bitop(op, int32_t) #define vm_bitopu(op) _vm_bitop(op, uint32_t) /* Call a non function type */ static Janet call_nonfn(JanetFiber *fiber, Janet callee) { int32_t argn = fiber->stacktop - fiber->stackstart; Janet ds, key; if (argn != 1) janet_panicf("%v called with arity %d, expected 1", callee, argn); if (janet_checktypes(callee, JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY | JANET_TFLAG_STRING | JANET_TFLAG_BUFFER | JANET_TFLAG_ABSTRACT)) { ds = callee; key = fiber->data[fiber->stackstart]; } else { ds = fiber->data[fiber->stackstart]; key = callee; } fiber->stacktop = fiber->stackstart; return janet_get(ds, key); } /* Interpreter main loop */ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status) { /* Interpreter state */ register Janet *stack; register uint32_t *pc; register JanetFunction *func; vm_restore(); /* Only should be hit if the fiber is either waiting for a child, or * waiting to be resumed. In those cases, use input and increment pc. We * DO NOT use input when resuming a fiber that has been interrupted at a * breakpoint. */ if (status != JANET_STATUS_NEW && ((*pc & 0xFF) == JOP_SIGNAL || (*pc & 0xFF) == JOP_RESUME)) { stack[A] = in; pc++; } /* The first opcode to execute. If the first opcode has * the breakpoint bit set and we were in the debug state, skip * that first breakpoint. */ uint8_t first_opcode = (status == JANET_STATUS_DEBUG) ? (*pc & 0x7F) : (*pc & 0xFF); /* Main interpreter loop. Semantically is a switch on * (*pc & 0xFF) inside of an infinite loop. */ VM_START(); VM_DEFAULT(); 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(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(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) vm_binop(-); VM_OP(JOP_MULTIPLY_IMMEDIATE) vm_binop_immediate(*); VM_OP(JOP_MULTIPLY) vm_binop(*); VM_OP(JOP_NUMERIC_LESS_THAN) vm_numcomp( <); VM_OP(JOP_NUMERIC_LESS_THAN_EQUAL) vm_numcomp( <=); VM_OP(JOP_NUMERIC_GREATER_THAN) vm_numcomp( >); VM_OP(JOP_NUMERIC_GREATER_THAN_EQUAL) vm_numcomp( >=); VM_OP(JOP_NUMERIC_EQUAL) vm_numcomp( ==); VM_OP(JOP_DIVIDE_IMMEDIATE) vm_binop_immediate( /); VM_OP(JOP_DIVIDE) vm_binop( /); 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]; vm_assert_type(op, JANET_NUMBER); stack[A] = janet_wrap_integer(~janet_unwrap_integer(op)); vm_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_next(); VM_OP(JOP_JUMP_IF) if (janet_truthy(stack[A])) { pc += ES; } else { pc++; } vm_next(); VM_OP(JOP_JUMP_IF_NOT) if (janet_truthy(stack[A])) { pc++; } else { pc += ES; } vm_next(); VM_OP(JOP_LESS_THAN) stack[A] = janet_wrap_boolean(janet_compare(stack[B], stack[C]) < 0); vm_pcnext(); VM_OP(JOP_LESS_THAN_IMMEDIATE) stack[A] = janet_wrap_boolean(janet_unwrap_integer(stack[B]) < CS); vm_pcnext(); VM_OP(JOP_GREATER_THAN) stack[A] = janet_wrap_boolean(janet_compare(stack[B], stack[C]) > 0); vm_pcnext(); VM_OP(JOP_GREATER_THAN_IMMEDIATE) stack[A] = janet_wrap_boolean(janet_unwrap_integer(stack[B]) > CS); vm_pcnext(); 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_unwrap_integer(stack[B]) == CS); vm_pcnext(); VM_OP(JOP_COMPARE) stack[A] = janet_wrap_integer(janet_compare(stack[B], stack[C])); 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"); if (env->offset) { /* 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"); if (env->offset) { 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) + (elen * sizeof(JanetFuncEnv *))); fn->def = fd; { int32_t i; for (i = 0; i < elen; ++i) { int32_t inherit = fd->environments[i]; if (inherit == -1) { 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 %t", JANET_TFLAG_INDEXED, stack[D]); } } stack = fiber->data + fiber->frame; vm_checkgc_pcnext(); VM_OP(JOP_CALL) { Janet callee = stack[E]; if (fiber->stacktop > fiber->maxstack) { vm_throw("stack overflow"); } if (janet_checktype(callee, JANET_KEYWORD)) { vm_commit(); int32_t argc = fiber->stacktop - fiber->stackstart; if (argc < 1) janet_panicf("method call takes at least 1 argument, got %d", argc); callee = janet_get(fiber->data[fiber->stackstart], callee); } if (janet_checktype(callee, JANET_FUNCTION)) { func = janet_unwrap_function(callee); janet_stack_frame(stack)->pc = pc; 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); /*if (fiber->frame == 0) vm_return(JANET_SIGNAL_OK, ret);*/ 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) { Janet callee = stack[D]; if (janet_checktype(callee, JANET_KEYWORD)) { vm_commit(); int32_t argc = fiber->stacktop - fiber->stackstart; if (argc < 1) janet_panicf("method call takes at least 1 argument, got %d", argc); callee = janet_get(fiber->data[fiber->stackstart], callee); } if (janet_checktype(callee, JANET_FUNCTION)) { func = janet_unwrap_function(callee); 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(JANET_SIGNAL_OK, retreg); vm_restore(); stack[A] = retreg; vm_checkgc_pcnext(); } } VM_OP(JOP_RESUME) { Janet retreg; vm_assert_type(stack[B], JANET_FIBER); JanetFiber *child = janet_unwrap_fiber(stack[B]); fiber->child = child; JanetSignal sig = janet_continue(child, stack[C], &retreg); if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) vm_return(sig, retreg); fiber->child = NULL; 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_PUT) vm_commit(); janet_put(stack[A], stack[B], stack[C]); vm_checkgc_pcnext(); VM_OP(JOP_PUT_INDEX) vm_commit(); janet_putindex(stack[A], C, stack[B]); vm_checkgc_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_wrap_integer(janet_length(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) { int32_t count = fiber->stacktop - fiber->stackstart; Janet *mem = fiber->data + fiber->stackstart; stack[D] = janet_wrap_tuple(janet_tuple_n(mem, count)); 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_throw("expected even number of arguments to table constructor"); 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_throw("expected even number of arguments to struct constructor"); 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() } Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) { Janet ret; Janet *old_return_reg = janet_vm_return_reg; /* 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"); /* Push frame */ janet_fiber_pushn(janet_vm_fiber, argv, argc); if (janet_fiber_funcframe(janet_vm_fiber, fun)) { janet_panicf("arity mismatch in %v", fun); } janet_fiber_frame(janet_vm_fiber)->flags |= JANET_STACKFRAME_ENTRANCE; /* Set up */ int32_t oldn = janet_vm_stackn++; int handle = janet_gclock(); janet_vm_return_reg = &ret; /* Run vm */ JanetSignal signal = run_vm(janet_vm_fiber, janet_wrap_nil(), JANET_STATUS_ALIVE); /* Teardown */ janet_vm_return_reg = old_return_reg; janet_vm_stackn = oldn; janet_gcunlock(handle); if (signal != JANET_SIGNAL_OK) janet_panicv(ret); return ret; } /* Enter the main vm loop */ JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) { jmp_buf buf; /* 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 (old_status == JANET_STATUS_ALIVE || old_status == JANET_STATUS_DEAD || old_status == JANET_STATUS_ERROR) { *out = janet_cstringv("cannot resume alive, dead, or errored fiber"); return JANET_SIGNAL_ERROR; } /* Continue child fiber if it exists */ if (fiber->child) { JanetFiber *child = fiber->child; janet_vm_stackn++; JanetSignal sig = janet_continue(child, in, &in); janet_vm_stackn--; if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { *out = in; return sig; } fiber->child = NULL; } /* Save global state */ int32_t oldn = janet_vm_stackn++; int handle = janet_vm_gc_suspend; JanetFiber *old_vm_fiber = janet_vm_fiber; jmp_buf *old_vm_jmp_buf = janet_vm_jmp_buf; Janet *old_vm_return_reg = janet_vm_return_reg; /* Setup fiber */ janet_vm_fiber = fiber; janet_gcroot(janet_wrap_fiber(fiber)); janet_fiber_set_status(fiber, JANET_STATUS_ALIVE); janet_vm_return_reg = out; janet_vm_jmp_buf = &buf; /* Run loop */ JanetSignal signal; if (setjmp(buf)) { signal = JANET_SIGNAL_ERROR; } else { signal = run_vm(fiber, in, old_status); } /* Tear down fiber */ janet_fiber_set_status(fiber, signal); janet_gcunroot(janet_wrap_fiber(fiber)); /* Restore global state */ janet_vm_gc_suspend = handle; janet_vm_fiber = old_vm_fiber; janet_vm_stackn = oldn; janet_vm_return_reg = old_vm_return_reg; janet_vm_jmp_buf = old_vm_jmp_buf; return signal; } JanetSignal janet_pcall( JanetFunction *fun, int32_t argc, const Janet *argv, Janet *out, JanetFiber **f) { JanetFiber *fiber = janet_fiber(fun, 64, argc, argv); if (f) *f = fiber; if (!fiber) { *out = janet_cstringv("arity mismatch"); return JANET_SIGNAL_ERROR; } return janet_continue(fiber, janet_wrap_nil(), out); } /* Setup VM */ int janet_init(void) { /* Garbage collection */ janet_vm_blocks = NULL; janet_vm_next_collection = 0; /* Setting memoryInterval to zero forces * a collection pretty much every cycle, which is * incredibly horrible for performance, but can help ensure * there are no memory bugs during development */ janet_vm_gc_interval = 0x10000; janet_symcache_init(); /* Initialize gc roots */ janet_vm_roots = NULL; janet_vm_root_count = 0; janet_vm_root_capacity = 0; /* Initialize registry */ janet_vm_registry = janet_table(0); janet_gcroot(janet_wrap_table(janet_vm_registry)); return 0; } /* Clear all memory associated with the VM */ void janet_deinit(void) { janet_clear_memory(); janet_symcache_deinit(); free(janet_vm_roots); janet_vm_roots = NULL; janet_vm_root_count = 0; janet_vm_root_capacity = 0; janet_vm_registry = NULL; } /* * Copyright (c) 2019 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 #endif void *janet_memalloc_empty(int32_t count) { int32_t i; void *mem = malloc(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 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_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 /* Wrapper functions wrap a data type that is used from C into a * janet value, which can then be used in janet internal functions. Use * these functions sparingly, as these function will let the programmer * leak memory, where as the stack based API ensures that all values can * be collected by the garbage collector. */ Janet janet_wrap_nil() { Janet y; y.type = JANET_NIL; y.as.u64 = 0; return y; } Janet janet_wrap_true(void) { Janet y; y.type = JANET_TRUE; y.as.u64 = 0; return y; } Janet janet_wrap_false(void) { Janet y; y.type = JANET_FALSE; y.as.u64 = 0; return y; } Janet janet_wrap_boolean(int x) { Janet y; y.type = x ? JANET_TRUE : JANET_FALSE; y.as.u64 = 0; 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) #undef JANET_WRAP_DEFINE #endif #ifndef JANET_AMALG #include #endif static const unsigned char janet_core_image_bytes[] = { 0xD3, 0x81, 0x4F, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0xD3, 0x02, 0xD0, 0x05, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0xD0, 0x03, 0x64, 0x6F, 0x63, 0xCE, 0x80, 0x83, 0x28, 0x6F, 0x73, 0x2F, 0x63, 0x6C, 0x6F, 0x63, 0x6B, 0x29, 0x0A, 0x0A, 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, 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, 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, 0x20, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x20, 0x72, 0x65, 0x61, 0x6C, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x2E, 0xCF, 0x06, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x06, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0xDA, 0x05, 0xCE, 0x80, 0xAB, 0x28, 0x64, 0x69, 0x73, 0x61, 0x73, 0x6D, 0x20, 0x66, 0x75, 0x6E, 0x63, 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, 0x62, 0x65, 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, 0x0A, 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, 0x0A, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xCF, 0x06, 0x62, 0x79, 0x74, 0x65, 0x73, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x36, 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, 0x6F, 0x72, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xD0, 0x0A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x2D, 0x6D, 0x61, 0x70, 0xD2, 0x03, 0x00, 0xCE, 0x0A, 0x63, 0x6F, 0x72, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x8C, 0x0E, 0x8C, 0xB7, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x05, 0x17, 0xCE, 0x06, 0x62, 0x79, 0x74, 0x65, 0x73, 0x3F, 0xDA, 0x10, 0xD8, 0x04, 0x74, 0x79, 0x70, 0x65, 0xD0, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xD0, 0x06, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0xD0, 0x07, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0xD0, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x1A, 0x05, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x26, 0x07, 0x03, 0x00, 0x1F, 0x06, 0x03, 0x07, 0x1A, 0x06, 0x03, 0x00, 0x23, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x26, 0x08, 0x04, 0x00, 0x1F, 0x07, 0x03, 0x08, 0x03, 0x07, 0x00, 0x00, 0x8C, 0x0E, 0x80, 0xA9, 0xBF, 0x9E, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x08, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x55, 0xBF, 0xAB, 0x55, 0xBF, 0xAB, 0x55, 0xBF, 0xC6, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xDE, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEF, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xCF, 0x02, 0x2B, 0x3D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x24, 0x28, 0x2B, 0x3D, 0x20, 0x78, 0x20, 0x6E, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x93, 0x9D, 0x93, 0xE1, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x02, 0x2B, 0x3D, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x09, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x01, 0x2B, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x06, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x06, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCF, 0x03, 0x73, 0x65, 0x74, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x93, 0x9D, 0x44, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x0A, 0x67, 0x63, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x67, 0x63, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xDA, 0x05, 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, 0xCF, 0x0B, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x62, 0x79, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x62, 0x79, 0x74, 0x65, 0xDA, 0x05, 0xCE, 0x5C, 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, 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, 0xCF, 0x04, 0x6F, 0x64, 0x64, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x87, 0x97, 0x87, 0xCB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x01, 0x0C, 0xCE, 0x04, 0x6F, 0x64, 0x64, 0x3F, 0xDA, 0x10, 0xD8, 0x01, 0x25, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x02, 0x00, 0x2C, 0x00, 0x02, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x25, 0x04, 0x00, 0x00, 0x1F, 0x03, 0x04, 0x02, 0x19, 0x03, 0x03, 0x00, 0x23, 0x03, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x87, 0x97, 0x34, 0xBF, 0xF8, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF2, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xCF, 0x06, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x95, 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, 0x20, 0x20, 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, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x54, 0x54, 0xCD, 0x00, 0x00, 0x55, 0x39, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x03, 0x00, 0x10, 0xCE, 0x06, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0xDA, 0x10, 0x28, 0x03, 0x00, 0x00, 0x17, 0x04, 0x01, 0x00, 0x17, 0x05, 0x02, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x3E, 0x08, 0x06, 0x07, 0x1A, 0x08, 0x08, 0x00, 0x33, 0x09, 0x05, 0x06, 0x17, 0x0A, 0x09, 0x00, 0x2C, 0x04, 0x0A, 0x00, 0x2F, 0x04, 0x00, 0x00, 0x25, 0x09, 0x01, 0x00, 0x06, 0x06, 0x09, 0x06, 0x18, 0xF8, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x54, 0x54, 0x80, 0xE5, 0xBF, 0xBF, 0x0D, 0x04, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xF6, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xD9, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0x22, 0x80, 0xE5, 0xCF, 0x03, 0x69, 0x6E, 0x63, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x92, 0xC5, 0x92, 0xEB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x03, 0x69, 0x6E, 0x63, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x01, 0x00, 0x06, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x92, 0xC5, 0x26, 0xBF, 0xF9, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xCF, 0x06, 0x69, 0x66, 0x2D, 0x6C, 0x65, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x80, 0xC4, 0x28, 0x69, 0x66, 0x2D, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x74, 0x72, 0x75, 0x20, 0x66, 0x61, 0x6C, 0x20, 0x26, 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, 0x20, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x75, 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, 0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x61, 0x6C, 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, 0x6C, 0x65, 0x74, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x45, 0xDF, 0xCD, 0x00, 0x00, 0x49, 0xD2, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBA, 0x00, 0x00, 0x09, 0x03, 0x04, 0x16, 0x01, 0xCE, 0x06, 0x69, 0x66, 0x2D, 0x6C, 0x65, 0x74, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x05, 0x7A, 0x65, 0x72, 0x6F, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x42, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x87, 0xCD, 0x2E, 0xBF, 0xF8, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 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, 0xDA, 0x33, 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, 0x28, 0x03, 0x00, 0x00, 0x37, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x1A, 0x06, 0x04, 0x00, 0x26, 0x07, 0x01, 0x00, 0x01, 0x07, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x1A, 0x06, 0x04, 0x00, 0x26, 0x07, 0x03, 0x00, 0x01, 0x07, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x2A, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x08, 0x00, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x30, 0x07, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x01, 0x06, 0x46, 0x01, 0xCE, 0x03, 0x61, 0x75, 0x78, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x01, 0x02, 0x09, 0x01, 0xCE, 0x0B, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, 0x65, 0x6E, 0x74, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xD8, 0x03, 0x6E, 0x6F, 0x74, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x27, 0x04, 0x00, 0x01, 0x33, 0x03, 0x04, 0x02, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x8F, 0xD8, 0x39, 0xBF, 0xF6, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xDD, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0x00, 0x04, 0xDA, 0x4F, 0xD5, 0x05, 0xDA, 0x17, 0xCB, 0xD0, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0xCB, 0xD0, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xCB, 0xD0, 0x05, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xCB, 0xD0, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xCB, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8E, 0xEB, 0x90, 0x13, 0xDA, 0x03, 0xDA, 0x4F, 0xDA, 0x03, 0xD8, 0x06, 0x67, 0x65, 0x6E, 0x73, 0x79, 0x6D, 0xCF, 0x03, 0x64, 0x65, 0x66, 0xD8, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xCF, 0x02, 0x69, 0x66, 0xCF, 0x02, 0x64, 0x6F, 0x28, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00, 0x33, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x06, 0x04, 0x05, 0x00, 0x27, 0x06, 0x00, 0x00, 0x33, 0x05, 0x06, 0x04, 0x17, 0x04, 0x05, 0x00, 0x27, 0x07, 0x00, 0x05, 0x41, 0x06, 0x00, 0x07, 0x1A, 0x06, 0x03, 0x00, 0x27, 0x07, 0x00, 0x01, 0x03, 0x07, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x08, 0x00, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x08, 0x07, 0x00, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x07, 0x03, 0x00, 0x18, 0x04, 0x00, 0x00, 0x26, 0x0A, 0x01, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x07, 0x09, 0x00, 0x17, 0x09, 0x07, 0x00, 0x1A, 0x08, 0x13, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2D, 0x07, 0x09, 0x04, 0x26, 0x0A, 0x03, 0x00, 0x2F, 0x07, 0x0A, 0x00, 0x25, 0x0B, 0x02, 0x00, 0x06, 0x0A, 0x0B, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0B, 0x01, 0x00, 0x26, 0x0A, 0x04, 0x00, 0x2D, 0x0A, 0x09, 0x0B, 0x27, 0x0A, 0x00, 0x02, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x0A, 0x0C, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2D, 0x0B, 0x07, 0x0A, 0x26, 0x0B, 0x03, 0x00, 0x30, 0x0B, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2D, 0x07, 0x09, 0x04, 0x26, 0x0A, 0x03, 0x00, 0x2F, 0x07, 0x0A, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2D, 0x0A, 0x03, 0x09, 0x26, 0x0B, 0x03, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x25, 0x0C, 0x02, 0x00, 0x06, 0x0B, 0x0C, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x2F, 0x0C, 0x01, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2D, 0x0B, 0x0A, 0x0C, 0x26, 0x0D, 0x03, 0x00, 0x2F, 0x0B, 0x0D, 0x00, 0x26, 0x0A, 0x04, 0x00, 0x2D, 0x0A, 0x09, 0x0B, 0x27, 0x0A, 0x00, 0x02, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x0A, 0x0C, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2D, 0x0B, 0x07, 0x0A, 0x26, 0x0B, 0x03, 0x00, 0x30, 0x0B, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x47, 0x4E, 0x82, 0x79, 0xBD, 0xA1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE9, 0x18, 0x1C, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE3, 0x1E, 0x0A, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF3, 0x82, 0x24, 0xBD, 0xDC, 0x82, 0x24, 0xBD, 0xDC, 0x82, 0x24, 0xBE, 0x10, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE8, 0x19, 0x13, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xF8, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0xBF, 0xE4, 0x1D, 0x0A, 0x81, 0xAD, 0xBE, 0x9C, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x27, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE5, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0x9F, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0x49, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x64, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x26, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x97, 0x6A, 0xBF, 0x96, 0x6A, 0xBF, 0x96, 0x6A, 0xBF, 0x96, 0x6A, 0xBF, 0x6F, 0x80, 0xAE, 0xBF, 0x52, 0x80, 0xAE, 0xBF, 0x52, 0x80, 0xAE, 0xBF, 0x52, 0x80, 0xAE, 0xBF, 0x52, 0x80, 0xAE, 0xBF, 0x52, 0x80, 0xAE, 0xBF, 0x11, 0x80, 0xF0, 0xBF, 0x10, 0x80, 0xF0, 0xBF, 0x10, 0x80, 0xF0, 0xBF, 0x10, 0x80, 0xF0, 0xCD, 0x00, 0x00, 0x45, 0xDF, 0x83, 0xF3, 0xBC, 0xEE, 0x10, 0xBF, 0xE7, 0x1A, 0x08, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x35, 0xBF, 0xDB, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xCC, 0x35, 0x08, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF3, 0x3C, 0xBF, 0xD3, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xC5, 0x3C, 0x04, 0x82, 0x79, 0xBD, 0x87, 0x82, 0x79, 0x04, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xCF, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x04, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x5B, 0x2C, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x5D, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 0x54, 0x68, 0x72, 0x6F, 0x77, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x74, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0xCF, 0x02, 0x2D, 0x2D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x93, 0x59, 0x93, 0x9B, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x09, 0xCE, 0x02, 0x2D, 0x2D, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0A, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x01, 0x2D, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x07, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x07, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x22, 0x28, 0x01, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x25, 0x04, 0x01, 0x00, 0x2D, 0x03, 0x00, 0x04, 0x3D, 0x02, 0x00, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2D, 0x04, 0x00, 0x02, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x93, 0x59, 0x42, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0xDA, 0x05, 0xCE, 0x26, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6C, 0x6F, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x32, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x0A, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x74, 0x79, 0x70, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x74, 0x79, 0x70, 0x65, 0xDA, 0x05, 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, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x05, 0xCE, 0x80, 0xF5, 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, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 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, 0x74, 0x6F, 0x20, 0x67, 0x6F, 0x20, 0x69, 0x6E, 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, 0x02, 0x2D, 0x3D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x24, 0x28, 0x2D, 0x3D, 0x20, 0x78, 0x20, 0x6E, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x93, 0xE3, 0x94, 0x27, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x02, 0x2D, 0x3D, 0xDA, 0x10, 0xDA, 0x6A, 0xDA, 0x22, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x93, 0xE3, 0x44, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x09, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xDA, 0x05, 0xCE, 0x80, 0xC2, 0x28, 0x75, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x5B, 0x2C, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x5D, 0x29, 0x0A, 0x0A, 0x55, 0x6E, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x61, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 0xCF, 0x02, 0x2D, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x20, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 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, 0x20, 0x20, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x67, 0x1D, 0xCD, 0x00, 0x00, 0x68, 0xFA, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x06, 0x01, 0x01, 0x06, 0x01, 0xCE, 0x02, 0x2D, 0x3E, 0xDA, 0x10, 0xDA, 0x3A, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x02, 0x06, 0x25, 0xCE, 0x03, 0x66, 0x6F, 0x70, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xD8, 0x0B, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x5B, 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0xD8, 0x0B, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x06, 0x04, 0x1A, 0x05, 0x0C, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x04, 0x01, 0x06, 0x25, 0x06, 0x01, 0x00, 0x2C, 0x01, 0x06, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x03, 0x07, 0x00, 0x18, 0x06, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2C, 0x01, 0x04, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x03, 0x06, 0x00, 0x35, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x35, 0x04, 0x03, 0x01, 0x17, 0x06, 0x04, 0x00, 0x2C, 0x05, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x04, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x04, 0x07, 0x00, 0x25, 0x08, 0x00, 0x00, 0x2C, 0x04, 0x08, 0x00, 0x26, 0x08, 0x05, 0x00, 0x30, 0x08, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x68, 0x0E, 0x80, 0xD4, 0xBF, 0x5C, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x6B, 0xBF, 0xC5, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xB5, 0x6B, 0xBF, 0x95, 0x6B, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x96, 0x6B, 0xBF, 0x8A, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0x11, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xDC, 0x25, 0x06, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCD, 0x00, 0x00, 0x67, 0x1D, 0x81, 0xDD, 0xBF, 0x14, 0x80, 0xD4, 0xBF, 0x2C, 0x80, 0xD4, 0x04, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0xDA, 0x05, 0xCE, 0x80, 0xDC, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x70, 0x6C, 0x69, 0x74, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x20, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x53, 0x70, 0x6C, 0x69, 0x74, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 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, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 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, 0xCF, 0x09, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x3F, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x3F, 0xDA, 0x05, 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, 0xCF, 0x04, 0x63, 0x6F, 0x72, 0x6F, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x51, 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, 0x2E, 0x20, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x28, 0x66, 0x6E, 0x20, 0x5B, 0x26, 0x5D, 0x20, 0x2E, 0x2E, 0x2E, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x29, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x44, 0x45, 0xCD, 0x00, 0x00, 0x44, 0xD0, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x04, 0x00, 0x04, 0x0B, 0xCE, 0x04, 0x63, 0x6F, 0x72, 0x6F, 0xDA, 0x10, 0xCF, 0x02, 0x66, 0x6E, 0xD2, 0x01, 0x01, 0xCF, 0x01, 0x26, 0xDA, 0x5B, 0xD8, 0x09, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2C, 0x02, 0x03, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x26, 0x03, 0x02, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x03, 0x03, 0x00, 0x2C, 0x03, 0x02, 0x00, 0x26, 0x03, 0x02, 0x00, 0x30, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x44, 0x45, 0x80, 0x8B, 0xBF, 0xE9, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xDA, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xCF, 0x04, 0x6C, 0x61, 0x73, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x50, 0x87, 0xCD, 0x00, 0x00, 0x50, 0xEE, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x00, 0x06, 0xCE, 0x04, 0x6C, 0x61, 0x73, 0x74, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x25, 0x04, 0x01, 0x00, 0x07, 0x03, 0x02, 0x04, 0x33, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x50, 0x87, 0x67, 0xBF, 0xF1, 0x0A, 0xBF, 0xF3, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xCF, 0x04, 0x6E, 0x65, 0x67, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x88, 0x35, 0x88, 0x68, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x04, 0x6E, 0x65, 0x67, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x3E, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x88, 0x35, 0x33, 0xBF, 0xF9, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xCF, 0x0D, 0x67, 0x63, 0x73, 0x65, 0x74, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x67, 0x63, 0x73, 0x65, 0x74, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6C, 0xDA, 0x05, 0xCE, 0x80, 0xD4, 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, 0x69, 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, 0xCF, 0x04, 0x64, 0x65, 0x66, 0x2D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x85, 0xC1, 0x86, 0x34, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x06, 0x01, 0x02, 0x07, 0xCE, 0x04, 0x64, 0x65, 0x66, 0x2D, 0xDA, 0x10, 0xDA, 0x5A, 0xD0, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x04, 0x00, 0x05, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x85, 0xC1, 0x73, 0xBF, 0xE4, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x65, 0x6E, 0x73, 0x75, 0x72, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x65, 0x6E, 0x73, 0x75, 0x72, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x26, 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, 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, 0x68, 0x61, 0x73, 0x20, 0x65, 0x6E, 0x6F, 0x75, 0x67, 0x68, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x2E, 0x20, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 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, 0xCF, 0x08, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x89, 0xA4, 0x89, 0xE7, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x08, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x16, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x89, 0xA4, 0x43, 0xBF, 0xEE, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x06, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8A, 0xCF, 0x8B, 0x09, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x06, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x52, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8A, 0xCF, 0x3A, 0xBF, 0xF0, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCF, 0x05, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x52, 0x28, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 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, 0x69, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x29, 0x20, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x5B, 0x4A, 0xCD, 0x00, 0x00, 0x5C, 0x04, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x02, 0x00, 0x14, 0xCE, 0x05, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0xDA, 0x10, 0x28, 0x02, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x17, 0x04, 0x01, 0x00, 0x37, 0x05, 0x04, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x3E, 0x07, 0x05, 0x06, 0x1A, 0x07, 0x0C, 0x00, 0x33, 0x08, 0x04, 0x05, 0x17, 0x09, 0x08, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x08, 0x00, 0x00, 0x1A, 0x08, 0x04, 0x00, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x03, 0x03, 0x0A, 0x18, 0x01, 0x00, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x05, 0x08, 0x05, 0x18, 0xF4, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5B, 0x4A, 0x80, 0xBA, 0xBF, 0xA7, 0x0E, 0x04, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xE1, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x22, 0xBF, 0xF4, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xDF, 0x22, 0xBF, 0xC5, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0xC4, 0x3C, 0xBF, 0x51, 0x80, 0xBA, 0xCF, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x62, 0x79, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x62, 0x79, 0x74, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0xA6, 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, 0x78, 0x29, 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, 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, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x39, 0x28, 0x64, 0x6F, 0x63, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x77, 0x72, 0x61, 0x70, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x94, 0x81, 0xCD, 0x00, 0x00, 0x97, 0xD0, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x14, 0x01, 0x07, 0x4A, 0x01, 0xCE, 0x0A, 0x64, 0x6F, 0x63, 0x2D, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xDA, 0x10, 0xD1, 0x01, 0x50, 0xCE, 0x04, 0x20, 0x20, 0x20, 0x20, 0xCE, 0x00, 0xCE, 0x02, 0x20, 0x20, 0xD8, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xDA, 0x80, 0xD6, 0xCE, 0x05, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x28, 0x01, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x35, 0x03, 0x03, 0x00, 0x25, 0x04, 0x08, 0x00, 0x07, 0x02, 0x03, 0x04, 0x17, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x39, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x39, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x08, 0x00, 0x00, 0x2A, 0x09, 0x00, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x17, 0x0B, 0x00, 0x00, 0x37, 0x0C, 0x0B, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x25, 0x0C, 0x00, 0x00, 0x3E, 0x0E, 0x0C, 0x0D, 0x1A, 0x0E, 0x32, 0x00, 0x33, 0x0F, 0x0B, 0x0C, 0x17, 0x10, 0x0F, 0x00, 0x25, 0x12, 0x0A, 0x00, 0x1F, 0x11, 0x10, 0x12, 0x19, 0x11, 0x03, 0x00, 0x23, 0x11, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x11, 0x00, 0x00, 0x1A, 0x11, 0x09, 0x00, 0x25, 0x13, 0x20, 0x00, 0x1F, 0x12, 0x10, 0x13, 0x19, 0x12, 0x03, 0x00, 0x23, 0x12, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x12, 0x00, 0x00, 0x17, 0x0F, 0x12, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0F, 0x00, 0x00, 0x1A, 0x0F, 0x0D, 0x00, 0x25, 0x12, 0x09, 0x00, 0x1F, 0x11, 0x10, 0x12, 0x1A, 0x11, 0x06, 0x00, 0x26, 0x12, 0x03, 0x00, 0x2C, 0x07, 0x12, 0x00, 0x26, 0x13, 0x04, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x18, 0x04, 0x00, 0x00, 0x2C, 0x07, 0x10, 0x00, 0x26, 0x13, 0x05, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x18, 0x10, 0x00, 0x00, 0x37, 0x11, 0x07, 0x00, 0x25, 0x13, 0x00, 0x00, 0x40, 0x12, 0x11, 0x13, 0x1A, 0x12, 0x03, 0x00, 0x2F, 0x11, 0x0A, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x12, 0x0A, 0x00, 0x1F, 0x11, 0x10, 0x12, 0x1A, 0x11, 0x07, 0x00, 0x26, 0x12, 0x06, 0x00, 0x2C, 0x05, 0x12, 0x00, 0x26, 0x13, 0x04, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x25, 0x08, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x0F, 0x01, 0x00, 0x06, 0x0C, 0x0F, 0x0C, 0x18, 0xCE, 0xFF, 0xFF, 0x2F, 0x0B, 0x0A, 0x00, 0x03, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x00, 0x04, 0x2B, 0x01, 0xCE, 0x08, 0x70, 0x75, 0x73, 0x68, 0x77, 0x6F, 0x72, 0x64, 0xDA, 0x10, 0xDA, 0x80, 0xE3, 0xCE, 0x01, 0x20, 0xDA, 0x80, 0xE2, 0xD8, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x28, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x08, 0x27, 0x04, 0x00, 0x07, 0x37, 0x03, 0x04, 0x00, 0x27, 0x05, 0x00, 0x08, 0x06, 0x04, 0x05, 0x03, 0x25, 0x05, 0x01, 0x00, 0x06, 0x04, 0x04, 0x05, 0x27, 0x05, 0x00, 0x03, 0x3F, 0x03, 0x05, 0x04, 0x1A, 0x03, 0x05, 0x00, 0x25, 0x04, 0x00, 0x00, 0x29, 0x04, 0x00, 0x08, 0x26, 0x02, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x27, 0x05, 0x00, 0x08, 0x25, 0x06, 0x01, 0x00, 0x06, 0x04, 0x05, 0x06, 0x29, 0x04, 0x00, 0x08, 0x26, 0x02, 0x01, 0x00, 0x17, 0x03, 0x02, 0x00, 0x27, 0x05, 0x00, 0x07, 0x37, 0x04, 0x05, 0x00, 0x27, 0x06, 0x00, 0x08, 0x06, 0x05, 0x06, 0x04, 0x29, 0x05, 0x00, 0x08, 0x25, 0x06, 0x00, 0x00, 0x40, 0x04, 0x01, 0x06, 0x1A, 0x04, 0x06, 0x00, 0x27, 0x06, 0x00, 0x05, 0x2C, 0x06, 0x03, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x18, 0x01, 0x00, 0x00, 0x27, 0x04, 0x00, 0x05, 0x27, 0x06, 0x00, 0x07, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2F, 0x04, 0x06, 0x00, 0x27, 0x06, 0x00, 0x07, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x06, 0x03, 0x00, 0x30, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x95, 0x22, 0x81, 0x4B, 0xBE, 0xCF, 0x13, 0x32, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE9, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xDB, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xD6, 0x6F, 0xBF, 0xC9, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xBA, 0x6F, 0xBF, 0x91, 0x6F, 0xBF, 0xEF, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0x97, 0x6F, 0xBF, 0x7F, 0x80, 0x82, 0x12, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0x0A, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x36, 0xBF, 0xE1, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xCB, 0x36, 0x06, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0x06, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x00, 0x94, 0x81, 0x83, 0x4F, 0xBD, 0x05, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x1D, 0x04, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0x04, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0x04, 0x0E, 0x05, 0x81, 0x4B, 0xBE, 0xB5, 0x81, 0x4B, 0x05, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xE6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF1, 0x1C, 0xBF, 0xF5, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xE5, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE0, 0x81, 0x22, 0xBF, 0x0C, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF6, 0x58, 0xBF, 0xBE, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xCD, 0x58, 0xBF, 0xE7, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0x7F, 0x81, 0x22, 0xBF, 0x7F, 0x0C, 0xBF, 0xF1, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x22, 0xBF, 0xF6, 0x09, 0xBF, 0xDF, 0x22, 0x12, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF3, 0x58, 0xBF, 0xC3, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0x0E, 0x0E, 0xBF, 0xA9, 0x58, 0xBE, 0xC9, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0xBE, 0xC6, 0x81, 0x3A, 0x13, 0x09, 0xBC, 0xB9, 0x83, 0x4F, 0xCF, 0x04, 0x77, 0x68, 0x65, 0x6E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x96, 0x65, 0x96, 0xF1, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x06, 0x01, 0x02, 0x09, 0xCE, 0x04, 0x77, 0x68, 0x65, 0x6E, 0xDA, 0x10, 0xDA, 0x5D, 0xDA, 0x5C, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x96, 0x65, 0x80, 0x8C, 0xBF, 0xE4, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xCF, 0x0F, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x61, 0x72, 0x67, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0F, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x61, 0x72, 0x67, 0x2D, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xDA, 0x05, 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, 0xCF, 0x07, 0x70, 0x72, 0x65, 0x77, 0x61, 0x6C, 0x6B, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x42, 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, 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x72, 0xCD, 0xCD, 0x00, 0x00, 0x73, 0x43, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x06, 0x02, 0x01, 0x07, 0x01, 0xCE, 0x07, 0x70, 0x72, 0x65, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0A, 0x02, 0x09, 0x24, 0xCE, 0x04, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x52, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0C, 0x02, 0x01, 0x1C, 0xCE, 0x09, 0x77, 0x61, 0x6C, 0x6B, 0x2D, 0x64, 0x69, 0x63, 0x74, 0xDA, 0x10, 0xD8, 0x04, 0x6E, 0x65, 0x78, 0x74, 0x28, 0x02, 0x00, 0x00, 0x3C, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x01, 0x00, 0x22, 0x06, 0x00, 0x00, 0x2C, 0x05, 0x06, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x07, 0x06, 0x00, 0x22, 0x08, 0x00, 0x00, 0x1F, 0x06, 0x08, 0x07, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x0C, 0x00, 0x17, 0x08, 0x07, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x2F, 0x09, 0x00, 0x00, 0x33, 0x0A, 0x01, 0x08, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0B, 0x00, 0x00, 0x34, 0x04, 0x09, 0x0B, 0x2C, 0x05, 0x07, 0x00, 0x26, 0x09, 0x00, 0x00, 0x2F, 0x07, 0x09, 0x00, 0x18, 0xEF, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x70, 0x1A, 0x6B, 0xBF, 0xB0, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xE9, 0x04, 0xBF, 0xFC, 0x04, 0x05, 0x0B, 0xBF, 0xF2, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE2, 0x1F, 0xBF, 0xC8, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0x9C, 0x6B, 0xDA, 0x51, 0xD8, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x74, 0x6F, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xDA, 0x50, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0F, 0x02, 0x02, 0x18, 0xCE, 0x08, 0x77, 0x61, 0x6C, 0x6B, 0x2D, 0x69, 0x6E, 0x64, 0xDA, 0x10, 0xD8, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x17, 0x07, 0x01, 0x00, 0x37, 0x08, 0x07, 0x00, 0x17, 0x09, 0x08, 0x00, 0x25, 0x08, 0x00, 0x00, 0x3E, 0x0A, 0x08, 0x09, 0x1A, 0x0A, 0x0B, 0x00, 0x33, 0x0B, 0x07, 0x08, 0x17, 0x0C, 0x0B, 0x00, 0x2B, 0x0C, 0x00, 0x00, 0x2F, 0x0B, 0x00, 0x00, 0x2C, 0x06, 0x0B, 0x00, 0x26, 0x0E, 0x01, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x25, 0x0B, 0x01, 0x00, 0x06, 0x08, 0x0B, 0x08, 0x18, 0xF5, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x6F, 0x9D, 0x7A, 0xBF, 0xA9, 0x0C, 0xBF, 0xEB, 0x16, 0x0D, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xE9, 0x18, 0x04, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xFA, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0x8D, 0x7A, 0xDA, 0x53, 0xDA, 0x80, 0x8C, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x26, 0x05, 0x01, 0x00, 0x1F, 0x03, 0x04, 0x05, 0x1A, 0x03, 0x04, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x05, 0x02, 0x00, 0x30, 0x05, 0x00, 0x00, 0x26, 0x06, 0x03, 0x00, 0x1F, 0x05, 0x04, 0x06, 0x1A, 0x05, 0x07, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x07, 0x04, 0x00, 0x30, 0x07, 0x00, 0x00, 0x26, 0x07, 0x05, 0x00, 0x1F, 0x06, 0x04, 0x07, 0x1A, 0x06, 0x04, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x07, 0x06, 0x00, 0x30, 0x07, 0x00, 0x00, 0x26, 0x08, 0x07, 0x00, 0x1F, 0x07, 0x04, 0x08, 0x1A, 0x07, 0x07, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x09, 0x06, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x09, 0x08, 0x00, 0x30, 0x09, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x70, 0x88, 0x81, 0x70, 0xBF, 0x54, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF0, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x6C, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xD2, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x9C, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xA1, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0xBB, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0x84, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0x4F, 0x80, 0xB1, 0xBF, 0xE5, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0x59, 0x80, 0xB1, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x2F, 0x04, 0x00, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x01, 0xDA, 0x10, 0x27, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x02, 0x30, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x73, 0x2B, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xCD, 0x00, 0x00, 0x72, 0xCD, 0x76, 0xBF, 0xE0, 0x15, 0x02, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xDC, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0xDA, 0x05, 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, 0xCF, 0x03, 0x6D, 0x69, 0x6E, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4E, 0xBD, 0xCD, 0x00, 0x00, 0x4F, 0x14, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x03, 0x00, 0x02, 0x05, 0xCE, 0x03, 0x6D, 0x69, 0x6E, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1B, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x01, 0x3C, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x3E, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x02, 0x01, 0x1A, 0xCE, 0x07, 0x65, 0x78, 0x74, 0x72, 0x65, 0x6D, 0x65, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x04, 0x70, 0x6F, 0x73, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x40, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x87, 0xFD, 0x36, 0xBF, 0xF9, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x1A, 0x05, 0x13, 0x00, 0x35, 0x06, 0x01, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x17, 0x08, 0x04, 0x00, 0x3E, 0x09, 0x06, 0x08, 0x1A, 0x09, 0x0C, 0x00, 0x17, 0x0A, 0x06, 0x00, 0x33, 0x0B, 0x01, 0x0A, 0x17, 0x0C, 0x0B, 0x00, 0x2C, 0x0C, 0x07, 0x00, 0x2F, 0x0B, 0x00, 0x00, 0x1A, 0x0B, 0x03, 0x00, 0x17, 0x07, 0x0C, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x0B, 0x01, 0x00, 0x06, 0x06, 0x06, 0x0B, 0x18, 0xF4, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4C, 0xEB, 0x81, 0x75, 0xBF, 0x63, 0x0C, 0xBF, 0xEB, 0x16, 0x0A, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF1, 0x80, 0x8B, 0xBF, 0x8A, 0x0F, 0xBF, 0xF1, 0x0F, 0x06, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xCE, 0x0B, 0xBF, 0xEE, 0x13, 0x0C, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x1D, 0xBF, 0xF5, 0x0A, 0xBF, 0xE4, 0x1D, 0xBF, 0xA9, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0x7E, 0x80, 0x8B, 0xBF, 0x75, 0x80, 0x8B, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4E, 0xBD, 0x57, 0xBF, 0xF0, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xCF, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x72, 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, 0x20, 0x20, 0x45, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x73, 0x20, 0x74, 0x6F, 0x20, 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, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x95, 0x08, 0x95, 0xB4, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x03, 0x0D, 0xCE, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0xDA, 0x10, 0xCF, 0x01, 0x3D, 0xDA, 0x5C, 0xDA, 0x5A, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x2D, 0x04, 0x05, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x03, 0x01, 0x2B, 0x00, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x05, 0x02, 0x00, 0x2D, 0x05, 0x00, 0x04, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x95, 0x08, 0x80, 0xAC, 0xBF, 0xD9, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xCF, 0x02, 0x2F, 0x3D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x28, 0x28, 0x2F, 0x3D, 0x20, 0x78, 0x20, 0x6E, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x94, 0x73, 0x94, 0xBB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x02, 0x2F, 0x3D, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x01, 0x2F, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x01, 0x00, 0x35, 0x04, 0x00, 0x00, 0x0B, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x0B, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x22, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x94, 0x73, 0x48, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x04, 0x6E, 0x6F, 0x74, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x19, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x04, 0x6E, 0x6F, 0x74, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x4C, 0x28, 0x6E, 0x6F, 0x74, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x74, 0x72, 0x75, 0x65, 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, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x2E, 0xCF, 0x07, 0x62, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x11, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x07, 0x62, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x01, 0x00, 0x35, 0x04, 0x00, 0x00, 0x12, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x12, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x65, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x65, 0x6B, 0xDA, 0x05, 0xCE, 0x81, 0xC1, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x65, 0x6B, 0x20, 0x66, 0x20, 0x5B, 0x2C, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x5B, 0x2C, 0x6E, 0x5D, 0x5D, 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, 0x2E, 0x20, 0x27, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x27, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x0A, 0x0A, 0x09, 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, 0x09, 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, 0x09, 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, 0x27, 0x77, 0x68, 0x65, 0x6E, 0x63, 0x65, 0x27, 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, 0x6E, 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, 0x6E, 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, 0x65, 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, 0xCF, 0x04, 0x64, 0x65, 0x66, 0x6E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x54, 0x28, 0x64, 0x65, 0x66, 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, 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, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x80, 0x99, 0x84, 0x60, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x17, 0x01, 0x0D, 0x38, 0x01, 0xCE, 0x04, 0x64, 0x65, 0x66, 0x6E, 0xDA, 0x10, 0xDA, 0x80, 0xE0, 0xCE, 0x01, 0x28, 0xD8, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xDA, 0x80, 0xE5, 0xDA, 0x80, 0xE2, 0xCE, 0x02, 0x25, 0x70, 0xD8, 0x0D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xCE, 0x03, 0x29, 0x0A, 0x0A, 0xD8, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xDA, 0x81, 0x00, 0xDA, 0x80, 0x8C, 0xDA, 0x80, 0x9C, 0xDA, 0x5A, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x38, 0x05, 0x00, 0x00, 0x17, 0x06, 0x05, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2A, 0x08, 0x00, 0x00, 0x17, 0x09, 0x08, 0x00, 0x25, 0x0A, 0x00, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0A, 0x09, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x33, 0x0C, 0x01, 0x0B, 0x17, 0x0D, 0x0C, 0x00, 0x25, 0x0E, 0x00, 0x00, 0x37, 0x0F, 0x0D, 0x00, 0x17, 0x10, 0x0F, 0x00, 0x26, 0x11, 0x01, 0x00, 0x2C, 0x11, 0x00, 0x00, 0x26, 0x12, 0x02, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x17, 0x12, 0x11, 0x00, 0x3E, 0x13, 0x0E, 0x10, 0x1A, 0x13, 0x0D, 0x00, 0x26, 0x14, 0x03, 0x00, 0x2C, 0x12, 0x14, 0x00, 0x26, 0x15, 0x04, 0x00, 0x2F, 0x14, 0x15, 0x00, 0x33, 0x14, 0x0D, 0x0E, 0x26, 0x15, 0x05, 0x00, 0x2D, 0x12, 0x15, 0x14, 0x26, 0x16, 0x06, 0x00, 0x2F, 0x15, 0x16, 0x00, 0x25, 0x14, 0x01, 0x00, 0x06, 0x0E, 0x0E, 0x14, 0x18, 0xF3, 0xFF, 0xFF, 0x26, 0x13, 0x07, 0x00, 0x2D, 0x12, 0x13, 0x07, 0x26, 0x14, 0x08, 0x00, 0x2F, 0x13, 0x14, 0x00, 0x2C, 0x06, 0x13, 0x00, 0x26, 0x15, 0x09, 0x00, 0x2F, 0x14, 0x15, 0x00, 0x2C, 0x01, 0x0B, 0x00, 0x26, 0x15, 0x0A, 0x00, 0x2F, 0x13, 0x15, 0x00, 0x26, 0x16, 0x0B, 0x00, 0x2C, 0x16, 0x00, 0x00, 0x2E, 0x13, 0x00, 0x00, 0x3D, 0x15, 0x00, 0x00, 0x26, 0x16, 0x0C, 0x00, 0x2C, 0x16, 0x00, 0x00, 0x2E, 0x06, 0x00, 0x00, 0x2B, 0x15, 0x00, 0x00, 0x3D, 0x13, 0x00, 0x00, 0x03, 0x13, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x04, 0x1D, 0x01, 0xCE, 0x05, 0x72, 0x65, 0x63, 0x75, 0x72, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x14, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x01, 0x33, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x02, 0x04, 0x00, 0x17, 0x04, 0x02, 0x00, 0x26, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x04, 0x06, 0x1A, 0x05, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x1F, 0x06, 0x04, 0x07, 0x1A, 0x06, 0x03, 0x00, 0x29, 0x03, 0x00, 0x07, 0x18, 0x05, 0x00, 0x00, 0x27, 0x07, 0x00, 0x06, 0x2C, 0x07, 0x03, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x27, 0x07, 0x00, 0x04, 0x3E, 0x06, 0x00, 0x07, 0x1A, 0x06, 0x05, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x07, 0x00, 0x08, 0x2B, 0x07, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0x81, 0x7C, 0x81, 0x0A, 0xBF, 0x0C, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x11, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF0, 0x11, 0x0E, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x80, 0xBD, 0xBF, 0x43, 0x80, 0xBD, 0xBF, 0x7E, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x59, 0xBF, 0xC7, 0x0F, 0xBF, 0xD1, 0x59, 0xBF, 0xE6, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0x13, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x1D, 0xBF, 0xF8, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xE4, 0x1D, 0x81, 0x07, 0x83, 0x58, 0xBC, 0xCC, 0x0C, 0xBF, 0xEB, 0x16, 0x06, 0x12, 0xBF, 0xEE, 0x12, 0x06, 0x0E, 0x18, 0x81, 0x0A, 0xBE, 0xE4, 0x81, 0x1D, 0x11, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEC, 0x15, 0x10, 0x0F, 0xBF, 0xE7, 0x1A, 0x30, 0x0C, 0x12, 0x0C, 0xBF, 0xE8, 0x19, 0x0F, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE7, 0x1A, 0x0D, 0x0F, 0xBF, 0xEA, 0x80, 0x88, 0xBF, 0x96, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0x20, 0x0F, 0xBF, 0xD9, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0x13, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0x7A, 0x80, 0x88, 0x1C, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xD0, 0x31, 0xBF, 0xCF, 0x31, 0xBF, 0xCF, 0x31, 0x42, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xC5, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xBF, 0xC3, 0x3D, 0xCF, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xDA, 0x05, 0xCE, 0x4B, 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, 0x73, 0x74, 0x72, 0x2E, 0xCF, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x9F, 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, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x73, 0x20, 0x69, 0x74, 0x73, 0x27, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x2C, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6F, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x27, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7A, 0xB4, 0xCD, 0x00, 0x00, 0x7B, 0x9A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x08, 0x03, 0x00, 0x08, 0xCE, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0xDA, 0x10, 0x28, 0x04, 0x00, 0x00, 0x33, 0x05, 0x00, 0x01, 0x17, 0x06, 0x05, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x2E, 0x03, 0x00, 0x00, 0x2F, 0x07, 0x02, 0x00, 0x34, 0x00, 0x01, 0x07, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7A, 0xB4, 0x80, 0xE6, 0xBF, 0xD1, 0x0B, 0xBF, 0xEC, 0x15, 0x12, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xCF, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x75, 0x70, 0x70, 0x65, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x75, 0x70, 0x70, 0x65, 0x72, 0xDA, 0x05, 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, 0x04, 0x65, 0x76, 0x61, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x81, 0x28, 0x65, 0x76, 0x61, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x26, 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, 0x20, 0x20, 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, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xB9, 0xFC, 0xCD, 0x00, 0x00, 0xBB, 0x08, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x0A, 0x02, 0x06, 0x1A, 0xCE, 0x04, 0x65, 0x76, 0x61, 0x6C, 0xDA, 0x10, 0xD1, 0x01, 0xDA, 0x00, 0xDA, 0x81, 0x56, 0xDA, 0x61, 0xDA, 0x13, 0xD0, 0x08, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xD0, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x28, 0x02, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x1F, 0x04, 0x05, 0x01, 0x1A, 0x04, 0x04, 0x00, 0x26, 0x03, 0x00, 0x00, 0x35, 0x03, 0x03, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x00, 0x04, 0x05, 0x26, 0x06, 0x02, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x26, 0x09, 0x04, 0x00, 0x1F, 0x08, 0x07, 0x09, 0x1A, 0x08, 0x02, 0x00, 0x30, 0x06, 0x00, 0x00, 0x26, 0x07, 0x05, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x2F, 0x07, 0x06, 0x00, 0x01, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xB9, 0xFC, 0x81, 0x0C, 0xBF, 0x84, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x0D, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xDF, 0x22, 0x0B, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF4, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE5, 0x3F, 0xBF, 0xE2, 0x04, 0x0D, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x0F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x74, 0x6F, 0x2D, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0xFD, 0xDA, 0x05, 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, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x62, 0x79, 0x74, 0x65, 0x73, 0xDA, 0x05, 0xCE, 0x58, 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, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 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, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x62, 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, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x77, 0x8E, 0xCD, 0x00, 0x00, 0x78, 0x94, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0C, 0x01, 0x03, 0x16, 0xCE, 0x07, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x03, 0x64, 0x65, 0x63, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x01, 0x00, 0x07, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x92, 0xED, 0x26, 0xBF, 0xF9, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xDA, 0x80, 0xFF, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x09, 0x00, 0x00, 0x41, 0x08, 0x05, 0x09, 0x1A, 0x08, 0x08, 0x00, 0x33, 0x09, 0x00, 0x05, 0x2C, 0x07, 0x09, 0x00, 0x26, 0x0B, 0x02, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x25, 0x09, 0x01, 0x00, 0x07, 0x05, 0x05, 0x09, 0x18, 0xF7, 0xFF, 0xFF, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x77, 0x8E, 0x81, 0x06, 0xBF, 0x73, 0x09, 0xBF, 0xEE, 0x13, 0x0B, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF1, 0x10, 0x12, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xE4, 0x1D, 0x0B, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x3E, 0xBF, 0xEB, 0x08, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0x06, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0xC3, 0x3E, 0xBF, 0x06, 0x81, 0x06, 0xCF, 0x11, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x11, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x65, 0x74, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xDA, 0x05, 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, 0xCF, 0x05, 0x74, 0x72, 0x75, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8E, 0x18, 0x8E, 0x48, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x05, 0x74, 0x72, 0x75, 0x65, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x8E, 0x18, 0x30, 0xBF, 0xF6, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xCF, 0x08, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x41, 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, 0x78, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x82, 0x88, 0xCD, 0x00, 0x00, 0x83, 0x4F, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0E, 0x01, 0x01, 0x19, 0xCE, 0x08, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74, 0xDA, 0x10, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x3C, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x17, 0x06, 0x00, 0x00, 0x37, 0x07, 0x06, 0x00, 0x17, 0x08, 0x07, 0x00, 0x25, 0x07, 0x00, 0x00, 0x3E, 0x09, 0x07, 0x08, 0x1A, 0x09, 0x0E, 0x00, 0x33, 0x0A, 0x06, 0x07, 0x17, 0x0B, 0x0A, 0x00, 0x33, 0x0A, 0x05, 0x0B, 0x1A, 0x0A, 0x02, 0x00, 0x18, 0x06, 0x00, 0x00, 0x23, 0x0C, 0x00, 0x00, 0x34, 0x05, 0x0B, 0x0C, 0x2C, 0x03, 0x0B, 0x00, 0x26, 0x0D, 0x00, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x07, 0x0A, 0x07, 0x18, 0xF2, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x82, 0x88, 0x80, 0xC7, 0xBF, 0x88, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x0D, 0xBF, 0xF3, 0x0D, 0x04, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xC5, 0x0B, 0xBF, 0xF1, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xDB, 0x10, 0xBF, 0xF0, 0x10, 0x02, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xB3, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0xB0, 0x50, 0xBF, 0x40, 0x80, 0xC7, 0xCF, 0x04, 0x2D, 0x3F, 0x3E, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x81, 0x1D, 0x28, 0x2D, 0x3F, 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, 0x20, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x20, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x6D, 0x43, 0xCD, 0x00, 0x00, 0x6F, 0x9A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x06, 0x01, 0x01, 0x06, 0x01, 0xCE, 0x04, 0x2D, 0x3F, 0x3E, 0x3E, 0xDA, 0x10, 0xDA, 0x3A, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0E, 0x02, 0x09, 0x33, 0xDA, 0x80, 0x89, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x80, 0x8A, 0xDA, 0x5B, 0xDA, 0x59, 0xDA, 0x80, 0x8B, 0xDA, 0x80, 0x8C, 0xDA, 0x5C, 0xCF, 0x03, 0x6C, 0x65, 0x74, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x06, 0x04, 0x1A, 0x05, 0x0C, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x04, 0x01, 0x06, 0x25, 0x06, 0x01, 0x00, 0x2C, 0x01, 0x06, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x03, 0x07, 0x00, 0x18, 0x06, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2C, 0x01, 0x04, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x03, 0x06, 0x00, 0x35, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x35, 0x04, 0x03, 0x01, 0x17, 0x06, 0x04, 0x00, 0x26, 0x07, 0x04, 0x00, 0x2F, 0x04, 0x07, 0x00, 0x17, 0x07, 0x04, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x38, 0x08, 0x00, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x38, 0x09, 0x00, 0x00, 0x2D, 0x08, 0x06, 0x09, 0x26, 0x0B, 0x05, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x17, 0x08, 0x0A, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x25, 0x0B, 0x00, 0x00, 0x2C, 0x08, 0x0B, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x2D, 0x0D, 0x07, 0x0B, 0x3D, 0x0C, 0x00, 0x00, 0x26, 0x0D, 0x08, 0x00, 0x2D, 0x0D, 0x09, 0x0C, 0x3D, 0x0B, 0x00, 0x00, 0x03, 0x0B, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x6E, 0x76, 0x81, 0x0C, 0xBF, 0x24, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x6B, 0xBF, 0xC5, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xB5, 0x6B, 0xBF, 0x95, 0x6B, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x96, 0x6B, 0xBF, 0x8A, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0x0F, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0x11, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xDA, 0x27, 0x06, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xCD, 0x00, 0x00, 0x6D, 0x43, 0x82, 0x57, 0xBE, 0xDC, 0x81, 0x0C, 0xBE, 0xF4, 0x81, 0x0C, 0x04, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x07, 0x62, 0x6C, 0x73, 0x68, 0x69, 0x66, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x10, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x07, 0x62, 0x6C, 0x73, 0x68, 0x69, 0x66, 0x74, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x01, 0x00, 0x35, 0x04, 0x00, 0x00, 0x10, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x10, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x70, 0x6F, 0x70, 0x65, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x70, 0x6F, 0x70, 0x65, 0x6E, 0xDA, 0x05, 0xCE, 0x81, 0x1A, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x70, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x5B, 0x2C, 0x6D, 0x6F, 0x64, 0x65, 0x5D, 0x29, 0x0A, 0x0A, 0x4F, 0x70, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x62, 0x61, 0x63, 0x6B, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x72, 0x20, 0x28, 0x72, 0x65, 0x61, 0x64, 0x29, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3A, 0x77, 0x20, 0x28, 0x77, 0x72, 0x69, 0x74, 0x65, 0x29, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x3A, 0x72, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x3A, 0x77, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6E, 0x20, 0x74, 0x6F, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0xCF, 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0xD0, 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, 0x5B, 0x2C, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x5D, 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, 0x69, 0x6E, 0x64, 0x65, 0x78, 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, 0x05, 0x79, 0x69, 0x65, 0x6C, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x08, 0x00, 0x04, 0x02, 0x01, 0x00, 0x02, 0xCE, 0x05, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x32, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x80, 0xDE, 0x28, 0x79, 0x69, 0x65, 0x6C, 0x64, 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, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0xDA, 0x05, 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, 0x04, 0x63, 0x61, 0x73, 0x65, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x6F, 0x64, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x72, 0x67, 0x75, 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, 0x20, 0x20, 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, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x99, 0x66, 0x9B, 0xC5, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x0C, 0x01, 0x05, 0x1D, 0x01, 0xCE, 0x04, 0x63, 0x61, 0x73, 0x65, 0xDA, 0x10, 0xDA, 0x4F, 0xDA, 0x59, 0xDA, 0x5A, 0xDA, 0x5B, 0xDA, 0x5D, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x1A, 0x04, 0x03, 0x00, 0x17, 0x05, 0x00, 0x00, 0x18, 0x04, 0x00, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x2A, 0x07, 0x00, 0x00, 0x17, 0x08, 0x07, 0x00, 0x1A, 0x04, 0x04, 0x00, 0x25, 0x09, 0x00, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x30, 0x08, 0x00, 0x00, 0x26, 0x09, 0x02, 0x00, 0x2D, 0x09, 0x06, 0x00, 0x26, 0x0A, 0x03, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x25, 0x0A, 0x00, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0A, 0x08, 0x00, 0x26, 0x0B, 0x04, 0x00, 0x2D, 0x0B, 0x09, 0x0A, 0x26, 0x0B, 0x03, 0x00, 0x30, 0x0B, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x03, 0x23, 0x01, 0xDA, 0x4C, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x18, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x01, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x5B, 0xDA, 0x5C, 0x28, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x01, 0x37, 0x02, 0x03, 0x00, 0x07, 0x03, 0x02, 0x00, 0x17, 0x02, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x1F, 0x04, 0x02, 0x05, 0x1A, 0x04, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x25, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x02, 0x06, 0x1A, 0x05, 0x04, 0x00, 0x27, 0x07, 0x00, 0x01, 0x33, 0x06, 0x07, 0x00, 0x03, 0x06, 0x00, 0x00, 0x27, 0x07, 0x00, 0x01, 0x33, 0x06, 0x07, 0x00, 0x26, 0x07, 0x00, 0x00, 0x27, 0x08, 0x00, 0x06, 0x2D, 0x07, 0x08, 0x06, 0x26, 0x08, 0x01, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x06, 0x00, 0x08, 0x27, 0x09, 0x00, 0x01, 0x33, 0x08, 0x09, 0x06, 0x25, 0x09, 0x02, 0x00, 0x06, 0x06, 0x00, 0x09, 0x2B, 0x06, 0x00, 0x00, 0x2F, 0x09, 0x01, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2D, 0x06, 0x07, 0x08, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x06, 0x01, 0x00, 0x30, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0x9A, 0x7F, 0x80, 0xE6, 0xBF, 0x3C, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF0, 0x13, 0xBF, 0xE0, 0x21, 0x0A, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x80, 0xAC, 0xBF, 0x54, 0x80, 0xAC, 0xBF, 0x74, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x80, 0x8F, 0xBF, 0x83, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0x22, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE7, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0x1C, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0x16, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x9B, 0x66, 0xBF, 0x9A, 0x66, 0xBF, 0x9A, 0x66, 0xBF, 0x9A, 0x66, 0xBF, 0x9A, 0x66, 0x99, 0x66, 0x82, 0x5F, 0xBE, 0x79, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x0D, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xF8, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xE8, 0x19, 0xBF, 0xDE, 0x23, 0x04, 0x80, 0xE6, 0xBF, 0x1A, 0x80, 0xE6, 0x04, 0x5B, 0xBF, 0xB1, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0x1C, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0x0D, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xBF, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xCF, 0x07, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x07, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0xDA, 0x05, 0xCE, 0x81, 0x7B, 0x28, 0x6D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x78, 0x20, 0x5B, 0x2C, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0x20, 0x5B, 0x2C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5D, 0x5D, 0x29, 0x0A, 0x0A, 0x4D, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6C, 0x20, 0x61, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 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, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x9C, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 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, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x20, 0x20, 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, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x63, 0xCB, 0xCD, 0x00, 0x00, 0x64, 0xA9, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x02, 0x00, 0x18, 0xCE, 0x0A, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0xDA, 0x10, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x23, 0x06, 0x00, 0x00, 0x3E, 0x08, 0x05, 0x04, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x07, 0x06, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1A, 0x07, 0x0B, 0x00, 0x33, 0x08, 0x01, 0x05, 0x17, 0x09, 0x08, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x08, 0x00, 0x00, 0x1A, 0x08, 0x03, 0x00, 0x24, 0x06, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x05, 0x05, 0x0A, 0x18, 0xF1, 0xFF, 0xFF, 0x1A, 0x06, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5F, 0xEC, 0x81, 0x25, 0xBF, 0x59, 0x0B, 0xBF, 0xEC, 0x15, 0x04, 0x08, 0x04, 0x0F, 0x0F, 0x08, 0xBF, 0xF4, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE6, 0x64, 0xBF, 0xC6, 0x0A, 0xBF, 0xEC, 0x15, 0x0A, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x28, 0xBF, 0xE8, 0x10, 0xBF, 0xE0, 0x28, 0xBF, 0xFA, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0x9E, 0x64, 0x04, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xDA, 0x80, 0x8A, 0x28, 0x02, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2C, 0x01, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x63, 0xCB, 0x80, 0xDE, 0xBF, 0xD4, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE5, 0x1C, 0x04, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x6C, 0x69, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x6C, 0x69, 0x74, 0xDA, 0x05, 0xCE, 0x81, 0x16, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x6C, 0x69, 0x74, 0x20, 0x64, 0x65, 0x73, 0x74, 0x20, 0x73, 0x72, 0x63, 0x20, 0x5B, 0x2C, 0x20, 0x64, 0x65, 0x73, 0x74, 0x2D, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x20, 0x5B, 0x2C, 0x20, 0x73, 0x72, 0x63, 0x2D, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x20, 0x5B, 0x2C, 0x20, 0x73, 0x72, 0x63, 0x2D, 0x65, 0x6E, 0x64, 0x3D, 0x2D, 0x31, 0x5D, 0x5D, 0x5D, 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, 0x73, 0x72, 0x63, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x64, 0x65, 0x73, 0x74, 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, 0x73, 0x72, 0x63, 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, 0x64, 0x65, 0x73, 0x74, 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, 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, 0x73, 0x72, 0x63, 0x20, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x73, 0x74, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x64, 0x65, 0x73, 0x74, 0x2E, 0xCF, 0x10, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x2A, 0x73, 0x79, 0x73, 0x70, 0x61, 0x74, 0x68, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xAB, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2E, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x65, 0x74, 0x20, 0x61, 0x74, 0x20, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 0x20, 0x2F, 0x75, 0x73, 0x72, 0x2F, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x2F, 0x6C, 0x69, 0x62, 0x2F, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x6C, 0x69, 0x6E, 0x75, 0x78, 0x2F, 0x70, 0x6F, 0x73, 0x69, 0x78, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x20, 0x6F, 0x6E, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x69, 0x73, 0x20, 0x43, 0x3A, 0x2F, 0x4A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x4C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xC0, 0x05, 0xCD, 0x00, 0x00, 0xC0, 0xEF, 0xD0, 0x03, 0x72, 0x65, 0x66, 0xD1, 0x01, 0xCE, 0x14, 0x2F, 0x75, 0x73, 0x72, 0x2F, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x2F, 0x6C, 0x69, 0x62, 0x2F, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xCF, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xDA, 0x05, 0xCE, 0x81, 0x91, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 0x3A, 0x75, 0x73, 0x65, 0x72, 0x28, 0x30, 0x2D, 0x39, 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, 0x09, 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, 0x09, 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, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0xDA, 0x05, 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, 0xCF, 0x06, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x4A, 0x28, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, 0x20, 0x78, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x9B, 0x2F, 0xCD, 0x00, 0x00, 0xA4, 0x1E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x1C, 0x01, 0x14, 0x5A, 0x07, 0xCE, 0x06, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x31, 0xDA, 0x10, 0xCF, 0x03, 0x76, 0x61, 0x72, 0xDA, 0x22, 0xCF, 0x05, 0x71, 0x75, 0x6F, 0x74, 0x65, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x02, 0x01, 0x00, 0x02, 0xCE, 0x08, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4C, 0x31, 0x48, 0xBF, 0xB8, 0x48, 0xDA, 0x5A, 0xDA, 0x5C, 0xCF, 0x0A, 0x71, 0x75, 0x61, 0x73, 0x69, 0x71, 0x75, 0x6F, 0x74, 0x65, 0xDA, 0x5D, 0xDA, 0x80, 0x9C, 0xCF, 0x05, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x72, 0xD0, 0x08, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x1C, 0x01, 0x02, 0x80, 0x8A, 0xCE, 0x03, 0x6D, 0x61, 0x70, 0xDA, 0x10, 0xCE, 0x26, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x6C, 0x65, 0x61, 0x73, 0x74, 0x20, 0x31, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xDA, 0x80, 0xFF, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x25, 0x06, 0x00, 0x00, 0x1F, 0x05, 0x06, 0x04, 0x1A, 0x05, 0x04, 0x00, 0x26, 0x06, 0x00, 0x00, 0x01, 0x06, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x05, 0x01, 0x06, 0x37, 0x06, 0x05, 0x00, 0x17, 0x05, 0x06, 0x00, 0x25, 0x07, 0x00, 0x00, 0x17, 0x08, 0x04, 0x00, 0x3E, 0x09, 0x07, 0x08, 0x1A, 0x09, 0x0C, 0x00, 0x17, 0x0A, 0x07, 0x00, 0x33, 0x0B, 0x01, 0x0A, 0x37, 0x0C, 0x0B, 0x00, 0x17, 0x0B, 0x0C, 0x00, 0x3E, 0x0C, 0x0B, 0x05, 0x1A, 0x0C, 0x03, 0x00, 0x17, 0x05, 0x0B, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x0B, 0x01, 0x00, 0x06, 0x07, 0x07, 0x0B, 0x18, 0xF4, 0xFF, 0xFF, 0x35, 0x07, 0x01, 0x00, 0x17, 0x08, 0x07, 0x00, 0x35, 0x07, 0x01, 0x01, 0x17, 0x09, 0x07, 0x00, 0x35, 0x07, 0x01, 0x02, 0x17, 0x0A, 0x07, 0x00, 0x35, 0x07, 0x01, 0x03, 0x17, 0x0B, 0x07, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x0C, 0x01, 0x00, 0x2F, 0x07, 0x0C, 0x00, 0x17, 0x0C, 0x07, 0x00, 0x25, 0x0E, 0x01, 0x00, 0x1F, 0x0D, 0x04, 0x0E, 0x1A, 0x0D, 0x0E, 0x00, 0x25, 0x0E, 0x00, 0x00, 0x17, 0x0F, 0x05, 0x00, 0x3E, 0x10, 0x0E, 0x0F, 0x1A, 0x10, 0x09, 0x00, 0x17, 0x11, 0x0E, 0x00, 0x33, 0x12, 0x08, 0x11, 0x2B, 0x12, 0x00, 0x00, 0x2F, 0x13, 0x00, 0x00, 0x34, 0x0C, 0x11, 0x13, 0x25, 0x12, 0x01, 0x00, 0x06, 0x0E, 0x0E, 0x12, 0x18, 0xF7, 0xFF, 0xFF, 0x18, 0x52, 0x00, 0x00, 0x25, 0x0F, 0x02, 0x00, 0x1F, 0x0E, 0x04, 0x0F, 0x1A, 0x0E, 0x0F, 0x00, 0x25, 0x0F, 0x00, 0x00, 0x17, 0x10, 0x05, 0x00, 0x3E, 0x11, 0x0F, 0x10, 0x1A, 0x11, 0x0A, 0x00, 0x17, 0x12, 0x0F, 0x00, 0x33, 0x13, 0x08, 0x12, 0x33, 0x14, 0x09, 0x12, 0x2C, 0x13, 0x14, 0x00, 0x2F, 0x15, 0x00, 0x00, 0x34, 0x0C, 0x12, 0x15, 0x25, 0x13, 0x01, 0x00, 0x06, 0x0F, 0x0F, 0x13, 0x18, 0xF6, 0xFF, 0xFF, 0x18, 0x41, 0x00, 0x00, 0x25, 0x10, 0x03, 0x00, 0x1F, 0x0F, 0x04, 0x10, 0x1A, 0x0F, 0x10, 0x00, 0x25, 0x10, 0x00, 0x00, 0x17, 0x11, 0x05, 0x00, 0x3E, 0x12, 0x10, 0x11, 0x1A, 0x12, 0x0B, 0x00, 0x17, 0x13, 0x10, 0x00, 0x33, 0x14, 0x08, 0x13, 0x33, 0x15, 0x09, 0x13, 0x33, 0x16, 0x0A, 0x13, 0x2D, 0x14, 0x15, 0x16, 0x2F, 0x17, 0x00, 0x00, 0x34, 0x0C, 0x13, 0x17, 0x25, 0x14, 0x01, 0x00, 0x06, 0x10, 0x10, 0x14, 0x18, 0xF5, 0xFF, 0xFF, 0x18, 0x2F, 0x00, 0x00, 0x25, 0x11, 0x04, 0x00, 0x1F, 0x10, 0x04, 0x11, 0x1A, 0x10, 0x12, 0x00, 0x25, 0x11, 0x00, 0x00, 0x17, 0x12, 0x05, 0x00, 0x3E, 0x13, 0x11, 0x12, 0x1A, 0x13, 0x0D, 0x00, 0x17, 0x14, 0x11, 0x00, 0x33, 0x15, 0x08, 0x14, 0x33, 0x16, 0x09, 0x14, 0x33, 0x17, 0x0A, 0x14, 0x33, 0x18, 0x0B, 0x14, 0x2D, 0x15, 0x16, 0x17, 0x2B, 0x18, 0x00, 0x00, 0x2F, 0x19, 0x00, 0x00, 0x34, 0x0C, 0x14, 0x19, 0x25, 0x15, 0x01, 0x00, 0x06, 0x11, 0x11, 0x15, 0x18, 0xF3, 0xFF, 0xFF, 0x18, 0x1B, 0x00, 0x00, 0x25, 0x11, 0x00, 0x00, 0x17, 0x12, 0x05, 0x00, 0x3E, 0x13, 0x11, 0x12, 0x1A, 0x13, 0x17, 0x00, 0x17, 0x14, 0x11, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x26, 0x16, 0x01, 0x00, 0x2F, 0x15, 0x16, 0x00, 0x17, 0x16, 0x15, 0x00, 0x25, 0x15, 0x00, 0x00, 0x17, 0x17, 0x04, 0x00, 0x3E, 0x18, 0x15, 0x17, 0x1A, 0x18, 0x08, 0x00, 0x17, 0x19, 0x15, 0x00, 0x33, 0x1A, 0x01, 0x19, 0x33, 0x1B, 0x1A, 0x14, 0x34, 0x16, 0x19, 0x1B, 0x25, 0x1A, 0x01, 0x00, 0x06, 0x15, 0x15, 0x1A, 0x18, 0xF8, 0xFF, 0xFF, 0x2E, 0x16, 0x00, 0x00, 0x2F, 0x15, 0x00, 0x00, 0x34, 0x0C, 0x14, 0x15, 0x25, 0x15, 0x01, 0x00, 0x06, 0x11, 0x11, 0x15, 0x18, 0xE9, 0xFF, 0xFF, 0x03, 0x0C, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x55, 0x3C, 0x83, 0x99, 0xBC, 0xF4, 0x0C, 0xBF, 0xE9, 0x18, 0x08, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x40, 0xBF, 0xD0, 0x2F, 0xBF, 0xD1, 0x2F, 0xBF, 0xC1, 0x40, 0x17, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xED, 0x14, 0xBF, 0xE1, 0x20, 0x04, 0x5F, 0xBF, 0xA1, 0x5F, 0xBF, 0xA1, 0x5F, 0xBF, 0xA1, 0x5F, 0xBF, 0xA1, 0x5F, 0xBF, 0xCF, 0x0B, 0xBF, 0xED, 0x14, 0xBF, 0xE5, 0x1C, 0x0A, 0x0A, 0xBF, 0xF2, 0x1D, 0xBF, 0xF3, 0x0C, 0xBF, 0xE4, 0x1D, 0xBF, 0xA2, 0x5F, 0xBF, 0xA1, 0x5F, 0xBF, 0xA1, 0x5F, 0x04, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0x0D, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE7, 0x1A, 0x04, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x22, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xF4, 0x09, 0xBF, 0xF4, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xE6, 0x1B, 0xBF, 0xCA, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xB7, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x61, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xE9, 0x09, 0x02, 0x09, 0xBF, 0xE9, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xDB, 0x26, 0xBF, 0xBF, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0x6D, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0xAB, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0xDE, 0x09, 0x02, 0x09, 0x02, 0x09, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xD0, 0x31, 0xBF, 0xB4, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0xB3, 0x4D, 0xBF, 0x18, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBE, 0x10, 0x81, 0xF0, 0xBF, 0x00, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xD3, 0x09, 0x02, 0x09, 0x02, 0x09, 0x02, 0x09, 0xBF, 0xD3, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xC5, 0x3C, 0xBF, 0xA9, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBE, 0xB8, 0x81, 0xF0, 0xBF, 0x5E, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBF, 0x8A, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE6, 0x1B, 0x08, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xF0, 0x0B, 0xBF, 0xF0, 0x13, 0xBF, 0xDF, 0x22, 0xBF, 0xC3, 0x3E, 0xBF, 0xC2, 0x3E, 0xBF, 0xC2, 0x3E, 0x15, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xEB, 0x16, 0xBF, 0x60, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBF, 0x5F, 0x80, 0xA1, 0xBC, 0x6F, 0x83, 0x99, 0xD8, 0x0E, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0xDA, 0x50, 0xDA, 0x51, 0xDA, 0x80, 0xFD, 0xDA, 0x52, 0x28, 0x01, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x2A, 0x04, 0x01, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2A, 0x06, 0x02, 0x00, 0x17, 0x07, 0x06, 0x00, 0x2A, 0x08, 0x03, 0x00, 0x17, 0x09, 0x08, 0x00, 0x2A, 0x0A, 0x04, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x2A, 0x0C, 0x05, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x26, 0x0E, 0x00, 0x00, 0x26, 0x0F, 0x01, 0x00, 0x2D, 0x0E, 0x07, 0x0F, 0x26, 0x0E, 0x02, 0x00, 0x26, 0x0F, 0x03, 0x00, 0x2D, 0x07, 0x0E, 0x0F, 0x26, 0x0E, 0x04, 0x00, 0x26, 0x0F, 0x05, 0x00, 0x2D, 0x0E, 0x07, 0x0F, 0x26, 0x0E, 0x06, 0x00, 0x2D, 0x09, 0x0E, 0x0D, 0x26, 0x0E, 0x07, 0x00, 0x26, 0x0F, 0x08, 0x00, 0x2D, 0x0E, 0x09, 0x0F, 0x26, 0x0E, 0x09, 0x00, 0x2D, 0x0B, 0x0E, 0x09, 0x3B, 0x0E, 0x00, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x2A, 0x10, 0x06, 0x00, 0x17, 0x11, 0x10, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x13, 0x0A, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x17, 0x13, 0x12, 0x00, 0x26, 0x15, 0x0B, 0x00, 0x1F, 0x14, 0x13, 0x15, 0x1A, 0x14, 0x14, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x17, 0x0C, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x18, 0x0D, 0x00, 0x1F, 0x17, 0x16, 0x18, 0x1A, 0x17, 0x09, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x18, 0x0E, 0x00, 0x2F, 0x16, 0x18, 0x00, 0x2E, 0x16, 0x00, 0x00, 0x26, 0x19, 0x0F, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x17, 0x15, 0x18, 0x00, 0x18, 0x04, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x2F, 0x16, 0x11, 0x00, 0x17, 0x15, 0x16, 0x00, 0x17, 0x12, 0x15, 0x00, 0x18, 0x1E, 0x00, 0x00, 0x26, 0x17, 0x10, 0x00, 0x1F, 0x16, 0x13, 0x17, 0x1A, 0x16, 0x06, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x18, 0x0E, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x17, 0x15, 0x17, 0x00, 0x18, 0x15, 0x00, 0x00, 0x26, 0x19, 0x11, 0x00, 0x1F, 0x18, 0x13, 0x19, 0x1A, 0x18, 0x08, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x2F, 0x19, 0x03, 0x00, 0x2B, 0x19, 0x00, 0x00, 0x26, 0x1B, 0x12, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x17, 0x17, 0x1A, 0x00, 0x18, 0x0A, 0x00, 0x00, 0x26, 0x1B, 0x13, 0x00, 0x1F, 0x1A, 0x13, 0x1B, 0x1A, 0x1A, 0x05, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x2F, 0x1B, 0x03, 0x00, 0x17, 0x19, 0x1B, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x19, 0x00, 0x00, 0x17, 0x17, 0x19, 0x00, 0x17, 0x15, 0x17, 0x00, 0x17, 0x12, 0x15, 0x00, 0x17, 0x13, 0x12, 0x00, 0x03, 0x13, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x02, 0x01, 0x1B, 0x01, 0xCE, 0x07, 0x64, 0x6F, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0xFB, 0x28, 0x02, 0x00, 0x00, 0x3C, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x22, 0x05, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x22, 0x08, 0x00, 0x00, 0x1F, 0x07, 0x08, 0x06, 0x19, 0x07, 0x03, 0x00, 0x23, 0x07, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x07, 0x00, 0x00, 0x1A, 0x07, 0x0C, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x27, 0x09, 0x00, 0x01, 0x2F, 0x08, 0x09, 0x00, 0x33, 0x09, 0x00, 0x06, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x0A, 0x01, 0x00, 0x34, 0x04, 0x08, 0x0A, 0x2C, 0x00, 0x06, 0x00, 0x26, 0x08, 0x00, 0x00, 0x2F, 0x06, 0x08, 0x00, 0x18, 0xEF, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x9B, 0x88, 0x80, 0xBE, 0xBF, 0x61, 0x0D, 0xBF, 0xF3, 0x0D, 0x0F, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEC, 0x15, 0x0D, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEC, 0x67, 0xBF, 0xBF, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0x0C, 0x0A, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD4, 0x2D, 0x11, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0x9B, 0x67, 0xBF, 0x4C, 0x80, 0xBE, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x01, 0x08, 0x26, 0x01, 0xCE, 0x0F, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x50, 0xDA, 0x81, 0xD4, 0xDA, 0x53, 0xDA, 0x80, 0x8C, 0xDA, 0x52, 0xDA, 0x51, 0xDA, 0x80, 0xFD, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x04, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x04, 0x02, 0x00, 0x30, 0x04, 0x00, 0x00, 0x26, 0x05, 0x03, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x07, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x06, 0x04, 0x00, 0x30, 0x06, 0x00, 0x00, 0x26, 0x06, 0x05, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x1A, 0x05, 0x04, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x27, 0x06, 0x00, 0x03, 0x30, 0x06, 0x00, 0x00, 0x26, 0x07, 0x06, 0x00, 0x1F, 0x06, 0x03, 0x07, 0x1A, 0x06, 0x07, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x27, 0x08, 0x00, 0x03, 0x2F, 0x07, 0x08, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x08, 0x07, 0x00, 0x30, 0x08, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x07, 0x00, 0x01, 0x30, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x9C, 0x4B, 0x80, 0xFB, 0xBF, 0x29, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF3, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x40, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xCE, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x72, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDD, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0x9B, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x98, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0x72, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0x24, 0x80, 0xDC, 0xBF, 0xD3, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xD5, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0x08, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0B, 0x01, 0x02, 0x20, 0x01, 0xCE, 0x09, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x64, 0x65, 0x66, 0xDA, 0x10, 0xDA, 0x80, 0x8C, 0xDA, 0x80, 0x8B, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x25, 0x04, 0x01, 0x00, 0x07, 0x03, 0x02, 0x04, 0x33, 0x02, 0x00, 0x03, 0x17, 0x03, 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x17, 0x05, 0x04, 0x00, 0x25, 0x07, 0x00, 0x00, 0x33, 0x06, 0x00, 0x07, 0x2B, 0x05, 0x00, 0x00, 0x27, 0x08, 0x00, 0x05, 0x2F, 0x07, 0x08, 0x00, 0x2C, 0x06, 0x07, 0x00, 0x38, 0x06, 0x00, 0x00, 0x25, 0x07, 0x02, 0x00, 0x25, 0x08, 0xFE, 0xFF, 0x2D, 0x00, 0x07, 0x08, 0x26, 0x08, 0x00, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x27, 0x09, 0x00, 0x01, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x38, 0x08, 0x00, 0x00, 0x2D, 0x06, 0x07, 0x08, 0x26, 0x0A, 0x01, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x9D, 0x4B, 0x80, 0xDF, 0xBF, 0x4D, 0x09, 0xBF, 0xF4, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEA, 0x17, 0xBF, 0xDF, 0x22, 0x11, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xED, 0x14, 0x31, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xC8, 0x70, 0xBF, 0x90, 0x70, 0xBF, 0xD3, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0x0C, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x92, 0x70, 0xBF, 0x90, 0x70, 0xBF, 0x90, 0x70, 0xBF, 0x90, 0x70, 0xBF, 0x90, 0x70, 0xBF, 0x7D, 0x80, 0x84, 0xBF, 0x7C, 0x80, 0x84, 0xBF, 0x7C, 0x80, 0x84, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x01, 0x03, 0x10, 0x01, 0xCE, 0x09, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x61, 0x6C, 0x6C, 0xDA, 0x10, 0xDA, 0x80, 0x8C, 0xDA, 0x81, 0xD4, 0xDA, 0x5B, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x01, 0x00, 0x2C, 0x00, 0x02, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x27, 0x03, 0x00, 0x01, 0x2C, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x02, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x33, 0x04, 0x00, 0x05, 0x2B, 0x04, 0x00, 0x00, 0x2E, 0x02, 0x00, 0x00, 0x26, 0x05, 0x02, 0x00, 0x30, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x9E, 0x2F, 0x5D, 0xBF, 0xD1, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xD9, 0x28, 0x0D, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF1, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x08, 0x01, 0x05, 0x26, 0x01, 0xCE, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x66, 0x6E, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x07, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x15, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x89, 0x62, 0x40, 0xBF, 0xEF, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xDA, 0x80, 0x8C, 0xDA, 0x81, 0xD4, 0xDA, 0x80, 0x9C, 0xDA, 0x5B, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x01, 0x00, 0x33, 0x02, 0x00, 0x03, 0x17, 0x03, 0x02, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x1A, 0x04, 0x11, 0x00, 0x25, 0x05, 0x03, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x27, 0x06, 0x00, 0x01, 0x2C, 0x06, 0x05, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x05, 0x06, 0x00, 0x25, 0x07, 0x02, 0x00, 0x33, 0x06, 0x00, 0x07, 0x26, 0x07, 0x03, 0x00, 0x2D, 0x07, 0x03, 0x06, 0x2E, 0x05, 0x00, 0x00, 0x26, 0x07, 0x04, 0x00, 0x30, 0x07, 0x00, 0x00, 0x25, 0x05, 0x02, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x27, 0x06, 0x00, 0x01, 0x2C, 0x06, 0x05, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x05, 0x06, 0x00, 0x26, 0x06, 0x03, 0x00, 0x2C, 0x06, 0x03, 0x00, 0x2E, 0x05, 0x00, 0x00, 0x26, 0x06, 0x04, 0x00, 0x30, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x9E, 0x91, 0x80, 0xFD, 0xBF, 0x22, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF0, 0x11, 0x0A, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x80, 0xCE, 0xBF, 0x6B, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xD9, 0x28, 0x18, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xEA, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0x2B, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xD9, 0x28, 0x0A, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCD, 0x00, 0xFC, 0x00, 0x00, 0x07, 0x01, 0x01, 0x0C, 0x01, 0x01, 0xCE, 0x08, 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x71, 0x71, 0xDA, 0x10, 0xDA, 0x5B, 0x28, 0x01, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x25, 0x05, 0x00, 0x00, 0x33, 0x04, 0x00, 0x05, 0x25, 0x06, 0x01, 0x00, 0x33, 0x05, 0x00, 0x06, 0x2B, 0x05, 0x00, 0x00, 0x2F, 0x06, 0x03, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x0D, 0x47, 0x01, 0xCE, 0x02, 0x71, 0x71, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xCF, 0x07, 0x75, 0x6E, 0x71, 0x75, 0x6F, 0x74, 0x65, 0xCF, 0x10, 0x75, 0x6E, 0x71, 0x75, 0x6F, 0x74, 0x65, 0x2D, 0x73, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x6E, 0x67, 0xDA, 0x5B, 0xDA, 0x81, 0xD4, 0xDA, 0x80, 0x8C, 0xDA, 0x50, 0xDA, 0x52, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x01, 0x03, 0x1F, 0xCE, 0x03, 0x6B, 0x76, 0x73, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x25, 0x04, 0x02, 0x00, 0x09, 0x03, 0x04, 0x02, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x02, 0x04, 0x00, 0x17, 0x03, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x2C, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x05, 0x07, 0x06, 0x19, 0x05, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x05, 0x00, 0x00, 0x1A, 0x05, 0x0A, 0x00, 0x17, 0x07, 0x06, 0x00, 0x33, 0x08, 0x00, 0x07, 0x2D, 0x03, 0x07, 0x08, 0x26, 0x0A, 0x02, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2F, 0x06, 0x08, 0x00, 0x18, 0xF1, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x84, 0xF5, 0x80, 0xED, 0xBF, 0xB2, 0x0C, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xD9, 0x28, 0x04, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xF3, 0x0B, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xCD, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0x1A, 0x80, 0xED, 0xD8, 0x05, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xDA, 0x51, 0xD8, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x21, 0x00, 0x25, 0x05, 0x00, 0x00, 0x33, 0x04, 0x00, 0x05, 0x17, 0x05, 0x04, 0x00, 0x26, 0x06, 0x02, 0x00, 0x1F, 0x04, 0x06, 0x05, 0x17, 0x06, 0x04, 0x00, 0x1A, 0x06, 0x03, 0x00, 0x17, 0x04, 0x06, 0x00, 0x18, 0x09, 0x00, 0x00, 0x26, 0x08, 0x03, 0x00, 0x1F, 0x07, 0x08, 0x05, 0x17, 0x08, 0x07, 0x00, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x07, 0x08, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x07, 0x00, 0x00, 0x17, 0x04, 0x07, 0x00, 0x1A, 0x04, 0x09, 0x00, 0x25, 0x07, 0x01, 0x00, 0x33, 0x06, 0x00, 0x07, 0x2B, 0x06, 0x00, 0x00, 0x27, 0x08, 0x00, 0x01, 0x2F, 0x07, 0x08, 0x00, 0x2C, 0x05, 0x07, 0x00, 0x26, 0x06, 0x04, 0x00, 0x30, 0x06, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x07, 0x05, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x07, 0x06, 0x00, 0x30, 0x07, 0x00, 0x00, 0x26, 0x05, 0x07, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x04, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x26, 0x05, 0x05, 0x00, 0x30, 0x05, 0x00, 0x00, 0x26, 0x06, 0x08, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x1A, 0x05, 0x0A, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x07, 0x09, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2C, 0x01, 0x06, 0x00, 0x26, 0x08, 0x05, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x06, 0x0A, 0x00, 0x30, 0x06, 0x00, 0x00, 0x26, 0x07, 0x0B, 0x00, 0x1F, 0x06, 0x03, 0x07, 0x1A, 0x06, 0x0A, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x08, 0x09, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2C, 0x01, 0x07, 0x00, 0x26, 0x09, 0x05, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x07, 0x0C, 0x00, 0x30, 0x07, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x9F, 0xAA, 0x81, 0x71, 0xBE, 0xA8, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xDE, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF0, 0x11, 0x1B, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xEE, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xE8, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xD5, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD0, 0x80, 0x8E, 0xBF, 0xC9, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF0, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xE5, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0x22, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0x1C, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBF, 0x9A, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0x00, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBF, 0xC3, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF2, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBE, 0xD8, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBE, 0xA3, 0x81, 0x5D, 0xBF, 0xED, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF2, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE9, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBE, 0xAE, 0x81, 0x5D, 0xCD, 0x00, 0x00, 0x9F, 0x93, 0x81, 0xAE, 0xBE, 0x69, 0x81, 0x71, 0xBE, 0x8F, 0x81, 0x71, 0x0D, 0x08, 0xBF, 0xF8, 0x08, 0x06, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xE2, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0E, 0x01, 0x05, 0x2F, 0x01, 0xCE, 0x05, 0x64, 0x6F, 0x74, 0x75, 0x70, 0xDA, 0x10, 0xDA, 0x81, 0x57, 0xDA, 0x03, 0xDA, 0x1D, 0xDA, 0x80, 0x8C, 0xDA, 0x81, 0xD4, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x33, 0x02, 0x00, 0x03, 0x17, 0x03, 0x02, 0x00, 0x27, 0x05, 0x00, 0x0F, 0x33, 0x04, 0x05, 0x03, 0x17, 0x05, 0x04, 0x00, 0x26, 0x07, 0x00, 0x00, 0x35, 0x07, 0x07, 0x00, 0x33, 0x06, 0x07, 0x03, 0x17, 0x07, 0x06, 0x00, 0x1A, 0x07, 0x03, 0x00, 0x17, 0x06, 0x07, 0x00, 0x18, 0x08, 0x00, 0x00, 0x3B, 0x08, 0x00, 0x00, 0x17, 0x09, 0x08, 0x00, 0x1A, 0x09, 0x03, 0x00, 0x17, 0x08, 0x09, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x08, 0x00, 0x00, 0x17, 0x06, 0x08, 0x00, 0x17, 0x07, 0x06, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x2F, 0x08, 0x07, 0x00, 0x17, 0x09, 0x08, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0A, 0x07, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x1A, 0x05, 0x03, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0x1A, 0x0B, 0x07, 0x00, 0x25, 0x0C, 0x01, 0x00, 0x2C, 0x00, 0x0C, 0x00, 0x26, 0x0D, 0x03, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x2E, 0x0C, 0x00, 0x00, 0x30, 0x09, 0x00, 0x00, 0x27, 0x0C, 0x00, 0x01, 0x2C, 0x0C, 0x00, 0x00, 0x26, 0x0D, 0x04, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x2B, 0x0C, 0x00, 0x00, 0x26, 0x0D, 0x03, 0x00, 0x30, 0x0D, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xA2, 0x0F, 0x80, 0xF8, 0xBF, 0x23, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF1, 0x10, 0x0D, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xED, 0x14, 0x15, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE1, 0x20, 0x0D, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEC, 0x15, 0x0E, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEB, 0x16, 0x06, 0x56, 0xBF, 0xB8, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xEE, 0x56, 0xBF, 0xCA, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0x15, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xE6, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xCD, 0x00, 0x00, 0x9B, 0x2F, 0x88, 0xEF, 0xB7, 0x6A, 0x80, 0xBE, 0xBF, 0x42, 0x80, 0xBE, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0x05, 0x80, 0xDF, 0xBF, 0x21, 0x80, 0xDF, 0x05, 0x5D, 0xBF, 0xA3, 0x5D, 0x05, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0x05, 0x81, 0xAE, 0xBE, 0x52, 0x81, 0xAE, 0x05, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0xBF, 0x3C, 0x80, 0xC4, 0x05, 0x80, 0xF8, 0xBF, 0x08, 0x80, 0xF8, 0x18, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF3, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x26, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF0, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE1, 0x69, 0xBF, 0xD7, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xE2, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xB1, 0x69, 0xBF, 0x97, 0x69, 0xBF, 0xF7, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0x98, 0x69, 0xBF, 0x7B, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x97, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0x5F, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0xC5, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0x2C, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0xE6, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0x0C, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBF, 0x03, 0x80, 0xFD, 0xBE, 0xF6, 0x81, 0x0B, 0xB7, 0x18, 0x88, 0xEF, 0xCF, 0x02, 0x6F, 0x72, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x6F, 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, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x21, 0x5E, 0xCD, 0x00, 0x00, 0x23, 0x09, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0D, 0x00, 0x06, 0x28, 0xCE, 0x02, 0x6F, 0x72, 0xDA, 0x10, 0xDA, 0x4F, 0xDA, 0x5C, 0xDA, 0x5B, 0xDA, 0x59, 0xDA, 0x5A, 0xDA, 0x5D, 0x28, 0x01, 0x00, 0x00, 0x22, 0x02, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x07, 0x00, 0x00, 0x40, 0x06, 0x05, 0x07, 0x1A, 0x06, 0x20, 0x00, 0x25, 0x07, 0x01, 0x00, 0x07, 0x05, 0x05, 0x07, 0x33, 0x07, 0x00, 0x05, 0x17, 0x08, 0x07, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x09, 0x00, 0x00, 0x2F, 0x07, 0x09, 0x00, 0x1A, 0x07, 0x07, 0x00, 0x26, 0x09, 0x01, 0x00, 0x2D, 0x09, 0x08, 0x08, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x09, 0x02, 0x00, 0x2F, 0x02, 0x09, 0x00, 0x18, 0x11, 0x00, 0x00, 0x26, 0x0A, 0x03, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x26, 0x09, 0x04, 0x00, 0x2D, 0x09, 0x0A, 0x08, 0x26, 0x0B, 0x02, 0x00, 0x2F, 0x09, 0x0B, 0x00, 0x26, 0x0B, 0x01, 0x00, 0x2D, 0x0B, 0x0A, 0x0A, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x0C, 0x02, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x26, 0x0C, 0x05, 0x00, 0x2D, 0x0C, 0x09, 0x0B, 0x26, 0x0C, 0x02, 0x00, 0x2F, 0x02, 0x0C, 0x00, 0x18, 0xDF, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x21, 0x5E, 0x81, 0xAB, 0xBE, 0xD7, 0x0C, 0x0D, 0x0D, 0xBF, 0xEA, 0x17, 0x04, 0x0A, 0x0B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x80, 0xE9, 0xBF, 0x2A, 0x05, 0xBF, 0xFB, 0x05, 0x0E, 0x0C, 0xBF, 0xEC, 0x15, 0x13, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xED, 0x80, 0xA5, 0xBF, 0x76, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD1, 0x80, 0xA5, 0xBF, 0xA7, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0x15, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x11, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xBC, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0x1B, 0x80, 0xE9, 0xBE, 0x5C, 0x81, 0xAB, 0xCF, 0x04, 0x74, 0x79, 0x70, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x13, 0xDA, 0x05, 0xCE, 0x80, 0xE7, 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, 0x78, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0x20, 0x78, 0x20, 0x69, 0x73, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x0A, 0x09, 0x3A, 0x6E, 0x69, 0x6C, 0x0A, 0x09, 0x3A, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x0A, 0x09, 0x3A, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x0A, 0x09, 0x3A, 0x72, 0x65, 0x61, 0x6C, 0x0A, 0x09, 0x3A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x0A, 0x09, 0x3A, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x0A, 0x09, 0x3A, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x0A, 0x09, 0x3A, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x0A, 0x09, 0x3A, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x0A, 0x09, 0x3A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x0A, 0x09, 0x3A, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x0A, 0x09, 0x3A, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x0A, 0x09, 0x3A, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x09, 0x3A, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x0A, 0x0A, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2E, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0x68, 0xDA, 0x05, 0xCE, 0x32, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x74, 0x61, 0x6E, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 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, 0x06, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x06, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x26, 0x28, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x5B, 0x2C, 0x65, 0x6E, 0x76, 0x5D, 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, 0xCF, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x05, 0xCE, 0x80, 0xA8, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x74, 0x74, 0x20, 0x73, 0x74, 0x72, 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, 0x70, 0x61, 0x74, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 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, 0x70, 0x61, 0x74, 0x74, 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, 0x64, 0x65, 0x66, 0x6E, 0x2D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x85, 0x44, 0x85, 0xBE, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x04, 0x01, 0x02, 0x06, 0xCE, 0x05, 0x64, 0x65, 0x66, 0x6E, 0x2D, 0xDA, 0x10, 0xDA, 0x80, 0xB9, 0xDA, 0x81, 0x41, 0x28, 0x02, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2C, 0x00, 0x03, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x30, 0x03, 0x00, 0x00, 0x85, 0x44, 0x7A, 0xBF, 0xE1, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xCF, 0x05, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x05, 0x70, 0x72, 0x69, 0x6E, 0x74, 0xDA, 0x05, 0xCE, 0x80, 0xB9, 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, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x02, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 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, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x27, 0x73, 0x20, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x28, 0x6C, 0x69, 0x6E, 0x65, 0x2C, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x29, 0x2E, 0x20, 0x4C, 0x69, 0x6E, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x31, 0x2C, 0x20, 0x28, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x31, 0x2C, 0x20, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x20, 0x31, 0x29, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x41, 0x53, 0x43, 0x49, 0x49, 0x20, 0x30, 0x78, 0x30, 0x41, 0x2E, 0xCF, 0x0D, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0xDA, 0x05, 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, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x8C, 0x28, 0x64, 0x65, 0x65, 0x70, 0x3D, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x3D, 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, 0x20, 0x20, 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, 0x3D, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA7, 0xD3, 0xCD, 0x00, 0x00, 0xA8, 0x83, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x02, 0x02, 0x07, 0xCE, 0x05, 0x64, 0x65, 0x65, 0x70, 0x3D, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x13, 0x02, 0x0C, 0x80, 0x82, 0xCE, 0x09, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, 0x74, 0x3D, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x81, 0xD4, 0xDA, 0x81, 0xCE, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x02, 0x01, 0x1B, 0xCE, 0x04, 0x73, 0x6F, 0x6D, 0x65, 0xDA, 0x10, 0xDA, 0x4E, 0x28, 0x02, 0x00, 0x00, 0x22, 0x03, 0x00, 0x00, 0x17, 0x04, 0x01, 0x00, 0x37, 0x05, 0x04, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x3E, 0x08, 0x05, 0x06, 0x1A, 0x08, 0x06, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x07, 0x09, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1A, 0x07, 0x0C, 0x00, 0x33, 0x08, 0x04, 0x05, 0x17, 0x09, 0x08, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x08, 0x00, 0x00, 0x17, 0x0A, 0x08, 0x00, 0x1A, 0x0A, 0x03, 0x00, 0x17, 0x03, 0x0A, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x05, 0x08, 0x05, 0x18, 0xED, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA4, 0xD1, 0x80, 0xC9, 0xBF, 0xA6, 0x0C, 0x04, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xD4, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xE1, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xEA, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xF5, 0x0A, 0xBF, 0xE1, 0x20, 0xBF, 0xBE, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0xBD, 0x43, 0xBF, 0x3E, 0x80, 0xC9, 0xDA, 0x50, 0xDA, 0x51, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0A, 0x01, 0x04, 0x1E, 0xCE, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x80, 0xFB, 0xDA, 0x5B, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x02, 0x03, 0x00, 0x22, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x06, 0x07, 0x05, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x0C, 0x00, 0x33, 0x07, 0x00, 0x05, 0x2C, 0x05, 0x07, 0x00, 0x26, 0x09, 0x02, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2C, 0x02, 0x08, 0x00, 0x26, 0x09, 0x03, 0x00, 0x2F, 0x07, 0x09, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x05, 0x07, 0x00, 0x18, 0xEF, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7F, 0x8D, 0x80, 0xDD, 0xBF, 0x80, 0x09, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x13, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x53, 0xBF, 0xDE, 0x08, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0x0D, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xAF, 0x53, 0xBF, 0x2A, 0x80, 0xDD, 0xDA, 0x52, 0xDA, 0x80, 0xFD, 0xDA, 0x17, 0xDA, 0x81, 0x3F, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x1F, 0x06, 0x04, 0x05, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x17, 0x05, 0x06, 0x00, 0x1A, 0x05, 0x02, 0x00, 0x03, 0x05, 0x00, 0x00, 0x26, 0x08, 0x01, 0x00, 0x1F, 0x07, 0x04, 0x08, 0x1A, 0x07, 0x1B, 0x00, 0x37, 0x08, 0x00, 0x00, 0x37, 0x09, 0x01, 0x00, 0x1F, 0x0A, 0x08, 0x09, 0x19, 0x0A, 0x03, 0x00, 0x23, 0x0A, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x0A, 0x00, 0x00, 0x17, 0x08, 0x0A, 0x00, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x09, 0x08, 0x00, 0x18, 0x0E, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x01, 0x26, 0x0B, 0x02, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x26, 0x0B, 0x03, 0x00, 0x2C, 0x0B, 0x0A, 0x00, 0x26, 0x0C, 0x04, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x17, 0x0A, 0x0B, 0x00, 0x1A, 0x0A, 0x03, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0B, 0x00, 0x00, 0x17, 0x09, 0x0B, 0x00, 0x17, 0x06, 0x09, 0x00, 0x18, 0x52, 0x00, 0x00, 0x26, 0x0A, 0x05, 0x00, 0x1F, 0x09, 0x04, 0x0A, 0x1A, 0x09, 0x1B, 0x00, 0x37, 0x0A, 0x00, 0x00, 0x37, 0x0B, 0x01, 0x00, 0x1F, 0x0C, 0x0A, 0x0B, 0x19, 0x0C, 0x03, 0x00, 0x23, 0x0C, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x0C, 0x00, 0x00, 0x17, 0x0A, 0x0C, 0x00, 0x1A, 0x0A, 0x03, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x18, 0x0E, 0x00, 0x00, 0x2D, 0x02, 0x00, 0x01, 0x26, 0x0D, 0x02, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x26, 0x0D, 0x03, 0x00, 0x2C, 0x0D, 0x0C, 0x00, 0x26, 0x0E, 0x04, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x17, 0x0C, 0x0D, 0x00, 0x1A, 0x0C, 0x03, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0D, 0x00, 0x00, 0x17, 0x0B, 0x0D, 0x00, 0x17, 0x08, 0x0B, 0x00, 0x18, 0x34, 0x00, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x1F, 0x0B, 0x04, 0x0C, 0x1A, 0x0B, 0x0B, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x0E, 0x07, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x2C, 0x0C, 0x0D, 0x00, 0x2F, 0x0E, 0x02, 0x00, 0x17, 0x0A, 0x0E, 0x00, 0x18, 0x26, 0x00, 0x00, 0x26, 0x0E, 0x08, 0x00, 0x1F, 0x0D, 0x04, 0x0E, 0x1A, 0x0D, 0x0B, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x0F, 0x09, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x10, 0x09, 0x00, 0x2F, 0x0F, 0x10, 0x00, 0x2C, 0x0E, 0x0F, 0x00, 0x2F, 0x10, 0x02, 0x00, 0x17, 0x0C, 0x10, 0x00, 0x18, 0x18, 0x00, 0x00, 0x26, 0x10, 0x0A, 0x00, 0x1F, 0x0F, 0x04, 0x10, 0x1A, 0x0F, 0x0E, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x11, 0x0B, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x12, 0x0B, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x1F, 0x12, 0x10, 0x11, 0x19, 0x12, 0x03, 0x00, 0x23, 0x12, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x12, 0x00, 0x00, 0x17, 0x0E, 0x12, 0x00, 0x18, 0x07, 0x00, 0x00, 0x1F, 0x10, 0x00, 0x01, 0x19, 0x10, 0x03, 0x00, 0x23, 0x10, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x10, 0x00, 0x00, 0x17, 0x0E, 0x10, 0x00, 0x17, 0x0C, 0x0E, 0x00, 0x17, 0x0A, 0x0C, 0x00, 0x17, 0x08, 0x0A, 0x00, 0x17, 0x06, 0x08, 0x00, 0x17, 0x07, 0x06, 0x00, 0x1A, 0x07, 0x02, 0x00, 0x03, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA5, 0x9D, 0x82, 0x33, 0xBE, 0x7A, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF1, 0x10, 0x15, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xE7, 0x81, 0x79, 0xBE, 0x87, 0x81, 0x79, 0xBE, 0x87, 0x81, 0x79, 0xBE, 0xA6, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xC7, 0x09, 0x02, 0x09, 0xBF, 0xE6, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE1, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xEC, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xBD, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xA6, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBF, 0x1A, 0x09, 0x02, 0x09, 0xBF, 0xE6, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE1, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xEC, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xBD, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0xBC, 0x44, 0xBF, 0x53, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBF, 0x6F, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0x25, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBF, 0x9C, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x02, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xCF, 0x32, 0xBF, 0xCE, 0x32, 0xBE, 0xE4, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBF, 0xD9, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0x02, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xE6, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBE, 0xB9, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBF, 0xF6, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBE, 0xA8, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0xA7, 0x81, 0x59, 0xBE, 0x88, 0x81, 0x79, 0xBE, 0x87, 0x81, 0x79, 0xBE, 0x87, 0x81, 0x79, 0xBE, 0x87, 0x81, 0x79, 0xDA, 0x4E, 0x28, 0x02, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x04, 0x01, 0x00, 0x30, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA7, 0xD3, 0x80, 0xB0, 0xBF, 0xF0, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xED, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x6F, 0x70, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x6F, 0x70, 0xDA, 0x05, 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, 0x02, 0x70, 0x70, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x1F, 0x28, 0x70, 0x70, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x65, 0x74, 0x74, 0x79, 0x20, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA9, 0xB0, 0xCD, 0x00, 0x00, 0xA9, 0xFF, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x04, 0x0B, 0xCE, 0x02, 0x70, 0x70, 0xDA, 0x10, 0xDA, 0x80, 0xE0, 0xDA, 0x81, 0x3C, 0xDA, 0x81, 0x3D, 0xDA, 0x82, 0x06, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x39, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2D, 0x02, 0x03, 0x00, 0x26, 0x04, 0x02, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x02, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA9, 0xB0, 0x4F, 0xBF, 0xE5, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE0, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xCF, 0x06, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x06, 0x73, 0x74, 0x64, 0x6F, 0x75, 0x74, 0xDA, 0x05, 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, 0xCF, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x04, 0x01, 0x00, 0x00, 0x02, 0xCE, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x32, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x80, 0x8C, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 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, 0x6E, 0x69, 0x6C, 0x2E, 0xCF, 0x0B, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0x8C, 0xDA, 0x05, 0xCE, 0x81, 0x04, 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, 0x20, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x65, 0x78, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x65, 0x6E, 0x64, 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, 0x61, 0x72, 0x72, 0x74, 0x75, 0x70, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6C, 0x79, 0x2E, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x68, 0x65, 0x6C, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x68, 0x65, 0x6C, 0x6C, 0xDA, 0x05, 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, 0xCF, 0x06, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8E, 0x4A, 0x8E, 0x7D, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x06, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x8E, 0x4A, 0x33, 0xBF, 0xF5, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xCF, 0x0B, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x89, 0x28, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x26, 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, 0x20, 0x20, 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, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xB7, 0x18, 0xCD, 0x00, 0x00, 0xB9, 0xF9, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBA, 0x00, 0x00, 0x0C, 0x02, 0x0A, 0x1B, 0x02, 0xCE, 0x0B, 0x65, 0x76, 0x61, 0x6C, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xDA, 0x10, 0xDA, 0x81, 0x3F, 0xD0, 0x0E, 0x6F, 0x6E, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0xCE, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x01, 0x00, 0x00, 0x00, 0xD0, 0x06, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0xD0, 0x09, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD0, 0x06, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0xDA, 0x81, 0x56, 0xD0, 0x03, 0x65, 0x6E, 0x76, 0xD0, 0x10, 0x6F, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x23, 0x01, 0x15, 0x80, 0x82, 0x01, 0xCE, 0x0B, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0xDA, 0x10, 0xDA, 0x82, 0x45, 0xDA, 0x82, 0x48, 0xDA, 0x82, 0x49, 0xDA, 0x82, 0x4A, 0xDA, 0x82, 0x4B, 0xDA, 0x82, 0x4C, 0xDA, 0x81, 0x57, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x07, 0x02, 0x06, 0x17, 0xCE, 0x07, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0xE0, 0xDA, 0x82, 0x2A, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xD8, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6E, 0xD0, 0x04, 0x6C, 0x69, 0x6E, 0x65, 0xD8, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x28, 0x02, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x1F, 0x04, 0x05, 0x00, 0x1A, 0x04, 0x06, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x39, 0x05, 0x00, 0x00, 0x17, 0x03, 0x05, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x1A, 0x01, 0x06, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x18, 0x01, 0x00, 0x00, 0x26, 0x05, 0x03, 0x00, 0x26, 0x06, 0x04, 0x00, 0x2D, 0x05, 0x06, 0x04, 0x26, 0x06, 0x05, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xAD, 0x50, 0x80, 0x9C, 0xBF, 0xAA, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0x04, 0x1D, 0xBF, 0xEB, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE4, 0x1D, 0x04, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0x6B, 0x80, 0x9C, 0xD8, 0x10, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x03, 0x06, 0x0E, 0xCE, 0x0B, 0x62, 0x61, 0x64, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x10, 0xD8, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0xCE, 0x0F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x3A, 0x20, 0xCE, 0x11, 0x20, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0xCE, 0x01, 0x0A, 0xDA, 0x82, 0x4F, 0xDA, 0x82, 0x54, 0x28, 0x03, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x04, 0x05, 0x00, 0x26, 0x04, 0x02, 0x00, 0x26, 0x05, 0x03, 0x00, 0x2D, 0x04, 0x02, 0x05, 0x26, 0x05, 0x04, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x1A, 0x01, 0x04, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x05, 0x05, 0x00, 0x30, 0x05, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xAC, 0x89, 0x80, 0xC4, 0xBF, 0x8E, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xB9, 0x47, 0x04, 0x26, 0xBF, 0xE7, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xDB, 0x26, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x02, 0x0A, 0x1A, 0xCE, 0x09, 0x62, 0x61, 0x64, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0xDA, 0x10, 0xDA, 0x82, 0x0A, 0xDA, 0x81, 0x3F, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xCE, 0x13, 0x75, 0x6E, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x65, 0x6C, 0x69, 0x6D, 0x69, 0x74, 0x65, 0x72, 0xDA, 0x82, 0x56, 0xCE, 0x0F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x69, 0x6E, 0x20, 0xCE, 0x0D, 0x20, 0x61, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0xCE, 0x02, 0x3A, 0x20, 0xDA, 0x82, 0x59, 0xDA, 0x82, 0x4F, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x05, 0x02, 0x00, 0x2F, 0x03, 0x05, 0x00, 0x17, 0x05, 0x03, 0x00, 0x1A, 0x05, 0x03, 0x00, 0x17, 0x03, 0x05, 0x00, 0x18, 0x03, 0x00, 0x00, 0x26, 0x06, 0x03, 0x00, 0x17, 0x03, 0x06, 0x00, 0x26, 0x05, 0x04, 0x00, 0x26, 0x06, 0x05, 0x00, 0x2D, 0x05, 0x06, 0x01, 0x26, 0x05, 0x06, 0x00, 0x26, 0x06, 0x07, 0x00, 0x2D, 0x05, 0x04, 0x06, 0x26, 0x05, 0x08, 0x00, 0x2C, 0x03, 0x05, 0x00, 0x26, 0x05, 0x09, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xAB, 0x54, 0x81, 0x32, 0xBF, 0x8E, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE9, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0x27, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xED, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0x28, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xBF, 0x14, 0x80, 0xEC, 0xCE, 0x0B, 0x3C, 0x61, 0x6E, 0x6F, 0x6E, 0x79, 0x6D, 0x6F, 0x75, 0x73, 0x3E, 0xD8, 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x80, 0xE0, 0xDA, 0x80, 0xE6, 0xDA, 0x81, 0x90, 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, 0xD8, 0x0D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xDA, 0x81, 0x59, 0xD0, 0x07, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x28, 0x01, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x33, 0x02, 0x00, 0x03, 0x17, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x33, 0x02, 0x00, 0x04, 0x17, 0x04, 0x02, 0x00, 0x26, 0x05, 0x02, 0x00, 0x33, 0x02, 0x00, 0x05, 0x17, 0x05, 0x02, 0x00, 0x26, 0x06, 0x03, 0x00, 0x33, 0x02, 0x00, 0x06, 0x17, 0x06, 0x02, 0x00, 0x26, 0x07, 0x04, 0x00, 0x33, 0x02, 0x00, 0x07, 0x17, 0x07, 0x02, 0x00, 0x26, 0x08, 0x05, 0x00, 0x33, 0x02, 0x00, 0x08, 0x17, 0x08, 0x02, 0x00, 0x22, 0x0A, 0x00, 0x00, 0x1F, 0x09, 0x0A, 0x07, 0x1A, 0x09, 0x04, 0x00, 0x26, 0x02, 0x06, 0x00, 0x35, 0x02, 0x02, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x02, 0x07, 0x00, 0x17, 0x09, 0x02, 0x00, 0x22, 0x0C, 0x00, 0x00, 0x1F, 0x0B, 0x0C, 0x04, 0x1A, 0x0B, 0x03, 0x00, 0x26, 0x0A, 0x07, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x0A, 0x04, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x22, 0x0E, 0x00, 0x00, 0x1F, 0x0D, 0x0E, 0x05, 0x1A, 0x0D, 0x03, 0x00, 0x26, 0x0C, 0x08, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x0C, 0x05, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x22, 0x10, 0x00, 0x00, 0x1F, 0x0F, 0x10, 0x08, 0x1A, 0x0F, 0x03, 0x00, 0x26, 0x0E, 0x09, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x0E, 0x08, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x22, 0x12, 0x00, 0x00, 0x1F, 0x11, 0x12, 0x03, 0x1A, 0x11, 0x03, 0x00, 0x26, 0x10, 0x0A, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x10, 0x03, 0x00, 0x17, 0x11, 0x10, 0x00, 0x22, 0x14, 0x00, 0x00, 0x1F, 0x13, 0x14, 0x06, 0x1A, 0x13, 0x03, 0x00, 0x26, 0x12, 0x0B, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x12, 0x06, 0x00, 0x17, 0x13, 0x12, 0x00, 0x23, 0x14, 0x00, 0x00, 0x26, 0x16, 0x0C, 0x00, 0x2F, 0x15, 0x16, 0x00, 0x17, 0x16, 0x15, 0x00, 0x2A, 0x17, 0x00, 0x00, 0x17, 0x18, 0x17, 0x00, 0x26, 0x19, 0x06, 0x00, 0x35, 0x19, 0x19, 0x00, 0x26, 0x1A, 0x06, 0x00, 0x36, 0x1A, 0x09, 0x00, 0x26, 0x1A, 0x0D, 0x00, 0x2B, 0x1A, 0x00, 0x00, 0x39, 0x1A, 0x00, 0x00, 0x17, 0x1B, 0x1A, 0x00, 0x1A, 0x14, 0x2A, 0x00, 0x2B, 0x1B, 0x00, 0x00, 0x26, 0x1D, 0x0E, 0x00, 0x2F, 0x1C, 0x1D, 0x00, 0x2C, 0x1B, 0x16, 0x00, 0x2F, 0x1C, 0x0B, 0x00, 0x25, 0x1C, 0x00, 0x00, 0x22, 0x1D, 0x00, 0x00, 0x37, 0x1E, 0x1B, 0x00, 0x17, 0x1F, 0x1E, 0x00, 0x25, 0x20, 0x00, 0x00, 0x1F, 0x1E, 0x1F, 0x20, 0x1A, 0x1E, 0x03, 0x00, 0x24, 0x14, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x40, 0x1E, 0x1F, 0x1C, 0x1A, 0x1E, 0x19, 0x00, 0x2D, 0x16, 0x1B, 0x1C, 0x26, 0x21, 0x0F, 0x00, 0x2F, 0x20, 0x21, 0x00, 0x06, 0x1C, 0x1C, 0x20, 0x2B, 0x16, 0x00, 0x00, 0x26, 0x21, 0x10, 0x00, 0x2F, 0x20, 0x21, 0x00, 0x1A, 0x20, 0x07, 0x00, 0x2B, 0x16, 0x00, 0x00, 0x26, 0x22, 0x11, 0x00, 0x2F, 0x21, 0x22, 0x00, 0x2B, 0x21, 0x00, 0x00, 0x2F, 0x22, 0x18, 0x00, 0x18, 0xF7, 0xFF, 0xFF, 0x2B, 0x16, 0x00, 0x00, 0x26, 0x21, 0x12, 0x00, 0x2F, 0x20, 0x21, 0x00, 0x26, 0x22, 0x13, 0x00, 0x1F, 0x21, 0x20, 0x22, 0x1A, 0x21, 0x04, 0x00, 0x2C, 0x16, 0x13, 0x00, 0x2F, 0x20, 0x11, 0x00, 0x18, 0x01, 0x00, 0x00, 0x18, 0xE7, 0xFF, 0xFF, 0x18, 0xD7, 0xFF, 0xFF, 0x2B, 0x16, 0x00, 0x00, 0x26, 0x1D, 0x12, 0x00, 0x2F, 0x1C, 0x1D, 0x00, 0x26, 0x1E, 0x14, 0x00, 0x1F, 0x1D, 0x1C, 0x1E, 0x1A, 0x1D, 0x04, 0x00, 0x2C, 0x16, 0x13, 0x00, 0x2F, 0x1C, 0x11, 0x00, 0x18, 0x01, 0x00, 0x00, 0x26, 0x1C, 0x06, 0x00, 0x36, 0x1C, 0x19, 0x00, 0x03, 0x09, 0x00, 0x00, 0xCD, 0x00, 0xFE, 0x00, 0x00, 0x08, 0x01, 0x02, 0x13, 0x01, 0x01, 0xCE, 0x05, 0x65, 0x76, 0x61, 0x6C, 0x31, 0xDA, 0x10, 0xD0, 0x01, 0x61, 0xDA, 0x80, 0x9F, 0x28, 0x01, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x03, 0x04, 0x00, 0x22, 0x06, 0x00, 0x00, 0x31, 0x05, 0x03, 0x06, 0x17, 0x06, 0x05, 0x00, 0x1A, 0x02, 0x07, 0x00, 0x27, 0x07, 0x00, 0x14, 0x1A, 0x07, 0x04, 0x00, 0x2C, 0x03, 0x06, 0x00, 0x27, 0x07, 0x00, 0x0D, 0x30, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x0B, 0x00, 0x0C, 0x30, 0x02, 0xDA, 0x10, 0xDA, 0x61, 0xDA, 0x13, 0xDA, 0x81, 0x58, 0xD0, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0xD0, 0x03, 0x65, 0x6E, 0x64, 0xD0, 0x05, 0x66, 0x69, 0x62, 0x65, 0x72, 0xDA, 0x81, 0x59, 0xDA, 0x82, 0x57, 0xCE, 0x05, 0x20, 0x61, 0x74, 0x20, 0x28, 0xCE, 0x01, 0x3A, 0xCE, 0x01, 0x29, 0xDA, 0x81, 0x3F, 0x27, 0x00, 0x00, 0x00, 0x27, 0x01, 0x01, 0x09, 0x27, 0x02, 0x01, 0x13, 0x2D, 0x00, 0x01, 0x02, 0x26, 0x01, 0x00, 0x00, 0x2F, 0x00, 0x01, 0x00, 0x17, 0x01, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x02, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x1A, 0x03, 0x02, 0x00, 0x30, 0x01, 0x00, 0x00, 0x24, 0x02, 0x00, 0x00, 0x29, 0x02, 0x00, 0x02, 0x26, 0x04, 0x03, 0x00, 0x33, 0x02, 0x01, 0x04, 0x17, 0x04, 0x02, 0x00, 0x26, 0x05, 0x04, 0x00, 0x33, 0x02, 0x01, 0x05, 0x17, 0x05, 0x02, 0x00, 0x26, 0x06, 0x05, 0x00, 0x33, 0x02, 0x01, 0x06, 0x17, 0x06, 0x02, 0x00, 0x26, 0x07, 0x06, 0x00, 0x33, 0x02, 0x01, 0x07, 0x17, 0x07, 0x02, 0x00, 0x25, 0x09, 0x00, 0x00, 0x3F, 0x08, 0x09, 0x04, 0x1A, 0x08, 0x0C, 0x00, 0x26, 0x09, 0x07, 0x00, 0x26, 0x0A, 0x08, 0x00, 0x2D, 0x09, 0x07, 0x0A, 0x26, 0x09, 0x09, 0x00, 0x2D, 0x04, 0x09, 0x05, 0x26, 0x09, 0x0A, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x0A, 0x0B, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x02, 0x09, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x02, 0x07, 0x00, 0x17, 0x08, 0x02, 0x00, 0x27, 0x02, 0x01, 0x13, 0x2D, 0x08, 0x06, 0x02, 0x27, 0x02, 0x01, 0x0F, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0x00, 0xCD, 0x00, 0x00, 0xB2, 0xFD, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xDE, 0x23, 0x13, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF4, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE5, 0x81, 0x70, 0xBE, 0xB9, 0x04, 0x20, 0x0F, 0xBF, 0xF1, 0x0F, 0x10, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0x2D, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x71, 0xBF, 0xB2, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xA6, 0x71, 0xBF, 0x8F, 0x71, 0xBF, 0x8F, 0x71, 0xBF, 0x76, 0x80, 0x8B, 0x10, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xCD, 0x00, 0x00, 0xB2, 0x96, 0x82, 0x55, 0xBD, 0xC4, 0x0E, 0x26, 0x81, 0xB1, 0xBE, 0x3C, 0x81, 0xD0, 0xBE, 0x30, 0x81, 0xD0, 0xBE, 0x30, 0x81, 0xD0, 0xBE, 0x30, 0x81, 0xD0, 0xBE, 0x23, 0x81, 0xDE, 0x0F, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEA, 0x17, 0x06, 0x26, 0xBF, 0xE5, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xF0, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE7, 0x1A, 0xBF, 0xDB, 0x26, 0xCD, 0x00, 0x00, 0xAD, 0xEF, 0x89, 0x26, 0xB9, 0x96, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0xBF, 0x51, 0x80, 0xAF, 0x04, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x04, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0x04, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0x04, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0x04, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0x04, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0x1A, 0x0F, 0x22, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x13, 0x20, 0x82, 0x55, 0xBD, 0xAB, 0x82, 0x55, 0x05, 0x11, 0xBF, 0xEF, 0x11, 0x04, 0x0E, 0xBF, 0xF2, 0x0E, 0x12, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x81, 0x7A, 0xBE, 0x97, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x06, 0x0D, 0xBF, 0xF3, 0x0D, 0x06, 0x0D, 0x06, 0x10, 0x0F, 0x0B, 0xBF, 0xEC, 0x15, 0x0A, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x1F, 0xBF, 0xEF, 0x10, 0xBF, 0xE2, 0x1F, 0x0D, 0x0D, 0xBF, 0xEC, 0x80, 0xD5, 0xBF, 0x52, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xD9, 0x28, 0x0F, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xE7, 0x3D, 0xBF, 0xED, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xC4, 0x3D, 0x11, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xED, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xDF, 0x43, 0xBF, 0xE8, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xBE, 0x43, 0xBF, 0x2C, 0x80, 0xD5, 0xBE, 0x87, 0x81, 0x7A, 0x0C, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xED, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xDF, 0x43, 0xBF, 0xE8, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xBE, 0x43, 0x05, 0x11, 0xBF, 0xEF, 0x11, 0xB6, 0xE2, 0x89, 0x26, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2A, 0x05, 0x00, 0x00, 0x17, 0x06, 0x05, 0x00, 0x22, 0x07, 0x00, 0x00, 0x2A, 0x08, 0x01, 0x00, 0x26, 0x09, 0x01, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x26, 0x0B, 0x03, 0x00, 0x2D, 0x09, 0x0A, 0x0B, 0x26, 0x09, 0x04, 0x00, 0x2D, 0x06, 0x09, 0x08, 0x26, 0x09, 0x05, 0x00, 0x26, 0x0A, 0x06, 0x00, 0x26, 0x0B, 0x07, 0x00, 0x2D, 0x09, 0x0A, 0x0B, 0x26, 0x09, 0x08, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2D, 0x01, 0x09, 0x0A, 0x3B, 0x08, 0x00, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x0A, 0x09, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x06, 0x02, 0x02, 0x0E, 0x01, 0xCE, 0x06, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0xDA, 0x10, 0xDA, 0x80, 0xE2, 0xDA, 0x82, 0x59, 0x28, 0x02, 0x00, 0x00, 0x27, 0x03, 0x00, 0x04, 0x22, 0x04, 0x00, 0x00, 0x29, 0x04, 0x00, 0x04, 0x1A, 0x03, 0x09, 0x00, 0x27, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x04, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2C, 0x00, 0x04, 0x00, 0x26, 0x04, 0x00, 0x00, 0x30, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xB7, 0xCB, 0x80, 0x92, 0xBF, 0x87, 0x0E, 0x06, 0x0E, 0xBF, 0xF2, 0x0E, 0x06, 0x50, 0xBF, 0xC0, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0x08, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xB1, 0x50, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x02, 0x03, 0x0B, 0x01, 0xDA, 0x10, 0xDA, 0x81, 0xBF, 0xD0, 0x04, 0x64, 0x65, 0x61, 0x64, 0xDA, 0x82, 0x54, 0x29, 0x01, 0x00, 0x07, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x1A, 0x03, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x02, 0x02, 0x00, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xB9, 0x3F, 0x12, 0x2A, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEE, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xDF, 0x5A, 0xBF, 0xA6, 0x5A, 0xBF, 0xE8, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xCD, 0x00, 0x00, 0xB7, 0x18, 0x82, 0xE1, 0xBD, 0xC2, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEA, 0x17, 0x04, 0x80, 0x92, 0xBF, 0x6E, 0x80, 0x92, 0x04, 0x12, 0x80, 0xA3, 0x80, 0xB5, 0xBE, 0xAC, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBE, 0x8B, 0x81, 0x75, 0xBD, 0x2C, 0x82, 0xE1, 0xCF, 0x11, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x11, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0xDA, 0x05, 0xCE, 0x80, 0x97, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x72, 0x6F, 0x6D, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x62, 0x79, 0x74, 0x65, 0x2D, 0x61, 0x72, 0x72, 0x61, 0x79, 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, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 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, 0xCF, 0x0B, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x62, 0x75, 0x69, 0x6C, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xCE, 0x07, 0x61, 0x39, 0x38, 0x32, 0x66, 0x33, 0x35, 0xDA, 0x05, 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, 0x02, 0xDA, 0x03, 0xC8, 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, 0xDA, 0x05, 0xCE, 0x0D, 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x69, 0x2E, 0xCF, 0x04, 0x70, 0x6F, 0x73, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x87, 0xFD, 0x88, 0x33, 0xDA, 0x03, 0xDA, 0x81, 0x12, 0xCF, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x12, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 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, 0x73, 0x74, 0x72, 0x29, 0x5D, 0x5D, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x65, 0x6E, 0x64, 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, 0x27, 0x73, 0x74, 0x61, 0x72, 0x74, 0x27, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x27, 0x65, 0x6E, 0x64, 0x27, 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, 0xCF, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x74, 0x6F, 0x67, 0x67, 0x6C, 0x65, 0xDA, 0x05, 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, 0xCF, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x42, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x28, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 0x29, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x64, 0xAC, 0xCD, 0x00, 0x00, 0x65, 0x1E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x02, 0x02, 0x07, 0xCE, 0x0A, 0x64, 0x72, 0x6F, 0x70, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x03, 0x01, 0x00, 0x03, 0x01, 0xCE, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x01, 0x06, 0x01, 0xDA, 0x10, 0xDA, 0x4E, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x00, 0x2F, 0x01, 0x02, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x4C, 0xE1, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF7, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xCD, 0x00, 0x00, 0x4C, 0x7C, 0x6C, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xDA, 0x81, 0xB0, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x26, 0x04, 0x01, 0x00, 0x30, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x64, 0xAC, 0x72, 0xBF, 0xEA, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0xDA, 0x05, 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, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x71, 0x72, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x71, 0x72, 0x74, 0xDA, 0x05, 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, 0x08, 0x62, 0x72, 0x75, 0x73, 0x68, 0x69, 0x66, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x12, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x08, 0x62, 0x72, 0x75, 0x73, 0x68, 0x69, 0x66, 0x74, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x01, 0x00, 0x35, 0x04, 0x00, 0x00, 0x14, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x14, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x04, 0x6A, 0x75, 0x78, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x45, 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, 0x6A, 0x75, 0x78, 0x74, 0x2A, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x66, 0x1F, 0xCD, 0x00, 0x00, 0x67, 0x1A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x26, 0xCE, 0x04, 0x6A, 0x75, 0x78, 0x74, 0xDA, 0x10, 0xCF, 0x05, 0x74, 0x75, 0x70, 0x6C, 0x65, 0xDA, 0x59, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x03, 0x06, 0x01, 0x00, 0x0C, 0xCE, 0x05, 0x61, 0x70, 0x70, 0x6C, 0x79, 0x37, 0x02, 0x01, 0x00, 0x20, 0x03, 0x02, 0x00, 0x19, 0x03, 0x09, 0x00, 0x25, 0x04, 0x00, 0x00, 0x33, 0x05, 0x01, 0x04, 0x05, 0x04, 0x04, 0x01, 0x1F, 0x03, 0x04, 0x02, 0x19, 0x03, 0x03, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x18, 0xFB, 0xFF, 0xFF, 0x2E, 0x05, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xDA, 0x5B, 0xDA, 0x81, 0x00, 0xDA, 0x80, 0x9D, 0xDA, 0x80, 0x8C, 0xDA, 0x80, 0x9C, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x17, 0x06, 0x00, 0x00, 0x37, 0x07, 0x06, 0x00, 0x17, 0x08, 0x07, 0x00, 0x25, 0x07, 0x00, 0x00, 0x3E, 0x09, 0x07, 0x08, 0x1A, 0x09, 0x0D, 0x00, 0x33, 0x0A, 0x06, 0x07, 0x17, 0x0B, 0x0A, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2D, 0x0A, 0x0B, 0x05, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x0A, 0x0C, 0x00, 0x2C, 0x03, 0x0A, 0x00, 0x26, 0x0D, 0x04, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x07, 0x0A, 0x07, 0x18, 0xF3, 0xFF, 0xFF, 0x26, 0x06, 0x05, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x25, 0x07, 0x00, 0x00, 0x2C, 0x03, 0x07, 0x00, 0x26, 0x08, 0x06, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x26, 0x08, 0x07, 0x00, 0x2D, 0x08, 0x06, 0x07, 0x26, 0x08, 0x03, 0x00, 0x30, 0x08, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x66, 0x1F, 0x80, 0xFB, 0xBF, 0x5C, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0x0F, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x04, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xEA, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDA, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xC2, 0x3F, 0xBF, 0xC1, 0x3F, 0xBF, 0xC1, 0x3F, 0x0F, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0x02, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD0, 0x31, 0xBF, 0xCF, 0x31, 0xBF, 0xCF, 0x31, 0xBF, 0xCF, 0x31, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x6F, 0x77, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x6F, 0x77, 0xDA, 0x05, 0xCE, 0x2B, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x70, 0x6F, 0x77, 0x20, 0x61, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 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, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x70, 0x65, 0x67, 0x2F, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xDA, 0x05, 0xCE, 0x81, 0x19, 0x28, 0x70, 0x65, 0x67, 0x2F, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x70, 0x65, 0x67, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x5B, 0x2C, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x5D, 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, 0x61, 0x72, 0x65, 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x73, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x6F, 0x73, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x4C, 0x50, 0x65, 0x67, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x73, 0x69, 0x6D, 0x69, 0x6C, 0x61, 0x72, 0x20, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6C, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2E, 0xCF, 0x0B, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0x8A, 0xDA, 0x05, 0xCE, 0x81, 0x3A, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x61, 0x72, 0x72, 0x74, 0x75, 0x70, 0x20, 0x5B, 0x2C, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x20, 0x5B, 0x2C, 0x20, 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, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x6E, 0x64, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x69, 0x73, 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x64, 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, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x08, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8B, 0xC9, 0x8C, 0x0C, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x08, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xD0, 0x07, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8B, 0xC9, 0x43, 0xBF, 0xEE, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x50, 0xDA, 0x05, 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, 0xCF, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x2D, 0x61, 0x6C, 0x6C, 0xDA, 0x05, 0xCE, 0x80, 0xA4, 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, 0x70, 0x61, 0x74, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 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, 0x70, 0x61, 0x74, 0x74, 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, 0x73, 0x74, 0x72, 0x2E, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x32, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x32, 0xDA, 0x05, 0xCE, 0x47, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x74, 0x61, 0x6E, 0x32, 0x20, 0x79, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 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, 0xCF, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x81, 0xE2, 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, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x6F, 0x72, 0x6D, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x20, 0x62, 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x73, 0x20, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x2A, 0x73, 0x79, 0x73, 0x70, 0x61, 0x74, 0x68, 0x2A, 0x2C, 0x20, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x20, 0x62, 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x2F, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x6C, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6C, 0x6C, 0x79, 0x2E, 0x20, 0x20, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0x20, 0x62, 0x65, 0x63, 0x6F, 0x6D, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x79, 0x6E, 0x61, 0x6D, 0x69, 0x63, 0x20, 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x64, 0x6C, 0x6C, 0x20, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x6F, 0x2E, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x77, 0x6F, 0x20, 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, 0x20, 0x20, 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, 0x20, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xBC, 0x3A, 0xCD, 0x00, 0x00, 0xC0, 0x02, 0xDA, 0x03, 0xD1, 0x0D, 0xD2, 0x02, 0x00, 0xCE, 0x0D, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x82, 0x4A, 0xD2, 0x02, 0x00, 0xCE, 0x12, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x69, 0x6E, 0x69, 0x74, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x82, 0x4A, 0xD2, 0x02, 0x00, 0xCE, 0x11, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0xDA, 0x82, 0x4A, 0xD2, 0x02, 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, 0x82, 0x4A, 0xD2, 0x02, 0x00, 0xCE, 0x10, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xD0, 0x06, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0xD2, 0x02, 0x00, 0xCE, 0x17, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x2E, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x82, 0xDA, 0xD2, 0x02, 0x00, 0xCE, 0x14, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x82, 0xDA, 0xD2, 0x02, 0x00, 0xCE, 0x1B, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x2E, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x82, 0xDA, 0xD2, 0x02, 0x00, 0xCE, 0x0E, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD0, 0x05, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD2, 0x02, 0x00, 0xCE, 0x15, 0x2E, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x82, 0xE3, 0xD2, 0x02, 0x00, 0xCE, 0x12, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x82, 0xE3, 0xD2, 0x02, 0x00, 0xCE, 0x19, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0x2F, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0x2F, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0x2E, 0x6A, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x82, 0xE3, 0xD2, 0x02, 0x00, 0xCE, 0x05, 0x3A, 0x61, 0x6C, 0x6C, 0x3A, 0xDA, 0x82, 0x4A, 0xCF, 0x0F, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x68, 0x61, 0x73, 0x2D, 0x6D, 0x6F, 0x72, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x64, 0xDA, 0x05, 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, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x63, 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, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x73, 0x20, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x20, 0x6E, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x87, 0x1A, 0xCD, 0x00, 0x00, 0x88, 0x94, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x02, 0x04, 0x26, 0xCE, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0xDA, 0x10, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x65, 0x69, 0x6C, 0xDA, 0x80, 0xFF, 0xDA, 0x80, 0x8C, 0xDA, 0x81, 0x00, 0x28, 0x02, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x17, 0x04, 0x00, 0x00, 0x37, 0x05, 0x01, 0x00, 0x17, 0x06, 0x05, 0x00, 0x0B, 0x07, 0x06, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x09, 0x00, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x09, 0x01, 0x00, 0x2F, 0x07, 0x09, 0x00, 0x17, 0x08, 0x07, 0x00, 0x3F, 0x09, 0x04, 0x06, 0x1A, 0x09, 0x0A, 0x00, 0x2D, 0x01, 0x03, 0x04, 0x26, 0x0B, 0x02, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x17, 0x03, 0x04, 0x00, 0x06, 0x04, 0x04, 0x00, 0x18, 0xF6, 0xFF, 0xFF, 0x1F, 0x09, 0x03, 0x06, 0x19, 0x09, 0x03, 0x00, 0x23, 0x09, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x09, 0x00, 0x00, 0x1A, 0x09, 0x08, 0x00, 0x2C, 0x01, 0x03, 0x00, 0x26, 0x0B, 0x02, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x18, 0x01, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x87, 0x1A, 0x81, 0x7A, 0xBE, 0xF8, 0x08, 0x02, 0x0C, 0x0D, 0x0B, 0xBF, 0xEC, 0x15, 0x23, 0x08, 0xBF, 0xED, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE1, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xD7, 0x2A, 0x0B, 0x0D, 0xBF, 0xEC, 0x67, 0xBF, 0xC3, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xD8, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0x06, 0x0C, 0x06, 0x0B, 0xBF, 0x9A, 0x67, 0x08, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x35, 0xBF, 0xEC, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xCC, 0x35, 0xBE, 0x8D, 0x81, 0x7A, 0xCF, 0x10, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x54, 0xDA, 0x05, 0xCE, 0x80, 0xD4, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 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, 0x54, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x65, 0x72, 0x72, 0x20, 0x6D, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x61, 0x73, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x27, 0x73, 0x20, 0x64, 0x6F, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x6B, 0x65, 0x65, 0x70, 0x20, 0x74, 0x72, 0x61, 0x63, 0x6B, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x72, 0x6F, 0x77, 0x6E, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0xCF, 0x04, 0x73, 0x70, 0x69, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x62, 0x28, 0x73, 0x70, 0x69, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x26, 0x29, 0x0A, 0x0A, 0x57, 0x72, 0x69, 0x74, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2E, 0x20, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x89, 0xAE, 0xCD, 0x00, 0x00, 0x8A, 0xCE, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x0B, 0x03, 0x07, 0x1C, 0xCE, 0x04, 0x73, 0x70, 0x69, 0x74, 0xDA, 0x10, 0xD0, 0x01, 0x77, 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, 0xCE, 0x0B, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0xDA, 0x81, 0x3F, 0xDA, 0x82, 0x4F, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0x28, 0x03, 0x00, 0x00, 0x22, 0x06, 0x00, 0x00, 0x1F, 0x05, 0x06, 0x02, 0x1A, 0x05, 0x03, 0x00, 0x26, 0x04, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x04, 0x02, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x07, 0x06, 0x00, 0x1A, 0x07, 0x02, 0x00, 0x18, 0x08, 0x00, 0x00, 0x26, 0x08, 0x02, 0x00, 0x26, 0x09, 0x03, 0x00, 0x2D, 0x08, 0x00, 0x09, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x09, 0x04, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x01, 0x08, 0x00, 0x00, 0x2C, 0x07, 0x01, 0x00, 0x26, 0x09, 0x05, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x0A, 0x06, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x89, 0xAE, 0x81, 0x20, 0xBF, 0x51, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0x0B, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE5, 0x1C, 0x04, 0x49, 0xBF, 0xB7, 0x49, 0xBF, 0xC8, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xC3, 0x3E, 0x05, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0x04, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBE, 0xE7, 0x81, 0x20, 0xCF, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x12, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x61, 0x73, 0x63, 0x69, 0x69, 0x2D, 0x6C, 0x6F, 0x77, 0x65, 0x72, 0xDA, 0x05, 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, 0xCF, 0x03, 0x73, 0x65, 0x71, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x78, 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, 0x6C, 0x6F, 0x6F, 0x70, 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, 0x20, 0x20, 0x53, 0x65, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x41, 0x3D, 0xCD, 0x00, 0x00, 0x42, 0x2D, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x09, 0x01, 0x05, 0x17, 0xCE, 0x03, 0x73, 0x65, 0x71, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x5A, 0xDA, 0x5D, 0xCF, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0xCF, 0x04, 0x6C, 0x6F, 0x6F, 0x70, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x38, 0x05, 0x00, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2D, 0x07, 0x04, 0x05, 0x3D, 0x06, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x05, 0x00, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2D, 0x08, 0x04, 0x05, 0x3D, 0x07, 0x00, 0x00, 0x26, 0x08, 0x04, 0x00, 0x2D, 0x08, 0x00, 0x07, 0x3D, 0x05, 0x00, 0x00, 0x26, 0x08, 0x02, 0x00, 0x2D, 0x08, 0x06, 0x05, 0x2B, 0x04, 0x00, 0x00, 0x3D, 0x07, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x41, 0x3D, 0x80, 0xF0, 0xBF, 0xA7, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xED, 0x14, 0x04, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xBF, 0xB4, 0x4C, 0xCF, 0x09, 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x65, 0x28, 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 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, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4F, 0xA1, 0xCD, 0x00, 0x00, 0x50, 0x28, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x03, 0x00, 0x02, 0x05, 0xCE, 0x09, 0x6D, 0x69, 0x6E, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x15, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x06, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3C, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1D, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x81, 0x13, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4F, 0xA1, 0x80, 0x87, 0xBF, 0xEB, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0xE6, 0xDA, 0x05, 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, 0x03, 0x6E, 0x6F, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x4E, 0xDA, 0x05, 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, 0xCF, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x77, 0x6F, 0x72, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x77, 0x6F, 0x72, 0x64, 0xDA, 0x05, 0xCE, 0x80, 0xE1, 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, 0x78, 0x29, 0x0A, 0x0A, 0x41, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x20, 0x77, 0x6F, 0x72, 0x64, 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, 0x62, 0x69, 0x67, 0x20, 0x65, 0x6E, 0x64, 0x69, 0x61, 0x6E, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2C, 0x20, 0x75, 0x6E, 0x73, 0x69, 0x67, 0x6E, 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, 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, 0x0B, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x81, 0x00, 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, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2E, 0x20, 0x20, 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, 0x20, 0x20, 0x6F, 0x72, 0x20, 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, 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, 0x20, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xC1, 0x47, 0xCD, 0x00, 0x00, 0xC5, 0x5A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x13, 0x01, 0x0E, 0x35, 0x02, 0xCE, 0x0B, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x10, 0xDA, 0x81, 0x23, 0xDA, 0x80, 0x90, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x77, 0x68, 0x69, 0x63, 0x68, 0xD0, 0x07, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0xCE, 0x03, 0x64, 0x6C, 0x6C, 0xCE, 0x02, 0x73, 0x6F, 0xDA, 0x82, 0xD0, 0xDA, 0x81, 0xD4, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x02, 0x01, 0x0B, 0xCE, 0x04, 0x66, 0x69, 0x6E, 0x64, 0xDA, 0x10, 0xDA, 0x81, 0xAF, 0x28, 0x02, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x22, 0x06, 0x00, 0x00, 0x1F, 0x05, 0x04, 0x06, 0x1A, 0x05, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x33, 0x06, 0x01, 0x04, 0x03, 0x06, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x61, 0x14, 0x81, 0x46, 0xBF, 0xC9, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE5, 0x1C, 0x08, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xF5, 0x0A, 0xBF, 0xF6, 0x0A, 0xDA, 0x80, 0xE3, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0C, 0x02, 0x02, 0x1E, 0xCE, 0x09, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x73, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x81, 0x00, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x25, 0x06, 0x02, 0x00, 0x09, 0x05, 0x06, 0x04, 0x25, 0x07, 0x01, 0x00, 0x07, 0x06, 0x05, 0x07, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x05, 0x07, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x08, 0x00, 0x00, 0x40, 0x07, 0x04, 0x08, 0x1A, 0x07, 0x06, 0x00, 0x25, 0x09, 0x00, 0x00, 0x33, 0x08, 0x01, 0x09, 0x25, 0x09, 0x00, 0x00, 0x34, 0x06, 0x09, 0x08, 0x18, 0x01, 0x00, 0x00, 0x25, 0x07, 0x01, 0x00, 0x3E, 0x08, 0x07, 0x04, 0x1A, 0x08, 0x08, 0x00, 0x33, 0x09, 0x01, 0x07, 0x2D, 0x06, 0x00, 0x09, 0x26, 0x0B, 0x01, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x25, 0x09, 0x01, 0x00, 0x06, 0x07, 0x07, 0x09, 0x18, 0xF8, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x85, 0xE5, 0x81, 0x32, 0xBF, 0x4C, 0x0B, 0xBF, 0xEC, 0x15, 0x1B, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF5, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xE7, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xDD, 0x24, 0x08, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x25, 0xBF, 0xF4, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xEB, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDC, 0x25, 0x04, 0x08, 0x0B, 0x08, 0xBF, 0xF1, 0x40, 0xBF, 0xE9, 0x0A, 0xBF, 0xE2, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0x06, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0xC1, 0x40, 0xBE, 0xD5, 0x81, 0x32, 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, 0xDA, 0x81, 0x3F, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x37, 0x04, 0x03, 0x00, 0x25, 0x06, 0x01, 0x00, 0x07, 0x05, 0x04, 0x06, 0x33, 0x04, 0x03, 0x05, 0x17, 0x05, 0x04, 0x00, 0x26, 0x08, 0x02, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x26, 0x09, 0x03, 0x00, 0x1F, 0x08, 0x09, 0x07, 0x1A, 0x08, 0x03, 0x00, 0x26, 0x06, 0x04, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x2A, 0x08, 0x00, 0x00, 0x17, 0x09, 0x08, 0x00, 0x2A, 0x0A, 0x01, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x2C, 0x09, 0x0C, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x2C, 0x0B, 0x0D, 0x00, 0x26, 0x0F, 0x08, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x1A, 0x0F, 0x02, 0x00, 0x03, 0x0F, 0x00, 0x00, 0x25, 0x10, 0x00, 0x00, 0x2C, 0x10, 0x0D, 0x00, 0x26, 0x11, 0x07, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x26, 0x11, 0x09, 0x00, 0x2C, 0x11, 0x10, 0x00, 0x26, 0x12, 0x0A, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x26, 0x10, 0x0B, 0x00, 0x26, 0x12, 0x0C, 0x00, 0x2D, 0x10, 0x00, 0x12, 0x2E, 0x11, 0x00, 0x00, 0x26, 0x12, 0x0D, 0x00, 0x2F, 0x10, 0x12, 0x00, 0x22, 0x11, 0x00, 0x00, 0x2C, 0x11, 0x10, 0x00, 0x3D, 0x10, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x01, 0x06, 0x1E, 0x01, 0xCE, 0x09, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x66, 0x75, 0x6C, 0x6C, 0xDA, 0x10, 0xCE, 0x06, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x3A, 0xD8, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0xCE, 0x05, 0x3A, 0x73, 0x79, 0x73, 0x3A, 0xDA, 0x81, 0xBB, 0xCE, 0x08, 0x3A, 0x6E, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3A, 0xDA, 0x82, 0xEB, 0x35, 0x01, 0x00, 0x00, 0x17, 0x02, 0x01, 0x00, 0x35, 0x01, 0x00, 0x01, 0x17, 0x03, 0x01, 0x00, 0x28, 0x01, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x27, 0x05, 0x00, 0x05, 0x2D, 0x04, 0x05, 0x02, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x05, 0x02, 0x00, 0x26, 0x06, 0x03, 0x00, 0x35, 0x06, 0x06, 0x00, 0x2D, 0x05, 0x06, 0x04, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x26, 0x04, 0x04, 0x00, 0x27, 0x06, 0x00, 0x07, 0x2D, 0x04, 0x06, 0x05, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x04, 0x06, 0x00, 0x26, 0x05, 0x05, 0x00, 0x27, 0x06, 0x00, 0x00, 0x2D, 0x05, 0x06, 0x04, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x04, 0x05, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x3D, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xC2, 0xE1, 0x81, 0x39, 0xBE, 0xC7, 0x81, 0x39, 0xBE, 0xC7, 0x81, 0x39, 0xBE, 0xC7, 0x81, 0x39, 0xBE, 0xC7, 0x81, 0x39, 0xBE, 0xFC, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x08, 0x80, 0xF9, 0x06, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x01, 0x0A, 0xCE, 0x0A, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x70, 0x61, 0x74, 0x68, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x01, 0x02, 0x0B, 0xCE, 0x07, 0x66, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0xDA, 0x10, 0xDA, 0x83, 0x02, 0xDA, 0x83, 0x05, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x1A, 0x03, 0x05, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xC0, 0xF2, 0x52, 0xBF, 0xCD, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEA, 0x17, 0x04, 0x1E, 0xBF, 0xEC, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xEF, 0x17, 0xBF, 0xE3, 0x1E, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x2F, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x1A, 0x03, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xC4, 0x1E, 0x2B, 0xBF, 0xF7, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF3, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xEE, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xCD, 0x00, 0x00, 0xC1, 0x47, 0x84, 0x13, 0xBD, 0x09, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDF, 0x22, 0x1C, 0x0D, 0xBF, 0xF0, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE2, 0x1F, 0xBF, 0xD7, 0x2A, 0x1E, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEB, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xE6, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xD0, 0x31, 0x04, 0x81, 0x39, 0xBE, 0xC7, 0x81, 0x39, 0x04, 0x2B, 0xBF, 0xD5, 0x2B, 0x0F, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xDA, 0x27, 0x0D, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xE1, 0x20, 0x04, 0x80, 0xBD, 0xBF, 0x43, 0x80, 0xBD, 0xBF, 0xF0, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0x57, 0x80, 0xAA, 0xBF, 0x56, 0x80, 0xAA, 0xBF, 0x56, 0x80, 0xAA, 0xBF, 0x56, 0x80, 0xAA, 0xBF, 0x56, 0x80, 0xAA, 0xBF, 0x56, 0x80, 0xAA, 0xBF, 0x51, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x77, 0x72, 0x69, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x4F, 0xDA, 0x05, 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, 0xCF, 0x0D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x66, 0xDA, 0x05, 0xCE, 0x80, 0xFD, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x06, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0xE4, 0xDA, 0x05, 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, 0xCF, 0x06, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x89, 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, 0x20, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x29, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x5A, 0x53, 0xCD, 0x00, 0x00, 0x5B, 0x47, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x02, 0x01, 0x16, 0xCE, 0x06, 0x66, 0x69, 0x6C, 0x74, 0x65, 0x72, 0xDA, 0x10, 0xDA, 0x81, 0x00, 0x28, 0x02, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x01, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x3E, 0x08, 0x06, 0x07, 0x1A, 0x08, 0x0D, 0x00, 0x33, 0x09, 0x05, 0x06, 0x17, 0x0A, 0x09, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x00, 0x00, 0x1A, 0x09, 0x05, 0x00, 0x2C, 0x04, 0x0A, 0x00, 0x26, 0x0C, 0x00, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x09, 0x01, 0x00, 0x06, 0x06, 0x09, 0x06, 0x18, 0xF3, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5A, 0x53, 0x80, 0xF4, 0xBF, 0xA4, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xD8, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x2B, 0xBF, 0xEB, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD6, 0x2B, 0xBF, 0xBC, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0xBB, 0x45, 0xBF, 0x13, 0x80, 0xF4, 0xCF, 0x0A, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x67, 0x28, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 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, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x5F, 0xEC, 0xCD, 0x00, 0x00, 0x61, 0x11, 0xDA, 0x03, 0xDA, 0x81, 0xAF, 0xDA, 0x82, 0xA9, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x5B, 0xDA, 0x05, 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, 0xCF, 0x03, 0x64, 0x65, 0x63, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x92, 0xED, 0x93, 0x13, 0xDA, 0x03, 0xDA, 0x81, 0x69, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xDA, 0x05, 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, 0xCF, 0x03, 0x6B, 0x76, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x77, 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, 0x20, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x20, 0x40, 0x5B, 0x6B, 0x20, 0x76, 0x20, 0x6B, 0x20, 0x76, 0x20, 0x2E, 0x2E, 0x2E, 0x5D, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x84, 0xF5, 0xCD, 0x00, 0x00, 0x85, 0xE2, 0xDA, 0x03, 0xDA, 0x81, 0xE2, 0xCF, 0x04, 0x73, 0x6F, 0x6D, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x61, 0x28, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x78, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x72, 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, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA4, 0xD1, 0xCD, 0x00, 0x00, 0xA5, 0x9A, 0xDA, 0x03, 0xDA, 0x82, 0x18, 0xCF, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xDA, 0x05, 0xCE, 0x59, 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, 0x74, 0x61, 0x62, 0x2E, 0xCF, 0x04, 0x6B, 0x65, 0x79, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7D, 0xEB, 0xCD, 0x00, 0x00, 0x7E, 0xB3, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x03, 0x1A, 0xCE, 0x04, 0x6B, 0x65, 0x79, 0x73, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x02, 0x03, 0x00, 0x22, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x06, 0x07, 0x05, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x08, 0x00, 0x2C, 0x02, 0x05, 0x00, 0x26, 0x08, 0x02, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x05, 0x07, 0x00, 0x18, 0xF3, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7D, 0xEB, 0x80, 0xC8, 0xBF, 0x92, 0x09, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x13, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x41, 0xBF, 0xD7, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x0D, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xC1, 0x41, 0xBF, 0x3F, 0x80, 0xC8, 0xCF, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x73, 0x65, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x73, 0x65, 0x74, 0xDA, 0x05, 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, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x73, 0x69, 0x6E, 0xDA, 0x05, 0xCE, 0x28, 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, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x01, 0x25, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x32, 0xDA, 0x05, 0xCE, 0x42, 0x28, 0x25, 0x20, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x6E, 0x64, 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x6F, 0x72, 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, 0x65, 0x6E, 0x64, 0x20, 0x2F, 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x6F, 0x72, 0x2E, 0xCF, 0x04, 0x6D, 0x65, 0x74, 0x61, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x37, 0x28, 0x6D, 0x65, 0x74, 0x61, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x41, 0x64, 0x64, 0x20, 0x6D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 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, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xD2, 0x83, 0xCD, 0x00, 0x00, 0xD3, 0x15, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0A, 0x00, 0x03, 0x1D, 0xCE, 0x04, 0x6D, 0x65, 0x74, 0x61, 0xDA, 0x10, 0xDA, 0x81, 0xE3, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0x57, 0x28, 0x01, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x17, 0x04, 0x03, 0x00, 0x22, 0x05, 0x00, 0x00, 0x2C, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x05, 0x07, 0x06, 0x19, 0x05, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x05, 0x00, 0x00, 0x1A, 0x05, 0x0B, 0x00, 0x17, 0x07, 0x06, 0x00, 0x33, 0x08, 0x04, 0x06, 0x17, 0x09, 0x08, 0x00, 0x26, 0x08, 0x02, 0x00, 0x35, 0x08, 0x08, 0x00, 0x34, 0x08, 0x07, 0x09, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2F, 0x06, 0x08, 0x00, 0x18, 0xF0, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xD2, 0x83, 0x80, 0x92, 0xBF, 0xC1, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xEA, 0x17, 0x04, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xF1, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xD4, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xCF, 0x01, 0x2A, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0B, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x01, 0x2A, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x01, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x01, 0x00, 0x35, 0x04, 0x00, 0x00, 0x09, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x09, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x01, 0x2B, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x21, 0xDA, 0x05, 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, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0xDA, 0x05, 0xCE, 0x60, 0x28, 0x6F, 0x73, 0x2F, 0x73, 0x6C, 0x65, 0x65, 0x70, 0x20, 0x6E, 0x73, 0x65, 0x63, 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, 0x6E, 0x73, 0x65, 0x63, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x73, 0x2E, 0x20, 0x27, 0x6E, 0x73, 0x65, 0x63, 0x27, 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, 0xCF, 0x01, 0x2D, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x6A, 0xDA, 0x05, 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, 0xCF, 0x01, 0x2F, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x24, 0xDA, 0x05, 0xCE, 0x80, 0xFA, 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, 0x20, 0x44, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x62, 0x79, 0x20, 0x74, 0x77, 0x6F, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x74, 0x72, 0x75, 0x6E, 0x63, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0xCF, 0x0D, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x3D, 0xDA, 0x05, 0xCE, 0x80, 0x82, 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, 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, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x65, 0x65, 0x6B, 0xDA, 0x05, 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, 0x0B, 0x70, 0x65, 0x67, 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x70, 0x65, 0x67, 0x2F, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0x93, 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, 0xCF, 0x03, 0x61, 0x6C, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x59, 0x28, 0x61, 0x6C, 0x6C, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x78, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA4, 0x21, 0xCD, 0x00, 0x00, 0xA4, 0xCE, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0A, 0x02, 0x00, 0x14, 0xCE, 0x03, 0x61, 0x6C, 0x6C, 0xDA, 0x10, 0x28, 0x02, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x17, 0x04, 0x01, 0x00, 0x37, 0x05, 0x04, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x3E, 0x08, 0x05, 0x06, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x07, 0x03, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1A, 0x07, 0x08, 0x00, 0x33, 0x08, 0x04, 0x05, 0x17, 0x09, 0x08, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x03, 0x00, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x05, 0x08, 0x05, 0x18, 0xF4, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA4, 0x21, 0x80, 0xAD, 0xBF, 0xBA, 0x0D, 0x04, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xF7, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xD4, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0x5A, 0x80, 0xAD, 0xCF, 0x04, 0x62, 0x78, 0x6F, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0F, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x04, 0x62, 0x78, 0x6F, 0x72, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x0E, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x0E, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0x01, 0x3C, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x0F, 0xDA, 0x05, 0xCE, 0x4B, 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, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 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, 0x1B, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0xA2, 0xDA, 0x05, 0xCE, 0x49, 0x28, 0x3D, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 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, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x2C, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2E, 0xCF, 0x01, 0x3E, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1A, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x01, 0x3E, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x40, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x4C, 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, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 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, 0xCF, 0x07, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xD8, 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, 0x20, 0x20, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x77, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 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, 0x20, 0x20, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xC6, 0x4D, 0xCD, 0x00, 0x00, 0xCB, 0xFB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x12, 0x01, 0x13, 0x5B, 0x02, 0xCE, 0x07, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0xDA, 0x10, 0xDA, 0x81, 0xE3, 0xD0, 0x04, 0x65, 0x78, 0x69, 0x74, 0xD3, 0x00, 0xDA, 0x83, 0x3F, 0xDA, 0x82, 0x4A, 0xDA, 0x83, 0x02, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x07, 0x01, 0x02, 0x0C, 0xCE, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0xDA, 0x10, 0xDA, 0x00, 0xDA, 0x83, 0x6C, 0x28, 0x01, 0x00, 0x00, 0x1A, 0x00, 0x03, 0x00, 0x17, 0x02, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x3C, 0x04, 0x00, 0x00, 0x2C, 0x04, 0x03, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x04, 0x05, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xAA, 0x32, 0x81, 0x1F, 0xBF, 0xB4, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDE, 0x23, 0x10, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xDA, 0x27, 0xBE, 0xEB, 0x81, 0x1F, 0xD3, 0x00, 0xDA, 0x82, 0x48, 0xDA, 0x82, 0x49, 0xDA, 0x82, 0x4B, 0xDA, 0x82, 0x70, 0xDA, 0x83, 0x05, 0xDA, 0x83, 0x6C, 0xDA, 0x82, 0xDA, 0xDA, 0x81, 0xF7, 0xDA, 0x82, 0xE3, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x08, 0x01, 0x07, 0x16, 0xCE, 0x05, 0x73, 0x6C, 0x75, 0x72, 0x70, 0xDA, 0x10, 0xD0, 0x01, 0x72, 0xDA, 0x83, 0x02, 0xDA, 0x83, 0x03, 0xDA, 0x81, 0x3F, 0xD0, 0x03, 0x61, 0x6C, 0x6C, 0xDA, 0x82, 0x52, 0xDA, 0x83, 0x05, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x00, 0x02, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x1A, 0x03, 0x02, 0x00, 0x18, 0x06, 0x00, 0x00, 0x26, 0x04, 0x02, 0x00, 0x2C, 0x04, 0x00, 0x00, 0x26, 0x05, 0x03, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x01, 0x04, 0x00, 0x00, 0x26, 0x04, 0x04, 0x00, 0x2C, 0x03, 0x04, 0x00, 0x26, 0x05, 0x05, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x07, 0x06, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x03, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x88, 0xB7, 0x80, 0xF4, 0xBF, 0x72, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xE7, 0x1A, 0x04, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xDB, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xD6, 0x2B, 0x13, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xE1, 0x20, 0x04, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0x18, 0x80, 0xF4, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x03, 0x08, 0xCE, 0x0A, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x10, 0xDA, 0x00, 0xD8, 0x0A, 0x65, 0x6E, 0x76, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xDA, 0x80, 0x81, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x2C, 0x00, 0x02, 0x00, 0x26, 0x03, 0x02, 0x00, 0x30, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xBB, 0xB6, 0x80, 0x81, 0xBF, 0xEE, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0x28, 0x02, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x33, 0x04, 0x03, 0x05, 0x17, 0x05, 0x04, 0x00, 0x26, 0x06, 0x02, 0x00, 0x33, 0x04, 0x06, 0x00, 0x17, 0x06, 0x04, 0x00, 0x1A, 0x06, 0x02, 0x00, 0x03, 0x06, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x04, 0x07, 0x00, 0x35, 0x07, 0x04, 0x00, 0x17, 0x08, 0x07, 0x00, 0x35, 0x07, 0x04, 0x01, 0x17, 0x09, 0x07, 0x00, 0x1A, 0x08, 0x02, 0x00, 0x18, 0x02, 0x00, 0x00, 0x01, 0x09, 0x00, 0x00, 0x26, 0x0A, 0x04, 0x00, 0x1F, 0x07, 0x09, 0x0A, 0x1A, 0x07, 0x25, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x2F, 0x0A, 0x0C, 0x00, 0x17, 0x0C, 0x0A, 0x00, 0x26, 0x0A, 0x07, 0x00, 0x23, 0x0D, 0x00, 0x00, 0x34, 0x0A, 0x08, 0x0D, 0x2A, 0x0A, 0x00, 0x00, 0x17, 0x0D, 0x0A, 0x00, 0x2A, 0x0A, 0x01, 0x00, 0x26, 0x0E, 0x08, 0x00, 0x26, 0x0F, 0x09, 0x00, 0x2D, 0x0E, 0x0D, 0x0F, 0x26, 0x0E, 0x04, 0x00, 0x2D, 0x0A, 0x0E, 0x08, 0x26, 0x0E, 0x0A, 0x00, 0x2C, 0x0E, 0x0C, 0x00, 0x3B, 0x0A, 0x00, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0F, 0x0B, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x26, 0x0E, 0x0C, 0x00, 0x2F, 0x0A, 0x0E, 0x00, 0x26, 0x0A, 0x07, 0x00, 0x22, 0x0E, 0x00, 0x00, 0x34, 0x0A, 0x08, 0x0E, 0x22, 0x0A, 0x00, 0x00, 0x2C, 0x0C, 0x0A, 0x00, 0x26, 0x0E, 0x0D, 0x00, 0x2F, 0x0A, 0x0E, 0x00, 0x17, 0x04, 0x0A, 0x00, 0x18, 0x19, 0x00, 0x00, 0x26, 0x0D, 0x0E, 0x00, 0x1F, 0x0C, 0x09, 0x0D, 0x1A, 0x0C, 0x08, 0x00, 0x26, 0x0E, 0x06, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x2C, 0x08, 0x0D, 0x00, 0x26, 0x0F, 0x0F, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x17, 0x0A, 0x0E, 0x00, 0x18, 0x0E, 0x00, 0x00, 0x26, 0x0F, 0x10, 0x00, 0x1F, 0x0E, 0x09, 0x0F, 0x1A, 0x0E, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x10, 0x11, 0x00, 0x2F, 0x0F, 0x10, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x26, 0x11, 0x12, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x17, 0x0D, 0x10, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0D, 0x00, 0x00, 0x17, 0x0A, 0x0D, 0x00, 0x17, 0x04, 0x0A, 0x00, 0x17, 0x07, 0x04, 0x00, 0x26, 0x04, 0x02, 0x00, 0x34, 0x04, 0x08, 0x07, 0x26, 0x04, 0x02, 0x00, 0x34, 0x04, 0x00, 0x07, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x05, 0x02, 0x01, 0x06, 0x01, 0xDA, 0x82, 0x71, 0xDA, 0x10, 0xDA, 0x82, 0x52, 0x28, 0x02, 0x00, 0x00, 0x27, 0x03, 0x00, 0x0B, 0x25, 0x04, 0x00, 0x08, 0x2D, 0x03, 0x04, 0x00, 0x26, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xC8, 0xF1, 0x2B, 0xBF, 0xEA, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x05, 0x02, 0x04, 0x15, 0x01, 0xDA, 0x10, 0xDA, 0x81, 0xBF, 0xDA, 0x82, 0x72, 0xDA, 0x82, 0x54, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x19, 0x03, 0x03, 0x00, 0x23, 0x03, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x1A, 0x03, 0x0B, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x02, 0x00, 0x2F, 0x02, 0x04, 0x00, 0x27, 0x02, 0x00, 0x05, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x02, 0x01, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x02, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xC9, 0xE7, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEB, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xDE, 0x80, 0xB7, 0xBF, 0x9C, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0x31, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xF5, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xE4, 0x1D, 0xBF, 0x4A, 0x80, 0xB7, 0xCD, 0x00, 0x00, 0xC6, 0x4D, 0x85, 0xAE, 0xBB, 0x55, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xD9, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0x13, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDB, 0x84, 0x99, 0xBB, 0x67, 0x84, 0x99, 0xBB, 0x67, 0x84, 0x99, 0xBB, 0xC0, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xD6, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0x08, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xF0, 0x0F, 0x12, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0xC5, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE6, 0x1B, 0x20, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEB, 0x16, 0x14, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0x14, 0x2B, 0xBF, 0xD5, 0x2B, 0x80, 0x88, 0x80, 0xEF, 0xBE, 0x9D, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0xBE, 0x6A, 0x81, 0x96, 0x14, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0x14, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0x14, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBC, 0xBD, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBF, 0xC8, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xE6, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBC, 0x8F, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBF, 0xEF, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE5, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBC, 0x62, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x61, 0x83, 0x9F, 0xBC, 0x58, 0x83, 0xA9, 0x08, 0x1E, 0xBF, 0xE2, 0x1E, 0x08, 0x1A, 0xBF, 0xE6, 0x1A, 0xBB, 0xA9, 0x84, 0x62, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0x02, 0xDA, 0x05, 0xCE, 0x81, 0xED, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x6F, 0x70, 0x65, 0x6E, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x5B, 0x2C, 0x6D, 0x6F, 0x64, 0x65, 0x5D, 0x29, 0x0A, 0x0A, 0x4F, 0x70, 0x65, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x2E, 0x20, 0x70, 0x61, 0x74, 0x68, 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, 0x6D, 0x6F, 0x64, 0x65, 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, 0x6D, 0x6F, 0x64, 0x65, 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, 0x09, 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, 0x09, 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, 0x09, 0x61, 0x20, 0x2D, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x0A, 0x09, 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, 0x09, 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, 0xCF, 0x0E, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0x39, 0xDA, 0x05, 0xCE, 0x80, 0xA7, 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, 0x70, 0x61, 0x74, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 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, 0x70, 0x61, 0x74, 0x74, 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, 0x73, 0x74, 0x72, 0x2E, 0xCF, 0x08, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x6C, 0x65, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x41, 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, 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, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x49, 0xD5, 0xCD, 0x00, 0x00, 0x4A, 0x47, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x06, 0x01, 0x02, 0x09, 0xCE, 0x08, 0x77, 0x68, 0x65, 0x6E, 0x2D, 0x6C, 0x65, 0x74, 0xDA, 0x10, 0xDA, 0x5D, 0xDA, 0x42, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x49, 0xD5, 0x72, 0xBF, 0xE1, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xCF, 0x09, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8A, 0x2B, 0x8A, 0x85, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x09, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x81, 0x58, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8A, 0x2B, 0x5A, 0xBF, 0xED, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xCF, 0x05, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x47, 0xDA, 0x05, 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, 0xCF, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x61, 0x67, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x6C, 0x69, 0x6E, 0x65, 0x61, 0x67, 0x65, 0xDA, 0x05, 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, 0xCF, 0x06, 0x69, 0x66, 0x2D, 0x6E, 0x6F, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x3D, 0x28, 0x69, 0x66, 0x2D, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x65, 0x78, 0x70, 0x2D, 0x31, 0x20, 0x65, 0x78, 0x70, 0x2D, 0x32, 0x20, 0x26, 0x29, 0x0A, 0x0A, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x68, 0x61, 0x6E, 0x64, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x28, 0x69, 0x66, 0x20, 0x28, 0x6E, 0x6F, 0x74, 0x20, 0x2E, 0x2E, 0x2E, 0x20, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x95, 0xF5, 0x96, 0x62, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x06, 0x03, 0x01, 0x06, 0xCE, 0x06, 0x69, 0x66, 0x2D, 0x6E, 0x6F, 0x74, 0xDA, 0x10, 0xDA, 0x5C, 0x28, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x02, 0x2B, 0x01, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x95, 0xF5, 0x6D, 0xBF, 0xE2, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xCF, 0x07, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x75, 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, 0x2C, 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, 0x20, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x84, 0x59, 0xCD, 0x00, 0x00, 0x84, 0xF2, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x01, 0x05, 0xCE, 0x07, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0B, 0x02, 0x02, 0x17, 0xCE, 0x0C, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x01, 0x03, 0x0D, 0xCE, 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x50, 0xDA, 0x53, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x03, 0x05, 0x00, 0x00, 0x8D, 0x2A, 0x6E, 0xBF, 0xD1, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x08, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xF4, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xDA, 0x81, 0x00, 0x28, 0x02, 0x00, 0x00, 0x17, 0x03, 0x01, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x06, 0x04, 0x05, 0x1A, 0x06, 0x10, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x09, 0x00, 0x00, 0x2F, 0x07, 0x09, 0x00, 0x1A, 0x07, 0x04, 0x00, 0x2C, 0x00, 0x08, 0x00, 0x2F, 0x09, 0x02, 0x00, 0x18, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x08, 0x00, 0x26, 0x0A, 0x01, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xF0, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x83, 0x52, 0x81, 0x04, 0xBF, 0x9C, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xBD, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x46, 0xBF, 0xD1, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD5, 0x46, 0xBF, 0xED, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xA6, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0xA4, 0x5C, 0xBF, 0x04, 0x81, 0x04, 0x28, 0x01, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x84, 0x59, 0x80, 0x99, 0xBF, 0xEB, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x0A, 0x65, 0x6E, 0x76, 0x2D, 0x6C, 0x6F, 0x6F, 0x6B, 0x75, 0x70, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0xCA, 0xDA, 0x05, 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, 0xCF, 0x0B, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x56, 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, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x80, 0x6D, 0xCD, 0x00, 0x00, 0x81, 0x40, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x01, 0x00, 0x18, 0xCE, 0x0B, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x3C, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, 0x37, 0x05, 0x04, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x3E, 0x07, 0x05, 0x06, 0x1A, 0x07, 0x0F, 0x00, 0x33, 0x08, 0x04, 0x05, 0x17, 0x09, 0x08, 0x00, 0x33, 0x08, 0x03, 0x09, 0x17, 0x0A, 0x08, 0x00, 0x1A, 0x0A, 0x05, 0x00, 0x25, 0x0C, 0x01, 0x00, 0x06, 0x0B, 0x0C, 0x0A, 0x17, 0x08, 0x0B, 0x00, 0x18, 0x02, 0x00, 0x00, 0x25, 0x08, 0x01, 0x00, 0x34, 0x03, 0x09, 0x08, 0x25, 0x08, 0x01, 0x00, 0x06, 0x05, 0x08, 0x05, 0x18, 0xF1, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x80, 0x6D, 0x80, 0xD3, 0xBF, 0x91, 0x0E, 0xBF, 0xF2, 0x0E, 0x04, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xCD, 0x0C, 0xBF, 0xED, 0x14, 0x15, 0x0F, 0xBF, 0xF7, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF4, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE2, 0x1F, 0xBF, 0xAD, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0xAC, 0x54, 0xBF, 0x36, 0x80, 0xD3, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0xDA, 0x05, 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, 0xCF, 0x04, 0x6E, 0x69, 0x6C, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8E, 0x7F, 0x8E, 0xAC, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x04, 0x6E, 0x69, 0x6C, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x22, 0x03, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x8E, 0x7F, 0x2D, 0xBF, 0xF7, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6F, 0x73, 0x2F, 0x73, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xDA, 0x05, 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, 0xCF, 0x0E, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0xA0, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 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, 0xCF, 0x09, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x65, 0x28, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 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, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4F, 0x17, 0xCD, 0x00, 0x00, 0x4F, 0x9E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x03, 0x00, 0x02, 0x05, 0xCE, 0x09, 0x6D, 0x61, 0x78, 0x2D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x14, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x06, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3E, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1B, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x81, 0x13, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4F, 0x17, 0x80, 0x87, 0xBF, 0xEB, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x0A, 0x6C, 0x6F, 0x61, 0x64, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x50, 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, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xBB, 0xB6, 0xCD, 0x00, 0x00, 0xBC, 0x37, 0xDA, 0x03, 0xDA, 0x83, 0xCB, 0xCF, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xDA, 0x05, 0xCE, 0x6F, 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, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 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, 0x2E, 0xCF, 0x03, 0x61, 0x6E, 0x64, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x70, 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, 0x65, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x20, 0x16, 0xCD, 0x00, 0x00, 0x21, 0x5B, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0A, 0x00, 0x02, 0x16, 0xCE, 0x03, 0x61, 0x6E, 0x64, 0xDA, 0x10, 0xDA, 0x5C, 0xDA, 0x5B, 0x28, 0x01, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x07, 0x00, 0x00, 0x40, 0x06, 0x05, 0x07, 0x1A, 0x06, 0x0E, 0x00, 0x25, 0x07, 0x01, 0x00, 0x07, 0x05, 0x05, 0x07, 0x23, 0x08, 0x00, 0x00, 0x1F, 0x07, 0x02, 0x08, 0x1A, 0x07, 0x03, 0x00, 0x33, 0x02, 0x00, 0x05, 0x18, 0x06, 0x00, 0x00, 0x33, 0x08, 0x00, 0x05, 0x26, 0x09, 0x00, 0x00, 0x2D, 0x09, 0x08, 0x02, 0x26, 0x09, 0x01, 0x00, 0x2F, 0x02, 0x09, 0x00, 0x18, 0xF1, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x20, 0x16, 0x81, 0x45, 0xBF, 0x3E, 0x0D, 0x0D, 0x0D, 0xBF, 0xEA, 0x17, 0x04, 0x0A, 0x0B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x80, 0x81, 0xBF, 0x92, 0x05, 0xBF, 0xFB, 0x05, 0x13, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x58, 0xBF, 0xC7, 0x0C, 0xBF, 0xD5, 0x58, 0xBF, 0xEE, 0x0C, 0xBF, 0xE9, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0x82, 0x80, 0x81, 0xBE, 0xC2, 0x81, 0x45, 0xCF, 0x09, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, 0x74, 0x3D, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x96, 0x28, 0x64, 0x65, 0x65, 0x70, 0x2D, 0x6E, 0x6F, 0x74, 0x3D, 0x20, 0x78, 0x20, 0x79, 0x29, 0x0A, 0x0A, 0x4C, 0x69, 0x6B, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x3D, 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, 0x20, 0x20, 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, 0x6E, 0x6F, 0x74, 0x3D, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA5, 0x9D, 0xCD, 0x00, 0x00, 0xA7, 0xD0, 0xDA, 0x03, 0xDA, 0x82, 0x1B, 0xCF, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x65, 0x65, 0x64, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0F, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x65, 0x65, 0x64, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xDA, 0x05, 0xCE, 0x65, 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, 0x27, 0x73, 0x65, 0x65, 0x64, 0x27, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2E, 0xCF, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x9F, 0x28, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 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, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x20, 0x20, 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, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x62, 0x5D, 0xCD, 0x00, 0x00, 0x63, 0x53, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x0B, 0xCE, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0xDA, 0x10, 0xDA, 0x81, 0xAF, 0xDA, 0x80, 0x8A, 0x28, 0x02, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x1A, 0x04, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x2D, 0x01, 0x05, 0x04, 0x26, 0x05, 0x01, 0x00, 0x30, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x62, 0x5D, 0x80, 0xF6, 0xBF, 0xBF, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE5, 0x1C, 0x04, 0x27, 0xBF, 0xE3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE2, 0x27, 0xCF, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79, 0xDA, 0x05, 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, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x74, 0x69, 0x6D, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x74, 0x69, 0x6D, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0x80, 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, 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, 0xCF, 0x08, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x84, 0x63, 0x84, 0xBC, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x04, 0x01, 0x02, 0x06, 0xCE, 0x08, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0xDA, 0x10, 0xDA, 0x1D, 0xDA, 0x81, 0x41, 0x28, 0x02, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2C, 0x00, 0x03, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x30, 0x03, 0x00, 0x00, 0x84, 0x63, 0x59, 0xBF, 0xE3, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xCF, 0x0A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x63, 0xDA, 0x05, 0xCE, 0x80, 0x91, 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, 0x2C, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0xCF, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x56, 0xDA, 0x05, 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, 0xCF, 0x02, 0x3C, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1D, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x02, 0x3C, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x3F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x51, 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, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 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, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x66, 0x6C, 0x75, 0x73, 0x68, 0xDA, 0x05, 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, 0xCF, 0x07, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x45, 0x55, 0xCD, 0x00, 0x00, 0x45, 0xDC, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x00, 0x0F, 0xCE, 0x07, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x01, 0x00, 0x17, 0x03, 0x00, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x06, 0x04, 0x05, 0x1A, 0x06, 0x07, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x09, 0x02, 0x02, 0x08, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xF9, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x45, 0x55, 0x80, 0x87, 0xBF, 0xCA, 0x0C, 0x04, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xF4, 0x0B, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0x82, 0x80, 0x87, 0xCF, 0x05, 0x61, 0x70, 0x70, 0x6C, 0x79, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0xAB, 0xDA, 0x05, 0xCE, 0x81, 0x5D, 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, 0x29, 0xCF, 0x0B, 0x72, 0x75, 0x6E, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x82, 0x96, 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, 0x6F, 0x66, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2C, 0x20, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x69, 0x73, 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, 0x20, 0x20, 0x6F, 0x70, 0x74, 0x73, 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, 0x09, 0x20, 0x20, 0x3A, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x20, 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, 0x09, 0x20, 0x20, 0x3A, 0x6F, 0x6E, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 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, 0x09, 0x20, 0x20, 0x3A, 0x65, 0x6E, 0x76, 0x20, 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, 0x2A, 0x65, 0x6E, 0x76, 0x2A, 0x0A, 0x09, 0x20, 0x20, 0x3A, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2D, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x73, 0x20, 0x2D, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x69, 0x73, 0x20, 0x22, 0x3C, 0x61, 0x6E, 0x6F, 0x6E, 0x79, 0x6D, 0x6F, 0x75, 0x73, 0x3E, 0x22, 0x0A, 0x09, 0x20, 0x20, 0x3A, 0x6F, 0x6E, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x2D, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 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, 0x09, 0x20, 0x20, 0x3A, 0x6F, 0x6E, 0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xAD, 0xEF, 0xCD, 0x00, 0x00, 0xB7, 0x15, 0xDA, 0x03, 0xDA, 0x82, 0x70, 0xCF, 0x0E, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x62, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0xD5, 0xDA, 0x05, 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, 0xCF, 0x0A, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8A, 0x87, 0x8A, 0xCD, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x0A, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xD0, 0x09, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8A, 0x87, 0x46, 0xBF, 0xEC, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xCF, 0x0C, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0xDA, 0x05, 0xCE, 0x6D, 0x28, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x75, 0x70, 0x20, 0x26, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 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, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x75, 0x70, 0x2E, 0xCF, 0x07, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x2B, 0x28, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x95, 0xB7, 0x95, 0xF2, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0xCE, 0x07, 0x63, 0x6F, 0x6D, 0x6D, 0x65, 0x6E, 0x74, 0xDA, 0x10, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x95, 0xB7, 0x3B, 0xBF, 0xC5, 0x3B, 0xCF, 0x07, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3C, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x17, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x07, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3C, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1B, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x6C, 0x28, 0x6F, 0x72, 0x64, 0x65, 0x72, 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, 0x6E, 0x6F, 0x74, 0x20, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x02, 0x3D, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1E, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x02, 0x3D, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x42, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x59, 0x28, 0x3D, 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, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x28, 0x34, 0x2E, 0x30, 0x20, 0x3D, 0x3D, 0x20, 0x34, 0x29, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x0C, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x05, 0xCE, 0x80, 0xD3, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x66, 0x75, 0x6E, 0x20, 0x5B, 0x2C, 0x70, 0x63, 0x3D, 0x30, 0x5D, 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, 0xCF, 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0xDA, 0x05, 0xCE, 0x80, 0x82, 0x28, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x20, 0x26, 0x20, 0x61, 0x72, 0x67, 0x73, 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, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x69, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x2E, 0xCF, 0x04, 0x73, 0x6F, 0x72, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x53, 0x28, 0x73, 0x6F, 0x72, 0x74, 0x20, 0x78, 0x73, 0x20, 0x5B, 0x2C, 0x20, 0x62, 0x79, 0x5D, 0x29, 0x0A, 0x0A, 0x53, 0x6F, 0x72, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x6E, 0x2D, 0x70, 0x6C, 0x61, 0x63, 0x65, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x51, 0x1A, 0xCD, 0x00, 0x00, 0x53, 0xDB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xD8, 0x00, 0x00, 0x06, 0x02, 0x01, 0x0E, 0x01, 0xCE, 0x04, 0x73, 0x6F, 0x72, 0x74, 0xDA, 0x10, 0xDA, 0x83, 0x1B, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x07, 0x04, 0x03, 0x05, 0x1A, 0x01, 0x03, 0x00, 0x17, 0x03, 0x01, 0x00, 0x18, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x17, 0x03, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x2D, 0x00, 0x05, 0x04, 0x2B, 0x03, 0x00, 0x00, 0x27, 0x05, 0x00, 0x02, 0x30, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x53, 0x92, 0x47, 0xBF, 0xE3, 0x09, 0xBF, 0xF4, 0x0F, 0xBF, 0xF1, 0x0F, 0x02, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xD3, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0x00, 0x05, 0xDA, 0x84, 0x9B, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x10, 0x04, 0x00, 0x1C, 0xDA, 0x82, 0xF5, 0xDA, 0x10, 0x28, 0x04, 0x00, 0x00, 0x33, 0x05, 0x00, 0x02, 0x17, 0x06, 0x05, 0x00, 0x17, 0x07, 0x01, 0x00, 0x17, 0x08, 0x01, 0x00, 0x17, 0x09, 0x02, 0x00, 0x3E, 0x0A, 0x08, 0x09, 0x1A, 0x0A, 0x11, 0x00, 0x17, 0x0B, 0x08, 0x00, 0x33, 0x0C, 0x00, 0x0B, 0x17, 0x0D, 0x0C, 0x00, 0x2C, 0x0D, 0x06, 0x00, 0x2F, 0x0C, 0x03, 0x00, 0x1A, 0x0C, 0x08, 0x00, 0x33, 0x0E, 0x00, 0x07, 0x17, 0x0F, 0x0E, 0x00, 0x34, 0x00, 0x07, 0x0D, 0x34, 0x00, 0x0B, 0x0F, 0x25, 0x0E, 0x01, 0x00, 0x06, 0x07, 0x07, 0x0E, 0x18, 0x01, 0x00, 0x00, 0x25, 0x0C, 0x01, 0x00, 0x06, 0x08, 0x08, 0x0C, 0x18, 0xEF, 0xFF, 0xFF, 0x33, 0x08, 0x00, 0x07, 0x34, 0x00, 0x02, 0x08, 0x34, 0x00, 0x07, 0x06, 0x03, 0x07, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x51, 0x89, 0x81, 0x45, 0xBE, 0xEF, 0x09, 0xBF, 0xEC, 0x15, 0x08, 0x09, 0x08, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x79, 0x08, 0xBF, 0xF0, 0x11, 0x10, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xEE, 0x73, 0xBF, 0xB3, 0x08, 0xBF, 0xF0, 0x11, 0x0C, 0x0D, 0x0C, 0x0D, 0x0C, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0x8E, 0x73, 0xBF, 0x51, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0xBF, 0x50, 0x80, 0xB0, 0x14, 0x08, 0xBF, 0xEC, 0x15, 0x08, 0x10, 0xBE, 0xC4, 0x81, 0x45, 0xD7, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x09, 0x04, 0x00, 0x14, 0x01, 0xCE, 0x09, 0x73, 0x6F, 0x72, 0x74, 0x2D, 0x68, 0x65, 0x6C, 0x70, 0xDA, 0x10, 0x28, 0x04, 0x00, 0x00, 0x40, 0x05, 0x02, 0x01, 0x1A, 0x05, 0x11, 0x00, 0x2D, 0x00, 0x01, 0x02, 0x2B, 0x03, 0x00, 0x00, 0x27, 0x07, 0x00, 0x01, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x08, 0x01, 0x00, 0x07, 0x06, 0x07, 0x08, 0x2D, 0x00, 0x01, 0x06, 0x2B, 0x03, 0x00, 0x00, 0x2F, 0x08, 0x04, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x06, 0x07, 0x08, 0x2D, 0x00, 0x06, 0x02, 0x2B, 0x03, 0x00, 0x00, 0x2F, 0x08, 0x04, 0x00, 0x18, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x52, 0xD5, 0x80, 0xB6, 0xBF, 0x79, 0x08, 0xBF, 0xF2, 0x80, 0x84, 0xBF, 0x9D, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x1A, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xE8, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0x17, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xEB, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0x7D, 0x80, 0x84, 0xBF, 0x53, 0x80, 0xB6, 0xDB, 0x01, 0xDA, 0x84, 0x96, 0xDA, 0x03, 0xCF, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x42, 0x28, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x53, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x28, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x75, 0x6E, 0x74, 0x69, 0x6C, 0x20, 0x28, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 0x29, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x63, 0x56, 0xCD, 0x00, 0x00, 0x63, 0xC8, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x02, 0x02, 0x07, 0xCE, 0x0A, 0x74, 0x61, 0x6B, 0x65, 0x2D, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x10, 0xDA, 0x82, 0x94, 0xDA, 0x84, 0x3F, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x26, 0x04, 0x01, 0x00, 0x30, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x63, 0x56, 0x72, 0xBF, 0xEA, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE4, 0x21, 0xBF, 0xDF, 0x21, 0xBF, 0xDF, 0x21, 0xCF, 0x05, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x82, 0x83, 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, 0x78, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x73, 0x74, 0x20, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x2E, 0x20, 0x45, 0x61, 0x73, 0x79, 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, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x6F, 0x20, 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, 0x41, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 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, 0x78, 0x27, 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x6F, 0x66, 0x20, 0x69, 0x74, 0x27, 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, 0x20, 0x78, 0x2E, 0x20, 0x41, 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, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6F, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x78, 0x2E, 0x20, 0x41, 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, 0x27, 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, 0x20, 0x66, 0x6F, 0x6C, 0x6C, 0x6F, 0x77, 0x69, 0x6E, 0x67, 0x20, 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, 0x20, 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, 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, 0x78, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x8F, 0xC9, 0xCD, 0x00, 0x00, 0x93, 0xE4, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x0A, 0x01, 0x06, 0x22, 0x01, 0xCE, 0x05, 0x6D, 0x61, 0x74, 0x63, 0x68, 0xDA, 0x10, 0xDA, 0x4F, 0xDA, 0x59, 0xDA, 0x81, 0x69, 0xDA, 0x5A, 0xDA, 0x5B, 0xDA, 0x5D, 0x28, 0x02, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x1A, 0x05, 0x03, 0x00, 0x17, 0x04, 0x03, 0x00, 0x18, 0x04, 0x00, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x04, 0x06, 0x00, 0x17, 0x05, 0x04, 0x00, 0x37, 0x04, 0x01, 0x00, 0x17, 0x06, 0x04, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x04, 0x07, 0x00, 0x17, 0x07, 0x04, 0x00, 0x2A, 0x04, 0x00, 0x00, 0x25, 0x08, 0x00, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x2F, 0x08, 0x04, 0x00, 0x17, 0x04, 0x08, 0x00, 0x1F, 0x06, 0x03, 0x05, 0x1A, 0x06, 0x02, 0x00, 0x03, 0x04, 0x00, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2D, 0x08, 0x05, 0x03, 0x26, 0x09, 0x04, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x26, 0x09, 0x05, 0x00, 0x2D, 0x09, 0x08, 0x04, 0x26, 0x09, 0x04, 0x00, 0x30, 0x09, 0x00, 0x00, 0xCD, 0x00, 0xFE, 0x00, 0x00, 0x0A, 0x01, 0x06, 0x27, 0x01, 0x01, 0xDA, 0x4C, 0xDA, 0x10, 0xDA, 0x59, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x13, 0x04, 0x0E, 0x80, 0x84, 0x03, 0xCE, 0x07, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x2D, 0x31, 0xDA, 0x10, 0xDA, 0x81, 0xDC, 0xDA, 0x81, 0x1B, 0xDA, 0x5C, 0xD2, 0x02, 0x00, 0xDA, 0x81, 0xCC, 0xCF, 0x07, 0x5F, 0x30, 0x30, 0x30, 0x30, 0x31, 0x78, 0xDA, 0x5A, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x06, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8B, 0x8A, 0x3D, 0xBF, 0xF0, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x06, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x50, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8B, 0x4A, 0x3E, 0xBF, 0xF0, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xDA, 0x4F, 0xDA, 0x59, 0xCF, 0x08, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x3F, 0xDA, 0x5B, 0xDA, 0x5D, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x01, 0x03, 0x0D, 0xCE, 0x0B, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x72, 0x79, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x52, 0xDA, 0x51, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x03, 0x05, 0x00, 0x00, 0x8C, 0xB9, 0x6F, 0xBF, 0xD0, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x08, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xCF, 0x0B, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x72, 0x79, 0x3F, 0x28, 0x04, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x1A, 0x05, 0x1D, 0x00, 0x33, 0x06, 0x03, 0x00, 0x1A, 0x06, 0x0B, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2D, 0x08, 0x00, 0x01, 0x3D, 0x07, 0x00, 0x00, 0x2F, 0x08, 0x02, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2D, 0x0A, 0x07, 0x08, 0x26, 0x0A, 0x03, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00, 0x23, 0x07, 0x00, 0x00, 0x34, 0x03, 0x00, 0x07, 0x26, 0x08, 0x04, 0x00, 0x2D, 0x08, 0x00, 0x01, 0x3D, 0x07, 0x00, 0x00, 0x26, 0x09, 0x01, 0x00, 0x22, 0x0A, 0x00, 0x00, 0x2D, 0x09, 0x0A, 0x07, 0x3D, 0x08, 0x00, 0x00, 0x2F, 0x07, 0x02, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x26, 0x0B, 0x03, 0x00, 0x2D, 0x0A, 0x08, 0x0B, 0x2B, 0x07, 0x00, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x07, 0x05, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x1A, 0x06, 0x07, 0x00, 0x25, 0x08, 0x00, 0x00, 0x33, 0x07, 0x00, 0x08, 0x2A, 0x08, 0x00, 0x00, 0x2D, 0x07, 0x01, 0x08, 0x2B, 0x03, 0x00, 0x00, 0x30, 0x04, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x08, 0x06, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x1A, 0x07, 0x25, 0x00, 0x37, 0x08, 0x00, 0x00, 0x17, 0x09, 0x08, 0x00, 0x25, 0x08, 0xFF, 0xFF, 0x17, 0x0A, 0x01, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x1A, 0x0C, 0x03, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x18, 0x04, 0x00, 0x00, 0x26, 0x0E, 0x08, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x17, 0x0B, 0x0D, 0x00, 0x17, 0x0C, 0x0B, 0x00, 0x26, 0x0D, 0x09, 0x00, 0x2C, 0x0D, 0x0C, 0x00, 0x3D, 0x0B, 0x00, 0x00, 0x2A, 0x0D, 0x01, 0x00, 0x2F, 0x0E, 0x0D, 0x00, 0x26, 0x0F, 0x02, 0x00, 0x2D, 0x0F, 0x0B, 0x0E, 0x26, 0x0F, 0x03, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x3D, 0x0D, 0x00, 0x00, 0x17, 0x0B, 0x0D, 0x00, 0x1F, 0x0D, 0x0A, 0x0C, 0x1A, 0x0D, 0x02, 0x00, 0x03, 0x0B, 0x00, 0x00, 0x26, 0x0E, 0x04, 0x00, 0x2D, 0x0E, 0x0C, 0x0A, 0x26, 0x0F, 0x0A, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x26, 0x0F, 0x0B, 0x00, 0x2D, 0x0F, 0x0E, 0x0B, 0x26, 0x0F, 0x0A, 0x00, 0x30, 0x0F, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x0B, 0x0C, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x1A, 0x0A, 0x23, 0x00, 0x22, 0x0B, 0x00, 0x00, 0x17, 0x0D, 0x01, 0x00, 0x2B, 0x0D, 0x00, 0x00, 0x26, 0x10, 0x07, 0x00, 0x2F, 0x0F, 0x10, 0x00, 0x1A, 0x0F, 0x03, 0x00, 0x17, 0x0E, 0x0D, 0x00, 0x18, 0x04, 0x00, 0x00, 0x26, 0x11, 0x08, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x17, 0x0E, 0x10, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x26, 0x10, 0x0D, 0x00, 0x2C, 0x10, 0x0F, 0x00, 0x3D, 0x0E, 0x00, 0x00, 0x2A, 0x10, 0x02, 0x00, 0x2F, 0x11, 0x10, 0x00, 0x26, 0x12, 0x02, 0x00, 0x2D, 0x12, 0x0E, 0x11, 0x26, 0x12, 0x03, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x3D, 0x10, 0x00, 0x00, 0x17, 0x0E, 0x10, 0x00, 0x1F, 0x10, 0x0D, 0x0F, 0x1A, 0x10, 0x02, 0x00, 0x03, 0x0E, 0x00, 0x00, 0x26, 0x11, 0x04, 0x00, 0x2D, 0x11, 0x0F, 0x0D, 0x26, 0x12, 0x0A, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x26, 0x12, 0x0B, 0x00, 0x2D, 0x12, 0x11, 0x0E, 0x26, 0x12, 0x0A, 0x00, 0x30, 0x12, 0x00, 0x00, 0x26, 0x0E, 0x01, 0x00, 0x2D, 0x0E, 0x00, 0x01, 0x3D, 0x0D, 0x00, 0x00, 0x2F, 0x0E, 0x02, 0x00, 0x26, 0x11, 0x02, 0x00, 0x2D, 0x11, 0x0D, 0x0E, 0x26, 0x11, 0x03, 0x00, 0x2B, 0x11, 0x00, 0x00, 0x3D, 0x10, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x00, 0x04, 0x11, 0x01, 0xDA, 0x10, 0xDA, 0x80, 0x8C, 0xDA, 0x84, 0x29, 0xDA, 0x5C, 0xDA, 0x84, 0xAE, 0x27, 0x00, 0x00, 0x00, 0x25, 0x01, 0x01, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x01, 0x00, 0x00, 0x2F, 0x00, 0x01, 0x00, 0x26, 0x02, 0x01, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x3D, 0x01, 0x00, 0x00, 0x27, 0x02, 0x00, 0x02, 0x2F, 0x00, 0x02, 0x00, 0x26, 0x03, 0x02, 0x00, 0x2D, 0x03, 0x01, 0x00, 0x26, 0x03, 0x03, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x8C, 0x99, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xDE, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x00, 0x02, 0x19, 0x01, 0xDA, 0x4C, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x06, 0x02, 0x02, 0x00, 0x02, 0xCE, 0x03, 0x67, 0x65, 0x74, 0x33, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x5B, 0x28, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x08, 0x25, 0x03, 0x01, 0x00, 0x06, 0x01, 0x02, 0x03, 0x29, 0x01, 0x00, 0x08, 0x27, 0x03, 0x00, 0x08, 0x27, 0x04, 0x00, 0x09, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x03, 0x00, 0x27, 0x03, 0x00, 0x02, 0x30, 0x03, 0x00, 0x00, 0x27, 0x04, 0x00, 0x00, 0x27, 0x05, 0x00, 0x08, 0x33, 0x03, 0x04, 0x05, 0x26, 0x04, 0x00, 0x00, 0x27, 0x05, 0x00, 0x0C, 0x27, 0x06, 0x00, 0x08, 0x2D, 0x04, 0x05, 0x06, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x2D, 0x03, 0x04, 0x00, 0x27, 0x05, 0x00, 0x03, 0x2B, 0x05, 0x00, 0x00, 0x27, 0x05, 0x00, 0x04, 0x30, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x8D, 0x6F, 0x80, 0xA0, 0xBF, 0x7A, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0xFB, 0x05, 0xBF, 0xFB, 0x05, 0x15, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x6F, 0xBF, 0xB0, 0x08, 0xBF, 0xF8, 0x08, 0x1C, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0x02, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xD6, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x07, 0x00, 0x03, 0x1B, 0x01, 0xDA, 0x4C, 0xDA, 0x10, 0xDA, 0x80, 0xFB, 0xDA, 0x84, 0xB8, 0xDA, 0x5B, 0x28, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, 0x27, 0x02, 0x00, 0x0B, 0x2C, 0x01, 0x02, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2F, 0x01, 0x02, 0x00, 0x29, 0x01, 0x00, 0x0B, 0x27, 0x03, 0x00, 0x0B, 0x22, 0x04, 0x00, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x03, 0x00, 0x27, 0x03, 0x00, 0x02, 0x30, 0x03, 0x00, 0x00, 0x27, 0x04, 0x00, 0x00, 0x27, 0x05, 0x00, 0x0B, 0x33, 0x03, 0x04, 0x05, 0x26, 0x04, 0x01, 0x00, 0x27, 0x05, 0x00, 0x0F, 0x27, 0x06, 0x00, 0x0B, 0x2D, 0x04, 0x05, 0x06, 0x26, 0x05, 0x02, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x2D, 0x03, 0x04, 0x00, 0x27, 0x05, 0x00, 0x03, 0x2B, 0x05, 0x00, 0x00, 0x27, 0x05, 0x00, 0x04, 0x30, 0x05, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x8E, 0xB5, 0x80, 0xBD, 0xBF, 0x66, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x16, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF2, 0x76, 0xBF, 0xAB, 0x08, 0xBF, 0xF8, 0x08, 0x1C, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0x02, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD1, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xCD, 0x00, 0x00, 0x8B, 0x34, 0x84, 0x92, 0xBB, 0xA8, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE5, 0x84, 0x62, 0xBB, 0xC3, 0x11, 0xBF, 0xEB, 0x80, 0xB5, 0xBF, 0x68, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0x14, 0x16, 0xBF, 0xEA, 0x16, 0x0A, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0xBF, 0xCA, 0x36, 0x09, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0x14, 0x84, 0x62, 0xBC, 0x9F, 0x0E, 0xBF, 0xF2, 0x0E, 0x0D, 0x49, 0xBF, 0x8D, 0x79, 0xBF, 0x87, 0x79, 0xBF, 0x87, 0x79, 0x07, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBE, 0x7F, 0x84, 0x62, 0xBD, 0x38, 0x0F, 0xBF, 0xE8, 0x19, 0x08, 0x09, 0x08, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBF, 0x25, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x49, 0x80, 0xA0, 0xBF, 0x3D, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x26, 0x80, 0xDA, 0xBF, 0x00, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0xBE, 0xFF, 0x81, 0x01, 0x08, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBD, 0x20, 0x84, 0x62, 0xBE, 0x8E, 0x0C, 0x08, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBF, 0x04, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x2C, 0x80, 0xBD, 0xBF, 0x1C, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBF, 0x05, 0x80, 0xFB, 0xBE, 0xDE, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0xBE, 0xDD, 0x81, 0x23, 0x0E, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBB, 0x9F, 0x84, 0x62, 0xDA, 0x5A, 0xDA, 0x81, 0x1B, 0xDA, 0x84, 0xAE, 0xDA, 0x5C, 0x28, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x07, 0x1F, 0x02, 0x00, 0x03, 0x1A, 0x02, 0x04, 0x00, 0x27, 0x04, 0x00, 0x01, 0x33, 0x03, 0x04, 0x00, 0x03, 0x03, 0x00, 0x00, 0x27, 0x04, 0x00, 0x07, 0x3E, 0x03, 0x00, 0x04, 0x1A, 0x03, 0x1D, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x27, 0x06, 0x00, 0x01, 0x33, 0x04, 0x06, 0x00, 0x2A, 0x06, 0x00, 0x00, 0x3C, 0x07, 0x00, 0x00, 0x27, 0x08, 0x00, 0x05, 0x2D, 0x04, 0x08, 0x06, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x09, 0x01, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2D, 0x06, 0x05, 0x08, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x07, 0x03, 0x00, 0x26, 0x08, 0x04, 0x00, 0x2D, 0x07, 0x08, 0x04, 0x3D, 0x06, 0x00, 0x00, 0x25, 0x07, 0x02, 0x00, 0x06, 0x04, 0x07, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x2F, 0x07, 0x01, 0x00, 0x26, 0x08, 0x05, 0x00, 0x2D, 0x08, 0x06, 0x07, 0x2B, 0x05, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x00, 0x01, 0x07, 0x02, 0xDA, 0x10, 0xDA, 0x41, 0x27, 0x00, 0x01, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x2F, 0x00, 0x01, 0x00, 0x27, 0x02, 0x00, 0x01, 0x33, 0x01, 0x02, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x93, 0x81, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x00, 0x92, 0xB9, 0x81, 0x26, 0xBE, 0xFE, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xE6, 0x81, 0x11, 0xBF, 0x0B, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0x0C, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xC2, 0x81, 0x11, 0xBF, 0x2F, 0x80, 0xD0, 0xBF, 0x30, 0x80, 0xD0, 0xBF, 0x30, 0x80, 0xD0, 0xBF, 0x81, 0x0C, 0xBF, 0xF4, 0x0C, 0x05, 0x1A, 0xBF, 0xAE, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0xD7, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0x7E, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBF, 0x5B, 0x80, 0xA5, 0xBE, 0xF1, 0x81, 0x11, 0xCD, 0x00, 0x00, 0x8F, 0xC9, 0x84, 0x1B, 0xBE, 0x82, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0xA3, 0x0D, 0xBF, 0xEA, 0x17, 0x13, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xED, 0x14, 0x09, 0x81, 0x26, 0xBE, 0xD9, 0x81, 0x2A, 0xBE, 0xD6, 0x81, 0x2A, 0xBE, 0xD6, 0x81, 0x2A, 0xBE, 0x84, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xBE, 0x83, 0x81, 0x7D, 0xCF, 0x05, 0x6D, 0x61, 0x63, 0x65, 0x78, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x24, 0x28, 0x6D, 0x61, 0x63, 0x65, 0x78, 0x20, 0x78, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xA8, 0x86, 0xCD, 0x00, 0x00, 0xA9, 0xAD, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x03, 0x19, 0xCE, 0x05, 0x6D, 0x61, 0x63, 0x65, 0x78, 0xDA, 0x10, 0xDA, 0x81, 0xE6, 0xDA, 0x82, 0x1B, 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, 0x28, 0x01, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x2C, 0x04, 0x02, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x1A, 0x06, 0x0E, 0x00, 0x25, 0x07, 0x01, 0x00, 0x06, 0x05, 0x05, 0x07, 0x25, 0x08, 0xC8, 0x00, 0x40, 0x07, 0x05, 0x08, 0x1A, 0x07, 0x04, 0x00, 0x26, 0x08, 0x02, 0x00, 0x01, 0x08, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x17, 0x02, 0x04, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x04, 0x07, 0x00, 0x18, 0xF0, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xA8, 0x86, 0x81, 0x27, 0xBF, 0x0B, 0x0F, 0x11, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEA, 0x17, 0x04, 0x0E, 0x0B, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xDE, 0x80, 0xAA, 0xBF, 0x85, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF2, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE9, 0x43, 0xBF, 0xDC, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xBE, 0x43, 0x06, 0x15, 0x13, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0x58, 0x80, 0xAA, 0xBE, 0xE4, 0x81, 0x27, 0xCF, 0x08, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xB7, 0x28, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x65, 0x6E, 0x76, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x26, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xAA, 0x32, 0xCD, 0x00, 0x00, 0xAB, 0x51, 0xDA, 0x03, 0xDA, 0x83, 0xC3, 0xCF, 0x0B, 0x2A, 0x64, 0x6F, 0x63, 0x2D, 0x77, 0x69, 0x64, 0x74, 0x68, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x28, 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, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x94, 0x3C, 0xCD, 0x00, 0x00, 0x94, 0x7E, 0xDA, 0x81, 0xBA, 0xDA, 0x80, 0xDE, 0xCF, 0x06, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3C, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0x1B, 0xDA, 0x05, 0xCE, 0x70, 0x28, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3C, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x69, 0x6E, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x06, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3E, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x84, 0x1E, 0xDA, 0x05, 0xCE, 0x70, 0x28, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3E, 0x20, 0x26, 0x20, 0x78, 0x73, 0x29, 0x0A, 0x0A, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x20, 0x69, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6C, 0x79, 0x20, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x02, 0x3E, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x02, 0x3E, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x41, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x50, 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, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 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, 0xCF, 0x09, 0x6F, 0x73, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6F, 0x73, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0xDA, 0x05, 0xCE, 0x46, 0x28, 0x6F, 0x73, 0x2F, 0x67, 0x65, 0x74, 0x65, 0x6E, 0x76, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 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, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x63, 0x6F, 0x73, 0xDA, 0x05, 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, 0xCF, 0x03, 0x67, 0x65, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x84, 0xB8, 0xDA, 0x05, 0xCE, 0x81, 0xB5, 0x28, 0x67, 0x65, 0x74, 0x20, 0x64, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x29, 0x0A, 0x0A, 0x47, 0x65, 0x74, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x6E, 0x79, 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, 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, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x67, 0x65, 0x74, 0x2E, 0x20, 0x4F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x2C, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x61, 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, 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, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0x20, 0x42, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x67, 0x65, 0x74, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x2E, 0xCF, 0x04, 0x64, 0x6F, 0x63, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x4A, 0x28, 0x64, 0x6F, 0x63, 0x2A, 0x20, 0x65, 0x6E, 0x76, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x97, 0xD3, 0xCD, 0x00, 0x00, 0x9A, 0xAA, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x11, 0x02, 0x16, 0x6E, 0xCE, 0x04, 0x64, 0x6F, 0x63, 0x2A, 0xDA, 0x10, 0xDA, 0x4E, 0xCE, 0x07, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0xCE, 0x0B, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xDA, 0x82, 0x06, 0xDA, 0x81, 0xBA, 0xDA, 0x13, 0xD0, 0x03, 0x76, 0x61, 0x72, 0xCE, 0x02, 0x20, 0x28, 0xDA, 0x82, 0x6F, 0xDA, 0x81, 0x3F, 0xDA, 0x1D, 0xDA, 0x03, 0xDA, 0x80, 0xDF, 0xDA, 0x82, 0x59, 0xDA, 0x0F, 0xDA, 0x05, 0xDA, 0x80, 0xE0, 0xDA, 0x82, 0x6E, 0xCE, 0x02, 0x29, 0x0A, 0xDA, 0x80, 0xE7, 0xCE, 0x17, 0x6E, 0x6F, 0x20, 0x64, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xCE, 0x02, 0x0A, 0x0A, 0x28, 0x02, 0x00, 0x00, 0x33, 0x03, 0x00, 0x01, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x1A, 0x05, 0x06, 0x00, 0x26, 0x06, 0x01, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2D, 0x06, 0x01, 0x07, 0x26, 0x06, 0x03, 0x00, 0x30, 0x06, 0x00, 0x00, 0x26, 0x07, 0x04, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x2F, 0x07, 0x04, 0x00, 0x1A, 0x07, 0x12, 0x00, 0x26, 0x08, 0x04, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x2F, 0x08, 0x04, 0x00, 0x25, 0x0A, 0x00, 0x00, 0x33, 0x09, 0x08, 0x0A, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x0A, 0x05, 0x00, 0x2F, 0x08, 0x0A, 0x00, 0x26, 0x09, 0x06, 0x00, 0x26, 0x0A, 0x07, 0x00, 0x2D, 0x09, 0x0A, 0x08, 0x26, 0x09, 0x08, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x0A, 0x09, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x06, 0x09, 0x00, 0x18, 0x0F, 0x00, 0x00, 0x26, 0x09, 0x0A, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x2F, 0x09, 0x04, 0x00, 0x1A, 0x09, 0x03, 0x00, 0x26, 0x08, 0x0A, 0x00, 0x18, 0x08, 0x00, 0x00, 0x26, 0x0A, 0x0B, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x0A, 0x04, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0C, 0x05, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x17, 0x08, 0x0B, 0x00, 0x17, 0x06, 0x08, 0x00, 0x26, 0x07, 0x0C, 0x00, 0x26, 0x08, 0x0D, 0x00, 0x2D, 0x07, 0x06, 0x08, 0x26, 0x08, 0x09, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x06, 0x07, 0x00, 0x26, 0x07, 0x0E, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x2F, 0x07, 0x04, 0x00, 0x17, 0x08, 0x07, 0x00, 0x26, 0x07, 0x0F, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x2F, 0x07, 0x04, 0x00, 0x17, 0x09, 0x07, 0x00, 0x1A, 0x09, 0x03, 0x00, 0x17, 0x07, 0x06, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x07, 0x10, 0x00, 0x17, 0x0A, 0x08, 0x00, 0x1A, 0x0A, 0x12, 0x00, 0x35, 0x0C, 0x0A, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x35, 0x0C, 0x0A, 0x01, 0x17, 0x0E, 0x0C, 0x00, 0x35, 0x0C, 0x0A, 0x02, 0x17, 0x0F, 0x0C, 0x00, 0x26, 0x0C, 0x0C, 0x00, 0x26, 0x10, 0x07, 0x00, 0x2D, 0x0C, 0x0D, 0x10, 0x26, 0x0C, 0x11, 0x00, 0x2D, 0x0E, 0x0C, 0x0F, 0x26, 0x0C, 0x12, 0x00, 0x2B, 0x0C, 0x00, 0x00, 0x26, 0x10, 0x09, 0x00, 0x2F, 0x0C, 0x10, 0x00, 0x17, 0x0B, 0x0C, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x0B, 0x10, 0x00, 0x1A, 0x09, 0x03, 0x00, 0x17, 0x0C, 0x09, 0x00, 0x18, 0x06, 0x00, 0x00, 0x1A, 0x08, 0x03, 0x00, 0x17, 0x0D, 0x08, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0D, 0x00, 0x00, 0x17, 0x0C, 0x0D, 0x00, 0x1A, 0x0C, 0x03, 0x00, 0x26, 0x0A, 0x0D, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x0A, 0x10, 0x00, 0x1A, 0x09, 0x06, 0x00, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x0E, 0x13, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x17, 0x0C, 0x0D, 0x00, 0x18, 0x02, 0x00, 0x00, 0x26, 0x0C, 0x14, 0x00, 0x26, 0x0D, 0x15, 0x00, 0x2D, 0x0D, 0x07, 0x0B, 0x26, 0x0D, 0x15, 0x00, 0x2D, 0x0A, 0x0C, 0x0D, 0x26, 0x0D, 0x03, 0x00, 0x30, 0x0D, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x97, 0xD3, 0x82, 0xD7, 0xBD, 0x88, 0x0C, 0xBF, 0xED, 0x14, 0x08, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF6, 0x82, 0x66, 0xBD, 0xAA, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0x5E, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xE1, 0x80, 0x97, 0xBF, 0xA7, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF4, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEB, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xD8, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xB2, 0x80, 0x97, 0xBF, 0x69, 0x80, 0x97, 0xBF, 0xCB, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0x95, 0x80, 0x97, 0xBF, 0x69, 0x80, 0x97, 0xBF, 0x69, 0x80, 0x97, 0xBF, 0xF5, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF1, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0x6A, 0x80, 0x97, 0xBF, 0x69, 0x80, 0x97, 0xBF, 0x4A, 0x80, 0xCC, 0xBF, 0x34, 0x80, 0xCC, 0xBF, 0x34, 0x80, 0xCC, 0xBF, 0x34, 0x80, 0xCC, 0xBF, 0x34, 0x80, 0xCC, 0xBF, 0x1D, 0x80, 0xE4, 0x10, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xEA, 0x17, 0x0F, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x23, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x0F, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xD0, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xB6, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0x13, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF4, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0x0F, 0x2E, 0xBF, 0xD8, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xED, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0x15, 0x81, 0x00, 0xBF, 0x00, 0x81, 0x00, 0xBF, 0x00, 0x81, 0x00, 0xBF, 0x00, 0x81, 0x00, 0xBF, 0x00, 0x81, 0x00, 0xBF, 0x00, 0x81, 0x00, 0xCF, 0x03, 0x62, 0x6F, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0E, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x03, 0x62, 0x6F, 0x72, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x0D, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x0D, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x05, 0x74, 0x61, 0x62, 0x6C, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0xE3, 0xDA, 0x05, 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, 0xCF, 0x07, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x88, 0x9F, 0x88, 0xDF, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x07, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xD0, 0x06, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x88, 0x9F, 0x40, 0xBF, 0xEF, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x03, 0x2D, 0x3E, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x20, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 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, 0x20, 0x20, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x68, 0xFD, 0xCD, 0x00, 0x00, 0x6A, 0xDC, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x06, 0x01, 0x01, 0x06, 0x01, 0xCE, 0x03, 0x2D, 0x3E, 0x3E, 0xDA, 0x10, 0xDA, 0x3A, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0A, 0x02, 0x06, 0x27, 0xDA, 0x80, 0x89, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x80, 0x8A, 0xDA, 0x5B, 0xDA, 0x80, 0x8B, 0xDA, 0x80, 0x8C, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x06, 0x04, 0x1A, 0x05, 0x0C, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x04, 0x01, 0x06, 0x25, 0x06, 0x01, 0x00, 0x2C, 0x01, 0x06, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x03, 0x07, 0x00, 0x18, 0x06, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2C, 0x01, 0x04, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x03, 0x06, 0x00, 0x35, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x35, 0x04, 0x03, 0x01, 0x17, 0x06, 0x04, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x38, 0x07, 0x00, 0x00, 0x2D, 0x04, 0x06, 0x07, 0x26, 0x09, 0x04, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x17, 0x04, 0x08, 0x00, 0x25, 0x07, 0x00, 0x00, 0x2C, 0x04, 0x07, 0x00, 0x26, 0x07, 0x05, 0x00, 0x30, 0x07, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x69, 0xED, 0x80, 0xD7, 0xBF, 0x59, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x6B, 0xBF, 0xC5, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xB5, 0x6B, 0xBF, 0x95, 0x6B, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x96, 0x6B, 0xBF, 0x8A, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0x11, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xD9, 0x28, 0x06, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCD, 0x00, 0x00, 0x68, 0xFD, 0x81, 0xDF, 0xBF, 0x11, 0x80, 0xD7, 0xBF, 0x29, 0x80, 0xD7, 0x04, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x0C, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x63, 0x61, 0x63, 0x68, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x3E, 0x54, 0x61, 0x62, 0x6C, 0x65, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xC5, 0x76, 0xCD, 0x00, 0x00, 0xC5, 0xD0, 0xDA, 0x03, 0xDA, 0x83, 0xC1, 0xCF, 0x07, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x89, 0x62, 0x89, 0xA2, 0xDA, 0x03, 0xDA, 0x81, 0xDC, 0xCF, 0x07, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3E, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x16, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x07, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x3E, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x1D, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x6C, 0x28, 0x6F, 0x72, 0x64, 0x65, 0x72, 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, 0x6E, 0x6F, 0x74, 0x20, 0x69, 0x6E, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x63, 0x63, 0x6F, 0x72, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x74, 0x6F, 0x74, 0x61, 0x6C, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x0A, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x69, 0x64, 0x65, 0x6D, 0x70, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x81, 0x3C, 0x28, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6E, 0x20, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x74, 0x6F, 0x6D, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, 0x65, 0x6E, 0x74, 0x20, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x28, 0x61, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x2C, 0x20, 0x65, 0x74, 0x63, 0x2E, 0x29, 0x2C, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x6E, 0x63, 0x65, 0x2C, 0x20, 0x65, 0x76, 0x65, 0x6E, 0x20, 0x69, 0x66, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73, 0x20, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x70, 0x6C, 0x65, 0x20, 0x20, 0x63, 0x6F, 0x70, 0x69, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x2E, 0x20, 0x49, 0x6E, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x2C, 0x20, 0x75, 0x73, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x90, 0x16, 0x92, 0x7A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x10, 0x02, 0x09, 0x3A, 0xCE, 0x0A, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x69, 0x64, 0x65, 0x6D, 0x70, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x5A, 0xCF, 0x0B, 0x69, 0x64, 0x65, 0x6D, 0x70, 0x6F, 0x74, 0x65, 0x6E, 0x74, 0x3F, 0xCF, 0x06, 0x67, 0x65, 0x6E, 0x73, 0x79, 0x6D, 0xDA, 0x5C, 0xDA, 0x5D, 0xDA, 0x81, 0x1B, 0xDA, 0x81, 0xCC, 0xDA, 0x82, 0xA9, 0x28, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x07, 0x06, 0x00, 0x26, 0x09, 0x01, 0x00, 0x2D, 0x09, 0x07, 0x01, 0x3D, 0x08, 0x00, 0x00, 0x26, 0x0A, 0x02, 0x00, 0x2C, 0x0A, 0x07, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x26, 0x0B, 0x03, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x3D, 0x0A, 0x00, 0x00, 0x26, 0x0C, 0x04, 0x00, 0x2D, 0x0C, 0x09, 0x07, 0x2B, 0x0A, 0x00, 0x00, 0x3D, 0x0B, 0x00, 0x00, 0x26, 0x0A, 0x01, 0x00, 0x2D, 0x0A, 0x00, 0x0B, 0x3D, 0x09, 0x00, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x2E, 0x02, 0x00, 0x00, 0x3D, 0x0A, 0x00, 0x00, 0x26, 0x0C, 0x01, 0x00, 0x2D, 0x0C, 0x05, 0x0A, 0x3D, 0x0B, 0x00, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x2D, 0x0C, 0x07, 0x00, 0x3D, 0x0A, 0x00, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x26, 0x0E, 0x05, 0x00, 0x2C, 0x0D, 0x0E, 0x00, 0x3D, 0x0C, 0x00, 0x00, 0x26, 0x0E, 0x07, 0x00, 0x26, 0x0F, 0x01, 0x00, 0x2C, 0x0E, 0x0F, 0x00, 0x3D, 0x0D, 0x00, 0x00, 0x26, 0x0F, 0x08, 0x00, 0x2D, 0x0F, 0x0D, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x3D, 0x0E, 0x00, 0x00, 0x26, 0x0F, 0x08, 0x00, 0x2D, 0x0F, 0x0C, 0x0E, 0x2B, 0x05, 0x00, 0x00, 0x3D, 0x0D, 0x00, 0x00, 0x26, 0x0E, 0x04, 0x00, 0x2D, 0x0E, 0x0A, 0x05, 0x2B, 0x0D, 0x00, 0x00, 0x3D, 0x0C, 0x00, 0x00, 0x26, 0x0D, 0x05, 0x00, 0x2D, 0x0D, 0x08, 0x09, 0x2C, 0x0B, 0x0C, 0x00, 0x3D, 0x0A, 0x00, 0x00, 0x03, 0x0A, 0x00, 0x00, 0x90, 0x16, 0x82, 0x64, 0xBE, 0xFB, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEC, 0x15, 0x0F, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x04, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xCF, 0x05, 0x61, 0x73, 0x3F, 0x2D, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x80, 0xDE, 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, 0x61, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x20, 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, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x20, 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, 0x20, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x74, 0xAE, 0xCD, 0x00, 0x00, 0x76, 0x57, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x09, 0x02, 0x03, 0x09, 0x02, 0xCE, 0x05, 0x61, 0x73, 0x3F, 0x2D, 0x3E, 0xDA, 0x10, 0xDA, 0x59, 0xD7, 0xCD, 0x00, 0xBE, 0x00, 0x00, 0x06, 0x02, 0x01, 0x07, 0x01, 0xCE, 0x08, 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 0xDA, 0x10, 0xDA, 0x81, 0x02, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x01, 0xDA, 0x10, 0x27, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x02, 0x30, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x72, 0xB4, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xCD, 0x00, 0x00, 0x72, 0x2F, 0x80, 0x9B, 0xBF, 0xE2, 0x16, 0xBF, 0xE4, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDB, 0x26, 0xBF, 0xDA, 0x26, 0xDA, 0x42, 0x28, 0x03, 0x00, 0x00, 0x17, 0x04, 0x00, 0x00, 0x17, 0x05, 0x02, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x2A, 0x08, 0x01, 0x00, 0x2F, 0x08, 0x08, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x01, 0xDA, 0x10, 0x27, 0x02, 0x00, 0x01, 0x1F, 0x01, 0x00, 0x02, 0x1A, 0x01, 0x03, 0x00, 0x27, 0x02, 0x00, 0x0B, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x76, 0x07, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF5, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0xFA, 0x00, 0x00, 0x07, 0x00, 0x03, 0x1E, 0x01, 0x01, 0xCE, 0x06, 0x5F, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x85, 0x27, 0xDA, 0x42, 0x27, 0x01, 0x00, 0x06, 0x27, 0x02, 0x00, 0x07, 0x3E, 0x00, 0x01, 0x02, 0x19, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x05, 0x27, 0x03, 0x00, 0x06, 0x33, 0x01, 0x02, 0x03, 0x17, 0x02, 0x01, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x01, 0x03, 0x00, 0x17, 0x03, 0x01, 0x00, 0x2A, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x01, 0x04, 0x00, 0x27, 0x05, 0x00, 0x04, 0x2C, 0x03, 0x05, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2D, 0x06, 0x04, 0x01, 0x3D, 0x05, 0x00, 0x00, 0x29, 0x05, 0x00, 0x04, 0x25, 0x04, 0x01, 0x00, 0x27, 0x05, 0x00, 0x06, 0x06, 0x01, 0x04, 0x05, 0x29, 0x01, 0x00, 0x06, 0x28, 0x04, 0x00, 0x00, 0x30, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x02, 0xDA, 0x10, 0x27, 0x02, 0x00, 0x01, 0x1F, 0x01, 0x00, 0x02, 0x1A, 0x01, 0x03, 0x00, 0x27, 0x02, 0x01, 0x03, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x76, 0x07, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF5, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x00, 0x75, 0xB0, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x85, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0x1F, 0x1B, 0xBF, 0xDB, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xC6, 0x3B, 0x10, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0x63, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xCD, 0x00, 0x00, 0x74, 0xAE, 0x81, 0xA9, 0xBF, 0x4A, 0x0B, 0x04, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBF, 0x61, 0x80, 0x9F, 0xBE, 0x5F, 0x81, 0xA9, 0xCF, 0x0C, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x72, 0x61, 0x77, 0x67, 0x65, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x72, 0x61, 0x77, 0x67, 0x65, 0x74, 0xDA, 0x05, 0xCE, 0x80, 0xE2, 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, 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, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x61, 0x62, 0x20, 0x64, 0x6F, 0x65, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x20, 0x74, 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, 0xCF, 0x0A, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x63, 0x6C, 0x6F, 0x73, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0x05, 0xDA, 0x05, 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, 0xCF, 0x08, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x39, 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, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4C, 0x31, 0xCD, 0x00, 0x00, 0x4C, 0x79, 0xDA, 0x03, 0xDA, 0x81, 0xCE, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x68, 0xDA, 0x05, 0xCE, 0x2F, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x73, 0x69, 0x6E, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 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, 0xCF, 0x03, 0x2D, 0x3F, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 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, 0x20, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x20, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x6A, 0xDF, 0xCD, 0x00, 0x00, 0x6D, 0x40, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x06, 0x01, 0x01, 0x06, 0x01, 0xCE, 0x03, 0x2D, 0x3F, 0x3E, 0xDA, 0x10, 0xDA, 0x3A, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x26, 0x05, 0x00, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0E, 0x02, 0x09, 0x31, 0xDA, 0x80, 0x89, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xDA, 0x80, 0x8A, 0xDA, 0x5B, 0xDA, 0x59, 0xDA, 0x80, 0x8B, 0xDA, 0x80, 0x8C, 0xDA, 0x5C, 0xDA, 0x81, 0x83, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x06, 0x04, 0x1A, 0x05, 0x0C, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x04, 0x01, 0x06, 0x25, 0x06, 0x01, 0x00, 0x2C, 0x01, 0x06, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x17, 0x03, 0x07, 0x00, 0x18, 0x06, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x2C, 0x01, 0x04, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x17, 0x03, 0x06, 0x00, 0x35, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x35, 0x04, 0x03, 0x01, 0x17, 0x06, 0x04, 0x00, 0x26, 0x07, 0x04, 0x00, 0x2F, 0x04, 0x07, 0x00, 0x17, 0x07, 0x04, 0x00, 0x2C, 0x05, 0x07, 0x00, 0x38, 0x08, 0x00, 0x00, 0x2C, 0x08, 0x06, 0x00, 0x26, 0x0A, 0x05, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x08, 0x09, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x3D, 0x0A, 0x00, 0x00, 0x25, 0x0B, 0x00, 0x00, 0x2C, 0x08, 0x0B, 0x00, 0x26, 0x0C, 0x06, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x26, 0x0D, 0x07, 0x00, 0x2D, 0x0D, 0x07, 0x0B, 0x3D, 0x0C, 0x00, 0x00, 0x26, 0x0D, 0x08, 0x00, 0x2D, 0x0D, 0x0A, 0x0C, 0x3D, 0x0B, 0x00, 0x00, 0x03, 0x0B, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x6C, 0x1F, 0x81, 0x09, 0xBF, 0x27, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x6B, 0xBF, 0xC5, 0x08, 0xBF, 0xF8, 0x08, 0x02, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xB5, 0x6B, 0xBF, 0x95, 0x6B, 0xBF, 0xF3, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0x96, 0x6B, 0xBF, 0x8A, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0xBF, 0x89, 0x77, 0x0F, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0x11, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xDD, 0x24, 0x06, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xCD, 0x00, 0x00, 0x6A, 0xDF, 0x82, 0x61, 0xBE, 0xDF, 0x81, 0x09, 0xBE, 0xF7, 0x81, 0x09, 0x04, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x0A, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x71, 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, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x2E, 0x20, 0x20, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xBB, 0x0B, 0xCD, 0x00, 0x00, 0xBB, 0xB3, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x04, 0x0B, 0xCE, 0x0A, 0x6D, 0x61, 0x6B, 0x65, 0x2D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xDA, 0x10, 0xDA, 0x00, 0xDA, 0x83, 0xCA, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x01, 0x18, 0xCE, 0x06, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x74, 0xDA, 0x10, 0xDA, 0x80, 0xFB, 0x28, 0x01, 0x00, 0x00, 0x3C, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x2C, 0x04, 0x05, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x17, 0x06, 0x05, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x05, 0x07, 0x06, 0x19, 0x05, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x05, 0x00, 0x00, 0x1A, 0x05, 0x08, 0x00, 0x17, 0x07, 0x06, 0x00, 0x33, 0x08, 0x00, 0x07, 0x34, 0x03, 0x08, 0x07, 0x2C, 0x04, 0x06, 0x00, 0x26, 0x08, 0x00, 0x00, 0x2F, 0x06, 0x08, 0x00, 0x18, 0xF3, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x78, 0x97, 0x81, 0x0C, 0xBF, 0xBC, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xF3, 0x09, 0xBF, 0xEE, 0x15, 0xBF, 0xD4, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBF, 0xD3, 0x2D, 0xBE, 0xFB, 0x81, 0x0C, 0xDA, 0x81, 0xA6, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x04, 0x02, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2C, 0x00, 0x03, 0x00, 0x26, 0x02, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xBB, 0x0B, 0x80, 0xA8, 0xBF, 0xED, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xDA, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xCF, 0x0E, 0x6D, 0x6F, 0x64, 0x75, 0x6C, 0x65, 0x2F, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x58, 0x54, 0x61, 0x62, 0x6C, 0x65, 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, 0x20, 0x20, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x6E, 0x63, 0x69, 0x65, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xC5, 0xD3, 0xCD, 0x00, 0x00, 0xC6, 0x4A, 0xDA, 0x03, 0xDA, 0x83, 0xC4, 0xCF, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x73, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x65, 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, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x79, 0x6D, 0x73, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x59, 0xA0, 0xCD, 0x00, 0x00, 0x5A, 0x50, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x06, 0x01, 0x02, 0x0A, 0x01, 0xCE, 0x09, 0x77, 0x69, 0x74, 0x68, 0x2D, 0x73, 0x79, 0x6D, 0x73, 0xDA, 0x10, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x02, 0x01, 0x14, 0xCE, 0x06, 0x6D, 0x61, 0x70, 0x63, 0x61, 0x74, 0xDA, 0x10, 0xDA, 0x80, 0x8B, 0x28, 0x02, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x01, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x3E, 0x08, 0x06, 0x07, 0x1A, 0x08, 0x0B, 0x00, 0x33, 0x09, 0x05, 0x06, 0x17, 0x0A, 0x09, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x00, 0x00, 0x2C, 0x04, 0x09, 0x00, 0x26, 0x0C, 0x00, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x25, 0x09, 0x01, 0x00, 0x06, 0x06, 0x09, 0x06, 0x18, 0xF5, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x58, 0xD8, 0x80, 0xC5, 0xBF, 0xBB, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xFA, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xD3, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0x42, 0x80, 0xC5, 0xDA, 0x81, 0x83, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2C, 0x05, 0x04, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x94, 0x00, 0x00, 0x03, 0x01, 0x02, 0x07, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x5B, 0x26, 0x01, 0x00, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x2F, 0x01, 0x02, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x38, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5A, 0x32, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xE7, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xCD, 0x00, 0x00, 0x59, 0xA0, 0x80, 0xB0, 0xBF, 0xD6, 0x1B, 0xBF, 0xD6, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xBF, 0xC8, 0x38, 0xCF, 0x06, 0x6D, 0x61, 0x70, 0x63, 0x61, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x71, 0x28, 0x6D, 0x61, 0x70, 0x63, 0x61, 0x74, 0x20, 0x66, 0x20, 0x69, 0x6E, 0x64, 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, 0x20, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x58, 0xD8, 0xCD, 0x00, 0x00, 0x59, 0x9D, 0xDA, 0x03, 0xDA, 0x85, 0x56, 0xCF, 0x07, 0x65, 0x78, 0x74, 0x72, 0x65, 0x6D, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xBF, 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, 0x61, 0x72, 0x67, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6F, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2E, 0x20, 0x20, 0x6F, 0x72, 0x64, 0x65, 0x72, 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, 0x20, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4C, 0xEB, 0xCD, 0x00, 0x00, 0x4E, 0x60, 0xDA, 0x03, 0xDA, 0x81, 0x13, 0xCF, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x30, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x30, 0xDA, 0x05, 0xCE, 0x29, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x6C, 0x6F, 0x67, 0x31, 0x30, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6C, 0x6F, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x31, 0x30, 0x20, 0x6F, 0x66, 0x20, 0x78, 0x2E, 0xCF, 0x04, 0x6E, 0x65, 0x78, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0xFB, 0xDA, 0x05, 0xCE, 0x81, 0x68, 0x28, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x64, 0x69, 0x63, 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, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x61, 0x62, 0x6C, 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, 0x79, 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, 0x20, 0xCF, 0x03, 0x61, 0x73, 0x6D, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x03, 0x61, 0x73, 0x6D, 0xDA, 0x05, 0xCE, 0x80, 0xB8, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x77, 0x69, 0x6B, 0x69, 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, 0xCF, 0x06, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x08, 0x01, 0x01, 0x00, 0x02, 0xCE, 0x06, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x37, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x04, 0x6F, 0x6E, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x88, 0x6A, 0x88, 0x9D, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x04, 0x6F, 0x6E, 0x65, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x01, 0x00, 0x42, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0x88, 0x6A, 0x33, 0xBF, 0xF8, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xCF, 0x04, 0x68, 0x61, 0x73, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x04, 0x68, 0x61, 0x73, 0x68, 0xDA, 0x05, 0xCE, 0x80, 0xD2, 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, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 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, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, 0xDA, 0x05, 0xCE, 0x31, 0x28, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x6F, 0x73, 0x68, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 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, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x5C, 0xDA, 0x05, 0xCE, 0x80, 0xFD, 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, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xCF, 0x06, 0x65, 0x76, 0x65, 0x72, 0x79, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x59, 0x28, 0x65, 0x76, 0x65, 0x72, 0x79, 0x3F, 0x20, 0x69, 0x6E, 0x64, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2C, 0x20, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x76, 0xD4, 0xCD, 0x00, 0x00, 0x77, 0x8B, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x00, 0x15, 0xCE, 0x06, 0x65, 0x76, 0x65, 0x72, 0x79, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x07, 0x04, 0x05, 0x1A, 0x07, 0x03, 0x00, 0x17, 0x06, 0x02, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x09, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x1A, 0x08, 0x02, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x02, 0x08, 0x00, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xF3, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x76, 0xD4, 0x80, 0xB7, 0xBF, 0xB1, 0x0D, 0x04, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xEA, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xF5, 0x0A, 0xBF, 0xCB, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0x50, 0x80, 0xB7, 0xCF, 0x0A, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x61, 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, 0x20, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 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, 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, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7B, 0x9D, 0xCD, 0x00, 0x00, 0x7C, 0xBB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0D, 0x01, 0x01, 0x21, 0xCE, 0x0A, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xDA, 0x10, 0xDA, 0x80, 0xFB, 0x28, 0x02, 0x00, 0x00, 0x17, 0x03, 0x01, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x06, 0x04, 0x05, 0x1A, 0x06, 0x1A, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x17, 0x07, 0x08, 0x00, 0x22, 0x09, 0x00, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x26, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x22, 0x0B, 0x00, 0x00, 0x1F, 0x09, 0x0B, 0x0A, 0x19, 0x09, 0x03, 0x00, 0x23, 0x09, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x09, 0x00, 0x00, 0x1A, 0x09, 0x08, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x33, 0x0C, 0x08, 0x0B, 0x34, 0x00, 0x0B, 0x0C, 0x2C, 0x07, 0x0A, 0x00, 0x26, 0x0C, 0x00, 0x00, 0x2F, 0x0A, 0x0C, 0x00, 0x18, 0xF3, 0xFF, 0xFF, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xE6, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7B, 0x9D, 0x81, 0x1E, 0xBF, 0xB1, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xF4, 0x0A, 0xBF, 0xE7, 0x1A, 0xBF, 0xB9, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBF, 0xB8, 0x48, 0xBE, 0xE9, 0x81, 0x1E, 0xCF, 0x03, 0x70, 0x75, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x07, 0x03, 0x03, 0x00, 0x02, 0xCE, 0x03, 0x70, 0x75, 0x74, 0x34, 0x00, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x3C, 0x28, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x73, 0x6C, 0x69, 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x5B, 0x2C, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3D, 0x30, 0x20, 0x5B, 0x2C, 0x20, 0x65, 0x6E, 0x64, 0x3D, 0x28, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x5D, 0x5D, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x6E, 0x64, 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, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x69, 0x73, 0x20, 0x30, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x64, 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, 0xCF, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x05, 0xCE, 0x81, 0x38, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x2D, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x29, 0x0A, 0x0A, 0x53, 0x65, 0x74, 0x73, 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x30, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 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, 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, 0x30, 0x30, 0x29, 0x0A, 0x0A, 0x77, 0x69, 0x6C, 0x20, 0x73, 0x65, 0x74, 0x20, 0x61, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x31, 0x30, 0x30, 0x30, 0x74, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x63, 0x6F, 0x72, 0x65, 0x2E, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2E, 0xCF, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0x4B, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 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, 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, 0xCF, 0x10, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x73, 0x65, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x10, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x63, 0x68, 0x65, 0x63, 0x6B, 0x2D, 0x73, 0x65, 0x74, 0xDA, 0x05, 0xCE, 0x80, 0xAC, 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, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x65, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x65, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x2C, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x64, 0x6F, 0x2E, 0xCF, 0x05, 0x2A, 0x65, 0x6E, 0x76, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x18, 0x54, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x6C, 0x80, 0x96, 0xDA, 0x81, 0xBA, 0xDA, 0x81, 0x57, 0xCF, 0x06, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8B, 0x4A, 0x8B, 0x88, 0xDA, 0x03, 0xDA, 0x84, 0xB2, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xDA, 0x05, 0xCE, 0x81, 0x00, 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, 0x6F, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x72, 0x72, 0x20, 0x61, 0x74, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x61, 0x74, 0x2E, 0x20, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 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, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6C, 0x6C, 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, 0x2C, 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, 0xCF, 0x0E, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x05, 0xCE, 0x47, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x66, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x66, 0x75, 0x6E, 0x20, 0x5B, 0x2C, 0x70, 0x63, 0x3D, 0x30, 0x5D, 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, 0xCF, 0x07, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x07, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0xDA, 0x05, 0xCE, 0x80, 0xA7, 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, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 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, 0xCF, 0x0D, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xCE, 0x05, 0x30, 0x2E, 0x34, 0x2E, 0x30, 0xDA, 0x05, 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, 0xCF, 0x06, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8E, 0xAE, 0x8E, 0xE9, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x00, 0x05, 0xCE, 0x06, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x3F, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, 0x1F, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, 0x00, 0x8E, 0xAE, 0x3B, 0xBF, 0xF4, 0x0A, 0xBF, 0xF1, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x07, 0x6F, 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0xDA, 0x05, 0xCE, 0x81, 0xFF, 0x28, 0x6F, 0x73, 0x2F, 0x64, 0x61, 0x74, 0x65, 0x20, 0x5B, 0x2C, 0x74, 0x69, 0x6D, 0x65, 0x5D, 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, 0x6E, 0x6F, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 0x69, 0x73, 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, 0x0A, 0x0A, 0x09, 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, 0x09, 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, 0x09, 0x3A, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 0x3A, 0x64, 0x73, 0x74, 0x20, 0x2D, 0x20, 0x49, 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, 0xCF, 0x0A, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6C, 0x65, 0x61, 0x76, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x5F, 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, 0x20, 0x74, 0x68, 0x65, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x2C, 0x20, 0x65, 0x74, 0x63, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x81, 0x43, 0xCD, 0x00, 0x00, 0x82, 0x85, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x13, 0x00, 0x04, 0x27, 0xCE, 0x0A, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x6C, 0x65, 0x61, 0x76, 0x65, 0xDA, 0x10, 0xDA, 0x85, 0x70, 0xDA, 0x81, 0xD4, 0xDA, 0x81, 0x14, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x37, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x07, 0x00, 0x00, 0x40, 0x06, 0x05, 0x07, 0x1A, 0x06, 0x1F, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2C, 0x07, 0x00, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2E, 0x07, 0x00, 0x00, 0x26, 0x09, 0x02, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x17, 0x07, 0x08, 0x00, 0x25, 0x08, 0x00, 0x00, 0x17, 0x09, 0x07, 0x00, 0x3E, 0x0A, 0x08, 0x09, 0x1A, 0x0A, 0x12, 0x00, 0x17, 0x0B, 0x08, 0x00, 0x25, 0x0C, 0x00, 0x00, 0x17, 0x0D, 0x05, 0x00, 0x3E, 0x0E, 0x0C, 0x0D, 0x1A, 0x0E, 0x0A, 0x00, 0x17, 0x0F, 0x0C, 0x00, 0x33, 0x10, 0x00, 0x0F, 0x33, 0x11, 0x10, 0x0B, 0x2C, 0x03, 0x11, 0x00, 0x26, 0x12, 0x03, 0x00, 0x2F, 0x10, 0x12, 0x00, 0x25, 0x10, 0x01, 0x00, 0x06, 0x0C, 0x0C, 0x10, 0x18, 0xF6, 0xFF, 0xFF, 0x25, 0x0C, 0x01, 0x00, 0x06, 0x08, 0x08, 0x0C, 0x18, 0xEE, 0xFF, 0xFF, 0x18, 0x01, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x81, 0x43, 0x81, 0x42, 0xBF, 0x2C, 0x0C, 0xBF, 0xF4, 0x0C, 0x0E, 0x0C, 0xBF, 0xEA, 0x17, 0x0A, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF1, 0x80, 0xA2, 0xBF, 0x81, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE0, 0x21, 0x06, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0xEF, 0x0C, 0xBF, 0xEF, 0x14, 0xBF, 0xDC, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0x9C, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x9B, 0x65, 0xBF, 0x5F, 0x80, 0xA2, 0xBE, 0xC5, 0x81, 0x42, 0xCF, 0x0D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x2F, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0xDA, 0x05, 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, 0xCF, 0x08, 0x70, 0x6F, 0x73, 0x74, 0x77, 0x61, 0x6C, 0x6B, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x65, 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, 0x28, 0x66, 0x20, 0x78, 0x29, 0x20, 0x20, 0x6F, 0x6E, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x76, 0x69, 0x73, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x72, 0x2F, 0xCD, 0x00, 0x00, 0x72, 0xCA, 0xDA, 0x03, 0xDA, 0x85, 0x27, 0xCF, 0x06, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x06, 0x73, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0xDA, 0x05, 0xCE, 0x80, 0xA4, 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, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 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, 0xCF, 0x09, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x63, 0x65, 0x69, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0xF6, 0xDA, 0x05, 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, 0x03, 0x64, 0x6F, 0x63, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x34, 0x28, 0x64, 0x6F, 0x63, 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, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x9A, 0xAD, 0xCD, 0x00, 0x00, 0x9B, 0x07, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x01, 0x03, 0x09, 0xCE, 0x03, 0x64, 0x6F, 0x63, 0xDA, 0x10, 0xDA, 0x81, 0xCC, 0xDA, 0x84, 0xF0, 0xDA, 0x85, 0xA7, 0x28, 0x01, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x00, 0x00, 0x3D, 0x02, 0x00, 0x00, 0x26, 0x04, 0x01, 0x00, 0x26, 0x05, 0x02, 0x00, 0x2D, 0x04, 0x05, 0x02, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x9A, 0xAD, 0x5A, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x09, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x73, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x66, 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, 0x69, 0x6E, 0x64, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x20, 0x73, 0x65, 0x70, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x85, 0xE5, 0xCD, 0x00, 0x00, 0x87, 0x17, 0xDA, 0x03, 0xDA, 0x83, 0x34, 0xCF, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x10, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0x2D, 0x63, 0x6C, 0x65, 0x61, 0x72, 0xDA, 0x05, 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, 0x0B, 0x62, 0x61, 0x64, 0x2D, 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x44, 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, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xAC, 0x89, 0xCD, 0x00, 0x00, 0xAD, 0x4D, 0xDA, 0x03, 0xDA, 0x82, 0x5A, 0xCF, 0x06, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xC8, 0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40, 0xDA, 0x05, 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, 0xCF, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0xDA, 0x05, 0xCE, 0x80, 0xC4, 0x28, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x75, 0x6E, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x20, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x2D, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 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, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x2E, 0x20, 0x41, 0x6E, 0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x30, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6C, 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, 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, 0xCF, 0x08, 0x6F, 0x73, 0x2F, 0x77, 0x68, 0x69, 0x63, 0x68, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0x2D, 0xDA, 0x05, 0xCE, 0x80, 0xA2, 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, 0x09, 0x3A, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x2D, 0x20, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x0A, 0x09, 0x3A, 0x6D, 0x61, 0x63, 0x6F, 0x73, 0x20, 0x2D, 0x20, 0x41, 0x70, 0x70, 0x6C, 0x65, 0x20, 0x6D, 0x61, 0x63, 0x6F, 0x73, 0x0A, 0x09, 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, 0xCF, 0x0C, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0x8B, 0xDA, 0x05, 0xCE, 0x81, 0x37, 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, 0x64, 0x69, 0x63, 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, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6D, 0x75, 0x73, 0x74, 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, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x72, 0x72, 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, 0x61, 0x72, 0x72, 0x2E, 0xCF, 0x0F, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x61, 0x6C, 0x6C, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0F, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x61, 0x6C, 0x6C, 0xDA, 0x05, 0xCE, 0x81, 0x4E, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x61, 0x74, 0x74, 0x20, 0x73, 0x74, 0x72, 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, 0x70, 0x61, 0x74, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x72, 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, 0x6E, 0x6F, 0x74, 0x20, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x64, 0x2C, 0x20, 0x6D, 0x65, 0x61, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x69, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x74, 0x6F, 0x20, 0x66, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x74, 0x20, 0x6D, 0x6F, 0x73, 0x74, 0x20, 0x6F, 0x6E, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x6F, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2C, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2E, 0xCF, 0x09, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x84, 0xBF, 0x85, 0x41, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x05, 0x01, 0x03, 0x07, 0xCE, 0x09, 0x64, 0x65, 0x66, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2D, 0xDA, 0x10, 0xDA, 0x1D, 0xDA, 0x80, 0xB9, 0xDA, 0x81, 0x41, 0x28, 0x02, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2D, 0x00, 0x03, 0x04, 0x2E, 0x01, 0x00, 0x00, 0x26, 0x03, 0x02, 0x00, 0x30, 0x03, 0x00, 0x00, 0x84, 0xBF, 0x80, 0x82, 0xBF, 0xDA, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xCF, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x08, 0x00, 0x05, 0x02, 0x02, 0x00, 0x02, 0xCE, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x31, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x81, 0x60, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6D, 0x65, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x5B, 0x2C, 0x78, 0x5D, 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, 0xCF, 0x06, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x4A, 0x28, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 0x20, 0x62, 0x79, 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, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x53, 0xDE, 0xCD, 0x00, 0x00, 0x54, 0x51, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x02, 0x02, 0x07, 0xCE, 0x06, 0x73, 0x6F, 0x72, 0x74, 0x65, 0x64, 0xDA, 0x10, 0xDA, 0x80, 0x8A, 0xDA, 0x84, 0x9B, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x26, 0x04, 0x01, 0x00, 0x30, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x53, 0xDE, 0x73, 0xBF, 0xEB, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xEA, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xCF, 0x0A, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4C, 0x7C, 0xCD, 0x00, 0x00, 0x4C, 0xE8, 0xDA, 0x03, 0xDA, 0x82, 0x94, 0xDA, 0x84, 0xB6, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x2E, 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, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8C, 0xB9, 0x8D, 0x28, 0xDA, 0x03, 0xDA, 0x84, 0xB5, 0xCF, 0x0C, 0x61, 0x6C, 0x6C, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x4B, 0x28, 0x61, 0x6C, 0x6C, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x65, 0x6E, 0x76, 0x20, 0x26, 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, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xD3, 0x18, 0xCD, 0x00, 0x00, 0xD4, 0x79, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x98, 0x00, 0x00, 0x13, 0x01, 0x07, 0x40, 0xCE, 0x0C, 0x61, 0x6C, 0x6C, 0x2D, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0xDA, 0x10, 0xDA, 0x81, 0x57, 0xDA, 0x81, 0x00, 0xD8, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0xDC, 0xDA, 0x83, 0x74, 0xDA, 0x84, 0x9B, 0x28, 0x01, 0x00, 0x00, 0x22, 0x04, 0x00, 0x00, 0x1F, 0x03, 0x04, 0x00, 0x1A, 0x03, 0x04, 0x00, 0x26, 0x02, 0x00, 0x00, 0x35, 0x02, 0x02, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x38, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x17, 0x06, 0x03, 0x00, 0x1A, 0x06, 0x08, 0x00, 0x2C, 0x05, 0x06, 0x00, 0x26, 0x08, 0x01, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x07, 0x02, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x18, 0xF9, 0xFF, 0xFF, 0x3C, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x17, 0x08, 0x05, 0x00, 0x37, 0x09, 0x08, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x25, 0x09, 0x00, 0x00, 0x3E, 0x0B, 0x09, 0x0A, 0x1A, 0x0B, 0x1F, 0x00, 0x33, 0x0C, 0x08, 0x09, 0x17, 0x0D, 0x0C, 0x00, 0x17, 0x0C, 0x0D, 0x00, 0x22, 0x0E, 0x00, 0x00, 0x2C, 0x0C, 0x0E, 0x00, 0x26, 0x0F, 0x03, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x22, 0x10, 0x00, 0x00, 0x1F, 0x0E, 0x10, 0x0F, 0x19, 0x0E, 0x03, 0x00, 0x23, 0x0E, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x0E, 0x00, 0x00, 0x1A, 0x0E, 0x0D, 0x00, 0x17, 0x10, 0x0F, 0x00, 0x2B, 0x10, 0x00, 0x00, 0x26, 0x12, 0x04, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x1A, 0x11, 0x04, 0x00, 0x23, 0x12, 0x00, 0x00, 0x34, 0x07, 0x10, 0x12, 0x18, 0x01, 0x00, 0x00, 0x2C, 0x0C, 0x0F, 0x00, 0x26, 0x11, 0x03, 0x00, 0x2F, 0x0F, 0x11, 0x00, 0x18, 0xEE, 0xFF, 0xFF, 0x25, 0x0C, 0x01, 0x00, 0x06, 0x09, 0x0C, 0x09, 0x18, 0xE1, 0xFF, 0xFF, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x09, 0x05, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2B, 0x08, 0x00, 0x00, 0x26, 0x09, 0x06, 0x00, 0x30, 0x09, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xD3, 0x18, 0x81, 0x61, 0xBE, 0xF8, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x04, 0x0D, 0xBF, 0xF3, 0x0D, 0x08, 0x0A, 0x02, 0x37, 0xBF, 0xD2, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x09, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xCB, 0x37, 0x05, 0x13, 0xBF, 0xED, 0x13, 0x04, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0xD8, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xBC, 0x62, 0xBF, 0xE9, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0x9F, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0xBF, 0x9E, 0x62, 0x0A, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xCF, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x3B, 0x28, 0x70, 0x61, 0x69, 0x72, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7F, 0x8D, 0xCD, 0x00, 0x00, 0x80, 0x6A, 0xDA, 0x03, 0xDA, 0x82, 0x1A, 0xCF, 0x08, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0xDA, 0x05, 0xCE, 0x51, 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, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x78, 0x2E, 0xCF, 0x07, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8B, 0x0B, 0x8B, 0x48, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x07, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x51, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x8B, 0x0B, 0x3D, 0xBF, 0xEF, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x04, 0x6B, 0x65, 0x65, 0x70, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xA3, 0x28, 0x6B, 0x65, 0x65, 0x70, 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, 0x20, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x29, 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, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x5C, 0x07, 0xCD, 0x00, 0x00, 0x5D, 0x1A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0D, 0x02, 0x01, 0x17, 0xCE, 0x04, 0x6B, 0x65, 0x65, 0x70, 0xDA, 0x10, 0xDA, 0x81, 0x00, 0x28, 0x02, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x17, 0x05, 0x01, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x3E, 0x08, 0x06, 0x07, 0x1A, 0x08, 0x0E, 0x00, 0x33, 0x09, 0x05, 0x06, 0x17, 0x0A, 0x09, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x00, 0x00, 0x17, 0x0B, 0x09, 0x00, 0x1A, 0x0B, 0x05, 0x00, 0x2C, 0x04, 0x0B, 0x00, 0x26, 0x0C, 0x00, 0x00, 0x2F, 0x09, 0x0C, 0x00, 0x18, 0x01, 0x00, 0x00, 0x25, 0x09, 0x01, 0x00, 0x06, 0x06, 0x09, 0x06, 0x18, 0xF2, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5C, 0x07, 0x81, 0x13, 0xBF, 0x9F, 0x0C, 0xBF, 0xF4, 0x0C, 0x04, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xDA, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xEB, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xEE, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xD1, 0x30, 0xBF, 0xB7, 0x4A, 0xBF, 0xB6, 0x4A, 0xBF, 0xB6, 0x4A, 0xBE, 0xF4, 0x81, 0x13, 0xCF, 0x07, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x38, 0x28, 0x67, 0x65, 0x74, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x62, 0x75, 0x66, 0x20, 0x70, 0x20, 0x26, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x61, 0x64, 0x20, 0x61, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x73, 0x74, 0x64, 0x69, 0x6E, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xAD, 0x50, 0xCD, 0x00, 0x00, 0xAD, 0xEC, 0xDA, 0x03, 0xDA, 0x82, 0x53, 0xCF, 0x05, 0x6E, 0x6F, 0x74, 0x3D, 0x3D, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x1F, 0x06, 0x00, 0x00, 0x10, 0xCE, 0x05, 0x6E, 0x6F, 0x74, 0x3D, 0x3D, 0x37, 0x01, 0x00, 0x00, 0x1E, 0x02, 0x01, 0x02, 0x19, 0x02, 0x0A, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x42, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x07, 0x00, 0x05, 0x05, 0x05, 0x01, 0x17, 0x03, 0x04, 0x00, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFA, 0xFF, 0x24, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 0xCE, 0x63, 0x28, 0x6E, 0x6F, 0x74, 0x3D, 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, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6C, 0x6C, 0x79, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x20, 0x28, 0x33, 0x2E, 0x30, 0x20, 0x6E, 0x6F, 0x74, 0x3D, 0x3D, 0x20, 0x34, 0x29, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x6C, 0x65, 0x61, 0x6E, 0x2E, 0xCF, 0x0E, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2F, 0x67, 0x65, 0x74, 0x70, 0x72, 0x6F, 0x74, 0x6F, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x86, 0x2C, 0xDA, 0x05, 0xCE, 0x80, 0x83, 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, 0x61, 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, 0xCF, 0x12, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0xE2, 0xDA, 0x05, 0xCE, 0x80, 0xD6, 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, 0x73, 0x74, 0x72, 0x29, 0x0A, 0x0A, 0x50, 0x75, 0x73, 0x68, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 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, 0x4E, 0x6F, 0x6E, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x62, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x70, 0x75, 0x73, 0x68, 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, 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, 0x06, 0x6F, 0x73, 0x2F, 0x63, 0x77, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x06, 0x6F, 0x73, 0x2F, 0x63, 0x77, 0x64, 0xDA, 0x05, 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, 0xCF, 0x04, 0x72, 0x65, 0x70, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xED, 0x28, 0x72, 0x65, 0x70, 0x6C, 0x20, 0x63, 0x68, 0x75, 0x6E, 0x6B, 0x73, 0x20, 0x6F, 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x20, 0x26, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x20, 0x20, 0x63, 0x61, 0x75, 0x67, 0x68, 0x74, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xCF, 0xC9, 0xCD, 0x00, 0x00, 0xD2, 0x80, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBA, 0x00, 0x00, 0x09, 0x02, 0x07, 0x18, 0x01, 0xCE, 0x04, 0x72, 0x65, 0x70, 0x6C, 0xDA, 0x10, 0xDA, 0x83, 0xC3, 0xDA, 0x82, 0x48, 0xDA, 0x82, 0x49, 0xDA, 0x82, 0x4A, 0xDA, 0x86, 0x5E, 0xDA, 0x82, 0x4B, 0xDA, 0x82, 0x70, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x06, 0x07, 0x01, 0x1A, 0x06, 0x04, 0x00, 0x2A, 0x07, 0x00, 0x00, 0x17, 0x05, 0x07, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x05, 0x01, 0x00, 0x17, 0x06, 0x05, 0x00, 0x26, 0x07, 0x01, 0x00, 0x26, 0x08, 0x02, 0x00, 0x2D, 0x07, 0x00, 0x08, 0x26, 0x07, 0x03, 0x00, 0x26, 0x08, 0x04, 0x00, 0x2D, 0x06, 0x07, 0x08, 0x26, 0x07, 0x05, 0x00, 0x2C, 0x07, 0x04, 0x00, 0x3B, 0x07, 0x00, 0x00, 0x2B, 0x07, 0x00, 0x00, 0x26, 0x08, 0x06, 0x00, 0x30, 0x08, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x07, 0x02, 0x09, 0x1A, 0x01, 0xDA, 0x10, 0xDA, 0x81, 0xBF, 0xDA, 0x82, 0x72, 0xDA, 0x03, 0xCF, 0x01, 0x5F, 0xDA, 0x80, 0xE0, 0xCE, 0x05, 0x25, 0x2E, 0x32, 0x30, 0x70, 0xDA, 0x81, 0x3D, 0xDA, 0x82, 0x06, 0xDA, 0x82, 0x54, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x11, 0x00, 0x26, 0x04, 0x02, 0x00, 0x2C, 0x04, 0x01, 0x00, 0x3C, 0x04, 0x00, 0x00, 0x27, 0x05, 0x00, 0x04, 0x26, 0x06, 0x03, 0x00, 0x34, 0x05, 0x06, 0x04, 0x26, 0x04, 0x04, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x39, 0x04, 0x00, 0x00, 0x26, 0x05, 0x05, 0x00, 0x2D, 0x04, 0x05, 0x01, 0x26, 0x06, 0x06, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x04, 0x07, 0x00, 0x30, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x26, 0x04, 0x08, 0x00, 0x30, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0xD1, 0x19, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xEB, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x16, 0x80, 0xEA, 0xBF, 0x6F, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0x29, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xDD, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0x1B, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xCD, 0x00, 0x00, 0xCF, 0xC9, 0x82, 0xB7, 0xBE, 0x53, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xEB, 0x16, 0x04, 0x81, 0x1E, 0xBE, 0xE2, 0x81, 0x1E, 0xBE, 0xE2, 0x81, 0x1E, 0xBE, 0xF4, 0x81, 0x0B, 0xBE, 0xE3, 0x81, 0x1E, 0xBE, 0xE2, 0x81, 0x1E, 0xBE, 0xE2, 0x81, 0x1E, 0xBE, 0xE2, 0x81, 0x1E, 0x04, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xBF, 0x84, 0x7C, 0xDA, 0x84, 0xB3, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8D, 0x2A, 0x8D, 0x98, 0xDA, 0x03, 0xDA, 0x83, 0xF8, 0xCF, 0x02, 0x25, 0x3D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x28, 0x28, 0x25, 0x3D, 0x20, 0x78, 0x20, 0x6E, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x94, 0xBD, 0x95, 0x05, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x02, 0x25, 0x3D, 0xDA, 0x10, 0xDA, 0x32, 0xDA, 0x22, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x94, 0xBD, 0x48, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x09, 0x63, 0x61, 0x6C, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x35, 0x28, 0x63, 0x61, 0x6C, 0x6C, 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, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x6F, 0x72, 0x20, 0x63, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8D, 0x9A, 0x8E, 0x16, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x01, 0x03, 0x0D, 0xCE, 0x09, 0x63, 0x61, 0x6C, 0x6C, 0x61, 0x62, 0x6C, 0x65, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x81, 0x58, 0xDA, 0x84, 0x76, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x17, 0x03, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x03, 0x00, 0x23, 0x05, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x03, 0x05, 0x00, 0x00, 0x8D, 0x9A, 0x7C, 0xBF, 0xCA, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x08, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xEE, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xF0, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xCF, 0x09, 0x62, 0x61, 0x64, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xAB, 0x54, 0xCD, 0x00, 0x00, 0xAC, 0x86, 0xDA, 0x03, 0xDA, 0x82, 0x61, 0xDA, 0x85, 0x1E, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x59, 0xDA, 0x05, 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, 0x04, 0x62, 0x6E, 0x6F, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x0C, 0x00, 0x13, 0x01, 0x01, 0x00, 0x02, 0xCE, 0x04, 0x62, 0x6E, 0x6F, 0x74, 0x0F, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x69, 0x6E, 0x66, 0xD3, 0x02, 0xDA, 0x03, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x7F, 0xDA, 0x05, 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, 0xCF, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x6E, 0x65, 0x77, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0xFF, 0xDA, 0x05, 0xCE, 0x80, 0xA6, 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, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x29, 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, 0xCF, 0x06, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x3B, 0xDA, 0x05, 0xCE, 0x80, 0xA8, 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, 0x6E, 0x65, 0x77, 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, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 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, 0xCF, 0x09, 0x76, 0x61, 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x86, 0xC3, 0x87, 0x4B, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x02, 0x03, 0x0E, 0xCE, 0x09, 0x76, 0x61, 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xDA, 0x10, 0xDA, 0x85, 0xDE, 0xDA, 0x81, 0xBA, 0xDA, 0x81, 0x57, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2C, 0x06, 0x05, 0x00, 0x3C, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x35, 0x06, 0x06, 0x00, 0x34, 0x06, 0x04, 0x05, 0x04, 0x00, 0x00, 0x00, 0x86, 0xC3, 0x80, 0x88, 0xBF, 0xC8, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE9, 0x18, 0x04, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0x7F, 0x80, 0x88, 0xDA, 0x83, 0x12, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x87, 0x11, 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, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 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, 0x20, 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, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x6F, 0x72, 0x20, 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, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x20, 0x73, 0x6F, 0x6D, 0x65, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x2E, 0x20, 0x54, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x69, 0x6B, 0x65, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x09, 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, 0x20, 0x20, 0x57, 0x68, 0x65, 0x72, 0x65, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 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, 0x3A, 0x76, 0x65, 0x72, 0x62, 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, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0x20, 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, 0x20, 0x20, 0x09, 0x3A, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 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, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x79, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x20, 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, 0x74, 0x77, 0x6F, 0x20, 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, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 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, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x2D, 0x20, 0x49, 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, 0x20, 0x20, 0x09, 0x3A, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x2D, 0x20, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x69, 0x6E, 0x20, 0x2D, 0x20, 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, 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, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x2D, 0x20, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2E, 0x20, 0x43, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x6F, 0x72, 0x20, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x65, 0x72, 0x2F, 0x63, 0x6F, 0x6E, 0x73, 0x75, 0x6D, 0x65, 0x72, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6E, 0x2E, 0x0A, 0x0A, 0x20, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 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, 0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x0A, 0x0A, 0x20, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 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, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6B, 0x65, 0x79, 0x77, 0x6F, 0x72, 0x64, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x6E, 0x74, 0x2E, 0x20, 0x20, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x62, 0x65, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x3A, 0x0A, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x77, 0x68, 0x69, 0x6C, 0x65, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x2D, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6B, 0x73, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x69, 0x66, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x79, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x6C, 0x65, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 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, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x61, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x74, 0x20, 0x6D, 0x61, 0x63, 0x72, 0x6F, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 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, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6E, 0x6E, 0x65, 0x72, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x2D, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x20, 0x61, 0x73, 0x20, 0x3A, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 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, 0x20, 0x6E, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6E, 0x6E, 0x65, 0x72, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x20, 0x6E, 0x20, 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, 0x6E, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x2E, 0x0A, 0x20, 0x20, 0x09, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x2D, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x6F, 0x6E, 0x64, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2E, 0x0A, 0x0A, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x23, 0x0C, 0xCD, 0x00, 0x00, 0x41, 0x3A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x09, 0x01, 0x03, 0x16, 0x01, 0xCE, 0x04, 0x6C, 0x6F, 0x6F, 0x70, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x53, 0xCE, 0x1C, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x68, 0x65, 0x61, 0x64, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x26, 0x07, 0x01, 0x00, 0x1F, 0x06, 0x07, 0x05, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x04, 0x00, 0x26, 0x05, 0x02, 0x00, 0x01, 0x05, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x2A, 0x05, 0x00, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x07, 0x00, 0x00, 0x22, 0x08, 0x00, 0x00, 0x2C, 0x07, 0x08, 0x00, 0x30, 0x06, 0x00, 0x00, 0xCD, 0x00, 0xD8, 0x00, 0x00, 0x1F, 0x02, 0x2A, 0x82, 0x46, 0x01, 0xCE, 0x05, 0x64, 0x6F, 0x6F, 0x6E, 0x65, 0xDA, 0x10, 0xDA, 0x84, 0x29, 0xDA, 0x5D, 0xD8, 0x0D, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0xDA, 0x80, 0xC5, 0xD0, 0x05, 0x77, 0x68, 0x69, 0x6C, 0x65, 0xDA, 0x81, 0x00, 0xD0, 0x03, 0x6C, 0x65, 0x74, 0xDA, 0x81, 0x83, 0xDA, 0x5B, 0xD0, 0x04, 0x77, 0x68, 0x65, 0x6E, 0xDA, 0x5C, 0xD0, 0x06, 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, 0xD0, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0xD0, 0x06, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xDA, 0x59, 0xDA, 0x81, 0x0F, 0xDA, 0x5A, 0xDA, 0x81, 0xCB, 0xDA, 0x80, 0x8C, 0xDA, 0x21, 0xDA, 0x22, 0xDA, 0x81, 0xD0, 0xCE, 0x1B, 0x75, 0x6E, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x3A, 0x20, 0xDA, 0x81, 0x3F, 0xD0, 0x07, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x65, 0xD0, 0x05, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xD0, 0x04, 0x6B, 0x65, 0x79, 0x73, 0xDA, 0x81, 0x29, 0xDA, 0x80, 0xFB, 0xD0, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0xDA, 0x81, 0xDC, 0xDA, 0x84, 0xB8, 0xD0, 0x02, 0x69, 0x6E, 0xDA, 0x85, 0x70, 0xD0, 0x08, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0xDA, 0x81, 0xBF, 0xDA, 0x81, 0xA2, 0xDA, 0x82, 0x67, 0xD0, 0x03, 0x6E, 0x65, 0x77, 0xDA, 0x81, 0xE7, 0xDA, 0x86, 0x14, 0xCE, 0x16, 0x75, 0x6E, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x76, 0x65, 0x72, 0x62, 0x3A, 0x20, 0x28, 0x02, 0x00, 0x00, 0x22, 0x05, 0x00, 0x00, 0x1F, 0x04, 0x05, 0x01, 0x1A, 0x04, 0x06, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x17, 0x03, 0x05, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x03, 0x01, 0x00, 0x17, 0x04, 0x03, 0x00, 0x27, 0x06, 0x00, 0x04, 0x41, 0x05, 0x00, 0x06, 0x1A, 0x05, 0x06, 0x00, 0x27, 0x06, 0x00, 0x01, 0x26, 0x07, 0x01, 0x00, 0x2C, 0x06, 0x07, 0x00, 0x26, 0x06, 0x02, 0x00, 0x30, 0x06, 0x00, 0x00, 0x25, 0x08, 0x02, 0x00, 0x06, 0x07, 0x00, 0x08, 0x27, 0x08, 0x00, 0x00, 0x33, 0x06, 0x08, 0x07, 0x17, 0x08, 0x06, 0x00, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x09, 0x00, 0x0A, 0x27, 0x0A, 0x00, 0x00, 0x33, 0x06, 0x0A, 0x09, 0x17, 0x0A, 0x06, 0x00, 0x27, 0x0B, 0x00, 0x00, 0x33, 0x06, 0x0B, 0x00, 0x17, 0x0B, 0x06, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x26, 0x0C, 0x03, 0x00, 0x2F, 0x06, 0x0C, 0x00, 0x1A, 0x06, 0x72, 0x00, 0x26, 0x0D, 0x04, 0x00, 0x1F, 0x0C, 0x0B, 0x0D, 0x1A, 0x0C, 0x08, 0x00, 0x2C, 0x04, 0x0A, 0x00, 0x26, 0x0E, 0x05, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x25, 0x0E, 0x02, 0x00, 0x06, 0x0D, 0x00, 0x0E, 0x2C, 0x0D, 0x04, 0x00, 0x30, 0x02, 0x00, 0x00, 0x26, 0x0E, 0x06, 0x00, 0x1F, 0x0D, 0x0B, 0x0E, 0x1A, 0x0D, 0x09, 0x00, 0x25, 0x0F, 0x02, 0x00, 0x06, 0x0E, 0x00, 0x0F, 0x2C, 0x0E, 0x04, 0x00, 0x2F, 0x0F, 0x02, 0x00, 0x26, 0x0E, 0x07, 0x00, 0x2D, 0x0E, 0x0A, 0x0F, 0x26, 0x0E, 0x08, 0x00, 0x30, 0x0E, 0x00, 0x00, 0x26, 0x0F, 0x09, 0x00, 0x1F, 0x0E, 0x0B, 0x0F, 0x1A, 0x0E, 0x09, 0x00, 0x25, 0x10, 0x02, 0x00, 0x06, 0x0F, 0x00, 0x10, 0x2C, 0x0F, 0x04, 0x00, 0x2F, 0x10, 0x02, 0x00, 0x26, 0x0F, 0x0A, 0x00, 0x2D, 0x0F, 0x0A, 0x10, 0x26, 0x0F, 0x08, 0x00, 0x30, 0x0F, 0x00, 0x00, 0x26, 0x10, 0x0B, 0x00, 0x1F, 0x0F, 0x0B, 0x10, 0x1A, 0x0F, 0x09, 0x00, 0x25, 0x11, 0x02, 0x00, 0x06, 0x10, 0x00, 0x11, 0x2C, 0x10, 0x04, 0x00, 0x2F, 0x11, 0x02, 0x00, 0x26, 0x10, 0x01, 0x00, 0x2D, 0x10, 0x0A, 0x11, 0x26, 0x10, 0x08, 0x00, 0x30, 0x10, 0x00, 0x00, 0x26, 0x11, 0x0C, 0x00, 0x1F, 0x10, 0x0B, 0x11, 0x1A, 0x10, 0x09, 0x00, 0x25, 0x12, 0x02, 0x00, 0x06, 0x11, 0x00, 0x12, 0x2C, 0x11, 0x04, 0x00, 0x2F, 0x12, 0x02, 0x00, 0x26, 0x11, 0x01, 0x00, 0x2D, 0x11, 0x12, 0x0A, 0x26, 0x11, 0x08, 0x00, 0x30, 0x11, 0x00, 0x00, 0x26, 0x12, 0x0D, 0x00, 0x1F, 0x11, 0x0B, 0x12, 0x1A, 0x11, 0x33, 0x00, 0x26, 0x13, 0x0E, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x17, 0x13, 0x12, 0x00, 0x26, 0x14, 0x0E, 0x00, 0x2F, 0x12, 0x14, 0x00, 0x17, 0x14, 0x12, 0x00, 0x26, 0x12, 0x0F, 0x00, 0x2D, 0x12, 0x13, 0x14, 0x26, 0x15, 0x08, 0x00, 0x2F, 0x12, 0x15, 0x00, 0x26, 0x15, 0x00, 0x00, 0x2C, 0x15, 0x12, 0x00, 0x38, 0x12, 0x00, 0x00, 0x17, 0x15, 0x12, 0x00, 0x25, 0x16, 0x02, 0x00, 0x06, 0x12, 0x00, 0x16, 0x2C, 0x12, 0x15, 0x00, 0x2F, 0x16, 0x02, 0x00, 0x17, 0x12, 0x16, 0x00, 0x26, 0x16, 0x10, 0x00, 0x2D, 0x16, 0x14, 0x0A, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x11, 0x00, 0x25, 0x18, 0x00, 0x00, 0x2D, 0x17, 0x13, 0x18, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x2B, 0x15, 0x00, 0x00, 0x26, 0x19, 0x12, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x26, 0x19, 0x13, 0x00, 0x25, 0x1A, 0x01, 0x00, 0x2D, 0x19, 0x1A, 0x13, 0x26, 0x1A, 0x08, 0x00, 0x2F, 0x19, 0x1A, 0x00, 0x26, 0x1A, 0x14, 0x00, 0x2D, 0x1A, 0x13, 0x19, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x26, 0x19, 0x15, 0x00, 0x2D, 0x19, 0x18, 0x1A, 0x2B, 0x12, 0x00, 0x00, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x19, 0x1B, 0x00, 0x26, 0x18, 0x01, 0x00, 0x2D, 0x18, 0x16, 0x17, 0x2B, 0x19, 0x00, 0x00, 0x26, 0x18, 0x08, 0x00, 0x30, 0x18, 0x00, 0x00, 0x26, 0x12, 0x16, 0x00, 0x2C, 0x12, 0x0B, 0x00, 0x26, 0x13, 0x17, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x01, 0x12, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x26, 0x0D, 0x18, 0x00, 0x1F, 0x0C, 0x0A, 0x0D, 0x1A, 0x0C, 0x26, 0x00, 0x26, 0x0E, 0x0E, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x17, 0x0E, 0x0D, 0x00, 0x26, 0x0D, 0x14, 0x00, 0x2D, 0x0D, 0x0E, 0x08, 0x26, 0x0F, 0x08, 0x00, 0x2F, 0x0D, 0x0F, 0x00, 0x26, 0x0F, 0x00, 0x00, 0x2C, 0x0F, 0x0D, 0x00, 0x38, 0x0D, 0x00, 0x00, 0x17, 0x0F, 0x0D, 0x00, 0x25, 0x10, 0x03, 0x00, 0x06, 0x0D, 0x00, 0x10, 0x2C, 0x0D, 0x0F, 0x00, 0x2F, 0x10, 0x02, 0x00, 0x17, 0x0D, 0x10, 0x00, 0x26, 0x10, 0x11, 0x00, 0x22, 0x11, 0x00, 0x00, 0x2D, 0x10, 0x0E, 0x11, 0x26, 0x11, 0x08, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x26, 0x12, 0x12, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x26, 0x12, 0x10, 0x00, 0x2D, 0x12, 0x0B, 0x0E, 0x26, 0x13, 0x08, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x26, 0x13, 0x15, 0x00, 0x2D, 0x13, 0x11, 0x12, 0x2B, 0x0D, 0x00, 0x00, 0x26, 0x14, 0x08, 0x00, 0x2F, 0x13, 0x14, 0x00, 0x26, 0x11, 0x01, 0x00, 0x2D, 0x11, 0x10, 0x13, 0x26, 0x11, 0x08, 0x00, 0x30, 0x11, 0x00, 0x00, 0x26, 0x0E, 0x19, 0x00, 0x1F, 0x0D, 0x0A, 0x0E, 0x1A, 0x0D, 0x40, 0x00, 0x35, 0x0E, 0x08, 0x00, 0x17, 0x0F, 0x0E, 0x00, 0x35, 0x0E, 0x08, 0x01, 0x17, 0x10, 0x0E, 0x00, 0x35, 0x0E, 0x08, 0x02, 0x17, 0x11, 0x0E, 0x00, 0x1A, 0x11, 0x03, 0x00, 0x17, 0x0E, 0x11, 0x00, 0x18, 0x02, 0x00, 0x00, 0x25, 0x0E, 0x01, 0x00, 0x17, 0x12, 0x0E, 0x00, 0x26, 0x13, 0x0E, 0x00, 0x2F, 0x0E, 0x13, 0x00, 0x17, 0x13, 0x0E, 0x00, 0x26, 0x14, 0x0E, 0x00, 0x2F, 0x0E, 0x14, 0x00, 0x17, 0x14, 0x0E, 0x00, 0x26, 0x0E, 0x0F, 0x00, 0x2D, 0x0E, 0x14, 0x13, 0x26, 0x15, 0x08, 0x00, 0x2F, 0x0E, 0x15, 0x00, 0x26, 0x15, 0x00, 0x00, 0x2C, 0x15, 0x0E, 0x00, 0x38, 0x0E, 0x00, 0x00, 0x17, 0x15, 0x0E, 0x00, 0x25, 0x16, 0x03, 0x00, 0x06, 0x0E, 0x00, 0x16, 0x2C, 0x0E, 0x15, 0x00, 0x2F, 0x16, 0x02, 0x00, 0x17, 0x0E, 0x16, 0x00, 0x26, 0x16, 0x11, 0x00, 0x2D, 0x16, 0x14, 0x0F, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x10, 0x00, 0x2D, 0x17, 0x13, 0x10, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x2B, 0x15, 0x00, 0x00, 0x26, 0x19, 0x12, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x26, 0x19, 0x10, 0x00, 0x2D, 0x19, 0x0B, 0x14, 0x26, 0x1A, 0x08, 0x00, 0x2F, 0x19, 0x1A, 0x00, 0x26, 0x1A, 0x13, 0x00, 0x2D, 0x1A, 0x14, 0x12, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x26, 0x1B, 0x14, 0x00, 0x2D, 0x1B, 0x14, 0x1A, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1B, 0x1C, 0x00, 0x26, 0x1A, 0x15, 0x00, 0x2D, 0x1A, 0x18, 0x19, 0x2C, 0x0E, 0x1B, 0x00, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1A, 0x1C, 0x00, 0x26, 0x18, 0x01, 0x00, 0x2D, 0x18, 0x16, 0x17, 0x2B, 0x1A, 0x00, 0x00, 0x26, 0x18, 0x08, 0x00, 0x30, 0x18, 0x00, 0x00, 0x26, 0x0F, 0x1A, 0x00, 0x1F, 0x0E, 0x0A, 0x0F, 0x1A, 0x0E, 0x3B, 0x00, 0x26, 0x10, 0x0E, 0x00, 0x2F, 0x0F, 0x10, 0x00, 0x17, 0x10, 0x0F, 0x00, 0x26, 0x11, 0x0E, 0x00, 0x2F, 0x0F, 0x11, 0x00, 0x17, 0x11, 0x0F, 0x00, 0x26, 0x0F, 0x1B, 0x00, 0x22, 0x12, 0x00, 0x00, 0x2D, 0x0F, 0x12, 0x11, 0x26, 0x12, 0x08, 0x00, 0x2F, 0x0F, 0x12, 0x00, 0x26, 0x12, 0x00, 0x00, 0x2C, 0x12, 0x0F, 0x00, 0x38, 0x0F, 0x00, 0x00, 0x17, 0x12, 0x0F, 0x00, 0x25, 0x13, 0x03, 0x00, 0x06, 0x0F, 0x00, 0x13, 0x2C, 0x0F, 0x12, 0x00, 0x2F, 0x13, 0x02, 0x00, 0x17, 0x0F, 0x13, 0x00, 0x26, 0x13, 0x10, 0x00, 0x2D, 0x13, 0x10, 0x08, 0x26, 0x14, 0x08, 0x00, 0x2F, 0x13, 0x14, 0x00, 0x26, 0x14, 0x1C, 0x00, 0x22, 0x15, 0x00, 0x00, 0x2D, 0x14, 0x10, 0x15, 0x26, 0x15, 0x08, 0x00, 0x2F, 0x14, 0x15, 0x00, 0x26, 0x15, 0x11, 0x00, 0x2D, 0x15, 0x11, 0x14, 0x26, 0x16, 0x08, 0x00, 0x2F, 0x15, 0x16, 0x00, 0x2B, 0x12, 0x00, 0x00, 0x26, 0x16, 0x12, 0x00, 0x2F, 0x14, 0x16, 0x00, 0x26, 0x16, 0x10, 0x00, 0x2D, 0x16, 0x0B, 0x11, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x1C, 0x00, 0x2D, 0x17, 0x10, 0x11, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x26, 0x18, 0x14, 0x00, 0x2D, 0x18, 0x11, 0x17, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x26, 0x17, 0x15, 0x00, 0x2D, 0x17, 0x14, 0x16, 0x2C, 0x0F, 0x18, 0x00, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x17, 0x19, 0x00, 0x26, 0x14, 0x01, 0x00, 0x2D, 0x14, 0x13, 0x15, 0x2B, 0x17, 0x00, 0x00, 0x26, 0x14, 0x08, 0x00, 0x30, 0x14, 0x00, 0x00, 0x26, 0x10, 0x1D, 0x00, 0x1F, 0x0F, 0x0A, 0x10, 0x1A, 0x0F, 0x64, 0x00, 0x2B, 0x0B, 0x00, 0x00, 0x26, 0x11, 0x1E, 0x00, 0x2F, 0x10, 0x11, 0x00, 0x17, 0x11, 0x10, 0x00, 0x26, 0x12, 0x0E, 0x00, 0x2F, 0x10, 0x12, 0x00, 0x17, 0x12, 0x10, 0x00, 0x26, 0x13, 0x0E, 0x00, 0x2F, 0x10, 0x13, 0x00, 0x17, 0x13, 0x10, 0x00, 0x26, 0x10, 0x1B, 0x00, 0x22, 0x14, 0x00, 0x00, 0x2D, 0x10, 0x14, 0x13, 0x26, 0x14, 0x08, 0x00, 0x2F, 0x10, 0x14, 0x00, 0x26, 0x14, 0x00, 0x00, 0x2C, 0x14, 0x10, 0x00, 0x38, 0x10, 0x00, 0x00, 0x17, 0x14, 0x10, 0x00, 0x25, 0x15, 0x03, 0x00, 0x06, 0x10, 0x00, 0x15, 0x2C, 0x10, 0x14, 0x00, 0x2F, 0x15, 0x02, 0x00, 0x17, 0x10, 0x15, 0x00, 0x26, 0x15, 0x10, 0x00, 0x2D, 0x15, 0x12, 0x08, 0x26, 0x16, 0x08, 0x00, 0x2F, 0x15, 0x16, 0x00, 0x26, 0x16, 0x1C, 0x00, 0x22, 0x17, 0x00, 0x00, 0x2D, 0x16, 0x12, 0x17, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x11, 0x00, 0x2D, 0x17, 0x13, 0x16, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x2B, 0x14, 0x00, 0x00, 0x26, 0x18, 0x12, 0x00, 0x2F, 0x16, 0x18, 0x00, 0x1A, 0x11, 0x0F, 0x00, 0x26, 0x19, 0x1F, 0x00, 0x2D, 0x19, 0x12, 0x13, 0x26, 0x1A, 0x08, 0x00, 0x2F, 0x19, 0x1A, 0x00, 0x26, 0x1A, 0x08, 0x00, 0x2D, 0x1A, 0x13, 0x19, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x26, 0x19, 0x10, 0x00, 0x2D, 0x19, 0x0B, 0x1A, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x19, 0x1B, 0x00, 0x17, 0x18, 0x19, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x18, 0x00, 0x00, 0x1A, 0x11, 0x03, 0x00, 0x22, 0x19, 0x00, 0x00, 0x18, 0x08, 0x00, 0x00, 0x25, 0x1B, 0x00, 0x00, 0x33, 0x1A, 0x0B, 0x1B, 0x26, 0x1B, 0x10, 0x00, 0x2D, 0x1B, 0x1A, 0x13, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1B, 0x1C, 0x00, 0x17, 0x19, 0x1B, 0x00, 0x1A, 0x11, 0x03, 0x00, 0x22, 0x1A, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x25, 0x1C, 0x01, 0x00, 0x33, 0x1B, 0x0B, 0x1C, 0x26, 0x1C, 0x1F, 0x00, 0x2D, 0x1C, 0x12, 0x13, 0x26, 0x1D, 0x08, 0x00, 0x2F, 0x1C, 0x1D, 0x00, 0x26, 0x1D, 0x10, 0x00, 0x2D, 0x1D, 0x1B, 0x1C, 0x26, 0x1E, 0x08, 0x00, 0x2F, 0x1D, 0x1E, 0x00, 0x17, 0x1A, 0x1D, 0x00, 0x26, 0x1B, 0x1C, 0x00, 0x2D, 0x1B, 0x12, 0x13, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1B, 0x1C, 0x00, 0x26, 0x1C, 0x14, 0x00, 0x2D, 0x1C, 0x13, 0x1B, 0x26, 0x1D, 0x08, 0x00, 0x2F, 0x1C, 0x1D, 0x00, 0x26, 0x1B, 0x15, 0x00, 0x2D, 0x1B, 0x16, 0x18, 0x2D, 0x19, 0x1A, 0x10, 0x2B, 0x1C, 0x00, 0x00, 0x26, 0x1D, 0x08, 0x00, 0x2F, 0x1B, 0x1D, 0x00, 0x26, 0x16, 0x01, 0x00, 0x2D, 0x16, 0x15, 0x17, 0x2B, 0x1B, 0x00, 0x00, 0x26, 0x16, 0x08, 0x00, 0x30, 0x16, 0x00, 0x00, 0x26, 0x11, 0x20, 0x00, 0x1F, 0x10, 0x0A, 0x11, 0x1A, 0x10, 0x47, 0x00, 0x26, 0x12, 0x0E, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x17, 0x12, 0x11, 0x00, 0x26, 0x13, 0x0E, 0x00, 0x2F, 0x11, 0x13, 0x00, 0x17, 0x13, 0x11, 0x00, 0x26, 0x14, 0x0E, 0x00, 0x2F, 0x11, 0x14, 0x00, 0x17, 0x14, 0x11, 0x00, 0x26, 0x11, 0x0F, 0x00, 0x2D, 0x11, 0x13, 0x12, 0x26, 0x15, 0x08, 0x00, 0x2F, 0x11, 0x15, 0x00, 0x26, 0x15, 0x00, 0x00, 0x2C, 0x15, 0x11, 0x00, 0x38, 0x11, 0x00, 0x00, 0x17, 0x15, 0x11, 0x00, 0x25, 0x16, 0x03, 0x00, 0x06, 0x11, 0x00, 0x16, 0x2C, 0x11, 0x15, 0x00, 0x2F, 0x16, 0x02, 0x00, 0x17, 0x11, 0x16, 0x00, 0x26, 0x16, 0x10, 0x00, 0x2D, 0x16, 0x14, 0x08, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x21, 0x00, 0x2C, 0x17, 0x14, 0x00, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x26, 0x18, 0x10, 0x00, 0x2D, 0x18, 0x12, 0x17, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x26, 0x17, 0x11, 0x00, 0x25, 0x19, 0x00, 0x00, 0x2D, 0x17, 0x13, 0x19, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x17, 0x19, 0x00, 0x25, 0x19, 0x00, 0x00, 0x2C, 0x15, 0x19, 0x00, 0x26, 0x1A, 0x12, 0x00, 0x2F, 0x19, 0x1A, 0x00, 0x26, 0x1A, 0x1F, 0x00, 0x2D, 0x1A, 0x14, 0x13, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x26, 0x1B, 0x10, 0x00, 0x2D, 0x1B, 0x0B, 0x1A, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1B, 0x1C, 0x00, 0x26, 0x1A, 0x13, 0x00, 0x25, 0x1C, 0x01, 0x00, 0x2D, 0x1A, 0x1C, 0x13, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1A, 0x1C, 0x00, 0x26, 0x1C, 0x14, 0x00, 0x2D, 0x1C, 0x13, 0x1A, 0x26, 0x1D, 0x08, 0x00, 0x2F, 0x1C, 0x1D, 0x00, 0x26, 0x1A, 0x15, 0x00, 0x2D, 0x1A, 0x19, 0x1B, 0x2C, 0x11, 0x1C, 0x00, 0x26, 0x1D, 0x08, 0x00, 0x2F, 0x1A, 0x1D, 0x00, 0x26, 0x19, 0x01, 0x00, 0x2D, 0x19, 0x16, 0x18, 0x2C, 0x17, 0x1A, 0x00, 0x26, 0x19, 0x08, 0x00, 0x30, 0x19, 0x00, 0x00, 0x26, 0x12, 0x22, 0x00, 0x1F, 0x11, 0x0A, 0x12, 0x1A, 0x11, 0x53, 0x00, 0x26, 0x13, 0x0E, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x17, 0x13, 0x12, 0x00, 0x26, 0x14, 0x0E, 0x00, 0x2F, 0x12, 0x14, 0x00, 0x17, 0x14, 0x12, 0x00, 0x26, 0x15, 0x0E, 0x00, 0x2F, 0x12, 0x15, 0x00, 0x17, 0x15, 0x12, 0x00, 0x26, 0x12, 0x23, 0x00, 0x2C, 0x12, 0x13, 0x00, 0x26, 0x16, 0x08, 0x00, 0x2F, 0x12, 0x16, 0x00, 0x26, 0x16, 0x10, 0x00, 0x2D, 0x16, 0x15, 0x12, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x12, 0x24, 0x00, 0x26, 0x17, 0x25, 0x00, 0x2D, 0x12, 0x15, 0x17, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x12, 0x17, 0x00, 0x26, 0x17, 0x24, 0x00, 0x26, 0x18, 0x26, 0x00, 0x2D, 0x17, 0x15, 0x18, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x26, 0x18, 0x27, 0x00, 0x2D, 0x18, 0x12, 0x17, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x26, 0x12, 0x01, 0x00, 0x2D, 0x12, 0x16, 0x18, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x12, 0x17, 0x00, 0x26, 0x15, 0x00, 0x00, 0x2C, 0x15, 0x12, 0x00, 0x38, 0x12, 0x00, 0x00, 0x17, 0x15, 0x12, 0x00, 0x25, 0x16, 0x03, 0x00, 0x06, 0x12, 0x00, 0x16, 0x2C, 0x12, 0x15, 0x00, 0x2F, 0x16, 0x02, 0x00, 0x17, 0x12, 0x16, 0x00, 0x26, 0x16, 0x10, 0x00, 0x2D, 0x16, 0x13, 0x08, 0x26, 0x17, 0x08, 0x00, 0x2F, 0x16, 0x17, 0x00, 0x26, 0x17, 0x28, 0x00, 0x2C, 0x17, 0x13, 0x00, 0x26, 0x18, 0x08, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x26, 0x18, 0x11, 0x00, 0x2D, 0x18, 0x14, 0x17, 0x26, 0x19, 0x08, 0x00, 0x2F, 0x18, 0x19, 0x00, 0x25, 0x17, 0x00, 0x00, 0x2C, 0x15, 0x17, 0x00, 0x26, 0x19, 0x12, 0x00, 0x2F, 0x17, 0x19, 0x00, 0x26, 0x19, 0x10, 0x00, 0x2D, 0x19, 0x0B, 0x14, 0x26, 0x1A, 0x08, 0x00, 0x2F, 0x19, 0x1A, 0x00, 0x26, 0x1A, 0x28, 0x00, 0x2C, 0x1A, 0x13, 0x00, 0x26, 0x1B, 0x08, 0x00, 0x2F, 0x1A, 0x1B, 0x00, 0x26, 0x1B, 0x14, 0x00, 0x2D, 0x1B, 0x14, 0x1A, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1B, 0x1C, 0x00, 0x26, 0x1A, 0x15, 0x00, 0x2D, 0x1A, 0x17, 0x19, 0x2C, 0x12, 0x1B, 0x00, 0x26, 0x1C, 0x08, 0x00, 0x2F, 0x1A, 0x1C, 0x00, 0x26, 0x17, 0x01, 0x00, 0x2D, 0x17, 0x16, 0x18, 0x2B, 0x1A, 0x00, 0x00, 0x26, 0x17, 0x08, 0x00, 0x30, 0x17, 0x00, 0x00, 0x26, 0x12, 0x29, 0x00, 0x2C, 0x12, 0x0A, 0x00, 0x26, 0x13, 0x17, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x01, 0x12, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x2A, 0xD8, 0x96, 0x51, 0xA9, 0xCF, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0x0A, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF3, 0x96, 0x14, 0xAA, 0x01, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0x4E, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xC0, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xD1, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xDB, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0x0E, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEA, 0x95, 0x7A, 0xAA, 0xA8, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x55, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0x1E, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0x84, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0xC2, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDB, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0x4A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0xFB, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDC, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0x11, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBD, 0x36, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDC, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBE, 0xD6, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBD, 0x6B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE1, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBE, 0x9C, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBC, 0x1A, 0x83, 0xE6, 0xBD, 0xB9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x20, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF1, 0x10, 0x2B, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xDC, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0xBF, 0xDA, 0x26, 0x28, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x40, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0x1F, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0x51, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0x38, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDE, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0xDD, 0x23, 0xBF, 0x72, 0x80, 0xB7, 0xBF, 0x49, 0x80, 0xB7, 0xBF, 0x49, 0x80, 0xB7, 0xBF, 0x49, 0x80, 0xB7, 0xBF, 0x49, 0x80, 0xB7, 0xBE, 0xBD, 0x81, 0x44, 0xBE, 0xBC, 0x81, 0x44, 0xBE, 0xBC, 0x81, 0x44, 0xBE, 0xBC, 0x81, 0x44, 0xBE, 0xBC, 0x81, 0x44, 0x16, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xD2, 0x2E, 0xBF, 0xCB, 0x36, 0xBF, 0xCA, 0x36, 0x0D, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0xE1, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x2B, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xD6, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0x2D, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x42, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0x2E, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x27, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0x9F, 0x80, 0x8F, 0xBF, 0x71, 0x80, 0x8F, 0xBF, 0x71, 0x80, 0x8F, 0xBF, 0x71, 0x80, 0x8F, 0xBF, 0x71, 0x80, 0x8F, 0xBF, 0x13, 0x80, 0xEE, 0xBF, 0x12, 0x80, 0xEE, 0xBF, 0x12, 0x80, 0xEE, 0xBF, 0x12, 0x80, 0xEE, 0xBE, 0x2B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xB0, 0x9F, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0x20, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE8, 0x19, 0x23, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xED, 0x14, 0x22, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x29, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD9, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0x2B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x3E, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0x1E, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0x2C, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x25, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0x62, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xDC, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0x2C, 0x80, 0xD5, 0xBF, 0x2B, 0x80, 0xD5, 0xBF, 0x2B, 0x80, 0xD5, 0xBF, 0x2B, 0x80, 0xD5, 0xBF, 0x2B, 0x80, 0xD5, 0xBE, 0x9B, 0x81, 0x66, 0xBE, 0x9A, 0x81, 0x66, 0xBE, 0x9A, 0x81, 0x66, 0xBE, 0x9A, 0x81, 0x66, 0xBE, 0x9A, 0x81, 0x66, 0xBB, 0x65, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xB3, 0x6E, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x21, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x28, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD9, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0x2A, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x3C, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0x2F, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD9, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0x2B, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x24, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0x60, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xD7, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0x2A, 0x80, 0xD7, 0xBF, 0x29, 0x80, 0xD7, 0xBF, 0x29, 0x80, 0xD7, 0xBF, 0x29, 0x80, 0xD7, 0xBF, 0x29, 0x80, 0xD7, 0xBE, 0x89, 0x81, 0x78, 0xBE, 0x88, 0x81, 0x78, 0xBE, 0x88, 0x81, 0x78, 0xBE, 0x88, 0x81, 0x78, 0xBE, 0x88, 0x81, 0x78, 0xB8, 0xF7, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xB5, 0xDD, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xE5, 0x1C, 0x22, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x22, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEE, 0x13, 0x29, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD9, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0x2B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x3E, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0x30, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xD9, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0x2C, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0x25, 0x6F, 0xBF, 0xE7, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xD7, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xC1, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0x92, 0x6F, 0xBF, 0x91, 0x6F, 0xBF, 0x91, 0x6F, 0x25, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xE9, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xE5, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xD1, 0x30, 0x25, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xBE, 0x42, 0xBF, 0xD7, 0x0F, 0xBF, 0xF1, 0x0F, 0x02, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xCD, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xCC, 0x34, 0xBF, 0xBF, 0x42, 0x62, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xD7, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBE, 0x16, 0x81, 0xEB, 0xBE, 0x15, 0x81, 0xEB, 0xBE, 0x15, 0x81, 0xEB, 0xBE, 0x15, 0x81, 0xEB, 0xBE, 0x15, 0x81, 0xEB, 0xBE, 0x15, 0x81, 0xEB, 0xBD, 0x72, 0x82, 0x8F, 0xBD, 0x71, 0x82, 0x8F, 0xBD, 0x71, 0x82, 0x8F, 0xBD, 0x71, 0x82, 0x8F, 0xBD, 0x71, 0x82, 0x8F, 0xB5, 0x39, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xB9, 0x95, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEF, 0x12, 0x1C, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF1, 0x10, 0x22, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEB, 0x16, 0x26, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDE, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0x28, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x38, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0xBF, 0xE5, 0x1B, 0x2C, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xD9, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0x1B, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0x29, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0x37, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xD5, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0xBF, 0xD4, 0x2C, 0x59, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0x29, 0x80, 0xD8, 0xBF, 0x28, 0x80, 0xD8, 0xBF, 0x28, 0x80, 0xD8, 0xBF, 0x28, 0x80, 0xD8, 0xBF, 0x28, 0x80, 0xD8, 0xBE, 0x60, 0x81, 0xA1, 0xBE, 0x5F, 0x81, 0xA1, 0xBE, 0x5F, 0x81, 0xA1, 0xBE, 0x5F, 0x81, 0xA1, 0xBE, 0x5F, 0x81, 0xA1, 0xB2, 0x8D, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xAE, 0x9B, 0x91, 0x65, 0xBC, 0x4C, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xED, 0x14, 0x26, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xEA, 0x17, 0x7A, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF2, 0x0F, 0x6A, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xE6, 0x1A, 0xBF, 0xD8, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0x38, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0x02, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xD1, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0x44, 0x80, 0xBD, 0xBF, 0x43, 0x80, 0xBD, 0xBF, 0x43, 0x80, 0xBD, 0xBF, 0x43, 0x80, 0xBD, 0xBE, 0xB2, 0x81, 0x51, 0xBE, 0xAF, 0x81, 0x51, 0xBE, 0xAF, 0x81, 0x51, 0xBE, 0xAF, 0x81, 0x51, 0x2B, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF3, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xDF, 0x22, 0x3E, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0x34, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD6, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0x2C, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0x25, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0x66, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xD6, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0x20, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBF, 0x1F, 0x80, 0xE1, 0xBE, 0x78, 0x81, 0x89, 0xBE, 0x77, 0x81, 0x89, 0xBE, 0x77, 0x81, 0x89, 0xBE, 0x77, 0x81, 0x89, 0xBE, 0x77, 0x81, 0x89, 0x16, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xD4, 0x2D, 0xBF, 0xD3, 0x2D, 0xCD, 0x00, 0x00, 0x23, 0x0C, 0x9E, 0x2E, 0xA9, 0x41, 0x0C, 0xBF, 0xEB, 0x16, 0x15, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xF6, 0x0A, 0xBF, 0xE9, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE4, 0x48, 0xBF, 0xDA, 0x25, 0xBF, 0xDB, 0x25, 0xBF, 0xB9, 0x48, 0x04, 0x96, 0x51, 0xA9, 0xAF, 0x96, 0x51, 0x04, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xCF, 0x05, 0x7A, 0x65, 0x72, 0x6F, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x87, 0xCD, 0x87, 0xFB, 0xDA, 0x03, 0xDA, 0x49, 0xCF, 0x09, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x80, 0x9F, 0xDA, 0x05, 0xCE, 0x82, 0x32, 0x28, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x20, 0x5B, 0x2C, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x73, 0x6B, 0x5D, 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, 0x74, 0x6F, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x65, 0x64, 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, 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, 0x20, 0x0A, 0x0A, 0x09, 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, 0x20, 0x0A, 0x0A, 0x09, 0x61, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x61, 0x6C, 0x6C, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x09, 0x64, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x09, 0x65, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x09, 0x75, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x09, 0x79, 0x20, 0x2D, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x79, 0x69, 0x65, 0x6C, 0x64, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x61, 0x6C, 0x73, 0x0A, 0x09, 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, 0xCF, 0x04, 0x66, 0x69, 0x6E, 0x64, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xF8, 0x28, 0x66, 0x69, 0x6E, 0x64, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x64, 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, 0x20, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x4E, 0x6F, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x20, 0x77, 0x61, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6E, 0x69, 0x6C, 0x20, 0x66, 0x72, 0x6F, 0x6D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x61, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0x20, 0x43, 0x6F, 0x6E, 0x73, 0x69, 0x64, 0x65, 0x72, 0x20, 0x66, 0x69, 0x6E, 0x64, 0x2D, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x61, 0x14, 0xCD, 0x00, 0x00, 0x62, 0x5A, 0xDA, 0x03, 0xDA, 0x83, 0x32, 0xCF, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2F, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xDA, 0x05, 0xCE, 0x83, 0x2D, 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, 0x20, 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, 0x20, 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, 0x09, 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, 0x09, 0x3A, 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, 0x09, 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, 0x09, 0x3A, 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, 0x09, 0x3A, 0x6E, 0x61, 0x6D, 0x65, 0x20, 0x2D, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x75, 0x6D, 0x61, 0x6E, 0x20, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0x09, 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, 0xCF, 0x05, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x7C, 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, 0x20, 0x20, 0x28, 0x28, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0x20, 0x61, 0x20, 0x62, 0x20, 0x63, 0x29, 0x20, 0x78, 0x29, 0x20, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x28, 0x28, 0x61, 0x20, 0x78, 0x29, 0x20, 0x28, 0x62, 0x20, 0x78, 0x29, 0x20, 0x28, 0x63, 0x20, 0x78, 0x29, 0x29, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x65, 0x21, 0xCD, 0x00, 0x00, 0x66, 0x1C, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x01, 0xCE, 0x05, 0x6A, 0x75, 0x78, 0x74, 0x2A, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0xD1, 0x00, 0x00, 0x0B, 0x00, 0x02, 0x16, 0x01, 0xDA, 0x10, 0xDA, 0x81, 0x00, 0xDA, 0x80, 0x8C, 0x38, 0x01, 0x00, 0x00, 0x17, 0x02, 0x01, 0x00, 0x27, 0x03, 0x00, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x06, 0x04, 0x05, 0x1A, 0x06, 0x0B, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x2F, 0x07, 0x08, 0x00, 0x2C, 0x02, 0x07, 0x00, 0x26, 0x0A, 0x00, 0x00, 0x2F, 0x09, 0x0A, 0x00, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xF5, 0xFF, 0xFF, 0x25, 0x03, 0x00, 0x00, 0x2C, 0x02, 0x03, 0x00, 0x26, 0x03, 0x01, 0x00, 0x30, 0x03, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x65, 0xBD, 0x0C, 0xBF, 0xF4, 0x0C, 0x06, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xF6, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xCE, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0x06, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x00, 0x65, 0x21, 0x80, 0xFB, 0xBF, 0x90, 0x6F, 0xBF, 0x91, 0x6F, 0xCF, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0xDA, 0x05, 0xCE, 0x76, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x6A, 0x6F, 0x69, 0x6E, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x5B, 0x2C, 0x73, 0x65, 0x70, 0x5D, 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, 0x73, 0x65, 0x70, 0x2E, 0xCF, 0x07, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x89, 0xE9, 0x8A, 0x29, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x07, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x17, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x89, 0xE9, 0x40, 0xBF, 0xEF, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x06, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x81, 0x16, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x20, 0x20, 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, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xCD, 0xE3, 0xCD, 0x00, 0x00, 0xCF, 0xC6, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xB9, 0x00, 0x00, 0x08, 0x01, 0x05, 0x0F, 0x01, 0xCE, 0x06, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0xDA, 0x10, 0xDA, 0x81, 0xD4, 0xDA, 0x81, 0x3F, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x14, 0x02, 0x0B, 0x53, 0xCE, 0x07, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x2A, 0xDA, 0x10, 0xDA, 0x81, 0xE3, 0xD0, 0x02, 0x61, 0x73, 0xD0, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0xDA, 0x83, 0xCD, 0xDA, 0x81, 0x23, 0xDA, 0x81, 0x3F, 0xDA, 0x80, 0xFB, 0xDA, 0x80, 0xB9, 0xDA, 0x4E, 0xDA, 0x83, 0x6C, 0xDA, 0x85, 0xDE, 0x28, 0x03, 0x00, 0x00, 0x2E, 0x02, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x26, 0x06, 0x01, 0x00, 0x33, 0x05, 0x04, 0x06, 0x17, 0x06, 0x05, 0x00, 0x26, 0x07, 0x02, 0x00, 0x33, 0x05, 0x04, 0x07, 0x17, 0x07, 0x05, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x2E, 0x02, 0x00, 0x00, 0x26, 0x08, 0x03, 0x00, 0x2F, 0x05, 0x08, 0x00, 0x17, 0x08, 0x05, 0x00, 0x1A, 0x06, 0x07, 0x00, 0x26, 0x0A, 0x04, 0x00, 0x2C, 0x06, 0x0A, 0x00, 0x26, 0x0B, 0x05, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x17, 0x09, 0x0A, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x09, 0x00, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x1A, 0x0A, 0x03, 0x00, 0x17, 0x09, 0x0A, 0x00, 0x18, 0x0F, 0x00, 0x00, 0x1A, 0x07, 0x03, 0x00, 0x17, 0x0B, 0x07, 0x00, 0x18, 0x0B, 0x00, 0x00, 0x26, 0x0C, 0x04, 0x00, 0x2C, 0x01, 0x0C, 0x00, 0x26, 0x0D, 0x05, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x1A, 0x0D, 0x03, 0x00, 0x17, 0x0C, 0x0D, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0C, 0x00, 0x00, 0x17, 0x0B, 0x0C, 0x00, 0x17, 0x09, 0x0B, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x17, 0x0B, 0x08, 0x00, 0x22, 0x0C, 0x00, 0x00, 0x2C, 0x0B, 0x0C, 0x00, 0x26, 0x0D, 0x06, 0x00, 0x2F, 0x0C, 0x0D, 0x00, 0x17, 0x0D, 0x0C, 0x00, 0x22, 0x0E, 0x00, 0x00, 0x1F, 0x0C, 0x0E, 0x0D, 0x19, 0x0C, 0x03, 0x00, 0x23, 0x0C, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x0C, 0x00, 0x00, 0x1A, 0x0C, 0x1C, 0x00, 0x17, 0x0E, 0x0D, 0x00, 0x33, 0x0F, 0x0B, 0x0D, 0x17, 0x10, 0x0F, 0x00, 0x26, 0x0F, 0x07, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x2F, 0x0F, 0x10, 0x00, 0x2B, 0x0F, 0x00, 0x00, 0x26, 0x12, 0x08, 0x00, 0x2F, 0x11, 0x12, 0x00, 0x1A, 0x11, 0x0E, 0x00, 0x26, 0x0F, 0x07, 0x00, 0x23, 0x12, 0x00, 0x00, 0x2C, 0x0F, 0x12, 0x00, 0x3C, 0x0F, 0x00, 0x00, 0x2C, 0x0F, 0x10, 0x00, 0x26, 0x13, 0x09, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x17, 0x0F, 0x12, 0x00, 0x2C, 0x0A, 0x0E, 0x00, 0x26, 0x13, 0x0A, 0x00, 0x2F, 0x12, 0x13, 0x00, 0x34, 0x00, 0x12, 0x0F, 0x18, 0x01, 0x00, 0x00, 0x2C, 0x0B, 0x0D, 0x00, 0x26, 0x0F, 0x06, 0x00, 0x2F, 0x0D, 0x0F, 0x00, 0x18, 0xDF, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xCB, 0xFE, 0x81, 0xE2, 0xBE, 0xF8, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xCF, 0x32, 0xBF, 0xCE, 0x32, 0xBF, 0xCE, 0x32, 0xBF, 0xCE, 0x32, 0xBF, 0xCE, 0x32, 0xBF, 0xCE, 0x32, 0x10, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE1, 0x20, 0x14, 0x17, 0xBF, 0xF1, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xF2, 0x0E, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE5, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xEF, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xCC, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xBF, 0x42, 0x04, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x9A, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF0, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xCE, 0x80, 0x8C, 0xBF, 0xB7, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xD4, 0x2D, 0x0F, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xE7, 0x1F, 0xBF, 0x75, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xBF, 0x74, 0x80, 0x8C, 0xDA, 0x85, 0xA7, 0xDA, 0x5B, 0x28, 0x02, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x2C, 0x03, 0x01, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x03, 0x04, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x26, 0x06, 0x02, 0x00, 0x26, 0x07, 0x03, 0x00, 0x2D, 0x06, 0x07, 0x05, 0x2E, 0x03, 0x00, 0x00, 0x26, 0x06, 0x04, 0x00, 0x30, 0x06, 0x00, 0x00, 0xCD, 0x00, 0x94, 0x00, 0x00, 0x03, 0x01, 0x02, 0x08, 0xDA, 0x10, 0xDA, 0x80, 0xC5, 0xDA, 0x81, 0x3F, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2F, 0x01, 0x02, 0x00, 0x1A, 0x01, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0xCF, 0x3C, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF1, 0x47, 0xBF, 0xB9, 0x47, 0xBF, 0xF6, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xCD, 0x00, 0x00, 0xCD, 0xE3, 0x81, 0xE3, 0xBF, 0x57, 0x63, 0xBF, 0x98, 0x7F, 0xBF, 0x81, 0x7F, 0xBF, 0x81, 0x7F, 0xBF, 0x77, 0x80, 0x8A, 0x1A, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xDE, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xBF, 0xD7, 0x29, 0xCF, 0x03, 0x6D, 0x61, 0x70, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x73, 0x28, 0x6D, 0x61, 0x70, 0x20, 0x66, 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, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x20, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x55, 0x3C, 0xCD, 0x00, 0x00, 0x58, 0xD5, 0xDA, 0x03, 0xDA, 0x81, 0xD4, 0xCF, 0x03, 0x74, 0x72, 0x79, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x81, 0x3C, 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, 0x42, 0x6F, 0x64, 0x79, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x20, 0x73, 0x68, 0x6F, 0x75, 0x6C, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x61, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x20, 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, 0x20, 0x20, 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, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2C, 0x20, 0x20, 0x6F, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6C, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x9D, 0xB7, 0xCD, 0x00, 0x00, 0x20, 0x13, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0E, 0x02, 0x0D, 0x3B, 0xCE, 0x03, 0x74, 0x72, 0x79, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x80, 0x9C, 0xDA, 0x80, 0x9F, 0xD0, 0x01, 0x65, 0xDA, 0x86, 0x11, 0xDA, 0x81, 0xBF, 0xDA, 0x81, 0x1B, 0xDA, 0x81, 0x59, 0xDA, 0x5A, 0xDA, 0x80, 0x8C, 0xDA, 0x5D, 0xDA, 0x5C, 0xDA, 0x81, 0x83, 0x28, 0x02, 0x00, 0x00, 0x35, 0x03, 0x01, 0x00, 0x35, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x35, 0x04, 0x03, 0x01, 0x17, 0x06, 0x04, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x03, 0x07, 0x00, 0x17, 0x07, 0x03, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x09, 0x01, 0x00, 0x2D, 0x09, 0x03, 0x00, 0x3D, 0x08, 0x00, 0x00, 0x26, 0x09, 0x02, 0x00, 0x26, 0x0A, 0x03, 0x00, 0x2D, 0x09, 0x08, 0x0A, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x09, 0x04, 0x00, 0x2C, 0x09, 0x04, 0x00, 0x3D, 0x08, 0x00, 0x00, 0x2D, 0x04, 0x03, 0x07, 0x2B, 0x08, 0x00, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x26, 0x08, 0x05, 0x00, 0x2C, 0x08, 0x04, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x0A, 0x06, 0x00, 0x26, 0x0B, 0x07, 0x00, 0x2D, 0x0A, 0x03, 0x0B, 0x3D, 0x08, 0x00, 0x00, 0x26, 0x0A, 0x08, 0x00, 0x2D, 0x0A, 0x05, 0x07, 0x3D, 0x03, 0x00, 0x00, 0x1A, 0x06, 0x06, 0x00, 0x26, 0x0C, 0x08, 0x00, 0x2D, 0x0C, 0x06, 0x04, 0x3D, 0x0B, 0x00, 0x00, 0x17, 0x0A, 0x0B, 0x00, 0x18, 0x02, 0x00, 0x00, 0x22, 0x0A, 0x00, 0x00, 0x25, 0x0B, 0x01, 0x00, 0x2C, 0x01, 0x0B, 0x00, 0x26, 0x0C, 0x09, 0x00, 0x2F, 0x0B, 0x0C, 0x00, 0x26, 0x0D, 0x0A, 0x00, 0x2D, 0x0D, 0x03, 0x0A, 0x2E, 0x0B, 0x00, 0x00, 0x3D, 0x0C, 0x00, 0x00, 0x26, 0x0A, 0x0B, 0x00, 0x2D, 0x0A, 0x08, 0x0C, 0x2B, 0x07, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x0A, 0x0C, 0x00, 0x2D, 0x0A, 0x09, 0x03, 0x3D, 0x08, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x9D, 0xB7, 0x82, 0x5C, 0xBE, 0xF6, 0x81, 0x09, 0xBE, 0xF7, 0x81, 0x09, 0xBE, 0xF7, 0x81, 0x09, 0xBE, 0xF7, 0x81, 0x09, 0xBE, 0xF7, 0x81, 0x09, 0xBF, 0x19, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xD7, 0x81, 0x09, 0xBF, 0x2C, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xC4, 0x81, 0x09, 0xBF, 0x3A, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0xCB, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0x63, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0xDC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0x4A, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xBF, 0x3B, 0x80, 0xC5, 0xCF, 0x04, 0x61, 0x73, 0x2D, 0x3E, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x80, 0x9E, 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, 0x61, 0x73, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x20, 0x20, 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, 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, 0x20, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x73, 0x46, 0xCD, 0x00, 0x00, 0x74, 0xAB, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x09, 0x02, 0x03, 0x09, 0x02, 0xCE, 0x04, 0x61, 0x73, 0x2D, 0x3E, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x85, 0x27, 0xDA, 0x81, 0x83, 0x28, 0x03, 0x00, 0x00, 0x17, 0x04, 0x00, 0x00, 0x17, 0x05, 0x02, 0x00, 0x37, 0x06, 0x05, 0x00, 0x17, 0x07, 0x06, 0x00, 0x25, 0x06, 0x00, 0x00, 0x2A, 0x08, 0x01, 0x00, 0x2F, 0x08, 0x08, 0x00, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x01, 0xDA, 0x10, 0x27, 0x02, 0x00, 0x01, 0x1F, 0x01, 0x00, 0x02, 0x1A, 0x01, 0x03, 0x00, 0x27, 0x02, 0x00, 0x0B, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x74, 0x5E, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF5, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0xFA, 0x00, 0x00, 0x07, 0x00, 0x03, 0x1E, 0x01, 0x01, 0xDA, 0x85, 0x28, 0xDA, 0x10, 0xDA, 0x59, 0xDA, 0x85, 0x27, 0xDA, 0x81, 0x83, 0x27, 0x01, 0x00, 0x06, 0x27, 0x02, 0x00, 0x07, 0x3E, 0x00, 0x01, 0x02, 0x19, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x05, 0x27, 0x03, 0x00, 0x06, 0x33, 0x01, 0x02, 0x03, 0x17, 0x02, 0x01, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x01, 0x03, 0x00, 0x17, 0x03, 0x01, 0x00, 0x2A, 0x01, 0x00, 0x00, 0x2C, 0x01, 0x02, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x01, 0x04, 0x00, 0x27, 0x05, 0x00, 0x04, 0x2C, 0x03, 0x05, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2D, 0x06, 0x04, 0x01, 0x3D, 0x05, 0x00, 0x00, 0x29, 0x05, 0x00, 0x04, 0x25, 0x04, 0x01, 0x00, 0x27, 0x05, 0x00, 0x06, 0x06, 0x01, 0x04, 0x05, 0x29, 0x01, 0x00, 0x06, 0x28, 0x04, 0x00, 0x00, 0x30, 0x04, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x02, 0xDA, 0x10, 0x27, 0x02, 0x00, 0x01, 0x1F, 0x01, 0x00, 0x02, 0x1A, 0x01, 0x03, 0x00, 0x27, 0x02, 0x01, 0x03, 0x03, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x74, 0x5E, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF5, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCD, 0x00, 0x00, 0x74, 0x07, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x88, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF0, 0x11, 0x1F, 0x1B, 0xBF, 0xDB, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xC6, 0x3B, 0x10, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0x66, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xCD, 0x00, 0x00, 0x73, 0x46, 0x81, 0x65, 0xBF, 0x4D, 0x0B, 0x04, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBF, 0x64, 0x80, 0x9C, 0xBE, 0xA3, 0x81, 0x65, 0xCF, 0x03, 0x6D, 0x61, 0x78, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4E, 0x63, 0xCD, 0x00, 0x00, 0x4E, 0xBA, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x03, 0x00, 0x02, 0x05, 0xCE, 0x03, 0x6D, 0x61, 0x78, 0xDA, 0x10, 0xDA, 0x83, 0xB8, 0xDA, 0x81, 0x13, 0x28, 0x01, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x26, 0x02, 0x01, 0x00, 0x30, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x4E, 0x63, 0x57, 0xBF, 0xF0, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xCF, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0xDA, 0x05, 0xCE, 0x51, 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, 0x6E, 0x20, 0x63, 0x6F, 0x70, 0x69, 0x65, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x63, 0x61, 0x74, 0x65, 0x6E, 0x61, 0x74, 0x65, 0x64, 0x2E, 0xCF, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0A, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x62, 0x69, 0x74, 0xDA, 0x05, 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, 0xCF, 0x06, 0x66, 0x69, 0x62, 0x65, 0x72, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x88, 0xE1, 0x89, 0x1E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x06, 0x66, 0x69, 0x62, 0x65, 0x72, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x82, 0x6C, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x88, 0xE1, 0x3D, 0xBF, 0xF0, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xCF, 0x03, 0x66, 0x6F, 0x72, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x54, 0x28, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x20, 0x26, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x29, 0x0A, 0x0A, 0x44, 0x6F, 0x20, 0x61, 0x20, 0x63, 0x20, 0x73, 0x74, 0x79, 0x6C, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x20, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x43, 0x20, 0xCD, 0x00, 0x00, 0x43, 0xC0, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x08, 0x03, 0x03, 0x0C, 0xCE, 0x03, 0x66, 0x6F, 0x72, 0xDA, 0x10, 0xDA, 0x5B, 0xDA, 0x86, 0xA1, 0xDA, 0x86, 0xA8, 0x28, 0x04, 0x00, 0x00, 0x2C, 0x01, 0x02, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x05, 0x06, 0x00, 0x26, 0x06, 0x01, 0x00, 0x2D, 0x00, 0x06, 0x05, 0x26, 0x07, 0x00, 0x00, 0x2F, 0x06, 0x07, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x2E, 0x03, 0x00, 0x00, 0x26, 0x05, 0x02, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x43, 0x20, 0x80, 0xA0, 0xBF, 0xE8, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xDA, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xD9, 0x27, 0xBF, 0xCD, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xBF, 0xC7, 0x39, 0xCF, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x50, 0x2B, 0xCD, 0x00, 0x00, 0x50, 0x84, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0xCE, 0x05, 0x66, 0x69, 0x72, 0x73, 0x74, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x33, 0x02, 0x00, 0x03, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x50, 0x2B, 0x59, 0xBF, 0xF6, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xCF, 0x04, 0x77, 0x61, 0x6C, 0x6B, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xAD, 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, 0x66, 0x20, 0x20, 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, 0x20, 0x2E, 0x20, 0x49, 0x66, 0x20, 0x61, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x20, 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, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x70, 0x88, 0xCD, 0x00, 0x00, 0x71, 0xF8, 0xDA, 0x03, 0xDA, 0x81, 0x02, 0xCF, 0x04, 0x65, 0x61, 0x63, 0x68, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x44, 0x28, 0x65, 0x61, 0x63, 0x68, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x69, 0x6E, 0x64, 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, 0x69, 0x6E, 0x64, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x43, 0xC3, 0xCD, 0x00, 0x00, 0x44, 0x42, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x06, 0x02, 0x03, 0x09, 0xCE, 0x04, 0x65, 0x61, 0x63, 0x68, 0xDA, 0x10, 0xDA, 0x86, 0xA4, 0xDA, 0x5B, 0xDA, 0x86, 0xA8, 0x28, 0x03, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x00, 0x04, 0x01, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x2E, 0x02, 0x00, 0x00, 0x26, 0x05, 0x02, 0x00, 0x30, 0x05, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x43, 0xC3, 0x7F, 0xBF, 0xE3, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xEA, 0x16, 0xBF, 0xDE, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xBF, 0xD8, 0x28, 0xCF, 0x0E, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0E, 0x66, 0x69, 0x62, 0x65, 0x72, 0x2F, 0x6D, 0x61, 0x78, 0x73, 0x74, 0x61, 0x63, 0x6B, 0xDA, 0x05, 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, 0xCF, 0x03, 0x73, 0x75, 0x6D, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x44, 0xD3, 0xCD, 0x00, 0x00, 0x45, 0x52, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x09, 0x01, 0x00, 0x0F, 0xCE, 0x03, 0x73, 0x75, 0x6D, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x37, 0x04, 0x03, 0x00, 0x17, 0x05, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x3E, 0x06, 0x04, 0x05, 0x1A, 0x06, 0x07, 0x00, 0x33, 0x07, 0x03, 0x04, 0x17, 0x08, 0x07, 0x00, 0x06, 0x02, 0x02, 0x08, 0x25, 0x07, 0x01, 0x00, 0x06, 0x04, 0x07, 0x04, 0x18, 0xF9, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x44, 0xD3, 0x7F, 0xBF, 0xCA, 0x0C, 0x04, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xF4, 0x0B, 0xBF, 0xE4, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0x8A, 0x7F, 0xCF, 0x0C, 0x66, 0x6C, 0x61, 0x74, 0x74, 0x65, 0x6E, 0x2D, 0x69, 0x6E, 0x74, 0x6F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0x91, 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, 0x2C, 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, 0x20, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x61, 0x6E, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x27, 0x69, 0x6E, 0x74, 0x6F, 0x27, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x83, 0x52, 0xCD, 0x00, 0x00, 0x84, 0x56, 0xDA, 0x03, 0xDA, 0x83, 0xF9, 0xCF, 0x06, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x38, 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, 0x28, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x28, 0x6E, 0x6F, 0x74, 0x20, 0x2E, 0x2E, 0x2E, 0x20, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x96, 0xF4, 0x97, 0x5E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x07, 0x01, 0x02, 0x0B, 0xCE, 0x06, 0x75, 0x6E, 0x6C, 0x65, 0x73, 0x73, 0xDA, 0x10, 0xDA, 0x5D, 0xDA, 0x5C, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x22, 0x06, 0x00, 0x00, 0x2D, 0x05, 0x00, 0x06, 0x2B, 0x03, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x96, 0xF4, 0x6A, 0xBF, 0xE0, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xBF, 0xE1, 0x1F, 0xCF, 0x0B, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0xDA, 0x05, 0xCE, 0x80, 0xD8, 0x28, 0x73, 0x63, 0x61, 0x6E, 0x2D, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 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, 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, 0x64, 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, 0xCF, 0x07, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x2A, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xA5, 0x28, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x2A, 0x20, 0x65, 0x6E, 0x76, 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, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6E, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x6F, 0x66, 0x20, 0x28, 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, 0x20, 0x2E, 0x2E, 0x2E, 0x29, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x65, 0x78, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74, 0x20, 0x65, 0x6E, 0x76, 0x69, 0x72, 0x6F, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0xCB, 0xFE, 0xCD, 0x00, 0x00, 0xCD, 0xE0, 0xDA, 0x03, 0xDA, 0x86, 0xD5, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x65, 0x78, 0x70, 0xDA, 0x05, 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, 0xCF, 0x0D, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x86, 0x98, 0xDA, 0x05, 0xCE, 0x80, 0xBC, 0x28, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2F, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x20, 0x74, 0x75, 0x70, 0x20, 0x26, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x29, 0x0A, 0x0A, 0x50, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x73, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0x20, 0x49, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6E, 0x64, 0x65, 0x64, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x2E, 0xCF, 0x09, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x82, 0x52, 0xDA, 0x05, 0xCE, 0x81, 0x9A, 0x28, 0x66, 0x69, 0x6C, 0x65, 0x2F, 0x72, 0x65, 0x61, 0x64, 0x20, 0x66, 0x20, 0x77, 0x68, 0x61, 0x74, 0x20, 0x5B, 0x2C, 0x62, 0x75, 0x66, 0x5D, 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, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x61, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2E, 0x20, 0x41, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 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, 0x66, 0x6F, 0x75, 0x72, 0x74, 0x68, 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, 0x27, 0x77, 0x68, 0x61, 0x74, 0x27, 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, 0x27, 0x77, 0x68, 0x61, 0x74, 0x27, 0x3A, 0x0A, 0x0A, 0x09, 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, 0x09, 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, 0x09, 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, 0x83, 0x11, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x00, 0xDA, 0x05, 0xCE, 0x66, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2F, 0x70, 0x75, 0x73, 0x68, 0x20, 0x61, 0x72, 0x72, 0x20, 0x78, 0x29, 0x0A, 0x0A, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, 0x61, 0x6E, 0x20, 0x65, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 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, 0xCF, 0x04, 0x63, 0x6F, 0x6D, 0x70, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x70, 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, 0x20, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x6F, 0x73, 0x65, 0x20, 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x73, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x4A, 0x4A, 0xCD, 0x00, 0x00, 0x4C, 0x2E, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x19, 0x00, 0x01, 0x41, 0x04, 0xCE, 0x04, 0x63, 0x6F, 0x6D, 0x70, 0xDA, 0x10, 0xDA, 0x80, 0x8C, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x25, 0x04, 0x00, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x04, 0x00, 0x25, 0x06, 0x00, 0x00, 0x33, 0x05, 0x00, 0x06, 0x03, 0x05, 0x00, 0x00, 0x25, 0x06, 0x02, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x1A, 0x05, 0x07, 0x00, 0x35, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x35, 0x06, 0x00, 0x01, 0x17, 0x08, 0x06, 0x00, 0x2A, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x25, 0x09, 0x03, 0x00, 0x1F, 0x06, 0x03, 0x09, 0x1A, 0x06, 0x09, 0x00, 0x35, 0x09, 0x00, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x35, 0x09, 0x00, 0x01, 0x17, 0x0B, 0x09, 0x00, 0x35, 0x09, 0x00, 0x02, 0x17, 0x0C, 0x09, 0x00, 0x2A, 0x09, 0x01, 0x00, 0x03, 0x09, 0x00, 0x00, 0x25, 0x0D, 0x04, 0x00, 0x1F, 0x09, 0x03, 0x0D, 0x1A, 0x09, 0x0B, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x17, 0x0E, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x01, 0x17, 0x0F, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x02, 0x17, 0x10, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x03, 0x17, 0x11, 0x0D, 0x00, 0x2A, 0x0D, 0x02, 0x00, 0x03, 0x0D, 0x00, 0x00, 0x35, 0x0D, 0x00, 0x00, 0x17, 0x12, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x01, 0x17, 0x13, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x02, 0x17, 0x14, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x03, 0x17, 0x15, 0x0D, 0x00, 0x35, 0x0D, 0x00, 0x04, 0x17, 0x16, 0x0D, 0x00, 0x2A, 0x0D, 0x03, 0x00, 0x25, 0x17, 0x05, 0x00, 0x25, 0x18, 0xFF, 0xFF, 0x2D, 0x00, 0x17, 0x18, 0x26, 0x18, 0x00, 0x00, 0x2F, 0x17, 0x18, 0x00, 0x2B, 0x0D, 0x00, 0x00, 0x2E, 0x17, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x01, 0xDA, 0x10, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x08, 0x2F, 0x01, 0x02, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x02, 0x00, 0x07, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x4B, 0x32, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF9, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x01, 0x00, 0x09, 0x01, 0xDA, 0x10, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x0C, 0x2F, 0x01, 0x02, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x0B, 0x2F, 0x02, 0x03, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00, 0x0A, 0x30, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x4B, 0x6C, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF9, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x01, 0x00, 0x0C, 0x01, 0xDA, 0x10, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x11, 0x2F, 0x01, 0x02, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x10, 0x2F, 0x02, 0x03, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x27, 0x03, 0x00, 0x0F, 0x2F, 0x01, 0x03, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x02, 0x00, 0x0E, 0x30, 0x02, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x4B, 0xAA, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF9, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF1, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xCD, 0x00, 0xD4, 0x00, 0x00, 0x04, 0x01, 0x00, 0x0F, 0x01, 0xDA, 0x10, 0x2B, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x16, 0x2F, 0x01, 0x02, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x15, 0x2F, 0x02, 0x03, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x27, 0x03, 0x00, 0x14, 0x2F, 0x01, 0x03, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x13, 0x2F, 0x02, 0x03, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00, 0x12, 0x30, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x4B, 0xF6, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xFC, 0x04, 0xBF, 0xF9, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF8, 0x08, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF1, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xED, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCD, 0x00, 0x00, 0x4A, 0x4A, 0x81, 0xE4, 0xBE, 0xA1, 0x11, 0xBF, 0xE9, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0xC5, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xF0, 0x10, 0xBF, 0xC7, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0xDD, 0x2F, 0xBF, 0xD1, 0x2F, 0xBF, 0xD1, 0x2F, 0xBF, 0xD1, 0x2F, 0xBF, 0xEE, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0x91, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBF, 0x14, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xCD, 0x33, 0xBF, 0xEA, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0x56, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBE, 0x9C, 0x81, 0x64, 0xBF, 0x4F, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xE6, 0x19, 0xBF, 0xE7, 0x19, 0x07, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0x8D, 0x73, 0xBF, 0xB6, 0x1D, 0x0F, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xE4, 0x1C, 0xBF, 0xB2, 0x4F, 0xBF, 0xB1, 0x4F, 0xBF, 0xB1, 0x4F, 0xCF, 0x09, 0x67, 0x63, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x09, 0x67, 0x63, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0xDA, 0x05, 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, 0xCF, 0x07, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x89, 0x20, 0x89, 0x60, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x07, 0xCE, 0x07, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x3F, 0xDA, 0x10, 0xDA, 0x13, 0xDA, 0x14, 0x28, 0x01, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x26, 0x04, 0x01, 0x00, 0x1F, 0x03, 0x02, 0x04, 0x03, 0x03, 0x00, 0x00, 0x89, 0x20, 0x40, 0xBF, 0xEF, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0xF6, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xDA, 0x85, 0x1D, 0xDA, 0x55, 0xCF, 0x06, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x74, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xB8, 0x28, 0x69, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x20, 0x64, 0x73, 0x29, 0x0A, 0x0A, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 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, 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, 0x6F, 0x66, 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, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6D, 0x65, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2C, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x77, 0x69, 0x6C, 0x6C, 0x20, 0x62, 0x65, 0x20, 0x69, 0x67, 0x6E, 0x6F, 0x72, 0x65, 0x64, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x78, 0x97, 0xCD, 0x00, 0x00, 0x79, 0xA3, 0xDA, 0x03, 0xDA, 0x85, 0x48, 0xCF, 0x0B, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0xDA, 0x05, 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, 0xCF, 0x09, 0x64, 0x65, 0x66, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x86, 0x37, 0x86, 0xC0, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x07, 0x02, 0x03, 0x0C, 0xCE, 0x09, 0x64, 0x65, 0x66, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, 0xDA, 0x10, 0xDA, 0x85, 0xDE, 0xDA, 0x03, 0xDA, 0x81, 0x57, 0x28, 0x02, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x04, 0x03, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2C, 0x05, 0x01, 0x00, 0x3C, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x35, 0x06, 0x06, 0x00, 0x34, 0x06, 0x04, 0x05, 0x04, 0x00, 0x00, 0x00, 0x86, 0x37, 0x80, 0x89, 0xBF, 0xC8, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xE9, 0x18, 0x04, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0xE0, 0x20, 0xBF, 0x7E, 0x80, 0x89, 0xCF, 0x04, 0x63, 0x6F, 0x6E, 0x64, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x20, 0x20, 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, 0x20, 0x20, 0x6F, 0x64, 0x64, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F, 0x66, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x2C, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x6E, 0x6F, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x20, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 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, 0x20, 0x6E, 0x69, 0x6C, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x97, 0x61, 0x99, 0x63, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x05, 0x00, 0x00, 0x06, 0x01, 0xCE, 0x04, 0x63, 0x6F, 0x6E, 0x64, 0xDA, 0x10, 0x28, 0x01, 0x00, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x25, 0x04, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xDC, 0x00, 0x00, 0x0A, 0x01, 0x02, 0x1E, 0x01, 0xDA, 0x4C, 0xDA, 0x10, 0xDA, 0x5C, 0xDA, 0x5B, 0x28, 0x01, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00, 0x37, 0x02, 0x03, 0x00, 0x07, 0x03, 0x02, 0x00, 0x17, 0x02, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x1F, 0x04, 0x02, 0x05, 0x1A, 0x04, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x25, 0x06, 0x01, 0x00, 0x1F, 0x05, 0x02, 0x06, 0x1A, 0x05, 0x04, 0x00, 0x27, 0x07, 0x00, 0x00, 0x33, 0x06, 0x07, 0x00, 0x03, 0x06, 0x00, 0x00, 0x27, 0x07, 0x00, 0x00, 0x33, 0x06, 0x07, 0x00, 0x25, 0x08, 0x01, 0x00, 0x06, 0x07, 0x00, 0x08, 0x27, 0x09, 0x00, 0x00, 0x33, 0x08, 0x09, 0x07, 0x25, 0x09, 0x02, 0x00, 0x06, 0x07, 0x00, 0x09, 0x2B, 0x07, 0x00, 0x00, 0x2F, 0x09, 0x01, 0x00, 0x26, 0x07, 0x00, 0x00, 0x2D, 0x07, 0x06, 0x08, 0x2B, 0x09, 0x00, 0x00, 0x26, 0x07, 0x01, 0x00, 0x30, 0x07, 0x00, 0x00, 0xBF, 0xFF, 0x98, 0x80, 0x80, 0xD8, 0xBF, 0x4A, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF0, 0x13, 0xBF, 0xE0, 0x21, 0x0A, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x80, 0x9E, 0xBF, 0x62, 0x80, 0x9E, 0xBF, 0x82, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF0, 0x80, 0x81, 0xBF, 0x91, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0x15, 0x0C, 0xBF, 0xF4, 0x0C, 0x1C, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0x16, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF5, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xA9, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0xBF, 0xA8, 0x58, 0x97, 0x61, 0x82, 0x02, 0xBF, 0x1D, 0x80, 0xD8, 0xBF, 0x28, 0x80, 0xD8, 0x04, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xDA, 0x81, 0x83, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x80, 0xAA, 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, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x73, 0x20, 0x69, 0x73, 0x20, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x64, 0x65, 0x66, 0x2C, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6F, 0x64, 0x79, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x65, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x20, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x9B, 0xC8, 0x9D, 0xB4, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0F, 0x01, 0x08, 0x29, 0xCE, 0x03, 0x6C, 0x65, 0x74, 0xDA, 0x10, 0xDA, 0x33, 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, 0x5D, 0xDA, 0x5A, 0xDA, 0x5B, 0xDA, 0x81, 0x00, 0xDA, 0x80, 0x8B, 0xDA, 0x80, 0x8C, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x1A, 0x04, 0x04, 0x00, 0x26, 0x03, 0x01, 0x00, 0x01, 0x03, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x25, 0x05, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x38, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x3E, 0x08, 0x05, 0x04, 0x1A, 0x08, 0x11, 0x00, 0x25, 0x0B, 0x01, 0x00, 0x06, 0x0A, 0x05, 0x0B, 0x33, 0x09, 0x00, 0x0A, 0x17, 0x0B, 0x09, 0x00, 0x33, 0x09, 0x00, 0x05, 0x17, 0x0C, 0x09, 0x00, 0x26, 0x09, 0x03, 0x00, 0x2D, 0x09, 0x0C, 0x0B, 0x26, 0x0D, 0x04, 0x00, 0x2F, 0x09, 0x0D, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x26, 0x0E, 0x05, 0x00, 0x2F, 0x0D, 0x0E, 0x00, 0x25, 0x09, 0x02, 0x00, 0x06, 0x05, 0x05, 0x09, 0x18, 0xEF, 0xFF, 0xFF, 0x2C, 0x07, 0x01, 0x00, 0x26, 0x09, 0x06, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x25, 0x09, 0x00, 0x00, 0x2C, 0x07, 0x09, 0x00, 0x26, 0x09, 0x07, 0x00, 0x30, 0x09, 0x00, 0x00, 0x9B, 0xC8, 0x81, 0xEC, 0xBE, 0xDC, 0x10, 0xBF, 0xEA, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE9, 0x17, 0xBF, 0xE5, 0x4E, 0xBF, 0xCF, 0x30, 0xBF, 0xD0, 0x30, 0xBF, 0xB3, 0x4E, 0x0D, 0x10, 0xBF, 0xE7, 0x1A, 0x04, 0x08, 0x04, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x0B, 0x08, 0xBF, 0xF1, 0x68, 0xBF, 0xB7, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF0, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0xBF, 0xE3, 0x1D, 0x18, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xDF, 0x22, 0xBF, 0xDE, 0x22, 0xBF, 0xDE, 0x22, 0x06, 0x07, 0xBF, 0xF9, 0x07, 0xBF, 0x99, 0x68, 0x04, 0x18, 0xBF, 0xE8, 0x18, 0xBF, 0xE8, 0x18, 0x04, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xCF, 0x06, 0x74, 0x75, 0x70, 0x6C, 0x65, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x8B, 0x8A, 0x8B, 0xC7, 0xDA, 0x03, 0xDA, 0x84, 0xB0, 0xCF, 0x07, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x83, 0xCC, 0xDA, 0x05, 0xCE, 0x7C, 0x28, 0x6F, 0x73, 0x2F, 0x65, 0x78, 0x69, 0x74, 0x20, 0x78, 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, 0xCF, 0x05, 0x65, 0x76, 0x65, 0x6E, 0x3F, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x87, 0x61, 0x87, 0x95, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x01, 0x08, 0xCE, 0x05, 0x65, 0x76, 0x65, 0x6E, 0x3F, 0xDA, 0x10, 0xDA, 0x32, 0x28, 0x01, 0x00, 0x00, 0x25, 0x02, 0x02, 0x00, 0x2C, 0x00, 0x02, 0x00, 0x26, 0x03, 0x00, 0x00, 0x2F, 0x02, 0x03, 0x00, 0x25, 0x04, 0x00, 0x00, 0x42, 0x03, 0x04, 0x02, 0x03, 0x03, 0x00, 0x00, 0x87, 0x61, 0x34, 0xBF, 0xF8, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xFA, 0x06, 0xBF, 0xF4, 0x0D, 0xBF, 0xF3, 0x0D, 0xBF, 0xF3, 0x0D, 0xCF, 0x07, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x76, 0x5A, 0xCD, 0x00, 0x00, 0x76, 0xD1, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0xBB, 0x00, 0x00, 0x06, 0x01, 0x01, 0x09, 0x01, 0xCE, 0x07, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0xDA, 0x10, 0xDA, 0x49, 0x28, 0x02, 0x00, 0x00, 0x37, 0x03, 0x01, 0x00, 0x2B, 0x03, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x1A, 0x04, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2A, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0xD1, 0x00, 0x00, 0x02, 0x00, 0x00, 0x05, 0x01, 0xDA, 0x10, 0x27, 0x01, 0x00, 0x01, 0x2E, 0x01, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0xBF, 0xFF, 0xCD, 0x00, 0x00, 0x76, 0xC3, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xCD, 0x00, 0x00, 0x76, 0x5A, 0x77, 0xBF, 0xD3, 0x0C, 0xBF, 0xED, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xEC, 0x14, 0xBF, 0xE8, 0x37, 0xBF, 0xC9, 0x37, 0xBF, 0xE9, 0x16, 0xBF, 0xEA, 0x16, 0xCF, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x62, 0x73, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x08, 0x6D, 0x61, 0x74, 0x68, 0x2F, 0x61, 0x62, 0x73, 0xDA, 0x05, 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, 0xCF, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x11, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x6E, 0x65, 0x77, 0x2D, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0xDA, 0x05, 0xCE, 0x74, 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, 0x5B, 0x2C, 0x20, 0x62, 0x79, 0x74, 0x65, 0x3D, 0x30, 0x5D, 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, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x66, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 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, 0xCF, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2F, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0xDA, 0x05, 0xCE, 0x75, 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, 0x73, 0x6E, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 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, 0x6A, 0x61, 0x6E, 0x65, 0x74, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x2E, 0xCF, 0x04, 0x62, 0x61, 0x6E, 0x64, 0xD3, 0x02, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x09, 0x00, 0x0D, 0x06, 0x00, 0x00, 0x13, 0xCE, 0x04, 0x62, 0x61, 0x6E, 0x64, 0x37, 0x01, 0x00, 0x00, 0x20, 0x02, 0x01, 0x00, 0x1A, 0x02, 0x03, 0x00, 0x25, 0x03, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x20, 0x02, 0x01, 0x01, 0x1A, 0x02, 0x05, 0x00, 0x25, 0x03, 0xFF, 0xFF, 0x35, 0x04, 0x00, 0x00, 0x0C, 0x03, 0x03, 0x04, 0x03, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x25, 0x05, 0x01, 0x00, 0x33, 0x04, 0x00, 0x05, 0x0C, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x01, 0x1F, 0x02, 0x05, 0x01, 0x1A, 0x02, 0xFC, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xDA, 0x05, 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, 0xCF, 0x05, 0x73, 0x6C, 0x75, 0x72, 0x70, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x50, 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, 0x70, 0x61, 0x74, 0x68, 0x20, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x88, 0xB7, 0xCD, 0x00, 0x00, 0x89, 0xAB, 0xDA, 0x03, 0xDA, 0x83, 0xC8, 0xCF, 0x07, 0x7A, 0x69, 0x70, 0x63, 0x6F, 0x6C, 0x6C, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x52, 0x28, 0x7A, 0x69, 0x70, 0x63, 0x6F, 0x6C, 0x6C, 0x20, 0x6B, 0x65, 0x79, 0x73, 0x20, 0x76, 0x61, 0x6C, 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, 0x20, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x79, 0xA6, 0xCD, 0x00, 0x00, 0x7A, 0xB1, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x11, 0x02, 0x00, 0x19, 0xCE, 0x07, 0x7A, 0x69, 0x70, 0x63, 0x6F, 0x6C, 0x6C, 0xDA, 0x10, 0x28, 0x02, 0x00, 0x00, 0x3C, 0x03, 0x00, 0x00, 0x17, 0x04, 0x03, 0x00, 0x37, 0x05, 0x00, 0x00, 0x17, 0x06, 0x05, 0x00, 0x37, 0x07, 0x01, 0x00, 0x17, 0x08, 0x07, 0x00, 0x3E, 0x0A, 0x06, 0x08, 0x1A, 0x0A, 0x03, 0x00, 0x17, 0x09, 0x06, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x09, 0x08, 0x00, 0x17, 0x0A, 0x09, 0x00, 0x25, 0x0B, 0x00, 0x00, 0x17, 0x0C, 0x0A, 0x00, 0x3E, 0x0D, 0x0B, 0x0C, 0x1A, 0x0D, 0x08, 0x00, 0x17, 0x0E, 0x0B, 0x00, 0x33, 0x0F, 0x00, 0x0E, 0x33, 0x10, 0x01, 0x0E, 0x34, 0x04, 0x0F, 0x10, 0x25, 0x0F, 0x01, 0x00, 0x06, 0x0B, 0x0B, 0x0F, 0x18, 0xF8, 0xFF, 0xFF, 0x03, 0x04, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x79, 0xA6, 0x81, 0x0B, 0xBF, 0x56, 0x0C, 0xBF, 0xF4, 0x0C, 0x0C, 0x0C, 0xBF, 0xEC, 0x15, 0x0C, 0x0C, 0xBF, 0xEC, 0x15, 0x11, 0x08, 0xBF, 0xF4, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xE4, 0x1D, 0x04, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xE6, 0x0B, 0x02, 0x0B, 0xBF, 0xDF, 0x22, 0xBF, 0xC1, 0x40, 0xBF, 0xC0, 0x40, 0xBF, 0xC0, 0x40, 0xBE, 0xFC, 0x81, 0x0B, 0xCF, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x6F, 0x70, 0x6E, 0xD3, 0x02, 0xDA, 0x03, 0xD8, 0x0B, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x2F, 0x70, 0x6F, 0x70, 0x6E, 0xDA, 0x05, 0xCE, 0x5E, 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, 0x6E, 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, 0xCF, 0x02, 0x2A, 0x3D, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x28, 0x28, 0x2A, 0x3D, 0x20, 0x78, 0x20, 0x6E, 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, 0x2A, 0x20, 0x78, 0x20, 0x6E, 0x29, 0x29, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x94, 0x29, 0x94, 0x71, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x06, 0x02, 0x02, 0x08, 0xCE, 0x02, 0x2A, 0x3D, 0xDA, 0x10, 0xDA, 0x83, 0x8A, 0xDA, 0x22, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2D, 0x04, 0x00, 0x01, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2D, 0x05, 0x00, 0x03, 0x3D, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x94, 0x29, 0x48, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x08, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 0xCE, 0x80, 0xA4, 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, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2E, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x62, 0x65, 0x72, 0x20, 0x20, 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, 0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6C, 0x73, 0x2E, 0xDA, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x42, 0x30, 0xCD, 0x00, 0x00, 0x43, 0x1D, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x07, 0x01, 0x06, 0x15, 0xCE, 0x08, 0x67, 0x65, 0x6E, 0x65, 0x72, 0x61, 0x74, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0x9D, 0xDA, 0x5D, 0xDA, 0x81, 0x92, 0xDA, 0x83, 0x12, 0xDA, 0x80, 0x9C, 0xDA, 0x86, 0xAE, 0x28, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2B, 0x04, 0x00, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x2E, 0x01, 0x00, 0x00, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x06, 0x02, 0x00, 0x2C, 0x06, 0x04, 0x00, 0x3D, 0x05, 0x00, 0x00, 0x26, 0x06, 0x03, 0x00, 0x2D, 0x06, 0x00, 0x05, 0x3D, 0x04, 0x00, 0x00, 0x26, 0x06, 0x04, 0x00, 0x2D, 0x06, 0x03, 0x04, 0x3D, 0x05, 0x00, 0x00, 0x26, 0x04, 0x05, 0x00, 0x2C, 0x04, 0x05, 0x00, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x42, 0x30, 0x80, 0xED, 0xBF, 0xCA, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xBF, 0xCB, 0x35, 0xCF, 0x05, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xDE, 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, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 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, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x5D, 0x1D, 0xCD, 0x00, 0x00, 0x5F, 0xE9, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x10, 0x00, 0x04, 0x4B, 0xCE, 0x05, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x82, 0xF6, 0xDA, 0x81, 0x00, 0xCE, 0x22, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x31, 0x20, 0x74, 0x6F, 0x20, 0x33, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x20, 0x74, 0x6F, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x25, 0x04, 0x01, 0x00, 0x1F, 0x02, 0x03, 0x04, 0x1A, 0x02, 0x11, 0x00, 0x35, 0x04, 0x00, 0x00, 0x17, 0x05, 0x04, 0x00, 0x2B, 0x05, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x2F, 0x04, 0x06, 0x00, 0x17, 0x06, 0x04, 0x00, 0x25, 0x04, 0x00, 0x00, 0x17, 0x07, 0x05, 0x00, 0x3E, 0x08, 0x04, 0x07, 0x1A, 0x08, 0x06, 0x00, 0x17, 0x09, 0x04, 0x00, 0x34, 0x06, 0x09, 0x09, 0x25, 0x0A, 0x01, 0x00, 0x06, 0x04, 0x04, 0x0A, 0x18, 0xFA, 0xFF, 0xFF, 0x03, 0x06, 0x00, 0x00, 0x25, 0x05, 0x02, 0x00, 0x1F, 0x04, 0x03, 0x05, 0x1A, 0x04, 0x14, 0x00, 0x35, 0x05, 0x00, 0x00, 0x17, 0x06, 0x05, 0x00, 0x35, 0x05, 0x00, 0x01, 0x17, 0x07, 0x05, 0x00, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x08, 0x00, 0x00, 0x2F, 0x05, 0x08, 0x00, 0x17, 0x08, 0x05, 0x00, 0x17, 0x05, 0x06, 0x00, 0x17, 0x09, 0x07, 0x00, 0x3E, 0x0A, 0x05, 0x09, 0x1A, 0x0A, 0x07, 0x00, 0x17, 0x0B, 0x05, 0x00, 0x07, 0x0C, 0x0B, 0x06, 0x34, 0x08, 0x0C, 0x0B, 0x25, 0x0C, 0x01, 0x00, 0x06, 0x05, 0x05, 0x0C, 0x18, 0xF9, 0xFF, 0xFF, 0x03, 0x08, 0x00, 0x00, 0x25, 0x06, 0x03, 0x00, 0x1F, 0x05, 0x03, 0x06, 0x1A, 0x05, 0x1A, 0x00, 0x35, 0x06, 0x00, 0x00, 0x17, 0x07, 0x06, 0x00, 0x35, 0x06, 0x00, 0x01, 0x17, 0x08, 0x06, 0x00, 0x35, 0x06, 0x00, 0x02, 0x17, 0x09, 0x06, 0x00, 0x0B, 0x06, 0x07, 0x09, 0x2B, 0x06, 0x00, 0x00, 0x26, 0x0B, 0x01, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x2B, 0x0A, 0x00, 0x00, 0x26, 0x0B, 0x00, 0x00, 0x2F, 0x06, 0x0B, 0x00, 0x17, 0x0A, 0x06, 0x00, 0x17, 0x06, 0x07, 0x00, 0x17, 0x0B, 0x08, 0x00, 0x3E, 0x0C, 0x06, 0x0B, 0x1A, 0x0C, 0x07, 0x00, 0x17, 0x0D, 0x06, 0x00, 0x2C, 0x0A, 0x0D, 0x00, 0x26, 0x0F, 0x02, 0x00, 0x2F, 0x0E, 0x0F, 0x00, 0x06, 0x06, 0x06, 0x09, 0x18, 0xF9, 0xFF, 0xFF, 0x03, 0x0A, 0x00, 0x00, 0x26, 0x06, 0x03, 0x00, 0x01, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x5D, 0x1D, 0x82, 0xCC, 0xBE, 0x28, 0x0C, 0xBF, 0xEE, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0x49, 0x0D, 0xBF, 0xF3, 0x0D, 0x13, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xEB, 0x16, 0x0A, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xF3, 0x0C, 0xBF, 0xDD, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0xDC, 0x24, 0xBF, 0x99, 0x74, 0xBF, 0x72, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0xC5, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0xBF, 0xF1, 0x0F, 0x13, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xF4, 0x0C, 0xBF, 0xEB, 0x16, 0x0A, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xF6, 0x06, 0xBF, 0xF1, 0x12, 0xBF, 0xD7, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0xD6, 0x2A, 0xBF, 0x91, 0x7C, 0xBE, 0xEE, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBE, 0x23, 0x81, 0xDD, 0xBF, 0x49, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0x29, 0x06, 0xBF, 0xEF, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xEE, 0x12, 0xBF, 0xE3, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xE2, 0x1E, 0xBF, 0xD9, 0x28, 0x0A, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xEE, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xEF, 0x11, 0xBF, 0xD6, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0x7C, 0x80, 0x91, 0x06, 0x2B, 0xBF, 0xD5, 0x2B, 0xBF, 0xD5, 0x2B, 0xCF, 0x05, 0x6D, 0x65, 0x72, 0x67, 0x65, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 0xCE, 0x80, 0xA9, 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, 0x74, 0x6F, 0x20, 0x6F, 0x6E, 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, 0x20, 0x20, 0x63, 0x6F, 0x6C, 0x6C, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 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, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x73, 0x20, 0x61, 0x20, 0x6E, 0x65, 0x77, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7C, 0xBE, 0xCD, 0x00, 0x00, 0x7D, 0xE8, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x99, 0x00, 0x00, 0x0E, 0x00, 0x01, 0x23, 0xCE, 0x05, 0x6D, 0x65, 0x72, 0x67, 0x65, 0xDA, 0x10, 0xDA, 0x80, 0xFB, 0x28, 0x01, 0x00, 0x00, 0x3C, 0x02, 0x00, 0x00, 0x17, 0x03, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, 0x37, 0x05, 0x04, 0x00, 0x17, 0x06, 0x05, 0x00, 0x25, 0x05, 0x00, 0x00, 0x3E, 0x07, 0x05, 0x06, 0x1A, 0x07, 0x1A, 0x00, 0x33, 0x08, 0x04, 0x05, 0x17, 0x09, 0x08, 0x00, 0x17, 0x08, 0x09, 0x00, 0x22, 0x0A, 0x00, 0x00, 0x2C, 0x08, 0x0A, 0x00, 0x26, 0x0B, 0x00, 0x00, 0x2F, 0x0A, 0x0B, 0x00, 0x17, 0x0B, 0x0A, 0x00, 0x22, 0x0C, 0x00, 0x00, 0x1F, 0x0A, 0x0C, 0x0B, 0x19, 0x0A, 0x03, 0x00, 0x23, 0x0A, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x0A, 0x00, 0x00, 0x1A, 0x0A, 0x08, 0x00, 0x17, 0x0C, 0x0B, 0x00, 0x33, 0x0D, 0x09, 0x0C, 0x34, 0x03, 0x0C, 0x0D, 0x2C, 0x08, 0x0B, 0x00, 0x26, 0x0D, 0x00, 0x00, 0x2F, 0x0B, 0x0D, 0x00, 0x18, 0xF3, 0xFF, 0xFF, 0x25, 0x08, 0x01, 0x00, 0x06, 0x05, 0x08, 0x05, 0x18, 0xE6, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7C, 0xBE, 0x81, 0x2A, 0xBF, 0x8F, 0x12, 0xBF, 0xEE, 0x12, 0x04, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xF4, 0x0A, 0xBF, 0xE1, 0x20, 0xBF, 0xB3, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBF, 0xB2, 0x4E, 0xBE, 0xE3, 0x81, 0x2A, 0xCF, 0x06, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0xD4, 0x02, 0xD3, 0x01, 0xDA, 0x05, 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, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0xCD, 0x00, 0x00, 0x7E, 0xB6, 0xCD, 0x00, 0x00, 0x7F, 0x8A, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x0A, 0x01, 0x03, 0x1B, 0xCE, 0x06, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0xDA, 0x10, 0xDA, 0x80, 0xFF, 0xDA, 0x80, 0xFB, 0xDA, 0x81, 0x00, 0x28, 0x01, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x2B, 0x02, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x2F, 0x03, 0x04, 0x00, 0x17, 0x02, 0x03, 0x00, 0x22, 0x04, 0x00, 0x00, 0x2C, 0x00, 0x04, 0x00, 0x26, 0x05, 0x01, 0x00, 0x2F, 0x04, 0x05, 0x00, 0x17, 0x05, 0x04, 0x00, 0x22, 0x07, 0x00, 0x00, 0x1F, 0x06, 0x07, 0x05, 0x19, 0x06, 0x03, 0x00, 0x23, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x24, 0x06, 0x00, 0x00, 0x1A, 0x06, 0x09, 0x00, 0x33, 0x07, 0x00, 0x05, 0x2C, 0x02, 0x07, 0x00, 0x26, 0x09, 0x02, 0x00, 0x2F, 0x08, 0x09, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x26, 0x07, 0x01, 0x00, 0x2F, 0x05, 0x07, 0x00, 0x18, 0xF2, 0xFF, 0xFF, 0x03, 0x02, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x7E, 0xB6, 0x80, 0xD4, 0xBF, 0x8A, 0x09, 0xBF, 0xEC, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xEB, 0x15, 0xBF, 0xE2, 0x1F, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x13, 0x0B, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xF5, 0x0B, 0xBF, 0xEE, 0x49, 0xBF, 0xDF, 0x08, 0xBF, 0xE8, 0x19, 0xBF, 0xE7, 0x19, 0xBF, 0xE7, 0x19, 0x0D, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xF7, 0x09, 0xBF, 0xB9, 0x49, 0xBF, 0x33, 0x80, 0xD4, 0xCF, 0x02, 0x2B, 0x2B, 0xD4, 0x02, 0xD3, 0x02, 0xDA, 0x05, 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, 0x1D, 0xCB, 0xDA, 0x0F, 0xD2, 0x03, 0x00, 0xDA, 0x10, 0x93, 0x15, 0x93, 0x57, 0xDA, 0x03, 0xD7, 0xCD, 0x00, 0x9C, 0x00, 0x00, 0x05, 0x01, 0x02, 0x09, 0xCE, 0x02, 0x2B, 0x2B, 0xDA, 0x10, 0xDA, 0x21, 0xDA, 0x22, 0x28, 0x01, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x25, 0x04, 0x01, 0x00, 0x2D, 0x03, 0x00, 0x04, 0x3D, 0x02, 0x00, 0x00, 0x26, 0x04, 0x01, 0x00, 0x2D, 0x04, 0x00, 0x02, 0x3D, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x93, 0x15, 0x42, 0xBF, 0xEC, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xBF, 0xED, 0x13, 0xCF, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0xD3, 0x02, 0xDA, 0x03, 0xDA, 0x81, 0x3F, 0xDA, 0x05, 0xCE, 0x80, 0xA7, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x26, 0x20, 0x70, 0x61, 0x72, 0x74, 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, 0x76, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6F, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2E, 0x20, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6F, 0x6E, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6E, 0x63, 0x65, 0x73, 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, 0 }; const unsigned char *janet_core_image = janet_core_image_bytes; size_t janet_core_image_size = sizeof(janet_core_image_bytes);