diff options
Diffstat (limited to 'rust/vendor/brotli-decompressor')
33 files changed, 32793 insertions, 0 deletions
diff --git a/rust/vendor/brotli-decompressor/.cargo-checksum.json b/rust/vendor/brotli-decompressor/.cargo-checksum.json new file mode 100644 index 0000000..7dd0bba --- /dev/null +++ b/rust/vendor/brotli-decompressor/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.lock":"3b5f17960d9518c52ec29f254840cedf964772dd7e7ac310958bac7138a9683c","Cargo.toml":"4cc27ab97f581286911baef94cbdd96e5d06adab0113ec42a4a6f85578f68831","LICENSE":"c0c56f26d9c051cac4d200c34c84e7ae9aaa853e01a982a1df08b09931e518ae","README.md":"02a7eaa6992e3449a636dc736f2fc62dabd60229867de1bc906c9ea9f35a0ed1","examples/decompress.rs":"a9e7e23279b667ed1859464e35b52343e224c133421c42945afa735e9830d182","rustfmt.toml":"e38d9677ca881648112d3d69529f58efe0ac3316d35d51c527a5bcdbfd21dcf0","src/bin/brotli-decompressor.rs":"28719128c232dd0f634beacafd93a4356a44d0df1d49534e95f12feda3c709cf","src/bin/error_handling_tests.rs":"31bc213c89b4da16b47124a39c99c07a2109ec3f657c571840985c9884a4df34","src/bin/integration_tests.rs":"849b190df5f9089a4467ad914aa8d78437be5690b44e0acd704b2090d45cc64c","src/bin/ipsum.brotli":"74106184c7abce3075914e8147e664e6a0c6ee0184d8a4a585be557ad2f8aede","src/bin/ipsum.raw":"dd598301a25441eeb17800b4d4f6b16a36942586479d57d71863c7173390b5c4","src/bin/ipsum_gen.py":"9b4824588a75449acfbc6d87a5217aa225384e0d4523cb6228c89064762201d4","src/bin/tests.rs":"a16f1c28812ee735fe14fd9c70a3f1dc226607aa4301b48c74a8ff35be4c3ec5","src/bit_reader/mod.rs":"7937b9afc656cddaa88cb6cd84361f1ca222d2765ac1503a652ada6e9fdeb973","src/brotli_alloc.rs":"997338adbc0292a6df1ac5fc3a74e4837110be4b023a13e9d7b8ddc20d12cb02","src/context.rs":"8fe7865962916fa7ce820b9fb407e6a2dd9b9c373191ad4a41c507b6be373e40","src/decode.rs":"ca10cf8ffe354a1f136f719a9ca6213c4ec59712ef8f8312475657e446cb58d2","src/dictionary/mod.rs":"e04c7480c6fb72d5971167d30a9d9936ac85da092f491abcca6d29d8aefaccdf","src/ffi/alloc_util.rs":"5fe0a71d277325d9cd5b62c8df8c5effd85fc949b1c67aee445a34f4e59de514","src/ffi/interface.rs":"3afac9d4efc04e599e615bf02143f7f28a4e7bd2d10619a088994875d262151f","src/ffi/mod.rs":"538fd3dbb29aa2ada26d04b309c4bb700c8a0ba92352d0909a53433e7c717e98","src/huffman/mod.rs":"3c0e0efcdfea10b6254d57b7535a1b97f0bb02262ebd243c22e3b4505baab9d0","src/huffman/tests.rs":"58d149830204e768f51a67317d70db0a008df8beec6c7035dab15680efefa49f","src/io_wrappers.rs":"0d51cc59268a5992d53ae88b89b27ee5c97cb5cd3ce0be3c1c53fb186869a4df","src/lib.rs":"c5bc83ebae4bb12849ab92df98af2af1bfe71870f90271aef445934f1195f24e","src/memory.rs":"6542bbbc5a322f43839702c2d56c1f53f4d52e4633c37f4cd8e4eb2eeefecde6","src/prefix.rs":"97103858450ab5c81747e0307c427a73d1fa7cf038435d0ad938ce55a25ee04a","src/reader.rs":"2fa15b3912ef670cc3497d7a04a8618302f618c7bb6e657fedeed33a8abd3117","src/state.rs":"61d3e342d22ab5748f8397d45a8c90d72b99d8f55fb98f9fe3d442144ae6d565","src/test.rs":"3c5b32e5300372dc8de172c47768059e01ba29a0f9990afbb68dee06ef457ff9","src/transform.rs":"d0f20a8c164bc28f7bba71e5b1e80d01ac55df48fa25eae53127dfb1970adffb","src/writer.rs":"1226bdf17d9244f1575e38a0057e01dbbfc68aee062c373ff136bf413a384ce8"},"package":"4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"}
\ No newline at end of file diff --git a/rust/vendor/brotli-decompressor/Cargo.lock b/rust/vendor/brotli-decompressor/Cargo.lock new file mode 100644 index 0000000..c132465 --- /dev/null +++ b/rust/vendor/brotli-decompressor/Cargo.lock @@ -0,0 +1,26 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "brotli-decompressor" +version = "2.5.1" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] diff --git a/rust/vendor/brotli-decompressor/Cargo.toml b/rust/vendor/brotli-decompressor/Cargo.toml new file mode 100644 index 0000000..3b364b1 --- /dev/null +++ b/rust/vendor/brotli-decompressor/Cargo.toml @@ -0,0 +1,60 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +name = "brotli-decompressor" +version = "2.5.1" +authors = [ + "Daniel Reiter Horn <danielrh@dropbox.com>", + "The Brotli Authors", +] +exclude = ["testdata/*"] +autobins = false +description = "A brotli decompressor that with an interface avoiding the rust stdlib. This makes it suitable for embedded devices and kernels. It is designed with a pluggable allocator so that the standard lib's allocator may be employed. The default build also includes a stdlib allocator and stream interface. Disable this with --features=no-stdlib. Alternatively, --features=unsafe turns off array bounds checks and memory initialization but provides a safe interface for the caller. Without adding the --features=unsafe argument, all included code is safe. For compression in addition to this library, download https://github.com/dropbox/rust-brotli " +homepage = "https://github.com/dropbox/rust-brotli-decompressor" +documentation = "https://github.com/dropbox/rust-brotli-decompressor/blob/master/README.md" +readme = "README.md" +keywords = [ + "brotli", + "decompression", + "lz77", + "huffman", + "nostd", +] +license = "BSD-3-Clause/MIT" +repository = "https://github.com/dropbox/rust-brotli-decompressor" + +[profile.release] +lto = true +incremental = false + +[[bin]] +name = "brotli-decompressor" +doc = false + +[dependencies.alloc-no-stdlib] +version = "~2.0" + +[dependencies.alloc-stdlib] +version = "~0.2" +optional = true + +[features] +benchmark = [] +default = ["std"] +disable-timer = [] +pass-through-ffi-panics = [] +seccomp = [] +std = ["alloc-stdlib"] +unsafe = [ + "alloc-no-stdlib/unsafe", + "alloc-stdlib/unsafe", +] diff --git a/rust/vendor/brotli-decompressor/LICENSE b/rust/vendor/brotli-decompressor/LICENSE new file mode 100644 index 0000000..cd496ba --- /dev/null +++ b/rust/vendor/brotli-decompressor/LICENSE @@ -0,0 +1,12 @@ +Copyright (c) 2016 Dropbox, Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/rust/vendor/brotli-decompressor/README.md b/rust/vendor/brotli-decompressor/README.md new file mode 100644 index 0000000..7bf9656 --- /dev/null +++ b/rust/vendor/brotli-decompressor/README.md @@ -0,0 +1,143 @@ +# rust-brotli-decompressor + +[](https://crates.io/crates/brotli-decompressor) +[](https://travis-ci.org/dropbox/rust-brotli-decompressor) + +## What's new in version 2.5.0 +* If you call write with extra bytes it will only return the bytes consumed +* Further calls to write will return Ok(0) + +## What's new in version 2.4.0 +* If you call read until the file is ended, it will return 0 bytes. +* Further calls to read will error if there are extra unconsumed bytes in the file. + +## What's new in version 2.3.5 +* Fix bug in BrotliFillBitWindow + +## What's new in version 2.3.4 +* Check for fully consumed buffers in the decompressor reader/writer. + +## What's new in version 2.3.x +* Error handling for Write and Read implementations. +* Fixed issue with small buffer sizes on certain files when repeatedly calling Decode stream +* Expose BrotliDecoderIsFinished + +## What's new in version 2.2.x +* into_impl for reader and writer classes +* removed BrotliStateCleanup since it happens upon drop() + +## What's new in version 2.1.2 +* Better handling of transient errors ( fixes #4 ) +* Do not panic in debug mode on unexpected bytes (handle arithmetic overflow) +* Smaller stack allocations +* Never create slice::from_raw_parts with nil +* Better panic reporting to C FFI +* Backport fixes to brotli issues 502 and 506 +b +## What's new in version 2.0.0 + +* Legacy Custom dictionaries (mostly useful for testing multithreaded brotli encoding and experimentation) +* New mechanism to request that the library should only depend on custom allocations: the --no-default-features flag since --features=std is on by default. +* Fully compatible C FFI to match the https://github.com/google/brotli C API and become a drop-in replacement + +## Project Requirements + +Direct no-stdlib port of the C brotli decompressor to Rust if --no-default-features is passed into the build + +no dependency on the Rust stdlib: this library would be ideal for decompressing within a rust kernel among other things. + +This will be useful to see how C and Rust compare in an apples-to-apples +comparison where the same algorithms and data structures and +optimizations are employed. + +The current expected performance losses come from + +1. an extra indirection in the hgroups +2. array bounds checks on every access +3. no ability to load a full aligned 64 bit or 128 bit item from a [u8] + +the system also enables all syscalls to be "frontloaded" in the initial generation +of a memory pool for the allocator. Afterwards, SECCOMP can be activated or +other mechanisms can be used to secure the application, if desired + +## Linking rust-brotli-decompressor with C code using the zero-cost rust FFI abstraction + +This library has FFI exports which comply with the original C interfaces. +To build them, enter the c directory and just type make there. +That will build a small example program and the cdylib with the appropriate ffi in place to link against + +the example, called c/main.c shows how to decompress a program using the streaming interface and the nonstreaming interface. + +If a nostdlib version is desired, then an unstable rust must be used (to enable the custom panic handler) +and then the BrotliDecoderDecompress function is deactivated since that has no facilities for specifying a custom malloc + +a customized malloc must be used if a nostdlib build is chosen and additionally the no-stdlib-ffi-binding cargo feature must be set +eg + +cargo build --features='no-stdlib no-stdlib-ffi-binding' --release + + +## Usage + +### With the io::Read abstraction + +```rust +let mut input = brotli_decompressor::Decompressor::new(&mut io::stdin(), 4096 /* buffer size */); +``` +then you can simply read input as you would any other io::Read class + +### With the Stream Copy abstraction + +```rust +match brotli_decompressor::BrotliDecompress(&mut io::stdin(), &mut io::stdout(), 65536 /* buffer size */) { + Ok(_) => {}, + Err(e) => panic!("Error {:?}", e), +} +``` + +### With manual memory management + +There are 3 steps to using brotli without stdlib + +1. setup the memory manager +2. setup the BrotliState +3. in a loop, call BrotliDecompressStream + +in Detail + +```rust +// at global scope declare a MemPool type -- in this case we'll choose the heap to +// avoid unsafe code, and avoid restrictions of the stack size + +declare_stack_allocator_struct!(MemPool, heap); + +// at local scope, make a heap allocated buffers to hold uint8's uint32's and huffman codes +let mut u8_buffer = define_allocator_memory_pool!(4096, u8, [0; 32 * 1024 * 1024], heap); +let mut u32_buffer = define_allocator_memory_pool!(4096, u32, [0; 1024 * 1024], heap); +let mut hc_buffer = define_allocator_memory_pool!(4096, HuffmanCode, [0; 4 * 1024 * 1024], heap); +let heap_u8_allocator = HeapPrealloc::<u8>::new_allocator(4096, &mut u8_buffer, bzero); +let heap_u32_allocator = HeapPrealloc::<u32>::new_allocator(4096, &mut u32_buffer, bzero); +let heap_hc_allocator = HeapPrealloc::<HuffmanCode>::new_allocator(4096, &mut hc_buffer, bzero); + +// At this point no more syscalls are going to be needed since everything can come from the allocators. + +// Feel free to activate SECCOMP jailing or other mechanisms to secure your application if you wish. + +// Now it's possible to setup the decompressor state +let mut brotli_state = BrotliState::new(heap_u8_allocator, heap_u32_allocator, heap_hc_allocator); + +// at this point the decompressor simply needs an input and output buffer and the ability to track +// the available data left in each buffer +loop { + result = BrotliDecompressStream(&mut available_in, &mut input_offset, &input.slice(), + &mut available_out, &mut output_offset, &mut output.slice_mut(), + &mut written, &mut brotli_state); + + // just end the decompression if result is BrotliResult::ResultSuccess or BrotliResult::ResultFailure +} +``` + +This interface is the same interface that the C brotli decompressor uses + +Also feel free to use custom allocators that invoke Box directly. +This example illustrates a mechanism to avoid subsequent syscalls after the initial allocation diff --git a/rust/vendor/brotli-decompressor/examples/decompress.rs b/rust/vendor/brotli-decompressor/examples/decompress.rs new file mode 100644 index 0000000..13a7c6a --- /dev/null +++ b/rust/vendor/brotli-decompressor/examples/decompress.rs @@ -0,0 +1,37 @@ +extern crate brotli_decompressor; +#[cfg(not(feature="std"))] +fn main() { + panic!("For no-stdlib examples please see the tests") +} +#[cfg(feature="std")] +fn main() { + use std::io; + let stdin = &mut io::stdin(); + { + use std::io::{Read, Write}; + let mut reader = brotli_decompressor::Decompressor::new( + stdin, + 4096, // buffer size + ); + let mut buf = [0u8; 4096]; + loop { + match reader.read(&mut buf[..]) { + Err(e) => { + if let io::ErrorKind::Interrupted = e.kind() { + continue; + } + panic!("{:?}", e); + } + Ok(size) => { + if size == 0 { + break; + } + match io::stdout().write_all(&buf[..size]) { + Err(e) => panic!("{:?}", e), + Ok(_) => {}, + } + } + } + } + } +} diff --git a/rust/vendor/brotli-decompressor/rustfmt.toml b/rust/vendor/brotli-decompressor/rustfmt.toml new file mode 100644 index 0000000..4d6c8c4 --- /dev/null +++ b/rust/vendor/brotli-decompressor/rustfmt.toml @@ -0,0 +1,4 @@ +max_width = 100 +ideal_width = 80 +reorder_imports = true +tab_spaces=2 diff --git a/rust/vendor/brotli-decompressor/src/bin/brotli-decompressor.rs b/rust/vendor/brotli-decompressor/src/bin/brotli-decompressor.rs new file mode 100644 index 0000000..4ad3d30 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/brotli-decompressor.rs @@ -0,0 +1,337 @@ +#![allow(unused_imports)] + +mod integration_tests; +mod error_handling_tests; +mod tests; +extern crate brotli_decompressor; +extern crate core; +#[macro_use] +extern crate alloc_no_stdlib; +use core::ops; +use brotli_decompressor::CustomRead; +pub struct Rebox<T> { + b: Box<[T]>, +} +impl<T> From<Vec<T>> for Rebox<T> { + #[inline(always)] + fn from(val: Vec<T>) -> Self { + Rebox::<T>{b:val.into_boxed_slice()} + } +} +impl<T> core::default::Default for Rebox<T> { + #[inline(always)] + fn default() -> Self { + let v: Vec<T> = Vec::new(); + let b = v.into_boxed_slice(); + Rebox::<T> { b: b } + } +} + +impl<T> ops::Index<usize> for Rebox<T> { + type Output = T; + #[inline(always)] + fn index(&self, index: usize) -> &T { + &(*self.b)[index] + } +} + +impl<T> ops::IndexMut<usize> for Rebox<T> { + #[inline(always)] + fn index_mut(&mut self, index: usize) -> &mut T { + &mut (*self.b)[index] + } +} + +impl<T> alloc_no_stdlib::SliceWrapper<T> for Rebox<T> { + #[inline(always)] + fn slice(&self) -> &[T] { + &*self.b + } +} + +impl<T> alloc_no_stdlib::SliceWrapperMut<T> for Rebox<T> { + #[inline(always)] + fn slice_mut(&mut self) -> &mut [T] { + &mut *self.b + } +} + +pub struct HeapAllocator<T: core::clone::Clone> { + pub default_value: T, +} + +#[cfg(not(feature="unsafe"))] +impl<T: core::clone::Clone> alloc_no_stdlib::Allocator<T> for HeapAllocator<T> { + type AllocatedMemory = Rebox<T>; + fn alloc_cell(self: &mut HeapAllocator<T>, len: usize) -> Rebox<T> { + let v: Vec<T> = vec![self.default_value.clone();len]; + let b = v.into_boxed_slice(); + Rebox::<T> { b: b } + } + fn free_cell(self: &mut HeapAllocator<T>, _data: Rebox<T>) {} +} + +#[cfg(feature="unsafe")] +impl<T: core::clone::Clone> alloc_no_stdlib::Allocator<T> for HeapAllocator<T> { + type AllocatedMemory = Rebox<T>; + fn alloc_cell(self: &mut HeapAllocator<T>, len: usize) -> Rebox<T> { + let mut v: Vec<T> = Vec::with_capacity(len); + unsafe { + v.set_len(len); + } + let b = v.into_boxed_slice(); + Rebox::<T> { b: b } + } + fn free_cell(self: &mut HeapAllocator<T>, _data: Rebox<T>) {} +} + + +#[allow(unused_imports)] +use alloc_no_stdlib::{SliceWrapper,SliceWrapperMut, StackAllocator, AllocatedStackMemory, Allocator, bzero}; +use brotli_decompressor::HuffmanCode; + +use std::io::{self, Error, ErrorKind, Read, Write}; + +use std::env; + +use std::fs::File; + +use std::path::Path; + + +// declare_stack_allocator_struct!(MemPool, 4096, global); + + + +struct IoWriterWrapper<'a, OutputType: Write + 'a>(&'a mut OutputType); + + +struct IoReaderWrapper<'a, OutputType: Read + 'a>(&'a mut OutputType); + +impl<'a, OutputType: Write> brotli_decompressor::CustomWrite<io::Error> for IoWriterWrapper<'a, OutputType> { + fn flush(self: &mut Self) -> Result<(), io::Error> { + loop { + match self.0.flush() { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(_) => return Ok(()), + } + } + } + + fn write(self: &mut Self, buf: &[u8]) -> Result<usize, io::Error> { + loop { + match self.0.write(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_written) => return Ok(cur_written), + } + } + } +} + + +impl<'a, InputType: Read> brotli_decompressor::CustomRead<io::Error> for IoReaderWrapper<'a, InputType> { + fn read(self: &mut Self, buf: &mut [u8]) -> Result<usize, io::Error> { + loop { + match self.0.read(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_read) => return Ok(cur_read), + } + } + } +} + +struct IntoIoReader<OutputType: Read>(OutputType); + +impl<InputType: Read> brotli_decompressor::CustomRead<io::Error> for IntoIoReader<InputType> { + fn read(self: &mut Self, buf: &mut [u8]) -> Result<usize, io::Error> { + loop { + match self.0.read(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_read) => return Ok(cur_read), + } + } + } +} +#[cfg(not(feature="seccomp"))] +pub fn decompress<InputType, OutputType>(r: &mut InputType, + w: &mut OutputType, + buffer_size: usize, + dict: Vec<u8>) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + let mut alloc_u8 = HeapAllocator::<u8> { default_value: 0 }; + let mut input_buffer = alloc_u8.alloc_cell(buffer_size); + let mut output_buffer = alloc_u8.alloc_cell(buffer_size); + brotli_decompressor::BrotliDecompressCustomIoCustomDict(&mut IoReaderWrapper::<InputType>(r), + &mut IoWriterWrapper::<OutputType>(w), + input_buffer.slice_mut(), + output_buffer.slice_mut(), + alloc_u8, + HeapAllocator::<u32> { default_value: 0 }, + HeapAllocator::<HuffmanCode> { + default_value: HuffmanCode::default(), + }, + Rebox::<u8>::from(dict), + Error::new(ErrorKind::UnexpectedEof, "Unexpected EOF")) +} +#[cfg(feature="seccomp")] +extern { + fn calloc(n_elem : usize, el_size : usize) -> *mut u8; + fn free(ptr : *mut u8); + fn syscall(value : i32) -> i32; + fn prctl(operation : i32, flags : u32) -> i32; +} +#[cfg(feature="seccomp")] +const PR_SET_SECCOMP : i32 = 22; +#[cfg(feature="seccomp")] +const SECCOMP_MODE_STRICT : u32 = 1; + +#[cfg(feature="seccomp")] +declare_stack_allocator_struct!(CallocAllocatedFreelist, 8192, calloc); + +#[cfg(feature="seccomp")] +pub fn decompress<InputType, OutputType>(r: &mut InputType, + mut w: &mut OutputType, + buffer_size: usize) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + + let mut u8_buffer = unsafe {define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 200], calloc)}; + let mut u32_buffer = unsafe {define_allocator_memory_pool!(4, u32, [0; 16384], calloc)}; + let mut hc_buffer = unsafe {define_allocator_memory_pool!(4, HuffmanCode, [0; 1024 * 1024 * 16], calloc)}; + let mut alloc_u8 = CallocAllocatedFreelist::<u8>::new_allocator(u8_buffer.data, bzero); + let alloc_u32 = CallocAllocatedFreelist::<u32>::new_allocator(u32_buffer.data, bzero); + let alloc_hc = CallocAllocatedFreelist::<HuffmanCode>::new_allocator(hc_buffer.data, bzero); + let ret = unsafe{prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT)}; + if ret != 0 { + panic!("Unable to activate seccomp"); + } + match brotli_decompressor::BrotliDecompressCustomIo(&mut IoReaderWrapper::<InputType>(r), + &mut IoWriterWrapper::<OutputType>(w), + &mut alloc_u8.alloc_cell(buffer_size).slice_mut(), + &mut alloc_u8.alloc_cell(buffer_size).slice_mut(), + alloc_u8, + alloc_u32, + alloc_hc, + Error::new(ErrorKind::UnexpectedEof, "Unexpected EOF")) { + Err(e) => Err(e), + Ok(()) => { + unsafe{syscall(60);}; + unreachable!() + }, + } +} + + + + + +// This decompressor is defined unconditionally on whether std is defined +// so we can exercise the code in any case +pub struct BrotliDecompressor<R: Read>(brotli_decompressor::DecompressorCustomIo<io::Error, + IntoIoReader<R>, + Rebox<u8>, + HeapAllocator<u8>, + HeapAllocator<u32>, + HeapAllocator<HuffmanCode>>); + + + +impl<R: Read> BrotliDecompressor<R> { + pub fn new(r: R, buffer_size: usize) -> Self { + let mut alloc_u8 = HeapAllocator::<u8> { default_value: 0 }; + let buffer = alloc_u8.alloc_cell(buffer_size); + let alloc_u32 = HeapAllocator::<u32> { default_value: 0 }; + let alloc_hc = HeapAllocator::<HuffmanCode> { default_value: HuffmanCode::default() }; + BrotliDecompressor::<R>( + brotli_decompressor::DecompressorCustomIo::<Error, + IntoIoReader<R>, + Rebox<u8>, + HeapAllocator<u8>, HeapAllocator<u32>, HeapAllocator<HuffmanCode> > + ::new(IntoIoReader::<R>(r), + buffer, + alloc_u8, alloc_u32, alloc_hc, + io::Error::new(ErrorKind::InvalidData, + "Invalid Data"))) + } +} + +impl<R: Read> Read for BrotliDecompressor<R> { + fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> { + self.0.read(buf) + } +} + +#[cfg(test)] +fn writeln0<OutputType: Write>(strm: &mut OutputType, + data: &str) + -> core::result::Result<(), io::Error> { + writeln!(strm, "{:}", data) +} +#[cfg(test)] +fn writeln_time<OutputType: Write>(strm: &mut OutputType, + data: &str, + v0: u64, + v1: u64, + v2: u32) + -> core::result::Result<(), io::Error> { + writeln!(strm, "{:} {:} {:}.{:09}", v0, data, v1, v2) +} + +fn main() { + let mut dictionary = Vec::<u8>::new(); + let mut double_dash = false; + let mut input: Option<File> = None; + let mut output: Option<File> = None; + for argument in env::args().skip(1) { + if argument == "--" { + double_dash = true; + continue; + } + if argument.starts_with("-dict=") && !double_dash { + let mut dict_file = File::open(&Path::new(&argument[6..])).unwrap(); + dict_file.read_to_end(&mut dictionary).unwrap(); + continue; + } + if input.is_none() { + input = Some(File::open(&Path::new(&argument)).unwrap()); + } else if output.is_none() { + output = Some(File::create(&Path::new(&argument)).unwrap()); + } else { + panic!("Cannot specify more than 2 filename args (input, output)") + } + } + if input.is_none() { + decompress(&mut io::stdin(), &mut io::stdout(), 65536, dictionary).unwrap(); + } else { + if output.is_none() { + decompress(&mut input.unwrap(), &mut io::stdout(), 65536, dictionary).unwrap(); + } else { + decompress(&mut input.unwrap(), &mut output.unwrap(), 65536, dictionary).unwrap(); + } + } +} diff --git a/rust/vendor/brotli-decompressor/src/bin/error_handling_tests.rs b/rust/vendor/brotli-decompressor/src/bin/error_handling_tests.rs new file mode 100644 index 0000000..543e6c1 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/error_handling_tests.rs @@ -0,0 +1,167 @@ +#![cfg(test)] +#![cfg(feature="std")] +use std::io::{self, Read, Cursor}; + +extern crate brotli_decompressor; + +static ENCODED: &'static [u8] = b"\x1b\x03)\x00\xa4\xcc\xde\xe2\xb3 vA\x00\x0c"; + +enum State { First, Second, Third, Fourth } +struct R(State); +impl Read for R { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + match self.0 { + State::First => { + buf[0] = ENCODED[0]; + self.0 = State::Second; + return Ok(1); + } + State::Second => { + self.0 = State::Third; + return Err(io::Error::new(io::ErrorKind::WouldBlock, "foo")); + } + State::Third => { + self.0 = State::Fourth; + buf[..ENCODED.len() - 1].copy_from_slice(&ENCODED[1..]); + return Ok(ENCODED[1..].len()); + } + State::Fourth => { + return Ok(0); + } + } + } +} +#[test] +fn test_would_block() { + + let mut d = brotli_decompressor::Decompressor::new(R(State::First), 8192); + let mut b = [0; 8192]; + assert_eq!(d.read(&mut b).unwrap_err().kind(), io::ErrorKind::WouldBlock); + assert!(d.read(&mut b).unwrap() != 0); + println!("{}", String::from_utf8(b.to_vec()).unwrap()); + assert!(d.read(&mut b).unwrap() != 0); + assert_eq!(d.read(&mut b).unwrap(), 0); +} + +static ENCODED2: &'static [u8] = include_bytes!("ipsum.brotli"); +static DECODED: &'static str = include_str!("ipsum.raw"); + +enum State2 { + First, + Second, + Third, + Fourth, + Fifth, + Sixth, + Seventh, + Eighth, +} + +struct R2 { + offset: usize, + len: usize, + state: State2, +} + +impl R2 { + fn new() -> R2 { + R2 { + offset: 0, + len: 1, + state: State2::First, + } + } +} +impl Read for R2 { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + match self.state { + State2::First => { + self.state = State2::Second; + let len = self.len; + buf[..len].copy_from_slice(&ENCODED2[self.offset..self.offset+len]); + self.offset += len; + self.len = 100; + return Ok(len); + } + State2::Second => { + self.state = State2::Third; + return Err(io::Error::new(io::ErrorKind::WouldBlock, "foo")); + } + State2::Third => { + self.state = State2::Fourth; + let len = self.len; + buf[..len].copy_from_slice(&ENCODED2[self.offset..self.offset+len]); + self.offset += len; + self.len = 100; + return Ok(len); + } + State2::Fourth => { + self.state = State2::Fifth; + return Err(io::Error::new(io::ErrorKind::WouldBlock, "foo")); + } + State2::Fifth => { + self.state = State2::Sixth; + let len = self.len; + buf[..len].copy_from_slice(&ENCODED2[self.offset..self.offset+len]); + self.offset += len; + self.len = 100; + return Ok(len); + } + State2::Sixth => { + self.state = State2::Seventh; + return Err(io::Error::new(io::ErrorKind::WouldBlock, "foo")); + } + State2::Seventh => { + self.state = State2::Eighth; + buf[..ENCODED2.len() - self.offset].copy_from_slice(&ENCODED2[self.offset..]); + return Ok(ENCODED2.len() - self.offset); + } + State2::Eighth => { + return Ok(0); + } + } + } +} + +#[test] +fn would_block_more() { + // Reference synchronous decoding. + let mut b = [0; 8192]; + let mut bytes = vec![]; + let mut d = brotli_decompressor::Decompressor::new(Cursor::new(ENCODED2), 8192); + let read = d.read(&mut b).unwrap(); + assert!(read != 0); + bytes.extend_from_slice(&b[0..read]); + + assert_eq!(d.read(&mut b).unwrap(), 0); + let reference_decoded = String::from_utf8(bytes).unwrap(); + // Ensure synchronous decoding matches original input. + assert_eq!(reference_decoded, DECODED); + + // Incremental decoding. + let r = R2::new(); + let mut d = brotli_decompressor::Decompressor::new(r, 8192); + let mut bytes = vec![]; + let mut b = [0; 8192]; + + assert_eq!(d.read(&mut b).unwrap_err().kind(), io::ErrorKind::WouldBlock); + + assert_eq!(d.read(&mut b).unwrap_err().kind(), io::ErrorKind::WouldBlock); + + let read = d.read(&mut b).unwrap(); + assert!(read != 0); + bytes.extend_from_slice(&b[0..read]); + + assert_eq!(d.read(&mut b).unwrap_err().kind(), io::ErrorKind::WouldBlock); + + let read = d.read(&mut b).unwrap(); + assert!(read != 0); + bytes.extend_from_slice(&b[0..read]); + + assert_eq!(d.read(&mut b).unwrap(), 0); + + let decoded = String::from_utf8(bytes).unwrap(); + + // Ensure incremental decoding matches original input after brotli decompressor is finished. + assert_eq!(decoded, reference_decoded); +} diff --git a/rust/vendor/brotli-decompressor/src/bin/integration_tests.rs b/rust/vendor/brotli-decompressor/src/bin/integration_tests.rs new file mode 100644 index 0000000..6de8e7b --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/integration_tests.rs @@ -0,0 +1,1006 @@ +#![cfg(test)] +extern crate core; +use std::io; +#[cfg(feature="std")] +use std::io::{Read,Write}; +use core::cmp; +use super::brotli_decompressor::BrotliResult; +use super::brotli_decompressor::BrotliDecompressStream; +#[cfg(feature="std")] +use super::brotli_decompressor::{Decompressor, DecompressorWriter}; +use super::brotli_decompressor::BrotliState; +use super::brotli_decompressor::HuffmanCode; +use super::HeapAllocator; + +#[allow(unused_imports)] +use super::alloc_no_stdlib::{Allocator, SliceWrapper, SliceWrapperMut}; +use std::time::Duration; +#[cfg(not(feature="disable-timer"))] +use std::time::SystemTime; + +struct Buffer { + data: Vec<u8>, + read_offset: usize, +} +#[cfg(feature="std")] +struct UnlimitedBuffer { + data: Vec<u8>, + read_offset: usize, +} + +#[cfg(feature="std")] +impl UnlimitedBuffer { + pub fn new(buf: &[u8]) -> Self { + let mut ret = UnlimitedBuffer { + data: Vec::<u8>::new(), + read_offset: 0, + }; + ret.data.extend(buf); + return ret; + } +} + +#[cfg(feature="std")] +impl io::Read for UnlimitedBuffer { + fn read(self: &mut Self, buf: &mut [u8]) -> io::Result<usize> { + let bytes_to_read = cmp::min(buf.len(), self.data.len() - self.read_offset); + if bytes_to_read > 0 { + buf[0..bytes_to_read].clone_from_slice(&self.data[self.read_offset.. + self.read_offset + bytes_to_read]); + } + self.read_offset += bytes_to_read; + return Ok(bytes_to_read); + } +} + +#[cfg(feature="std")] +impl io::Write for UnlimitedBuffer { + fn write(self: &mut Self, buf: &[u8]) -> io::Result<usize> { + self.data.extend(buf); + return Ok(buf.len()); + } + fn flush(self: &mut Self) -> io::Result<()> { + return Ok(()); + } +} + + +#[cfg(feature="disable-timer")] +fn now() -> Duration { + return Duration::new(0, 0); +} +#[cfg(not(feature="disable-timer"))] +fn now() -> SystemTime { + return SystemTime::now(); +} + +#[cfg(not(feature="disable-timer"))] +fn elapsed(start: SystemTime) -> (Duration, bool) { + match start.elapsed() { + Ok(delta) => return (delta, false), + _ => return (Duration::new(0, 0), true), + } +} + +#[cfg(feature="disable-timer")] +fn elapsed(_start: Duration) -> (Duration, bool) { + return (Duration::new(0, 0), true); +} + + +fn _write_all<OutputType>(w: &mut OutputType, buf: &[u8]) -> Result<(), io::Error> + where OutputType: io::Write +{ + let mut total_written: usize = 0; + while total_written < buf.len() { + match w.write(&buf[total_written..]) { + Err(e) => { + match e.kind() { + io::ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_written) => { + if cur_written == 0 { + return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Write EOF")); + } + total_written += cur_written; + } + } + } + Ok(()) +} + + +#[cfg(feature="benchmark")] +const NUM_BENCHMARK_ITERATIONS: usize = 1000; +#[cfg(not(feature="benchmark"))] +const NUM_BENCHMARK_ITERATIONS: usize = 2; + +// option_env!("BENCHMARK_MODE").is_some() + +pub fn decompress_internal<InputType, OutputType>(r: &mut InputType, + mut w: &mut OutputType, + input_buffer_limit: usize, + output_buffer_limit: usize, + benchmark_mode: bool) + -> Result<(), io::Error> + where InputType: io::Read, + OutputType: io::Write +{ + let mut total = Duration::new(0, 0); + let range: usize; + let mut timing_error: bool = false; + if benchmark_mode { + range = NUM_BENCHMARK_ITERATIONS; + } else { + range = 1; + } + for _i in 0..range { + let mut brotli_state = + BrotliState::new(HeapAllocator::<u8> { default_value: 0 }, + HeapAllocator::<u32> { default_value: 0 }, + HeapAllocator::<HuffmanCode> { default_value: HuffmanCode::default() }); + let mut input = brotli_state.alloc_u8.alloc_cell(input_buffer_limit); + let mut output = brotli_state.alloc_u8.alloc_cell(output_buffer_limit); + let mut available_out: usize = output.slice().len(); + + // let amount = try!(r.read(&mut buf)); + let mut available_in: usize = 0; + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut result: BrotliResult = BrotliResult::NeedsMoreInput; + loop { + match result { + BrotliResult::NeedsMoreInput => { + input_offset = 0; + match r.read(input.slice_mut()) { + Err(e) => { + match e.kind() { + io::ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(size) => { + if size == 0 { + return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Read EOF")); + } + available_in = size; + } + } + } + BrotliResult::NeedsMoreOutput => { + if let Err(e) = _write_all(&mut w, &output.slice()[..output_offset]) { + return Err(e) + } + output_offset = 0; + } + BrotliResult::ResultSuccess => break, + BrotliResult::ResultFailure => panic!("FAILURE"), + } + let mut written: usize = 0; + let start = now(); + result = BrotliDecompressStream(&mut available_in, + &mut input_offset, + &input.slice(), + &mut available_out, + &mut output_offset, + &mut output.slice_mut(), + &mut written, + &mut brotli_state); + + let (delta, err) = elapsed(start); + if err { + timing_error = true; + } + total = total + delta; + if output_offset != 0 { + if let Err(e) = _write_all(&mut w, &output.slice()[..output_offset]) { + return Err(e) + } + output_offset = 0; + available_out = output.slice().len() + } + } + } + if timing_error { + let _r = super::writeln0(&mut io::stderr(), "Timing error"); + } else { + let _r = super::writeln_time(&mut io::stderr(), + "Iterations; Time", + range as u64, + total.as_secs(), + total.subsec_nanos()); + } + Ok(()) +} + +impl Buffer { + pub fn new(buf: &[u8]) -> Buffer { + let mut ret = Buffer { + data: Vec::<u8>::new(), + read_offset: 0, + }; + ret.data.extend(buf); + return ret; + } +} +impl io::Read for Buffer { + fn read(self: &mut Self, buf: &mut [u8]) -> io::Result<usize> { + if self.read_offset == self.data.len() { + self.read_offset = 0; + } + let bytes_to_read = cmp::min(buf.len(), self.data.len() - self.read_offset); + if bytes_to_read > 0 { + buf[0..bytes_to_read] + .clone_from_slice(&self.data[self.read_offset..self.read_offset + bytes_to_read]); + } + self.read_offset += bytes_to_read; + return Ok(bytes_to_read); + } +} +impl io::Write for Buffer { + fn write(self: &mut Self, buf: &[u8]) -> io::Result<usize> { + if self.read_offset == self.data.len() { + return Ok(buf.len()); + } + self.data.extend(buf); + return Ok(buf.len()); + } + fn flush(self: &mut Self) -> io::Result<()> { + return Ok(()); + } +} +#[test] +fn test_10x_10y() { + let in_buf: [u8; 12] = [0x1b, 0x13, 0x00, 0x00, 0xa4, 0xb0, 0xb2, 0xea, 0x81, 0x47, 0x02, 0x8a]; + let mut input = Buffer::new(&in_buf); + let mut output = Buffer::new(&[]); + output.read_offset = 20; + match super::decompress(&mut input, &mut output, 65536, Vec::new()) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + let mut i: usize = 0; + while i < 10 { + assert_eq!(output.data[i], 'X' as u8); + assert_eq!(output.data[i + 10], 'Y' as u8); + i += 1; + } + assert_eq!(output.data.len(), 20); + assert_eq!(input.read_offset, in_buf.len()); +} + +#[test] +fn test_10x_10y_one_out_byte() { + let in_buf: [u8; 12] = [0x1b, 0x13, 0x00, 0x00, 0xa4, 0xb0, 0xb2, 0xea, 0x81, 0x47, 0x02, 0x8a]; + let mut input = Buffer::new(&in_buf); + let mut output = Buffer::new(&[]); + output.read_offset = 20; + match decompress_internal(&mut input, &mut output, 12, 1, false) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + let mut i: usize = 0; + while i < 10 { + assert_eq!(output.data[i], 'X' as u8); + assert_eq!(output.data[i + 10], 'Y' as u8); + i += 1; + } + assert_eq!(output.data.len(), 20); + assert_eq!(input.read_offset, in_buf.len()); +} +#[cfg(feature="std")] +fn reader_helper(in_buf: &[u8], mut desired_buf: &[u8], bufsize : usize) { + let mut cmp = [0u8; 178]; + let mut input = UnlimitedBuffer::new(&in_buf); + { + let mut rdec = Decompressor::new(&mut input, bufsize); + loop { + match rdec.read(&mut cmp[..]) { + Ok(size) => { + if size == 0 { + break; + } + assert_eq!(cmp[..size], desired_buf[..size]); + desired_buf = &desired_buf[size..]; + } + Err(e) => panic!("Error {:?}", e), + } + } + } + assert_eq!(desired_buf.len(), 0); +} + +#[test] +#[cfg(feature="std")] +fn test_reader_64x() { + reader_helper(include_bytes!("../../testdata/64x.compressed"), + include_bytes!("../../testdata/64x"), 181) + +} + +#[test] +#[cfg(feature="std")] +fn test_streaming_leftover_buffer() { + reader_helper(include_bytes!("../../testdata/reducetostream.map.compressed"), + include_bytes!("../../testdata/reducetostream.map"), 8192) +} + +#[test] +#[cfg(feature="std")] +fn test_reader_uni() { + reader_helper(include_bytes!("../../testdata/random_then_unicode.compressed"), + include_bytes!("../../testdata/random_then_unicode"), 121) + +} + + +#[cfg(feature="std")] +fn writer_helper(mut in_buf: &[u8], desired_out_buf: &[u8], buf_size: usize) { + let output = UnlimitedBuffer::new(&[]); + + {let mut wdec = DecompressorWriter::new(output, 517); + while in_buf.len() > 0 { + match wdec.write(&in_buf[..cmp::min(in_buf.len(), buf_size)]) { + Ok(size) => { + if size == 0 { + break; + } + in_buf = &in_buf[size..]; + } + Err(e) => panic!("Error {:?}", e), + } + } + let ub = match wdec.into_inner() { + Ok(w) => w, + Err(_) => panic!("error with into_inner"), + }; + assert_eq!(ub.data.len(), desired_out_buf.len()); + for i in 0..cmp::min(desired_out_buf.len(), ub.data.len()) { + assert_eq!(ub.data[i], desired_out_buf[i]); + } + + } +} + +#[cfg(feature="std")] +fn writer_early_out_helper(in_buf: &[u8], desired_out_buf: &[u8], buf_size: usize, ibuf: usize) { + let output = UnlimitedBuffer::new(&[]); + + {let mut wdec = DecompressorWriter::new(output, ibuf); + if in_buf.len() > 0 { + match wdec.write(&in_buf[..cmp::min(in_buf.len(), buf_size)]) { + Ok(_size) => { + } + Err(e) => panic!("Error {:?}", e), + } + } + match wdec.into_inner() { + Err(ub) => { + assert!(ub.data.len() != 0); + for i in 0..cmp::min(desired_out_buf.len(), ub.data.len()) { + assert_eq!(ub.data[i], desired_out_buf[i]); + } + }, + Ok(_) => panic!("unreachable"), + } + } +} + +#[test] +#[cfg(feature="std")] +fn test_writer_64x() { + writer_helper(include_bytes!("../../testdata/64x.compressed"), + include_bytes!("../../testdata/64x"), 1) + +} + + + +#[test] +#[cfg(feature="std")] +fn test_writer_mapsdatazrh() { + writer_helper(include_bytes!("../../testdata/mapsdatazrh.compressed"), + include_bytes!("../../testdata/mapsdatazrh"), 512) + +} + +#[test] +#[cfg(feature="std")] +fn test_writer_mapsdatazrh_truncated() { + writer_early_out_helper(include_bytes!("../../testdata/mapsdatazrh.compressed"), + include_bytes!("../../testdata/mapsdatazrh"), 65536, 65536) + +} + + +#[test] +fn test_10x_10y_byte_by_byte() { + let in_buf: [u8; 12] = [0x1b, 0x13, 0x00, 0x00, 0xa4, 0xb0, 0xb2, 0xea, 0x81, 0x47, 0x02, 0x8a]; + let mut input = Buffer::new(&in_buf); + let mut output = Buffer::new(&[]); + output.read_offset = 20; + match decompress_internal(&mut input, &mut output, 1, 1, false) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + let mut i: usize = 0; + while i < 10 { + assert_eq!(output.data[i], 'X' as u8); + assert_eq!(output.data[i + 10], 'Y' as u8); + i += 1; + } + assert_eq!(output.data.len(), 20); + assert_eq!(input.read_offset, in_buf.len()); +} + + +fn assert_decompressed_input_matches_output(input_slice: &[u8], + output_slice: &[u8], + input_buffer_size: usize, + output_buffer_size: usize) { + let mut input = Buffer::new(input_slice); + let mut output = Buffer::new(&[]); + output.read_offset = output_slice.len(); + if input_buffer_size == output_buffer_size { + match super::decompress(&mut input, &mut output, input_buffer_size, Vec::new()) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + } else { + match decompress_internal(&mut input, + &mut output, + input_buffer_size, + output_buffer_size, + false) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + } + assert_eq!(output.data.len(), output_slice.len()); + assert_eq!(output.data, output_slice) +} + +fn assert_huge_file_input_matches_output(input_slice: &[u8], + output_prefix: &[u8], + output_postfix: &[u8], + size: usize, + rep_gap: usize, + input_buffer_size: usize, + output_buffer_size: usize) { + let mut input = Buffer::new(input_slice); + let mut output = Buffer::new(&[]); + output.read_offset = size; + if input_buffer_size == output_buffer_size { + match super::decompress(&mut input, &mut output, input_buffer_size, Vec::new()) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + } else { + match decompress_internal(&mut input, + &mut output, + input_buffer_size, + output_buffer_size, + false) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + } + assert_eq!(output.data.len(), size); + assert_eq!(output.data.split_at(output_prefix.len()).0, output_prefix); + assert_eq!(output.data.split_at(output.data.len() - output_postfix.len()).1, output_postfix); + assert_eq!(output.data.split_at(output_prefix.len() + rep_gap).1.split_at(output_prefix.len()).0, output_prefix); + let mut zero_count: usize = 0; + for item in output.data { + if item == 0 { + zero_count += 1; + } + } + let mut nulls_in_input: usize = 0; + for item in output_prefix.iter().chain(output_prefix.iter().chain(output_postfix.iter())) { + if *item == 0 { + nulls_in_input += 1; + } + } + assert_eq!(zero_count - nulls_in_input, size - output_prefix.len() * 2 - output_postfix.len()); +} + +fn benchmark_decompressed_input(input_slice: &[u8], + output_slice: &[u8], + input_buffer_size: usize, + output_buffer_size: usize) { + let mut input = Buffer::new(input_slice); + let mut output = Buffer::new(&[]); + output.read_offset = output_slice.len(); + match decompress_internal(&mut input, + &mut output, + input_buffer_size, + output_buffer_size, + true) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + assert_eq!(output.data.len(), output_slice.len()); + assert_eq!(output.data, output_slice) +} + +#[test] +fn test_64x() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/64x.compressed"), + include_bytes!("../../testdata/64x"), + 3, + 3); +} + +#[test] +fn test_random1024() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/random1024.br"), + include_bytes!("../../testdata/random1024"), + 65536, + 65536); +} +#[test] +fn test_random1024small_buffer() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/random1024.br"), + include_bytes!("../../testdata/random1024"), + 1024, + 1024); +} + +#[test] +fn test_as_you_like_it() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/asyoulik.txt.compressed"), + include_bytes!("../../testdata/asyoulik.txt"), + 65536, + 65536); +} + + +#[test] +#[should_panic] +fn test_negative_hypothesis() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/64x"), + include_bytes!("../../testdata/64x"), + 3, + 3); +} +static ALICE29_BR: &'static [u8] = include_bytes!("../../testdata/alice29.txt.compressed"); +static ALICE29: &'static [u8] = include_bytes!("../../testdata/alice29.txt"); +#[test] +fn test_alice29() { + assert_decompressed_input_matches_output(ALICE29_BR, ALICE29, 65536, 65536); +} + +#[test] +fn benchmark_alice29() { + benchmark_decompressed_input(ALICE29_BR, ALICE29, 65536, 65536); +} + +#[test] +fn test_alice1() { + assert_decompressed_input_matches_output(ALICE29_BR, ALICE29, 1, 65536); +} + +#[test] +fn test_backward65536() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/backward65536.compressed"), + include_bytes!("../../testdata/backward65536"), + 65536, + 65536); +} + + +#[test] +fn test_compressed_file() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/compressed_file.compressed"), + include_bytes!("../../testdata/compressed_file"), + 65536, + 65536); +} + +#[test] +fn test_compressed_repeated() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/compressed_repeated.\ + compressed"), + include_bytes!("../../testdata/compressed_repeated"), + 65536, + 65536); +} + +#[test] +fn test_empty() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty0() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.00"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.01"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty2() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.02"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty3() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.03"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty4() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.04"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty5() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.05"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty6() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.06"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty7() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.07"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty8() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.08"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty9() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.09"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty10() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.10"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty11() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.11"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty12() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.12"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty13() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.13"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty14() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.14"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty15() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.15"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty16() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.16"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty17() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.17"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} +#[test] +fn test_empty18() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/empty.compressed.18"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} + +#[test] +fn lcet10() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/lcet10.txt.compressed"), + include_bytes!("../../testdata/lcet10.txt"), + 65536, + 65536); +} + +#[test] +fn test_mapsdatazrh() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/mapsdatazrh.compressed"), + include_bytes!("../../testdata/mapsdatazrh"), + 65536, + 65536); +} + +#[test] +fn test_monkey() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/monkey.compressed"), + include_bytes!("../../testdata/monkey"), + 65536, + 65536); +} + +#[test] +fn test_monkey1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/monkey.compressed"), + include_bytes!("../../testdata/monkey"), + 1, + 1); +} + +#[test] +fn test_monkey3() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/monkey.compressed"), + include_bytes!("../../testdata/monkey"), + 3, + 65536); +} + +#[test] +fn test_plrabn12() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/plrabn12.txt.compressed"), + include_bytes!("../../testdata/plrabn12.txt"), + 65536, + 65536); +} + +#[test] +fn test_random_org_10k() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/random_org_10k.bin.\ + compressed"), + include_bytes!("../../testdata/random_org_10k.bin"), + 65536, + 65536); +} + +#[test] +fn test_ukkonooa() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/ukkonooa.compressed"), + include_bytes!("../../testdata/ukkonooa"), + 65536, + 65536); +} + +#[test] +fn test_ukkonooa3() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/ukkonooa.compressed"), + include_bytes!("../../testdata/ukkonooa"), + 3, + 3); +} + +#[test] +fn test_ukkonooa1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/ukkonooa.compressed"), + include_bytes!("../../testdata/ukkonooa"), + 1, + 1); +} + +#[test] +fn test_x() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/x.compressed"), + include_bytes!("../../testdata/x"), + 65536, + 65536); +} +#[test] +fn test_x_0() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/x.compressed.00"), + include_bytes!("../../testdata/x"), + 65536, + 65536); +} +#[test] +fn test_x_1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/x.compressed.01"), + include_bytes!("../../testdata/x"), + 65536, + 65536); +} +#[test] +fn test_x_2() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/x.compressed.02"), + include_bytes!("../../testdata/x"), + 65536, + 65536); +} +#[test] +fn test_x_3() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/x.compressed.03"), + include_bytes!("../../testdata/x"), + 65536, + 65536); +} + +#[test] +fn test_xyzzy() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/xyzzy.compressed"), + include_bytes!("../../testdata/xyzzy"), + 65536, + 65536); +} + +#[test] +fn test_zeros() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/zeros.compressed"), + include_bytes!("../../testdata/zeros"), + 65536, + 65536); +} + + +#[test] +fn test_metablock_reset() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/metablock_reset.compressed"), + include_bytes!("../../testdata/metablock_reset"), + 65536, + 65536); +} + +#[test] +fn test_metablock_section_4_distance_symbol_0() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/fuzz502.compressed"), + include_bytes!("../../testdata/fuzz502"), + 65536, + 65536); +} + +#[test] +fn test_intact_distance_ring_buffer0() { + static BR:&'static[u8] = &[0x1b, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe3, 0xb4, 0x0d, 0x00, 0x00, + 0x07, 0x5b, 0x26, 0x31, 0x40, 0x02, 0x00, 0xe0, 0x4e, 0x1b, 0xa1, 0x80, + 0x20, 0x00]; + static OUT:&'static[u8] = b"himselfself"; + assert_decompressed_input_matches_output(BR, + OUT, + 65536, + 65536); +} + +#[test] +fn test_intact_distance_ring_buffer1() { + static BR:&'static[u8] = &[0x1b, 0x09, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe3, 0xb4, 0x0d, 0x00, 0x00, + 0x07, 0x5b, 0x26, 0x31, 0x40, 0x02, 0x00, 0xe0, 0x4e, 0x1b, 0x21, 0xa0, + 0x20, 0x00 + ]; + static OUT:&'static[u8] = b"scrollroll"; + assert_decompressed_input_matches_output(BR, + OUT, + 65536, + 65536); +} + +#[test] +fn test_intact_distance_ring_buffer2() { + static BR:&'static[u8] = &[0x1b, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe3, 0xb4, 0x0d, 0x00, 0x00, + 0x07, 0x5b, 0x26, 0x31, 0x40, 0x02, 0x00, 0xe0, 0x4e, 0x1b, 0x41, 0x80, + 0x20, 0x50, 0x10, 0x24, 0x08, 0x06]; + static OUT:&'static[u8] = b"leftdatadataleft"; + assert_decompressed_input_matches_output(BR, + OUT, + 65536, + 65536); +} + +#[test] +fn test_metablock_reset1_65536() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/metablock_reset.compressed"), + include_bytes!("../../testdata/metablock_reset"), + 1, + 65536); +} + +#[test] +fn test_metablock_reset65536_1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/metablock_reset.compressed"), + include_bytes!("../../testdata/metablock_reset"), + 65536, + 1); +} + +#[test] +fn test_metablock_reset1() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/metablock_reset.compressed"), + include_bytes!("../../testdata/metablock_reset"), + 1, + 1); +} + +#[test] +fn test_metablock_reset3() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/metablock_reset.compressed"), + include_bytes!("../../testdata/metablock_reset"), + 3, + 3); +} + +#[test] +#[should_panic] +fn test_broken_file() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/borked.compressed"), + include_bytes!("../../testdata/empty"), + 65536, + 65536); +} + +#[test] +fn test_ends_with_truncated_dictionary() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/ends_with_truncated_dictionary.\ + compressed"), + include_bytes!("../../testdata/ends_with_truncated_dictionary"), + 65536, + 65536); +} + +#[test] +fn test_random_then_unicode() { + assert_decompressed_input_matches_output(include_bytes!("../../testdata/random_then_unicode.\ + compressed"), + include_bytes!("../../testdata/random_then_unicode"), + 65536, + 65536); +} +#[test] +fn test_large_window() { + assert_huge_file_input_matches_output(include_bytes!("../../testdata/rnd_chunk.br"), + include_bytes!("../../testdata/rnd_prefix"), + include_bytes!("../../testdata/rnd_postfix"), + 100011280, + 100000000, + 1, + 16384); +} diff --git a/rust/vendor/brotli-decompressor/src/bin/ipsum.brotli b/rust/vendor/brotli-decompressor/src/bin/ipsum.brotli new file mode 100644 index 0000000..7f5d229 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/ipsum.brotli @@ -0,0 +1,6 @@ +™ ,lw•tÒæò(Í'5Mg×É)uGôPŒ;’_(±@L$¢ÈJí¬«d_û¾Ë«]VTu¼áÖT
«j½à²×y‰ ý8ŸÏøöæ„Ta<ïÏÎÌ•¤ÿ;ÊOée—z/êp Ù¶©V1 +ÐàFhؽÒÜB@íú¾ê±V¡çIÕúTV ¤Ú†G>R„ s/˜Öú#ª_õ·-ød™€‡OÛ¡¾©Ãû¯!Äf#oaÄÿY?óü{æ BæÝæ(\_S ýÉ4 MOš0uý ×z äl'yƒ¼Cb¿sãÌñ‚—yÉn“Î>=·i‘ÄãÎek_þýzQú/çÝfkE²ööÝo¾SOc½Ë{Ve / Y¬¯‡ZÇðÙÚôŽ%õQc¹[KÒá†k„k øè,2E}RTÕËàlv¸~ÀBl’`ñ²Íü3ºñåmÂmIÀ>D3e\]ûôG ù,¦¸ÿ@”7IѼ (Þ8£ØŽ`Ö ‚‡ú"ÛqzLŠ{²ïwŒ^ÍSœ&K Ǫj 0 9®z +R6v™j/^ù»ˆWB®—Â*íM€a]ÌÁ{ø½,=ßæcš¾ +OŠ™Ñ?üˆÄ\(¤\ö!}ýí·+äÿúëhköR@h9jýŽv›‰l¾þ8S ì·gNkÌšŸRíÅFv/FÀï)B1u6züÖš;aú$–×—õ16ûÝZè;ß=€Sí-óµ$12CNmÃ+KQ—¯eôi‘‹Nq=-h‚ží>B±ü,»Uá Éƽµ*ÈÅÄlí\_õjÿ0s¾vðd lØ Àåg˜(P‡»%.Œð~8ÜFŽ³Ø>Æ ûÄ_ÃÎ…ísšRóÜæIÇ`FB?UÚÏ ¸r,¢›Ó $aGüåÕ…éÊ ñö@[Cé:íµT–ÊŠ±X¾aV pØkºmäò*ëo æÿ_€…/åT„oÞƬ–5§§]ì^¿Xd ØiL¬g²Çñ¥Ð;×e‡.€zàÑœVô ;þƒ žÁö½Ë—âxa] îZôb <Þ«3ìàKþÚCá ÷³&?®¦u›uaqÍïIÆzNOñÊ:Åßk\–Å:<pnba'‰N~Úâ5*ÐiâDZô-Ä™O91ÉÕr9^8ÊP Σ^ÎL)‡ ÖC ˜Vl`פÁ"ŒúÊ„ÎA«Rn?p´ÛC˜ô¡zˆCJ¶#i&Tä¸÷hh¤TëDt2ÿ&O)ª»™˜ÀÇÚàSÜú´p“g QµL rLÚ`G¡ Gtœi½X9ev^¨›Ö<˜ÊdÕ’ÈÀÀæMË3¬¦WZ=~Þ «@=#r¸] &ì°ž:_ò$åb¾yi Æ>•S™'ɦo×~w˼~ÑXE6—
a ØËÔjB¨ž ¼òË3`Y"ô¾˜Ë¤S— Í p„p¢Žj? +–m Û`Ô&\b§9ÚËȃíïwŸñoF«}`îµ4ïÌŸÁìþ–B§”^ÄPº,eb.-8 ŠÓUqÃSˆZ"+J“ÔÆÝeÞŠu"lÆ(äÁ÷c îé)xF"¯K/W ܹ½¥CYQðäF¥Oì²q>N-ÿú8»sÄ|Í;,Çì'£ú¹ÙQ%ö„qç*VQ£»È‰·gçtáçµÀ8åv¡ {Œ› x#ùÅËôy¹^ ºÅ2¸p‘‹c,š§úª“VÅ>àåX>H™¦X›ú¾ÍýäŠn¡8 gcƒ ¶RLIz[ €£Åì‡çñŠ®´ê™2¢wäS×éPqýœÖkö¥`™}É›5èâÏŸ›mÃå<Ÿ5m¡¤µñ‡õ}2yteVö®Ôîc Úq@(ÖB¨Rî"vóîf·±ŠŒu|J° ¾á
gÃdâ±2¯£T©çóVúli‘ȳài@"WÉ|Êûáx¨äØu4%Ä_ûéù0fIo› ˜©Õ‰Œ«>¯H¢‘eVeêp«¥í¹f€Æ0À‹ ìÓ²Ælä4TAs3Ĭ¬ aNË·Ù¾Gˆ›˜R°Tp¨™†Õ_Iθ’'YïVÂ87Û+ýÒD÷„ìÔ5RO¡9<2¹ KöGŽÆS +
*h±ÑpÝ\©Ðy G•³Dº¡6°Ñ˜E‡l.JèêA´Yr@d!»‘ñŠÀÍKùºck¨F™)Ÿå¯Î#}ITF1T«à*>¾A{>¬êkê•ùBw 4ì¬Üè¬ä¶vÍ‘•
\ No newline at end of file diff --git a/rust/vendor/brotli-decompressor/src/bin/ipsum.raw b/rust/vendor/brotli-decompressor/src/bin/ipsum.raw new file mode 100644 index 0000000..8b9062f --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/ipsum.raw @@ -0,0 +1,19 @@ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut viverra neque in massa rutrum, non rutrum nunc pellentesque. Phasellus et nulla metus. Nam aliquet felis nec iaculis eleifend. Donec pretium tellus non aliquam tristique. Mauris feugiat eu velit sed maximus. Praesent fringilla lorem vel orci maximus accumsan. Fusce vel sapien ipsum. Nulla ac lectus non arcu semper laoreet. + +Aliquam et massa at ex elementum dictum vitae ac purus. Sed a nunc sed dui pulvinar mollis eu sed eros. Mauris vitae ullamcorper dolor. Ut sed nisl sem. Mauris pulvinar vitae orci nec tincidunt. Integer fringilla quam in lobortis vehicula. In aliquam egestas dapibus. Suspendisse est enim, maximus non massa eget, finibus finibus lorem. Phasellus a varius ante. Pellentesque tempor dignissim nunc ut malesuada. + +Ut rutrum massa vitae pellentesque lobortis. Vivamus gravida cursus venenatis. Sed metus lorem, commodo vitae pulvinar sagittis, scelerisque quis orci. Vivamus viverra lorem nibh, quis commodo orci luctus pulvinar. Morbi aliquam urna sed magna luctus, quis vulputate tellus pulvinar. Mauris congue velit sed volutpat sodales. Aenean faucibus sapien erat, ac vestibulum leo aliquam at. In magna lorem, hendrerit sed ultrices a, maximus a turpis. Sed sit amet magna eget velit luctus rutrum ac eu est. Donec tristique augue quis luctus auctor. Pellentesque eu mi viverra, lobortis orci et, semper justo. Nunc non viverra purus. Phasellus a purus id elit dictum ullamcorper at quis urna. Nullam semper porttitor diam, in feugiat mi imperdiet eget. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; + +Fusce sed mattis ligula, non viverra ante. Proin viverra maximus enim, non facilisis ante rhoncus eget. Praesent molestie justo ac diam luctus aliquam. Nunc vitae justo posuere ex convallis varius. Suspendisse potenti. Vivamus elementum lacus vel tortor varius, ut blandit nisl laoreet. Suspendisse potenti. Proin gravida facilisis dui, id maximus est porttitor rhoncus. + +Mauris ut quam purus. Cras maximus risus sit amet pretium facilisis. Vivamus ullamcorper arcu et est semper, nec malesuada metus interdum. Nulla tincidunt orci suscipit nisi congue aliquet. In ultrices pulvinar ipsum a egestas. Proin felis diam, malesuada vel suscipit quis, auctor vehicula augue. Vestibulum eget ipsum in neque volutpat aliquam porta ac augue. + +Etiam tincidunt nulla at tellus sodales, sit amet facilisis elit maximus. Nulla et lorem aliquam arcu molestie suscipit. Donec convallis tellus nibh, vel vulputate velit ultrices luctus. Nam et diam sit amet dolor suscipit auctor. Nam blandit felis quis ex pretium consectetur. Etiam vitae ultrices arcu. Nullam et urna pellentesque, ornare mi mattis, fringilla dolor. Vestibulum augue tortor, imperdiet in porta nec, vestibulum a sem. Phasellus nec mattis eros. Maecenas tristique enim egestas libero laoreet posuere. Sed eros nunc, auctor a molestie egestas, dictum a ante. In hac habitasse platea dictumst. Nullam luctus aliquam pellentesque. Morbi non diam ligula. Proin vulputate tortor dui, ac lacinia nisi luctus at. + +Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec dignissim urna sed ligula semper, id mattis enim malesuada. Nullam ac magna et justo commodo viverra ac ac erat. Praesent mi mi, aliquet sit amet augue eu, blandit tempus nisi. Donec dapibus ex et sodales malesuada. Vivamus venenatis aliquet nunc, eget egestas ipsum. Nunc venenatis iaculis congue. Sed iaculis rhoncus diam, at rhoncus arcu imperdiet vel. + +Suspendisse potenti. Praesent ut iaculis elit, a venenatis metus. Sed vitae neque ut neque vehicula placerat id eget erat. Aliquam erat volutpat. Sed dictum molestie nisi eget rhoncus. Nulla et laoreet nisl, a consectetur mauris. In ornare ut mauris quis scelerisque. Pellentesque ultrices nibh in lacus feugiat, id tempus lacus condimentum. + +Aenean tincidunt consequat augue, in bibendum nisl placerat in. Nulla non dignissim est. Nam ac mauris eleifend, elementum ex in, luctus justo. Aliquam ac leo facilisis, elementum libero et, tristique lacus. Aliquam commodo elementum consequat. Vestibulum mollis, lacus a porttitor lacinia, est ipsum mollis ante, non cursus elit tortor eget lacus. Quisque suscipit quam massa, sit amet tempus nulla varius sed. Ut maximus velit quis nulla blandit mollis eu a libero. Aliquam sed dignissim elit. Vivamus quis erat vitae turpis tincidunt ultrices. + +Nulla facilisis dui odio, at scelerisque erat cursus a. Ut arcu nunc, ullamcorper vitae orci eget, sollicitudin maximus sapien. Fusce eu arcu nunc. Integer vitae eros turpis. Fusce ac elit in nisi rutrum suscipit id consectetur lacus. Suspendisse rutrum ligula auctor fringilla cursus. Sed consequat erat in nunc lacinia, et ullamcorper velit vestibulum. Mauris sed est a tellus feugiat sagittis non nec neque. Sed eu bibendum orci. Donec diam diam, viverra sed dolor non, posuere sagittis mi. Duis rhoncus, risus sit amet luctus sodales, risus arcu faucibus enim, eu cras amet.
\ No newline at end of file diff --git a/rust/vendor/brotli-decompressor/src/bin/ipsum_gen.py b/rust/vendor/brotli-decompressor/src/bin/ipsum_gen.py new file mode 100644 index 0000000..ade7394 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/ipsum_gen.py @@ -0,0 +1,10 @@ +import brotli + +with open('ipsum.raw') as f: + decoded = f.read() + +with open('ipsum.brotli') as f: + c = brotli.Compressor() + c.process(decoded) + encoded = c.finish() + f.write(encoded) diff --git a/rust/vendor/brotli-decompressor/src/bin/tests.rs b/rust/vendor/brotli-decompressor/src/bin/tests.rs new file mode 100755 index 0000000..ee5e21d --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bin/tests.rs @@ -0,0 +1,197 @@ +#![cfg(test)] +extern crate core; +use std::io::{self, Write, Read}; +use core::cmp; + + +struct Buffer { + data: Vec<u8>, + read_offset: usize, +} +impl Buffer { + pub fn new(buf: &[u8]) -> Buffer { + let mut ret = Buffer { + data: Vec::<u8>::new(), + read_offset: 0, + }; + ret.data.extend(buf); + return ret; + } +} +impl io::Read for Buffer { + fn read(self: &mut Self, buf: &mut [u8]) -> io::Result<usize> { + let bytes_to_read = cmp::min(buf.len(), self.data.len() - self.read_offset); + if bytes_to_read > 0 { + buf[0..bytes_to_read] + .clone_from_slice(&self.data[self.read_offset..self.read_offset + bytes_to_read]); + } + self.read_offset += bytes_to_read; + return Ok(bytes_to_read); + } +} +impl io::Write for Buffer { + fn write(self: &mut Self, buf: &[u8]) -> io::Result<usize> { + self.data.extend(buf); + return Ok(buf.len()); + } + fn flush(self: &mut Self) -> io::Result<()> { + return Ok(()); + } +} + +fn copy_from_to<R: io::Read, W: io::Write>(mut r: R, mut w: W) -> io::Result<usize> { + let mut buffer: [u8; 65536] = [0; 65536]; + let mut out_size: usize = 0; + loop { + match r.read(&mut buffer[..]) { + Err(e) => { + match e.kind() { + io::ErrorKind::Interrupted => continue, + _ => {} + } + return Err(e); + } + Ok(size) => { + if size == 0 { + break; + } else { + match w.write_all(&buffer[..size]) { + Err(e) => { + match e.kind() { + io::ErrorKind::Interrupted => continue, + _ => {} + } + return Err(e); + } + Ok(_) => out_size += size, + } + } + } + } + } + return Ok(out_size); +} + + +fn ok_one_byte_brotli(b: u8) -> bool{ + b == 6 || b == 26 || b== 51 || + b == 53 || b == 55 || b == 57 || + b == 59 || b == 61 || b == 63 +} + +#[test] +fn test_one_byte_copier() { + for b in 0..256 { + let in_buf = [b as u8]; + let mut output = Buffer::new(&[]); + let mut input = super::BrotliDecompressor::new(Buffer::new(&in_buf), 4096); + match copy_from_to(&mut input, &mut output) { + Ok(_) => if ok_one_byte_brotli(in_buf[0]) { + assert_eq!(output.data, &[]) + } else { + panic!("Expected error not {}", b) + }, + Err(e) => assert_eq!(e.kind(), io::ErrorKind::InvalidData), + } + } +} + +#[cfg(features="std")] +#[test] +fn test_one_byte_writer() { + for b in 0..256 { + let in_buf = [b as u8]; + let mut output = Buffer::new(&[]); + let mut writer = super::brotli_decompressor::DecompressorWriter::new(&mut output, 4096); + match writer.write(&in_buf) { + Ok(v) => { + if ok_one_byte_brotli(b as u8) { + writer.close().unwrap(); + } else { + assert_eq!(writer.close().unwrap_err().kind(), io::ErrorKind::InvalidData); + } + assert_eq!(v, 1); + }, + Err(e) => { + assert_eq!(e.kind(), io::ErrorKind::InvalidData); + assert!(!ok_one_byte_brotli(b as u8)); + } + } + } +} + + +#[cfg(features="std")] +#[test] +fn test_error_byte_writer() { + let in_buf = b"\x8f\x02\x80\x68\x65\x6c\x6c\x6f\x0a\x03\x67\x6f\x6f\x64\x62\x79\x65\x0a"; + let mut output = Buffer::new(&[]); + let mut writer = super::brotli_decompressor::DecompressorWriter::new(&mut output, 4096); + match writer.write_all(&in_buf[..]) { + Ok(_) => { + assert_eq!(writer.close().unwrap_err().kind(), io::ErrorKind::InvalidData); + }, + Err(e) => { + assert_eq!(e.kind(), io::ErrorKind::InvalidData); + } + } +} + +#[cfg(features="std")] +#[test] +fn test_one_byte_reader() { + for b in 0..256 { + let in_buf = [b as u8]; + let mut output = [0u8;1]; + let mut reader = super::brotli_decompressor::Decompressor::new(&in_buf[..], 4096); + match reader.read(&mut output) { + Ok(v) => { + assert!(ok_one_byte_brotli(b as u8)); + assert_eq!(v, 0); + }, + Err(e) => { + assert_eq!(e.kind(), io::ErrorKind::InvalidData); + assert!(!ok_one_byte_brotli(b as u8)); + } + } + } +} + +#[test] +fn test_10x_10y() { + let in_buf: [u8; 12] = [0x1b, 0x13, 0x00, 0x00, 0xa4, 0xb0, 0xb2, 0xea, 0x81, 0x47, 0x02, 0x8a]; + + let mut output = Buffer::new(&[]); + let mut input = super::BrotliDecompressor::new(Buffer::new(&in_buf), 4096); + match copy_from_to(&mut input, &mut output) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + let mut i: usize = 0; + while i < 10 { + assert_eq!(output.data[i], 'X' as u8); + assert_eq!(output.data[i + 10], 'Y' as u8); + i += 1; + } + assert_eq!(output.data.len(), 20); +} + + +#[test] +fn test_alice() { + let in_buf = include_bytes!("../../testdata/alice29.txt.compressed"); + + let mut output = Buffer::new(&[]); + let mut input = super::BrotliDecompressor::new(Buffer::new(in_buf), 1); + match copy_from_to(&mut input, &mut output) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + let mut i: usize = 0; + let truth = include_bytes!("../../testdata/alice29.txt"); + while i < truth.len() { + assert_eq!(output.data[i], truth[i]); + i += 1; + } + assert_eq!(truth.len(), output.data.len()); +} diff --git a/rust/vendor/brotli-decompressor/src/bit_reader/mod.rs b/rust/vendor/brotli-decompressor/src/bit_reader/mod.rs new file mode 100644 index 0000000..824cc82 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/bit_reader/mod.rs @@ -0,0 +1,631 @@ +#![allow(non_snake_case)] +use core::default::Default; +macro_rules! xprintln ( + ($a : expr) => (); + ($a : expr, $b : expr) => (); + ($a : expr, $b : expr, $c : expr) => (); + ($a : expr, $b : expr, $c : expr, $d : expr) => (); + ($a : expr, $b : expr, $c : expr, $d : expr, $e : expr) => (); + ($a : expr, $b : expr, $c : expr, $d : expr, $e : expr, $f : expr) => (); +); + +pub const BROTLI_SHORT_FILL_BIT_WINDOW_READ: u32 = 4; + +#[allow(non_camel_case_types)] +pub type reg_t = u64; + +#[allow(non_upper_case_globals)] +const kBitMask: [u32; 33] = + [0x0000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, + 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, + 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, + 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, + 0xFFFFFFFF]; + +#[inline] +pub fn BitMask(n: u32) -> u32 { + if false { + // Masking with this expression turns to a single + // "Unsigned Bit Field Extract" UBFX instruction on ARM. + !((0xffffffffu32) << n) + } else { + fast!((kBitMask)[n as usize]) + } +} + +pub struct BrotliBitReader { + pub val_: reg_t, // pre-fetched bits + pub bit_pos_: u32, // current bit-reading position in val_ + pub next_in: u32, // the byte we're reading from + pub avail_in: u32, +} + +impl Default for BrotliBitReader { + fn default() -> Self { + BrotliBitReader { + val_: 0, + bit_pos_: 0, + next_in: 0, + avail_in: 0, + } + } +} + +pub struct BrotliBitReaderState { + pub val_: reg_t, // pre-fetched bits + pub bit_pos_: u32, // current bit-reading position in val_ + pub next_in: u32, // the byte we're reading from + pub avail_in: u32, +} +impl Default for BrotliBitReaderState { + #[inline] + fn default() -> Self { + BrotliBitReaderState { + val_: 0, + bit_pos_: 0, + next_in: 0, + avail_in: 0, + } + } +} + +pub fn BrotliBitReaderSaveState(from: &BrotliBitReader) -> BrotliBitReaderState { + BrotliBitReaderState { + val_: from.val_, + bit_pos_: from.bit_pos_, + next_in: from.next_in, + avail_in: from.avail_in, + } +} + +pub fn BrotliBitReaderRestoreState(to: &mut BrotliBitReader, from: &BrotliBitReaderState) { + to.val_ = from.val_; + to.bit_pos_ = from.bit_pos_; + to.next_in = from.next_in; + to.avail_in = from.avail_in; +} + +pub fn BrotliGetAvailableBits(br: &BrotliBitReader) -> u32 { + ((::core::mem::size_of::<reg_t>() as u32) << 3) - br.bit_pos_ +} + +// Returns amount of unread bytes the bit reader still has buffered from the +// BrotliInput, including whole bytes in br->val_. +pub fn BrotliGetRemainingBytes(br: &BrotliBitReader) -> u32 { + br.avail_in + (BrotliGetAvailableBits(br) >> 3) +} + +// Checks if there is at least num bytes left in the input ringbuffer (excluding +// the bits remaining in br->val_). +pub fn BrotliCheckInputAmount(br: &BrotliBitReader, num: u32) -> bool { + br.avail_in >= num +} + + +#[inline(always)] +fn BrotliLoad16LE(input: &[u8], next_in_u32: u32) -> u16 { + let next_in: usize = next_in_u32 as usize; + (fast!((input)[next_in]) as u16) | ((fast!((input)[next_in + 1]) as u16) << 8) +} + + +#[inline(always)] +fn BrotliLoad32LE(input: &[u8], next_in_u32: u32) -> u32 { + let next_in: usize = next_in_u32 as usize; + let mut four_byte: [u8; 4] = fast_uninitialized![4]; + four_byte.clone_from_slice(fast!((input)[next_in ; next_in + 4])); + (four_byte[0] as u32) | ((four_byte[1] as u32) << 8) | ((four_byte[2] as u32) << 16) | + ((four_byte[3] as u32) << 24) +} + +#[inline(always)] +fn BrotliLoad64LE(input: &[u8], next_in_u32: u32) -> u64 { + let next_in: usize = next_in_u32 as usize; + let mut eight_byte: [u8; 8] = fast_uninitialized![8]; + eight_byte.clone_from_slice(fast!((input)[next_in ; next_in + 8])); + + (eight_byte[0] as u64) | ((eight_byte[1] as u64) << 8) | ((eight_byte[2] as u64) << 16) | + ((eight_byte[3] as u64) << 24) | + ((eight_byte[4] as u64) << 32) | ((eight_byte[5] as u64) << 40) | + ((eight_byte[6] as u64) << 48) | ((eight_byte[7] as u64) << 56) +} +pub const BROTLI_ALIGNED_READ: u8 = 0; + +#[inline(always)] +pub fn BrotliFillBitWindow(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) { + if ::core::mem::size_of::<reg_t>() == 8 { + if (n_bits <= 8 && BROTLI_ALIGNED_READ == 0 && br.bit_pos_ >= 56) { + br.val_ >>= 56; + br.bit_pos_ ^= 56; // here same as -= 56 because of the if condition + br.val_ |= BrotliLoad64LE(input, br.next_in) << 8; + br.avail_in -= 7; + br.next_in += 7; + } else if (BROTLI_ALIGNED_READ == 0 && n_bits <= 16 && br.bit_pos_ >= 48) { + br.val_ >>= 48; + br.bit_pos_ ^= 48; // here same as -= 48 because of the if condition + br.val_ |= BrotliLoad64LE(input, br.next_in) << 16; + br.avail_in -= 6; + br.next_in += 6; + } else if br.bit_pos_ >= 32 { + br.val_ >>= 32; + br.bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */ + br.val_ |= (BrotliLoad32LE(input, br.next_in) as reg_t) << 32; + br.avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ; + br.next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ; + } + } else if (BROTLI_ALIGNED_READ == 0 && (n_bits <= 8)) { + if (br.bit_pos_ >= 24) { + br.val_ >>= 24; + br.bit_pos_ ^= 24; // here same as -= 24 because of the if condition + br.val_ |= (BrotliLoad32LE(input, br.next_in) << 8) as u64; + br.avail_in -= 3; + br.next_in += 3; + } + } else if br.bit_pos_ >= 16 { + br.val_ >>= 16; + br.bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */ + br.val_ |= (BrotliLoad16LE(input, br.next_in) as reg_t) << 16; + br.avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ; + br.next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ; + } +} + +#[inline(always)] +fn BrotliFillBitWindowCompileTimeNbits(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) { + if ::core::mem::size_of::<reg_t>() == 8 { + if BROTLI_ALIGNED_READ == 0 && n_bits <= 8 { + // !BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) { + if br.bit_pos_ >= 56 { + br.val_ >>= 56; + br.bit_pos_ ^= 56; /* here same as -= 56 because of the if condition */ + br.val_ |= BrotliLoad64LE(input, br.next_in) << 8; + br.avail_in -= 7; + br.next_in += 7; + } + } else if BROTLI_ALIGNED_READ == 0 && n_bits <= 16 { + // (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 16)) { + if br.bit_pos_ >= 48 { + br.val_ >>= 48; + br.bit_pos_ ^= 48; /* here same as -= 48 because of the if condition */ + br.val_ |= BrotliLoad64LE(input, br.next_in) << 16; + br.avail_in -= 6; + br.next_in += 6; + } + } else if br.bit_pos_ >= 32 { + br.val_ >>= 32; + br.bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */ + br.val_ |= (BrotliLoad32LE(input, br.next_in) as reg_t) << 32; + br.avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ; + br.next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ; + } + } else if + // BROTLI_ALIGNED_READ == false && + n_bits <= 8 { + // !BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) { + if br.bit_pos_ >= 24 { + br.val_ >>= 24; + br.bit_pos_ ^= 24; /* here same as -= 24 because of the if condition */ + br.val_ |= (BrotliLoad32LE(input, br.next_in) as reg_t) << 8; + br.avail_in -= 3; + br.next_in += 3; + } + } else if br.bit_pos_ >= 16 { + br.val_ >>= 16; + br.bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */ + br.val_ |= (BrotliLoad16LE(input, br.next_in) as reg_t) << 16; + br.avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ; + br.next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ; + } +} + +// Mosltly like BrotliFillBitWindow, but guarantees only 16 bits and reads no +// more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. +pub fn BrotliFillBitWindow16(br: &mut BrotliBitReader, input: &[u8]) { + BrotliFillBitWindowCompileTimeNbits(br, 17, input); +} + +// Pulls one byte of input to accumulator. +pub fn BrotliPullByte(br: &mut BrotliBitReader, input: &[u8]) -> bool { + if br.avail_in == 0 { + return false; + } + br.val_ >>= 8; + if ::core::mem::size_of::<reg_t>() == 8 { + br.val_ |= (fast!((input)[br.next_in as usize]) as reg_t) << 56; + } else { + br.val_ |= (fast!((input)[br.next_in as usize]) as reg_t) << 24; + } + br.bit_pos_ -= 8; + br.avail_in -= 1; + br.next_in += 1; + true +} + +// Returns currently available bits. +// The number of valid bits could be calclulated by BrotliGetAvailableBits. +#[inline(always)] +pub fn BrotliGetBitsUnmasked(br: &BrotliBitReader) -> reg_t { + br.val_ >> br.bit_pos_ +} + +// Like BrotliGetBits, but does not mask the result. +// The result contains at least 16 valid bits. +#[inline(always)] +pub fn BrotliGet16BitsUnmasked(br: &mut BrotliBitReader, input: &[u8]) -> u32 { + BrotliFillBitWindowCompileTimeNbits(br, 16, input); + (BrotliGetBitsUnmasked(br) & (0xffffffffu32 as reg_t)) as u32 +} + +// Returns the specified number of bits from br without advancing bit pos. +pub fn BrotliGetBits(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) -> u32 { + BrotliFillBitWindow(br, n_bits, input); + (BrotliGetBitsUnmasked(br) as u32) & BitMask(n_bits) +} + +// Returns the specified number of bits from br without advancing bit pos. +#[allow (dead_code)] +pub fn BrotliGetConstantNBits(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) -> u32 { + BrotliFillBitWindowCompileTimeNbits(br, n_bits, input); + (BrotliGetBitsUnmasked(br) as u32) & BitMask(n_bits) +} + +// Tries to peek the specified amount of bits. Returns 0, if there is not +// enough input. +pub fn BrotliSafeGetBits(br: &mut BrotliBitReader, + n_bits: u32, + val: &mut u32, + input: &[u8]) + -> bool { + while BrotliGetAvailableBits(br) < n_bits { + if !BrotliPullByte(br, input) { + return false; + } + } + *val = (BrotliGetBitsUnmasked(br) as u32) & BitMask(n_bits); + true +} + +// Advances the bit pos by n_bits. +#[inline(always)] +pub fn BrotliDropBits(br: &mut BrotliBitReader, n_bits: u32) { + br.bit_pos_ += n_bits; +} + +pub fn BrotliBitReaderUnload(br: &mut BrotliBitReader) { + let unused_bytes: u32 = BrotliGetAvailableBits(br) >> 3; + let unused_bits: u32 = unused_bytes << 3; + br.avail_in += unused_bytes; + br.next_in -= unused_bytes; + if unused_bits as usize == (::core::mem::size_of::<reg_t>() << 3) { + br.val_ = 0; + } else { + br.val_ <<= unused_bits; + } + br.bit_pos_ += unused_bits; +} + +// Reads the specified number of bits from br and advances the bit pos. +// Precondition: accumulator MUST contain at least n_bits. +#[inline(always)] +pub fn BrotliTakeBits(br: &mut BrotliBitReader, n_bits: u32, val: &mut u32) { + *val = (BrotliGetBitsUnmasked(br) as u32) & BitMask(n_bits); + // if true { + xprintln!("[BrotliReadBits] {:?} {:?} {:?} val: {:x}\n", + br.avail_in, br.bit_pos_, n_bits, *val); + // } + BrotliDropBits(br, n_bits); +} + +// Reads the specified number of bits from br and advances the bit pos. +// Assumes that there is enough input to perform BrotliFillBitWindow. +#[inline(always)] +pub fn BrotliReadBits(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) -> u32 { + if ::core::mem::size_of::<reg_t>() == 8 || (n_bits <= 16) { + let mut val: u32 = 0; + BrotliFillBitWindow(br, n_bits, input); + BrotliTakeBits(br, n_bits, &mut val); + val + } else { + let mut low_val: u32 = 0; + let mut high_val: u32 = 0; + BrotliFillBitWindowCompileTimeNbits(br, 16, input); + BrotliTakeBits(br, 16, &mut low_val); + BrotliFillBitWindowCompileTimeNbits(br, 8, input); + BrotliTakeBits(br, n_bits - 16, &mut high_val); + low_val | (high_val << 16) + } +} + +// Reads the specified number of bits from br and advances the bit pos. +// Assumes that there is enough input to perform BrotliFillBitWindow. +#[allow (dead_code)] +pub fn BrotliReadConstantNBits(br: &mut BrotliBitReader, n_bits: u32, input: &[u8]) -> u32 { + if ::core::mem::size_of::<reg_t>() == 8 || (n_bits <= 16) { + let mut val: u32 = 0; + BrotliFillBitWindowCompileTimeNbits(br, n_bits, input); + BrotliTakeBits(br, n_bits, &mut val); + val + } else { + let mut low_val: u32 = 0; + let mut high_val: u32 = 0; + BrotliFillBitWindowCompileTimeNbits(br, 16, input); + BrotliTakeBits(br, 16, &mut low_val); + BrotliFillBitWindowCompileTimeNbits(br, 8, input); + BrotliTakeBits(br, n_bits - 16, &mut high_val); + low_val | (high_val << 16) + } +} + +// Tries to read the specified amount of bits. Returns 0, if there is not +// enough input. n_bits MUST be positive. +pub fn BrotliSafeReadBits(br: &mut BrotliBitReader, + n_bits: u32, + val: &mut u32, + input: &[u8]) + -> bool { + while BrotliGetAvailableBits(br) < n_bits { + if !BrotliPullByte(br, input) { + return false; + } + } + BrotliTakeBits(br, n_bits, val); + true +} + +// Advances the bit reader position to the next byte boundary and verifies +// that any skipped bits are set to zero. +pub fn BrotliJumpToByteBoundary(br: &mut BrotliBitReader) -> bool { + let pad_bits_count: u32 = BrotliGetAvailableBits(br) & 0x7; + let mut pad_bits: u32 = 0; + if pad_bits_count != 0 { + BrotliTakeBits(br, pad_bits_count, &mut pad_bits); + } + pad_bits == 0 +} + +// Peeks a byte at specified offset. +// Precondition: bit reader is parked to a byte boundary. +// Returns -1 if operation is not feasible. +#[allow(dead_code)] +pub fn BrotliPeekByte(br: &mut BrotliBitReader, mut offset: u32, input: &[u8]) -> i32 { + let available_bits: u32 = BrotliGetAvailableBits(br); + let bytes_left: u32 = (available_bits >> 3); + assert!((available_bits & 7) == 0); + if offset < bytes_left { + return ((BrotliGetBitsUnmasked(br) >> ((offset << 3)) as u32) & 0xFF) as i32; + } + offset -= bytes_left; + if offset < br.avail_in { + return fast!((input)[br.next_in as usize + offset as usize]) as i32; + } + -1 +} + +// Copies remaining input bytes stored in the bit reader to the output. Value +// num may not be larger than BrotliGetRemainingBytes. The bit reader must be +// warmed up again after this. +pub fn BrotliCopyBytes(dest: &mut [u8], br: &mut BrotliBitReader, mut num: u32, input: &[u8]) { + let mut offset: u32 = 0; + while BrotliGetAvailableBits(br) >= 8 && num > 0 { + fast_mut!((dest)[offset as usize]) = BrotliGetBitsUnmasked(br) as u8; + BrotliDropBits(br, 8); + offset += 1; + num -= 1; + } + for index in 0..num { + fast_mut!((dest)[offset as usize + index as usize]) = + fast!((input)[br.next_in as usize + index as usize]); + } + br.avail_in -= num; + br.next_in += num; +} + +pub fn BrotliInitBitReader(br: &mut BrotliBitReader) { + br.val_ = 0; + br.bit_pos_ = (::core::mem::size_of::<reg_t>() << 3) as u32; +} + +pub fn BrotliWarmupBitReader(br: &mut BrotliBitReader, input: &[u8]) -> bool { + let _aligned_read_mask: usize = (::core::mem::size_of::<reg_t>() >> 1) - 1; + // Fixing alignment after unaligned BrotliFillWindow would result accumulator + // overflow. If unalignment is caused by BrotliSafeReadBits, then there is + // enough space in accumulator to fix aligment. + if BrotliGetAvailableBits(br) == 0 && !BrotliPullByte(br, input) { + return false; + } + // we can't tell about alignment yet + // while (((size_t)br->next_in) & aligned_read_mask) != 0 { + // if !BrotliPullByte(br) { + // If we consumed all the input, we don't care about the alignment. */ + // return true; + // } + // } + // + true +} + + + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn warmup_works() { + let data: [u8; 37] = [0xde, 0xad, 0xbe, 0xef /* 4 bytes garbage at beginning */, 0x21, + 0xfd, 0xff, 0x87, 0x03, 0x6c, 0x63, 0x90, 0xde, 0xe9, 0x36, 0x04, 0xf8, + 0x89, 0xb4, 0x4d, 0x57, 0x96, 0x51, 0x0a, 0x54, 0xb7, 0x54, 0xee, 0xf4, + 0xdc, 0xa0, 0x05, 0x9b, 0xd2, 0x2b, 0x30, 0x8f]; // 33 b goods + let mut bit_reader = BrotliBitReader { + val_: 0x0, + bit_pos_: 64, + avail_in: 33, + next_in: 4, + }; + let ret = BrotliWarmupBitReader(&mut bit_reader, &data[..]); + assert_eq!(ret, true); + assert_eq!(bit_reader.val_, 0x2100000000000000); + assert_eq!(bit_reader.bit_pos_, 56); + assert_eq!(bit_reader.avail_in, 32); + assert_eq!(bit_reader.next_in, 5); + } + #[test] + fn warmup_errcheck() { + let data: [u8; 3] = [0xde, 0xad, 0xeb]; // 3 bytes garbage at beginning + let mut bit_reader = BrotliBitReader { + val_: 0x86e884e1ffff577b, + bit_pos_: 64, + avail_in: 0, + next_in: 3, + }; + let ret = BrotliWarmupBitReader(&mut bit_reader, &data[..]); + assert_eq!(ret, false); + assert_eq!(bit_reader.val_, 0x86e884e1ffff577b); + assert_eq!(bit_reader.bit_pos_, 64); + assert_eq!(bit_reader.avail_in, 0); + assert_eq!(bit_reader.next_in, 3); + } + #[test] + fn safe_read_tests() { + { + let data: [u8; 12] = [0x50, 0x3b, 0xbb, 0x5e, 0xc5, 0x96, 0x81, 0xb7, 0x52, 0x89, 0xea, 0x3d]; + let mut bit_reader = BrotliBitReader { + val_: 0xe1e56a736e04fbf5, + bit_pos_: 6, + avail_in: 12, + next_in: 0, + }; + let mut val: u32 = 0; + let ret = BrotliSafeReadBits(&mut bit_reader, 7, &mut val, &data[..]); + assert_eq!(ret, true); + assert_eq!(val, 0x6f); + assert_eq!(bit_reader.avail_in, 12); + assert_eq!(bit_reader.next_in, 0); + assert_eq!(bit_reader.bit_pos_, 13); + } + { + let data: [u8; 7] = [0xba, 0xd0, 0xf0, 0x0d, 0xc8, 0xcd, 0xcc]; + let mut bit_reader = BrotliBitReader { + val_: 0x17f115ae26916f0, + bit_pos_: 57, + avail_in: 3, + next_in: 4, + }; + let mut val: u32 = 0; + let ret = BrotliSafeReadBits(&mut bit_reader, 15, &mut val, &data[..]); + assert_eq!(ret, true); + assert_eq!(val, 0x6400); + assert_eq!(bit_reader.avail_in, 2); + assert_eq!(bit_reader.next_in, 5); + assert_eq!(bit_reader.bit_pos_, 64); + } + { + let data: [u8; 4] = [0xee, 0xee, 0xf0, 0xd5]; + let mut bit_reader = BrotliBitReader { + val_: 0x5f43f252c027e447, + bit_pos_: 53, + avail_in: 2, + next_in: 2, + }; + let mut val: u32 = 0; + let ret = BrotliSafeReadBits(&mut bit_reader, 14, &mut val, &data[..]); + assert_eq!(ret, true); + assert_eq!(bit_reader.avail_in, 1); + assert_eq!(bit_reader.next_in, 3); + assert_eq!(bit_reader.bit_pos_, 59); + assert_eq!(bit_reader.val_, 0xf05f43f252c027e4); + assert_eq!(val, 0x2fa); + } + { + let data: [u8; 4] = [0xee, 0xee, 0xf0, 0xd5]; + let mut bit_reader = BrotliBitReader { + val_: 0x2f902339697460, + bit_pos_: 57, + avail_in: 0, + next_in: 4, + }; + let mut val: u32 = 0x74eca3f0; + let ret = BrotliSafeReadBits(&mut bit_reader, 14, &mut val, &data[..]); + assert_eq!(ret, false); + assert_eq!(bit_reader.avail_in, 0); + assert_eq!(bit_reader.next_in, 4); + assert_eq!(bit_reader.bit_pos_, 57); + assert_eq!(bit_reader.val_, 0x2f902339697460); + assert_eq!(val, 0x74eca3f0); + } + } + #[test] + fn bit_read_tests() { + { + let data: [u8; 32] = [0xba, 0xaa, 0xad, 0xdd, 0x57, 0x5c, 0xd9, 0xa3, 0x3e, 0xb3, 0x77, + 0xe7, 0xa0, 0x1e, 0x09, 0xd3, 0x12, 0xa1, 0x3f, 0xb8, 0x7e, 0x5a, + 0x06, 0x86, 0xe5, 0x36, 0xef, 0x9c, 0x9f, 0x6d, 0x9b, 0xcc]; + let mut bit_reader = BrotliBitReader { + val_: 0xf5917f07daaaeabb, + bit_pos_: 33, + avail_in: 29, + next_in: 3, + }; + let ret = BrotliReadBits(&mut bit_reader, 8, &data[..]); + assert_eq!(ret, 0x83); + assert_eq!(bit_reader.bit_pos_, 9); + assert_eq!(bit_reader.avail_in, 25); + assert_eq!(bit_reader.next_in, 7); + } + { + let data: [u8; 28] = [0xba, 0xaa, 0xaa, 0xad, 0x74, 0x40, 0x8e, 0xee, 0xd2, 0x38, 0xf1, + 0xf4, 0xf8, 0x1d, 0x9f, 0x24, 0x48, 0x1e, 0x82, 0xce, 0x48, 0x88, + 0xd7, 0x25, 0x74, 0xaf, 0xe3, 0xea]; + let mut bit_reader = BrotliBitReader { + val_: 0x27e33b2440d3feaf, + bit_pos_: 18, + avail_in: 24, + next_in: 4, + }; + let ret = BrotliReadBits(&mut bit_reader, 15, &data[..]); + assert_eq!(ret, 0x1034); + assert_eq!(bit_reader.bit_pos_, 33); + assert_eq!(bit_reader.avail_in, 24); + assert_eq!(bit_reader.next_in, 4); + } + } + #[test] + fn const_fill_bit_window_tests() { + { + let data: [u8; 36] = [0xff, 0x9a, 0xa0, 0xde, 0x50, 0x99, 0x67, 0x67, 0x69, 0x87, 0x0e, + 0x69, 0xeb, 0x6a, 0xd1, 0x56, 0xc0, 0x32, 0x96, 0xed, 0x78, 0x0e, + 0x19, 0xdd, 0x0b, 0xe8, 0xf8, 0x33, 0x9f, 0xe0, 0x69, 0x55, 0x59, + 0x3f, 0x5d, 0xc8]; + let mut bit_reader = BrotliBitReader { + val_: 0xb3fc441e0181dc4, + bit_pos_: 59, + avail_in: 33, + next_in: 1, + }; + let ret = BrotliReadConstantNBits(&mut bit_reader, 4, &data[..]); + assert_eq!(ret, 0x1); + assert_eq!(bit_reader.bit_pos_, 7); + assert_eq!(bit_reader.avail_in, 26); + assert_eq!(bit_reader.next_in, 8); + } + { + let data: [u8; 67] = [0xf0, 0x0d, 0x7e, 0x18, 0x70, 0x1c, 0x18, 0x57, 0xbd, 0x73, 0x47, + 0xc1, 0xb4, 0xf7, 0xe2, 0xbe, 0x17, 0x6e, 0x26, 0x01, 0xb2, 0xd5, + 0x55, 0xd8, 0x68, 0x1b, 0xc2, 0x87, 0xb4, 0xb1, 0xd9, 0x42, 0xac, + 0x0d, 0x67, 0xb1, 0x93, 0x54, 0x49, 0xa4, 0x69, 0xf8, 0x16, 0x0e, + 0x61, 0xb3, 0xdb, 0x98, 0xbb, 0xeb, 0xfa, 0xcb, 0x14, 0xcd, 0x68, + 0x77, 0xa1, 0x33, 0x6c, 0x49, 0xfa, 0x35, 0xbb, 0xeb, 0xee, 0x7b, 0xae]; + let mut bit_reader = BrotliBitReader { + val_: 0x655b1fe0dd6f1e78, + bit_pos_: 63, + avail_in: 65, + next_in: 2, + }; + let ret = BrotliGet16BitsUnmasked(&mut bit_reader, &data[..]); + assert_eq!(ret, 0x38e030fc); + assert_eq!(bit_reader.bit_pos_, 15); + assert_eq!(bit_reader.avail_in, 59); + assert_eq!(bit_reader.next_in, 8); + } + } +} diff --git a/rust/vendor/brotli-decompressor/src/brotli_alloc.rs b/rust/vendor/brotli-decompressor/src/brotli_alloc.rs new file mode 100644 index 0000000..702f94f --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/brotli_alloc.rs @@ -0,0 +1,62 @@ +#![cfg(feature="std")] +use core; +use core::ops; +use std::boxed::Box; +use std::vec::Vec; +pub struct WrapBox<T> { + v : Vec<T>, +} + +impl<T> core::default::Default for WrapBox<T> { + fn default() -> Self { + let v : Vec<T> = Vec::new(); + return WrapBox::<T>{v : v}; + } +} + +impl<T> ops::Index<usize> for WrapBox<T>{ + type Output = T; + fn index(&self, index : usize) -> &T { + return &self.v[index] + } +} + +impl<T> ops::IndexMut<usize> for WrapBox<T>{ + fn index_mut(&mut self, index : usize) -> &mut T { + return &mut self.v[index] + } +} + +impl<T> super::SliceWrapper<T> for WrapBox<T> { + fn slice(&self) -> & [T] { + return &self.v[..] + } +} + +impl<T> super::SliceWrapperMut<T> for WrapBox<T> { + fn slice_mut(&mut self) -> &mut [T] { + return &mut self.v[..] + } +} + +pub struct BrotliAlloc<T : core::clone::Clone>{ + pub default_value : T, +} +impl<T : core::clone::Clone+Default> BrotliAlloc<T> { + pub fn new() -> BrotliAlloc<T> { + return BrotliAlloc::<T>{default_value : T::default()}; + } + pub fn take_ownership(&self, data: Vec<T>) -> WrapBox<T>{ + WrapBox::<T>{v:data} + } +} + +impl<T : core::clone::Clone> super::Allocator<T> for BrotliAlloc<T> { + type AllocatedMemory = WrapBox<T>; + fn alloc_cell(self : &mut BrotliAlloc<T>, len : usize) -> WrapBox<T> { + + let v : Vec<T> = vec![self.default_value.clone();len]; + return WrapBox::<T>{v : v}; + } + fn free_cell(self : &mut BrotliAlloc<T>, _data : WrapBox<T>) {} +} diff --git a/rust/vendor/brotli-decompressor/src/context.rs b/rust/vendor/brotli-decompressor/src/context.rs new file mode 100644 index 0000000..1dc8a4f --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/context.rs @@ -0,0 +1,265 @@ +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] + +// Copyright 2013 Google Inc. All Rights Reserved. +// +// Distributed under MIT license. +// See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +// + +// Lookup table to map the previous two bytes to a context id. +// +// There are four different context modeling modes defined here: +// CONTEXT_LSB6: context id is the least significant 6 bits of the last byte, +// CONTEXT_MSB6: context id is the most significant 6 bits of the last byte, +// CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text, +// CONTEXT_SIGNED: second-order context model tuned for signed integers. +// +// The context id for the UTF8 context model is calculated as follows. If p1 +// and p2 are the previous two bytes, we calculate the context as +// +// context = kContextLookup[p1] | kContextLookup[p2 + 256]. +// +// If the previous two bytes are ASCII characters (i.e. < 128), this will be +// equivalent to +// +// context = 4 * context1(p1) + context2(p2), +// +// where context1 is based on the previous byte in the following way: +// +// 0 : non-ASCII control +// 1 : \t, \n, \r +// 2 : space +// 3 : other punctuation +// 4 : " ' +// 5 : % +// 6 : ( < [ { +// 7 : ) > ] } +// 8 : , ; : +// 9 : . +// 10 : = +// 11 : number +// 12 : upper-case vowel +// 13 : upper-case consonant +// 14 : lower-case vowel +// 15 : lower-case consonant +// +// and context2 is based on the second last byte: +// +// 0 : control, space +// 1 : punctuation +// 2 : upper-case letter, number +// 3 : lower-case letter +// +// If the last byte is ASCII, and the second last byte is not (in a valid UTF8 +// stream it will be a continuation byte, value between 128 and 191), the +// context is the same as if the second last byte was an ASCII control or space. +// +// If the last byte is a UTF8 lead byte (value >= 192), then the next byte will +// be a continuation byte and the context id is 2 or 3 depending on the LSB of +// the last byte and to a lesser extent on the second last byte if it is ASCII. +// +// If the last byte is a UTF8 continuation byte, the second last byte can be: +// - continuation byte: the next byte is probably ASCII or lead byte (assuming +// 4-byte UTF8 characters are rare) and the context id is 0 or 1. +// - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1 +// - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3 +// +// The possible value combinations of the previous two bytes, the range of +// context ids and the type of the next byte is summarized in the table below: +// +// |--------\-----------------------------------------------------------------| +// | \ Last byte | +// | Second \---------------------------------------------------------------| +// | last byte \ ASCII | cont. byte | lead byte | +// | \ (0-127) | (128-191) | (192-) | +// |=============|===================|=====================|==================| +// | ASCII | next: ASCII/lead | not valid | next: cont. | +// | (0-127) | context: 4 - 63 | | context: 2 - 3 | +// |-------------|-------------------|---------------------|------------------| +// | cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. | +// | (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 | +// |-------------|-------------------|---------------------|------------------| +// | lead byte | not valid | next: ASCII/lead | not valid | +// | (192-207) | | context: 0 - 1 | | +// |-------------|-------------------|---------------------|------------------| +// | lead byte | not valid | next: cont. | not valid | +// | (208-) | | context: 2 - 3 | | +// |-------------|-------------------|---------------------|------------------| +// +// The context id for the signed context mode is calculated as: +// +// context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2]. +// +// For any context modeling modes, the context ids can be calculated by |-ing +// together two lookups from one table using context model dependent offsets: +// +// context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2]. +// +// where offset1 and offset2 are dependent on the context mode. +// + +#[allow(dead_code)] +pub enum ContextType { + CONTEXT_LSB6, + CONTEXT_MSB6, + CONTEXT_UTF8, + CONTEXT_SIGNED, +} + +/* Common context lookup table for all context modes. */ +pub static kContextLookup:[[u8;512];4] = [ +[ +/* CONTEXT_LSB6, last byte. */ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + + /* CONTEXT_LSB6, second last byte, */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +],[ + /* CONTEXT_MSB6, last byte. */ + 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, + 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, + 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, + 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, + 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, + 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, + 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, + 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, + 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39, + 40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43, + 44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47, + 48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51, + 52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55, + 56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59, + 60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63, + + /* CONTEXT_MSB6, second last byte, */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +],[ + /* CONTEXT_UTF8, last byte. */ + /* ASCII range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 12, 16, 12, 12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12, + 12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52, 52, 48, + 52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24, 12, 28, 12, 12, + 12, 56, 60, 60, 60, 56, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56, + 60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 24, 12, 28, 12, 0, + /* UTF8 continuation byte range. */ + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + /* UTF8 lead byte range. */ + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + + /* CONTEXT_UTF8 second last byte. */ + /* ASCII range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0, + /* UTF8 continuation byte range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* UTF8 lead byte range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +],[ + /* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */ + 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56, + + /* CONTEXT_SIGNED, second last byte. */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, +] +]; + diff --git a/rust/vendor/brotli-decompressor/src/decode.rs b/rust/vendor/brotli-decompressor/src/decode.rs new file mode 100644 index 0000000..a77b1e5 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/decode.rs @@ -0,0 +1,3240 @@ +#![allow(non_snake_case)] +#![allow(unused_parens)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(unused_macros)] + +// #[macro_use] //<- for debugging, remove xprintln from bit_reader and replace with println +// extern crate std; +use core; +use super::alloc; +pub use alloc::{AllocatedStackMemory, Allocator, SliceWrapper, SliceWrapperMut, StackAllocator}; + +use core::mem; + +use super::bit_reader; +use super::huffman; +use super::state; +use super::prefix; + +use super::transform::{TransformDictionaryWord, kNumTransforms}; +use state::{BlockTypeAndLengthState, BrotliRunningContextMapState, BrotliRunningDecodeUint8State, + BrotliRunningHuffmanState, BrotliRunningMetablockHeaderState, + BrotliRunningReadBlockLengthState, BrotliRunningState, BrotliRunningTreeGroupState, + BrotliRunningUncompressedState, kLiteralContextBits, + BrotliDecoderErrorCode, +}; +use context::{kContextLookup}; +use ::dictionary::{kBrotliDictionary, kBrotliDictionaryOffsetsByLength, + kBrotliDictionarySizeBitsByLength, kBrotliMaxDictionaryWordLength, + kBrotliMinDictionaryWordLength}; +pub use huffman::{HuffmanCode, HuffmanTreeGroup}; +#[repr(C)] +#[derive(Debug)] +pub enum BrotliResult { + ResultSuccess = 1, + NeedsMoreInput = 2, + NeedsMoreOutput = 3, + ResultFailure = 0, +} +const kBrotliWindowGap: u32 = 16; +const kBrotliLargeMinWbits: u32 = 10; +const kBrotliLargeMaxWbits: u32 = 30; +const kBrotliMaxPostfix: usize = 3; +const kBrotliMaxAllowedDistance: u32 = 0x7FFFFFFC; +const kDefaultCodeLength: u32 = 8; +const kCodeLengthRepeatCode: u32 = 16; +pub const kNumLiteralCodes: u16 = 256; +pub const kNumInsertAndCopyCodes: u16 = 704; +pub const kNumBlockLengthCodes: u32 = 26; +const kDistanceContextBits: i32 = 2; +const HUFFMAN_TABLE_BITS: u32 = 8; +const HUFFMAN_TABLE_MASK: u32 = 0xff; +const CODE_LENGTH_CODES: usize = 18; +const kCodeLengthCodeOrder: [u8; CODE_LENGTH_CODES] = [1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, + 11, 12, 13, 14, 15]; + +// Static prefix code for the complex code length code lengths. +const kCodeLengthPrefixLength: [u8; 16] = [2, 2, 2, 3, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 2, 4]; + +const kCodeLengthPrefixValue: [u8; 16] = [0, 4, 3, 2, 0, 4, 3, 1, 0, 4, 3, 2, 0, 4, 3, 5]; + + +macro_rules! BROTLI_LOG_UINT ( + ($num : expr) => { + xprintln!("{:?} = {:?}", stringify!($num), $num) + }; +); + +macro_rules! BROTLI_LOG ( + ($str : expr, $num : expr) => {xprintln!("{:?} {:?}", $str, $num);}; + ($str : expr, $num0 : expr, $num1 : expr) => {xprintln!("{:?} {:?} {:?}", $str, $num0, $num1);}; + ($str : expr, $num0 : expr, $num1 : expr, $num2 : expr) => { + xprintln!("{:?} {:?} {:?} {:?}", $str, $num0, $num1, $num2); + }; + ($str : expr, $num0 : expr, $num1 : expr, $num2 : expr, $num3 : expr) => { + xprintln!("{:?} {:?} {:?} {:?} {:?}", $str, $num0, $num1, $num2, $num3); + }; +); +fn is_fatal(e: BrotliDecoderErrorCode) -> bool { + (e as i64) < 0 +} +fn assign_error_code(output: &mut BrotliDecoderErrorCode, input: BrotliDecoderErrorCode) -> BrotliDecoderErrorCode { + *output = input; + input +} + +#[allow(non_snake_case)] +macro_rules! SaveErrorCode { + ($state: expr, $e:expr) => { + match assign_error_code(&mut $state.error_code, $e) { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => + BrotliResult::ResultSuccess, + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT => + BrotliResult::NeedsMoreInput, + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT => + BrotliResult::NeedsMoreOutput, + _ => + BrotliResult::ResultFailure, + } + } +} +macro_rules! SaveResult { + ($state: expr, $e:expr) => { + match ($state.error_code = match $e { + BrotliResult::ResultSuccess => BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS, + BrotliResult::NeedsMoreInput => BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT, + BrotliResult::NeedsMoreOutput => BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT, + BrotliResult::ResultFailure => BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE, + }) { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => + BrotliResult::ResultSuccess, + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT => + BrotliResult::NeedsMoreInput, + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT => + BrotliResult::NeedsMoreOutput, + _ => + BrotliResult::ResultFailure, + } + } +} +macro_rules! BROTLI_LOG_ARRAY_INDEX ( + ($array : expr, $index : expr) => { + xprintln!("{:?}[{:?}] = {:?}", stringify!($array), $index, $array[$index as usize]) + }; +); + + +const NUM_DISTANCE_SHORT_CODES: u32 = 16; +pub const BROTLI_MAX_DISTANCE_BITS:u32 = 24; + +pub const BROTLI_LARGE_MAX_DISTANCE_BITS: u32 = 62; + +pub fn BROTLI_DISTANCE_ALPHABET_SIZE(NPOSTFIX: u32, NDIRECT:u32, MAXNBITS: u32) -> u32 { + NUM_DISTANCE_SHORT_CODES + (NDIRECT) + + ((MAXNBITS) << ((NPOSTFIX) + 1)) +} + +// pub struct BrotliState { +// total_written : usize, +// } +// +pub use state::BrotliState; +// impl BrotliState { +// pub fn new() -> BrotliState { +// return BrotliState {total_written: 0 }; +// } +// } + +/* Decodes WBITS by reading 1 - 7 bits, or 0x11 for "Large Window Brotli". + Precondition: bit-reader accumulator has at least 8 bits. */ +fn DecodeWindowBits(s_large_window: &mut bool, + s_window_bits:&mut u32, + br: &mut bit_reader::BrotliBitReader) -> BrotliDecoderErrorCode { + let mut n: u32 = 0; + let large_window = *s_large_window; + *s_large_window = false; + bit_reader::BrotliTakeBits(br, 1, &mut n); + if (n == 0) { + *s_window_bits = 16; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + bit_reader::BrotliTakeBits(br, 3, &mut n); + if (n != 0) { + *s_window_bits = 17 + n; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + bit_reader::BrotliTakeBits(br, 3, &mut n); + if (n == 1) { + if (large_window) { + bit_reader::BrotliTakeBits(br, 1, &mut n); + if (n == 1) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS; + } + *s_large_window = true; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } else { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS; + } + } + if (n != 0) { + *s_window_bits = 8 + n; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + *s_window_bits = 17; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; +} + + +#[cold] +fn mark_unlikely() {} + +fn DecodeVarLenUint8(substate_decode_uint8: &mut state::BrotliRunningDecodeUint8State, + mut br: &mut bit_reader::BrotliBitReader, + value: &mut u32, + input: &[u8]) + -> BrotliDecoderErrorCode { + let mut bits: u32 = 0; + loop { + match *substate_decode_uint8 { + BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_NONE => { + if !bit_reader::BrotliSafeReadBits(&mut br, 1, &mut bits, input) { + mark_unlikely(); + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (bits == 0) { + *value = 0; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_SHORT; + // No break, transit to the next state. + } + BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_SHORT => { + if !bit_reader::BrotliSafeReadBits(&mut br, 3, &mut bits, input) { + mark_unlikely(); + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_SHORT; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (bits == 0) { + *value = 1; + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + // Use output value as a temporary storage. It MUST be persisted. + *value = bits; + // No break, transit to the next state. + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_LONG; + } + BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_LONG => { + if !bit_reader::BrotliSafeReadBits(&mut br, *value, &mut bits, input) { + mark_unlikely(); + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_LONG; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + *value = (1u32 << *value) + bits; + *substate_decode_uint8 = BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + } + } +} + +fn DecodeMetaBlockLength<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + let mut bits: u32 = 0; + loop { + match s.substate_metablock_header { + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NONE => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.is_last_metablock = bits as u8; + s.meta_block_remaining_len = 0; + s.is_uncompressed = 0; + s.is_metadata = 0; + if (s.is_last_metablock == 0) { + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NIBBLES; + continue; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_EMPTY; + // No break, transit to the next state. + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_EMPTY => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if bits != 0 { + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NIBBLES; + // No break, transit to the next state. + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NIBBLES => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 2, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.size_nibbles = (bits + 4) as u8; + s.loop_counter = 0; + if (bits == 3) { + s.is_metadata = 1; + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_RESERVED; + continue; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_SIZE; + // No break, transit to the next state. + + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_SIZE => { + let mut i = s.loop_counter; + while i < s.size_nibbles as i32 { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 4, &mut bits, input) { + s.loop_counter = i; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (i + 1 == s.size_nibbles as i32 && s.size_nibbles > 4 && bits == 0) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE; + } + s.meta_block_remaining_len |= (bits << (i * 4)) as i32; + i += 1; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED; + // No break, transit to the next state. + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED => { + if (s.is_last_metablock == 0 && s.is_metadata == 0) { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.is_uncompressed = bits as u8; + } + s.meta_block_remaining_len += 1; + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_RESERVED => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (bits != 0) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_RESERVED; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_BYTES; + // No break, transit to the next state. + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_BYTES => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 2, &mut bits, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (bits == 0) { + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + s.size_nibbles = bits as u8; + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_METADATA; + // No break, transit to the next state. + } + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_METADATA => { + let mut i = s.loop_counter; + while i < s.size_nibbles as i32 { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 8, &mut bits, input) { + s.loop_counter = i; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (i + 1 == s.size_nibbles as i32 && s.size_nibbles > 1 && bits == 0) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE; + } + s.meta_block_remaining_len |= (bits << (i * 8)) as i32; + i += 1; + } + s.substate_metablock_header = + BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED; + continue; + } + } + } +} +// Decodes the Huffman code. +// This method doesn't read data from the bit reader, BUT drops the amount of +// bits that correspond to the decoded symbol. +// bits MUST contain at least 15 (BROTLI_HUFFMAN_MAX_CODE_LENGTH) valid bits. +#[inline(always)] +fn DecodeSymbol(bits: u32, table: &[HuffmanCode], br: &mut bit_reader::BrotliBitReader) -> u32 { + let mut table_index = bits & HUFFMAN_TABLE_MASK; + let mut table_element = fast!((table)[table_index as usize]); + if table_element.bits > HUFFMAN_TABLE_BITS as u8 { + let nbits = table_element.bits - HUFFMAN_TABLE_BITS as u8; + bit_reader::BrotliDropBits(br, HUFFMAN_TABLE_BITS); + table_index += table_element.value as u32; + table_element = fast!((table)[(table_index + + ((bits >> HUFFMAN_TABLE_BITS) + & bit_reader::BitMask(nbits as u32))) as usize]); + } + bit_reader::BrotliDropBits(br, table_element.bits as u32); + table_element.value as u32 +} + +// Reads and decodes the next Huffman code from bit-stream. +// This method peeks 16 bits of input and drops 0 - 15 of them. +#[inline(always)] +fn ReadSymbol(table: &[HuffmanCode], br: &mut bit_reader::BrotliBitReader, input: &[u8]) -> u32 { + DecodeSymbol(bit_reader::BrotliGet16BitsUnmasked(br, input), table, br) +} + +// Same as DecodeSymbol, but it is known that there is less than 15 bits of +// input are currently available. +fn SafeDecodeSymbol(table: &[HuffmanCode], + mut br: &mut bit_reader::BrotliBitReader, + result: &mut u32) + -> bool { + let mut available_bits = bit_reader::BrotliGetAvailableBits(br); + if (available_bits == 0) { + if (fast!((table)[0]).bits == 0) { + *result = fast!((table)[0]).value as u32; + return true; + } + return false; /* No valid bits at all. */ + } + let mut val = bit_reader::BrotliGetBitsUnmasked(br) as u32; + let table_index = (val & HUFFMAN_TABLE_MASK) as usize; + let table_element = fast!((table)[table_index]); + if (table_element.bits <= HUFFMAN_TABLE_BITS as u8) { + if (table_element.bits as u32 <= available_bits) { + bit_reader::BrotliDropBits(&mut br, table_element.bits as u32); + *result = table_element.value as u32; + return true; + } else { + return false; /* Not enough bits for the first level. */ + } + } + if (available_bits <= HUFFMAN_TABLE_BITS) { + return false; /* Not enough bits to move to the second level. */ + } + + // Speculatively drop HUFFMAN_TABLE_BITS. + val = (val & bit_reader::BitMask(table_element.bits as u32)) >> HUFFMAN_TABLE_BITS; + available_bits -= HUFFMAN_TABLE_BITS; + let table_sub_element = fast!((table)[table_index + table_element.value as usize + val as usize]); + if (available_bits < table_sub_element.bits as u32) { + return false; /* Not enough bits for the second level. */ + } + + bit_reader::BrotliDropBits(&mut br, HUFFMAN_TABLE_BITS + table_sub_element.bits as u32); + *result = table_sub_element.value as u32; + true +} + +fn SafeReadSymbol(table: &[HuffmanCode], + br: &mut bit_reader::BrotliBitReader, + result: &mut u32, + input: &[u8]) + -> bool { + let mut val: u32 = 0; + if (bit_reader::BrotliSafeGetBits(br, 15, &mut val, input)) { + *result = DecodeSymbol(val, table, br); + return true; + } else { + mark_unlikely(); + } + SafeDecodeSymbol(table, br, result) +} + +// Makes a look-up in first level Huffman table. Peeks 8 bits. +fn PreloadSymbol(safe: bool, + table: &[HuffmanCode], + br: &mut bit_reader::BrotliBitReader, + bits: &mut u32, + value: &mut u32, + input: &[u8]) { + if (safe) { + return; + } + let table_element = + fast!((table)[bit_reader::BrotliGetBits(br, HUFFMAN_TABLE_BITS, input) as usize]); + *bits = table_element.bits as u32; + *value = table_element.value as u32; +} + +// Decodes the next Huffman code using data prepared by PreloadSymbol. +// Reads 0 - 15 bits. Also peeks 8 following bits. +fn ReadPreloadedSymbol(table: &[HuffmanCode], + br: &mut bit_reader::BrotliBitReader, + bits: &mut u32, + value: &mut u32, + input: &[u8]) + -> u32 { + let result = if *bits > HUFFMAN_TABLE_BITS { + mark_unlikely(); + let val = bit_reader::BrotliGet16BitsUnmasked(br, input); + let mut ext_index = (val & HUFFMAN_TABLE_MASK) + *value; + let mask = bit_reader::BitMask((*bits - HUFFMAN_TABLE_BITS)); + bit_reader::BrotliDropBits(br, HUFFMAN_TABLE_BITS); + ext_index += (val >> HUFFMAN_TABLE_BITS) & mask; + let ext = fast!((table)[ext_index as usize]); + bit_reader::BrotliDropBits(br, ext.bits as u32); + ext.value as u32 + } else { + bit_reader::BrotliDropBits(br, *bits); + *value + }; + PreloadSymbol(false, table, br, bits, value, input); + result +} + +fn Log2Floor(mut x: u32) -> u32 { + let mut result: u32 = 0; + while x != 0 { + x >>= 1; + result += 1; + } + result +} + + +// Reads (s->symbol + 1) symbols. +// Totally 1..4 symbols are read, 1..11 bits each. +// The list of symbols MUST NOT contain duplicates. +// +fn ReadSimpleHuffmanSymbols<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (alphabet_size: u32, max_symbol: u32, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + // max_bits == 1..11; symbol == 0..3; 1..44 bits will be read. + let max_bits = Log2Floor(alphabet_size - 1); + let mut i = s.sub_loop_counter; + let num_symbols = s.symbol; + for symbols_lists_item in fast_mut!((s.symbols_lists_array)[s.sub_loop_counter as usize; + num_symbols as usize + 1]) + .iter_mut() { + let mut v: u32 = 0; + if !bit_reader::BrotliSafeReadBits(&mut s.br, max_bits, &mut v, input) { + mark_unlikely(); + s.sub_loop_counter = i; + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_READ; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (v >= max_symbol) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET; + } + *symbols_lists_item = v as u16; + BROTLI_LOG_UINT!(v); + i += 1; + } + i = 0; + for symbols_list_item in fast!((s.symbols_lists_array)[0; num_symbols as usize]).iter() { + for other_item in fast!((s.symbols_lists_array)[i as usize + 1 ; num_symbols as usize+ 1]) + .iter() { + if (*symbols_list_item == *other_item) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME; + } + } + i += 1; + } + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS +} + +// Process single decoded symbol code length: +// A) reset the repeat variable +// B) remember code length (if it is not 0) +// C) extend corredponding index-chain +// D) reduce the huffman space +// E) update the histogram +// +fn ProcessSingleCodeLength(code_len: u32, + symbol: &mut u32, + repeat: &mut u32, + space: &mut u32, + prev_code_len: &mut u32, + symbol_lists: &mut [u16], + symbol_list_index_offset: usize, + code_length_histo: &mut [u16], + next_symbol: &mut [i32]) { + *repeat = 0; + if (code_len != 0) { + // code_len == 1..15 + // next_symbol may be negative, hence we have to supply offset to function + fast_mut!((symbol_lists)[(symbol_list_index_offset as i32 + + fast_inner!((next_symbol)[code_len as usize])) as usize]) = + (*symbol) as u16; + fast_mut!((next_symbol)[code_len as usize]) = (*symbol) as i32; + *prev_code_len = code_len; + *space = space.wrapping_sub(32768 >> code_len); + fast_mut!((code_length_histo)[code_len as usize]) += 1; + BROTLI_LOG!("[ReadHuffmanCode] code_length[{:}]={:} histo[]={:}\n", + *symbol, code_len, code_length_histo[code_len as usize]); + } + (*symbol) += 1; +} + +// Process repeated symbol code length. +// A) Check if it is the extension of previous repeat sequence; if the decoded +// value is not kCodeLengthRepeatCode, then it is a new symbol-skip +// B) Update repeat variable +// C) Check if operation is feasible (fits alphapet) +// D) For each symbol do the same operations as in ProcessSingleCodeLength +// +// PRECONDITION: code_len == kCodeLengthRepeatCode or kCodeLengthRepeatCode + 1 +// +fn ProcessRepeatedCodeLength(code_len: u32, + mut repeat_delta: u32, + alphabet_size: u32, + symbol: &mut u32, + repeat: &mut u32, + space: &mut u32, + prev_code_len: &mut u32, + repeat_code_len: &mut u32, + symbol_lists: &mut [u16], + symbol_lists_index: usize, + code_length_histo: &mut [u16], + next_symbol: &mut [i32]) { + let old_repeat: u32; + let extra_bits: u32; + let new_len: u32; + if (code_len == kCodeLengthRepeatCode) { + extra_bits = 2; + new_len = *prev_code_len + } else { + extra_bits = 3; + new_len = 0 + } + if (*repeat_code_len != new_len) { + *repeat = 0; + *repeat_code_len = new_len; + } + old_repeat = *repeat; + if (*repeat > 0) { + *repeat -= 2; + *repeat <<= extra_bits; + } + *repeat += repeat_delta + 3; + repeat_delta = *repeat - old_repeat; + if (*symbol + repeat_delta > alphabet_size) { + *symbol = alphabet_size; + *space = 0xFFFFF; + return; + } + BROTLI_LOG!("[ReadHuffmanCode] code_length[{:}..{:}] = {:}\n", + *symbol, *symbol + repeat_delta - 1, *repeat_code_len); + if (*repeat_code_len != 0) { + let last: u32 = *symbol + repeat_delta; + let mut next: i32 = fast!((next_symbol)[*repeat_code_len as usize]); + loop { + fast_mut!((symbol_lists)[(symbol_lists_index as i32 + next) as usize]) = (*symbol) as u16; + next = (*symbol) as i32; + (*symbol) += 1; + if *symbol == last { + break; + } + } + fast_mut!((next_symbol)[*repeat_code_len as usize]) = next; + *space = space.wrapping_sub(repeat_delta << (15 - *repeat_code_len)); + fast_mut!((code_length_histo)[*repeat_code_len as usize]) = + (fast!((code_length_histo)[*repeat_code_len as usize]) as u32 + repeat_delta) as u16; + } else { + *symbol += repeat_delta; + } +} + +// Reads and decodes symbol codelengths. +fn ReadSymbolCodeLengths<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (alphabet_size: u32, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + let mut symbol = s.symbol; + let mut repeat = s.repeat; + let mut space = s.space; + let mut prev_code_len: u32 = s.prev_code_len; + let mut repeat_code_len: u32 = s.repeat_code_len; + if (!bit_reader::BrotliWarmupBitReader(&mut s.br, input)) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + while (symbol < alphabet_size && space > 0) { + let mut p_index = 0; + let code_len: u32; + if (!bit_reader::BrotliCheckInputAmount(&s.br, bit_reader::BROTLI_SHORT_FILL_BIT_WINDOW_READ)) { + s.symbol = symbol; + s.repeat = repeat; + s.prev_code_len = prev_code_len; + s.repeat_code_len = repeat_code_len; + s.space = space; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + bit_reader::BrotliFillBitWindow16(&mut s.br, input); + p_index += + bit_reader::BrotliGetBitsUnmasked(&s.br) & + bit_reader::BitMask(huffman::BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH as u32) as u64; + let p = fast!((s.table)[p_index as usize]); + bit_reader::BrotliDropBits(&mut s.br, p.bits as u32); /* Use 1..5 bits */ + code_len = p.value as u32; /* code_len == 0..17 */ + if (code_len < kCodeLengthRepeatCode) { + ProcessSingleCodeLength(code_len, + &mut symbol, + &mut repeat, + &mut space, + &mut prev_code_len, + &mut s.symbols_lists_array, + s.symbol_lists_index as usize, + &mut s.code_length_histo[..], + &mut s.next_symbol[..]); + } else { + // code_len == 16..17, extra_bits == 2..3 + let extra_bits: u32 = if code_len == kCodeLengthRepeatCode { + 2 + } else { + 3 + }; + let repeat_delta: u32 = bit_reader::BrotliGetBitsUnmasked(&s.br) as u32 & + bit_reader::BitMask(extra_bits); + bit_reader::BrotliDropBits(&mut s.br, extra_bits); + ProcessRepeatedCodeLength(code_len, + repeat_delta, + alphabet_size, + &mut symbol, + &mut repeat, + &mut space, + &mut prev_code_len, + &mut repeat_code_len, + &mut s.symbols_lists_array, + s.symbol_lists_index as usize, + &mut s.code_length_histo[..], + &mut s.next_symbol[..]); + } + } + s.space = space; + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS +} + +fn SafeReadSymbolCodeLengths<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (alphabet_size: u32, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + while (s.symbol < alphabet_size && s.space > 0) { + let mut p_index = 0; + let code_len: u32; + let mut bits: u32 = 0; + let available_bits: u32 = bit_reader::BrotliGetAvailableBits(&s.br); + if (available_bits != 0) { + bits = bit_reader::BrotliGetBitsUnmasked(&s.br) as u32; + } + p_index += bits & + bit_reader::BitMask(huffman::BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH as u32); + let p = fast!((s.table)[p_index as usize]); + if (p.bits as u32 > available_bits) { + // pullMoreInput; + if (!bit_reader::BrotliPullByte(&mut s.br, input)) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + continue; + } + code_len = p.value as u32; /* code_len == 0..17 */ + if (code_len < kCodeLengthRepeatCode) { + bit_reader::BrotliDropBits(&mut s.br, p.bits as u32); + ProcessSingleCodeLength(code_len, + &mut s.symbol, + &mut s.repeat, + &mut s.space, + &mut s.prev_code_len, + &mut s.symbols_lists_array, + s.symbol_lists_index as usize, + &mut s.code_length_histo[..], + &mut s.next_symbol[..]); + } else { + // code_len == 16..17, extra_bits == 2..3 + let extra_bits: u32 = code_len - 14; + let repeat_delta: u32 = (bits >> p.bits) & bit_reader::BitMask(extra_bits); + if (available_bits < p.bits as u32 + extra_bits) { + // pullMoreInput; + if (!bit_reader::BrotliPullByte(&mut s.br, input)) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + continue; + } + bit_reader::BrotliDropBits(&mut s.br, p.bits as u32 + extra_bits); + ProcessRepeatedCodeLength(code_len, + repeat_delta, + alphabet_size, + &mut s.symbol, + &mut s.repeat, + &mut s.space, + &mut s.prev_code_len, + &mut s.repeat_code_len, + &mut s.symbols_lists_array, + s.symbol_lists_index as usize, + &mut s.code_length_histo[..], + &mut s.next_symbol[..]); + } + } + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS +} + +// Reads and decodes 15..18 codes using static prefix code. +// Each code is 2..4 bits long. In total 30..72 bits are used. +fn ReadCodeLengthCodeLengths<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + let mut num_codes: u32 = s.repeat; + let mut space: u32 = s.space; + let mut i = s.sub_loop_counter; + for code_length_code_order in + fast!((kCodeLengthCodeOrder)[s.sub_loop_counter as usize; CODE_LENGTH_CODES]).iter() { + let code_len_idx = *code_length_code_order; + let mut ix: u32 = 0; + + if !bit_reader::BrotliSafeGetBits(&mut s.br, 4, &mut ix, input) { + mark_unlikely(); + let available_bits: u32 = bit_reader::BrotliGetAvailableBits(&s.br); + if (available_bits != 0) { + ix = bit_reader::BrotliGetBitsUnmasked(&s.br) as u32 & 0xF; + } else { + ix = 0; + } + if (fast!((kCodeLengthPrefixLength)[ix as usize]) as u32 > available_bits) { + s.sub_loop_counter = i; + s.repeat = num_codes; + s.space = space; + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_COMPLEX; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + } + BROTLI_LOG_UINT!(ix); + let v: u32 = fast!((kCodeLengthPrefixValue)[ix as usize]) as u32; + bit_reader::BrotliDropBits(&mut s.br, + fast!((kCodeLengthPrefixLength)[ix as usize]) as u32); + fast_mut!((s.code_length_code_lengths)[code_len_idx as usize]) = v as u8; + BROTLI_LOG_ARRAY_INDEX!(s.code_length_code_lengths, code_len_idx); + if v != 0 { + space = space.wrapping_sub(32 >> v); + num_codes += 1; + fast_mut!((s.code_length_histo)[v as usize]) += 1; + if space.wrapping_sub(1) >= 32 { + // space is 0 or wrapped around + break; + } + } + i += 1; + } + if (!(num_codes == 1 || space == 0)) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_CL_SPACE; + } + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS +} + + +// Decodes the Huffman tables. +// There are 2 scenarios: +// A) Huffman code contains only few symbols (1..4). Those symbols are read +// directly; their code lengths are defined by the number of symbols. +// For this scenario 4 - 49 bits will be read. +// +// B) 2-phase decoding: +// B.1) Small Huffman table is decoded; it is specified with code lengths +// encoded with predefined entropy code. 32 - 74 bits are used. +// B.2) Decoded table is used to decode code lengths of symbols in resulting +// Huffman table. In worst case 3520 bits are read. +// +fn ReadHuffmanCode<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (mut alphabet_size: u32, + max_symbol: u32, + table: &mut [HuffmanCode], + offset: usize, + opt_table_size: Option<&mut u32>, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + // Unnecessary masking, but might be good for safety. + alphabet_size &= 0x7ff; + // State machine + loop { + match s.substate_huffman { + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_NONE => { + if !bit_reader::BrotliSafeReadBits(&mut s.br, 2, &mut s.sub_loop_counter, input) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + + BROTLI_LOG_UINT!(s.sub_loop_counter); + // The value is used as follows: + // 1 for simple code; + // 0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths + if (s.sub_loop_counter != 1) { + s.space = 32; + s.repeat = 0; /* num_codes */ + let max_code_len_len = huffman::BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH as usize + 1; + for code_length_histo in fast_mut!((s.code_length_histo)[0;max_code_len_len]).iter_mut() { + *code_length_histo = 0; // memset + } + for code_length_code_length in s.code_length_code_lengths[..].iter_mut() { + *code_length_code_length = 0; + } + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_COMPLEX; + // goto Complex; + continue; + } + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_SIZE; + // No break, transit to the next state. + } + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_SIZE => { + // Read symbols, codes & code lengths directly. + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 2, &mut s.symbol, input)) { + // num_symbols + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_SIZE; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.sub_loop_counter = 0; + // No break, transit to the next state. + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_READ; + } + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_READ => { + let result = ReadSimpleHuffmanSymbols(alphabet_size, max_symbol, s, input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + // No break, transit to the next state. + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_BUILD; + } + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_BUILD => { + let table_size: u32; + if (s.symbol == 3) { + let mut bits: u32 = 0; + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input)) { + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_SIMPLE_BUILD; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.symbol += bits; + } + BROTLI_LOG_UINT!(s.symbol); + table_size = huffman::BrotliBuildSimpleHuffmanTable(&mut table[offset..], + HUFFMAN_TABLE_BITS as i32, + &s.symbols_lists_array[..], + s.symbol); + if let Some(opt_table_size_ref) = opt_table_size { + *opt_table_size_ref = table_size + } + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + + // Decode Huffman-coded code lengths. + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_COMPLEX => { + + let result = ReadCodeLengthCodeLengths(s, input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + huffman::BrotliBuildCodeLengthsHuffmanTable(&mut s.table, + &s.code_length_code_lengths, + &s.code_length_histo); + for code_length_histo in s.code_length_histo[..].iter_mut() { + *code_length_histo = 0; // memset + } + + let max_code_length = huffman::BROTLI_HUFFMAN_MAX_CODE_LENGTH as usize + 1; + for (i, next_symbol_mut) in fast_mut!((s.next_symbol)[0; max_code_length]) + .iter_mut() + .enumerate() { + *next_symbol_mut = i as i32 - (max_code_length as i32); + fast_mut!((s.symbols_lists_array)[(s.symbol_lists_index as i32 + + i as i32 + - (max_code_length as i32)) as usize]) = 0xFFFF; + } + + s.symbol = 0; + s.prev_code_len = kDefaultCodeLength; + s.repeat = 0; + s.repeat_code_len = 0; + s.space = 32768; + // No break, transit to the next state. + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS; + } + BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS => { + let table_size: u32; + let mut result = ReadSymbolCodeLengths(max_symbol, s, input); + if let BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT = result { + result = SafeReadSymbolCodeLengths(max_symbol, s, input) + } + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + + if (s.space != 0) { + BROTLI_LOG!("[ReadHuffmanCode] space = %d\n", s.space); + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE; + } + table_size = huffman::BrotliBuildHuffmanTable(fast_mut!((table)[offset;]), + HUFFMAN_TABLE_BITS as i32, + &s.symbols_lists_array[..], + s.symbol_lists_index, + &mut s.code_length_histo); + if let Some(opt_table_size_ref) = opt_table_size { + *opt_table_size_ref = table_size + } + s.substate_huffman = BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + } + } +} + +// Decodes a block length by reading 3..39 bits. +fn ReadBlockLength(table: &[HuffmanCode], + br: &mut bit_reader::BrotliBitReader, + input: &[u8]) + -> u32 { + let code: u32; + let nbits: u32; + code = ReadSymbol(table, br, input); + nbits = fast_ref!((prefix::kBlockLengthPrefixCode)[code as usize]).nbits as u32; /*nbits==2..24*/ + fast_ref!((prefix::kBlockLengthPrefixCode)[code as usize]).offset as u32 + + bit_reader::BrotliReadBits(br, nbits, input) +} + + +// WARNING: if state is not BROTLI_STATE_READ_BLOCK_LENGTH_NONE, then +// reading can't be continued with ReadBlockLength. +fn SafeReadBlockLengthIndex(substate_read_block_length: &state::BrotliRunningReadBlockLengthState, + block_length_index: u32, + table: &[HuffmanCode], + mut br: &mut bit_reader::BrotliBitReader, + input: &[u8]) + -> (bool, u32) { + match *substate_read_block_length { + state::BrotliRunningReadBlockLengthState::BROTLI_STATE_READ_BLOCK_LENGTH_NONE => { + let mut index: u32 = 0; + if (!SafeReadSymbol(table, &mut br, &mut index, input)) { + return (false, 0); + } + (true, index) + } + _ => (true, block_length_index), + } +} +fn SafeReadBlockLengthFromIndex< + AllocHC : alloc::Allocator<HuffmanCode> >(s : &mut BlockTypeAndLengthState<AllocHC>, + br : &mut bit_reader::BrotliBitReader, + result : &mut u32, + res_index : (bool, u32), + input : &[u8]) -> bool{ + let (res, index) = res_index; + if !res { + return false; + } + let mut bits: u32 = 0; + let nbits = fast_ref!((prefix::kBlockLengthPrefixCode)[index as usize]).nbits; /* nbits==2..24 */ + if (!bit_reader::BrotliSafeReadBits(br, nbits as u32, &mut bits, input)) { + s.block_length_index = index; + s.substate_read_block_length = + state::BrotliRunningReadBlockLengthState::BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX; + return false; + } + *result = fast_ref!((prefix::kBlockLengthPrefixCode)[index as usize]).offset as u32 + bits; + s.substate_read_block_length = + state::BrotliRunningReadBlockLengthState::BROTLI_STATE_READ_BLOCK_LENGTH_NONE; + true +} +macro_rules! SafeReadBlockLength ( + ($state : expr, $result : expr , $table : expr) => { + SafeReadBlockLengthFromIndex(&mut $state, &mut $result, + SafeReadBlockLengthIndex($state.substate_read_block_length, + $state.block_length_index, + $table, + &mut $state.br)) + }; +); + +// Transform: +// 1) initialize list L with values 0, 1,... 255 +// 2) For each input element X: +// 2.1) let Y = L[X] +// 2.2) remove X-th element from L +// 2.3) prepend Y to L +// 2.4) append Y to output +// +// In most cases max(Y) <= 7, so most of L remains intact. +// To reduce the cost of initialization, we reuse L, remember the upper bound +// of Y values, and reinitialize only first elements in L. +// +// Most of input values are 0 and 1. To reduce number of branches, we replace +// inner for loop with do-while. +// +fn InverseMoveToFrontTransform(v: &mut [u8], + v_len: u32, + mtf: &mut [u8;256], + mtf_upper_bound: &mut u32) { + // Reinitialize elements that could have been changed. + let mut upper_bound: u32 = *mtf_upper_bound; + for (i, item) in fast_mut!((mtf)[0;(upper_bound as usize + 1usize)]).iter_mut().enumerate() { + *item = i as u8; + } + + // Transform the input. + upper_bound = 0; + for v_i in fast_mut!((v)[0usize ; (v_len as usize)]).iter_mut() { + let mut index = (*v_i) as i32; + let value = fast!((mtf)[index as usize]); + upper_bound |= (*v_i) as u32; + *v_i = value; + if index <= 0 { + fast_mut!((mtf)[0]) = 0; + } else { + loop { + index -= 1; + fast_mut!((mtf)[(index + 1) as usize]) = fast!((mtf)[index as usize]); + if index <= 0 { + break; + } + } + } + fast_mut!((mtf)[0]) = value; + } + // Remember amount of elements to be reinitialized. + *mtf_upper_bound = upper_bound; +} +// Decodes a series of Huffman table using ReadHuffmanCode function. +fn HuffmanTreeGroupDecode<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (group_index: i32, + mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + let mut hcodes: AllocHC::AllocatedMemory; + let mut htrees: AllocU32::AllocatedMemory; + let alphabet_size: u16; + let group_num_htrees: u16; + let group_max_symbol; + if group_index == 0 { + hcodes = mem::replace(&mut s.literal_hgroup.codes, + AllocHC::AllocatedMemory::default()); + htrees = mem::replace(&mut s.literal_hgroup.htrees, + AllocU32::AllocatedMemory::default()); + group_num_htrees = s.literal_hgroup.num_htrees; + alphabet_size = s.literal_hgroup.alphabet_size; + group_max_symbol = s.literal_hgroup.max_symbol; + } else if group_index == 1 { + hcodes = mem::replace(&mut s.insert_copy_hgroup.codes, + AllocHC::AllocatedMemory::default()); + htrees = mem::replace(&mut s.insert_copy_hgroup.htrees, + AllocU32::AllocatedMemory::default()); + group_num_htrees = s.insert_copy_hgroup.num_htrees; + alphabet_size = s.insert_copy_hgroup.alphabet_size; + group_max_symbol = s.insert_copy_hgroup.max_symbol; + } else { + if group_index != 2 { + let ret = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE; + SaveErrorCode!(s, ret); + return ret; + } + hcodes = mem::replace(&mut s.distance_hgroup.codes, + AllocHC::AllocatedMemory::default()); + htrees = mem::replace(&mut s.distance_hgroup.htrees, + AllocU32::AllocatedMemory::default()); + group_num_htrees = s.distance_hgroup.num_htrees; + alphabet_size = s.distance_hgroup.alphabet_size; + group_max_symbol = s.distance_hgroup.max_symbol; + } + match s.substate_tree_group { + BrotliRunningTreeGroupState::BROTLI_STATE_TREE_GROUP_NONE => { + s.htree_next_offset = 0; + s.htree_index = 0; + s.substate_tree_group = BrotliRunningTreeGroupState::BROTLI_STATE_TREE_GROUP_LOOP; + } + BrotliRunningTreeGroupState::BROTLI_STATE_TREE_GROUP_LOOP => {} + } + let mut result = BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + for htree_iter in + fast_mut!((htrees.slice_mut())[s.htree_index as usize ; (group_num_htrees as usize)]) + .iter_mut() { + let mut table_size: u32 = 0; + result = ReadHuffmanCode(u32::from(alphabet_size), u32::from(group_max_symbol), + hcodes.slice_mut(), + s.htree_next_offset as usize, + Some(&mut table_size), + &mut s, + input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, // break and return the result code + } + *htree_iter = s.htree_next_offset; + s.htree_next_offset += table_size; + s.htree_index += 1; + } + if group_index == 0 { + let _ = mem::replace(&mut s.literal_hgroup.codes, + mem::replace(&mut hcodes, AllocHC::AllocatedMemory::default())); + let _ = mem::replace(&mut s.literal_hgroup.htrees, + mem::replace(&mut htrees, AllocU32::AllocatedMemory::default())); + } else if group_index == 1 { + let _ = mem::replace(&mut s.insert_copy_hgroup.codes, + mem::replace(&mut hcodes, AllocHC::AllocatedMemory::default())); + let _ = mem::replace(&mut s.insert_copy_hgroup.htrees, + mem::replace(&mut htrees, AllocU32::AllocatedMemory::default())); + } else { + let _ = mem::replace(&mut s.distance_hgroup.codes, + mem::replace(&mut hcodes, AllocHC::AllocatedMemory::default())); + let _ = mem::replace(&mut s.distance_hgroup.htrees, + mem::replace(&mut htrees, AllocU32::AllocatedMemory::default())); + } + if let BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS = result { + s.substate_tree_group = BrotliRunningTreeGroupState::BROTLI_STATE_TREE_GROUP_NONE + } + result +} +#[allow(dead_code)] +pub fn lg_window_size(first_byte: u8, second_byte: u8) -> Result<(u8, u8), ()> { + if first_byte & 1 == 0 { + return Ok((16, 1)); + } + match first_byte & 15 { + 0x3 => return Ok((18, 4)), + 0x5 => return Ok((19, 4)), + 0x7 => return Ok((20, 4)), + 0x9 => return Ok((21, 4)), + 0xb => return Ok((22, 4)), + 0xd => return Ok((23, 4)), + 0xf => return Ok((24, 4)), + _ => match first_byte & 127 { + 0x71 => return Ok((15, 7)), + 0x61 => return Ok((14, 7)), + 0x51 => return Ok((13, 7)), + 0x41 => return Ok((12, 7)), + 0x31 => return Ok((11, 7)), + 0x21 => return Ok((10, 7)), + 0x1 => return Ok((17, 7)), + _ => {}, + } + } + if (first_byte & 0x80) != 0 { + return Err(()); + } + let ret = second_byte & 0x3f; + if ret < 10 || ret > 30 { + return Err(()); + } + Ok((ret, 14)) + +} + + +fn bzero(data: &mut [u8]) { + for iter in data.iter_mut() { + *iter = 0; + } +} + + +// Decodes a context map. +// Decoding is done in 4 phases: +// 1) Read auxiliary information (6..16 bits) and allocate memory. +// In case of trivial context map, decoding is finished at this phase. +// 2) Decode Huffman table using ReadHuffmanCode function. +// This table will be used for reading context map items. +// 3) Read context map items; "0" values could be run-length encoded. +// 4) Optionally, apply InverseMoveToFront transform to the resulting map. +// +fn DecodeContextMapInner<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (context_map_size: u32, + num_htrees: &mut u32, + context_map_arg: &mut AllocU8::AllocatedMemory, + mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + let mut result; + loop { + match s.substate_context_map { + BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_NONE => { + result = DecodeVarLenUint8(&mut s.substate_decode_uint8, &mut s.br, num_htrees, input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + (*num_htrees) += 1; + s.context_index = 0; + BROTLI_LOG_UINT!(context_map_size); + BROTLI_LOG_UINT!(*num_htrees); + *context_map_arg = s.alloc_u8.alloc_cell(context_map_size as usize); + if (context_map_arg.slice().len() < context_map_size as usize) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP; + } + if (*num_htrees <= 1) { + // This happens automatically but we do it to retain C++ similarity: + bzero(context_map_arg.slice_mut()); // necessary if we compiler with unsafe feature flag + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_READ_PREFIX; + // No break, continue to next state. + } + BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_READ_PREFIX => { + let mut bits: u32 = 0; + // In next stage ReadHuffmanCode uses at least 4 bits, so it is safe + // to peek 4 bits ahead. + if (!bit_reader::BrotliSafeGetBits(&mut s.br, 5, &mut bits, input)) { + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if ((bits & 1) != 0) { + // Use RLE for zeroes. + s.max_run_length_prefix = (bits >> 1) + 1; + bit_reader::BrotliDropBits(&mut s.br, 5); + } else { + s.max_run_length_prefix = 0; + bit_reader::BrotliDropBits(&mut s.br, 1); + } + BROTLI_LOG_UINT!(s.max_run_length_prefix); + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_HUFFMAN; + // No break, continue to next state. + } + BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_HUFFMAN => { + + let mut local_context_map_table = mem::replace(&mut s.context_map_table, + AllocHC::AllocatedMemory::default()); + let alphabet_size = *num_htrees + s.max_run_length_prefix; + result = ReadHuffmanCode(alphabet_size, alphabet_size, + &mut local_context_map_table.slice_mut(), + 0, + None, + &mut s, + input); + let _ = mem::replace(&mut s.context_map_table, + mem::replace(&mut local_context_map_table, + AllocHC::AllocatedMemory::default())); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + s.code = 0xFFFF; + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_DECODE; + // No break, continue to next state. + } + BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_DECODE => { + let mut context_index: u32 = s.context_index; + let max_run_length_prefix: u32 = s.max_run_length_prefix; + let context_map = &mut context_map_arg.slice_mut(); + let mut code: u32 = s.code; + let mut rleCodeGoto = (code != 0xFFFF); + while (rleCodeGoto || context_index < context_map_size) { + if !rleCodeGoto { + if (!SafeReadSymbol(s.context_map_table.slice(), &mut s.br, &mut code, input)) { + s.code = 0xFFFF; + s.context_index = context_index; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + BROTLI_LOG_UINT!(code); + + if code == 0 { + fast_mut!((context_map)[context_index as usize]) = 0; + BROTLI_LOG_ARRAY_INDEX!(context_map, context_index as usize); + context_index += 1; + continue; + } + if code > max_run_length_prefix { + fast_mut!((context_map)[context_index as usize]) = + (code - max_run_length_prefix) as u8; + BROTLI_LOG_ARRAY_INDEX!(context_map, context_index as usize); + context_index += 1; + continue; + } + } + rleCodeGoto = false; // <- this was a goto beforehand... now we have reached label + // we are treated like everyday citizens from this point forth + { + let mut reps: u32 = 0; + if (!bit_reader::BrotliSafeReadBits(&mut s.br, code, &mut reps, input)) { + s.code = code; + s.context_index = context_index; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + reps += 1u32 << code; + BROTLI_LOG_UINT!(reps); + if (context_index + reps > context_map_size) { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT; + } + loop { + fast_mut!((context_map)[context_index as usize]) = 0; + BROTLI_LOG_ARRAY_INDEX!(context_map, context_index as usize); + context_index += 1; + reps -= 1; + if reps == 0 { + break; + } + } + } + } + // No break, continue to next state. + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_TRANSFORM; + } + BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_TRANSFORM => { + let mut bits: u32 = 0; + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 1, &mut bits, input)) { + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_TRANSFORM; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + if (bits != 0) { + if let Ok(ref mut mtf) = s.mtf_or_error_string { + InverseMoveToFrontTransform(context_map_arg.slice_mut(), + context_map_size, + mtf, + &mut s.mtf_upper_bound); + } else { + // the error state is stored here--we can't make it this deep with an active error + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE; + } + } + s.substate_context_map = BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_NONE; + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + } + } + // unreachable!(); (compiler will error if it's reachable due to the unit return type) +} + +fn DecodeContextMap<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (context_map_size: usize, + is_dist_context_map: bool, + mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + match s.state { + BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_1 => assert_eq!(is_dist_context_map, false), + BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_2 => assert_eq!(is_dist_context_map, true), + _ => unreachable!(), + } + let (mut num_htrees, mut context_map_arg) = if is_dist_context_map { + (s.num_dist_htrees, mem::replace(&mut s.dist_context_map, AllocU8::AllocatedMemory::default())) + } else { + (s.num_literal_htrees, mem::replace(&mut s.context_map, AllocU8::AllocatedMemory::default())) + }; + + let retval = DecodeContextMapInner(context_map_size as u32, + &mut num_htrees, + &mut context_map_arg, + &mut s, + input); + if is_dist_context_map { + s.num_dist_htrees = num_htrees; + let _ = mem::replace(&mut s.dist_context_map, + mem::replace(&mut context_map_arg, AllocU8::AllocatedMemory::default())); + } else { + s.num_literal_htrees = num_htrees; + let _ = mem::replace(&mut s.context_map, + mem::replace(&mut context_map_arg, AllocU8::AllocatedMemory::default())); + } + retval +} + +// Decodes a command or literal and updates block type ringbuffer. +// Reads 3..54 bits. +fn DecodeBlockTypeAndLength< + AllocHC : alloc::Allocator<HuffmanCode>> (safe : bool, + s : &mut BlockTypeAndLengthState<AllocHC>, + br : &mut bit_reader::BrotliBitReader, + tree_type : i32, + input : &[u8]) -> bool { + let max_block_type = fast!((s.num_block_types)[tree_type as usize]); + let tree_offset = tree_type as usize * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize; + + let mut block_type: u32 = 0; + if max_block_type <= 1 { + return false; + } + // Read 0..15 + 3..39 bits + if (!safe) { + block_type = ReadSymbol(fast_slice!((s.block_type_trees)[tree_offset;]), br, input); + fast_mut!((s.block_length)[tree_type as usize]) = + ReadBlockLength(fast_slice!((s.block_len_trees)[tree_offset;]), br, input); + } else { + let memento = bit_reader::BrotliBitReaderSaveState(br); + if (!SafeReadSymbol(fast_slice!((s.block_type_trees)[tree_offset;]), + br, + &mut block_type, + input)) { + return false; + } + let mut block_length_out: u32 = 0; + + let index_ret = SafeReadBlockLengthIndex(&s.substate_read_block_length, + s.block_length_index, + fast_slice!((s.block_len_trees)[tree_offset;]), + br, + input); + if !SafeReadBlockLengthFromIndex(s, br, &mut block_length_out, index_ret, input) { + s.substate_read_block_length = + BrotliRunningReadBlockLengthState::BROTLI_STATE_READ_BLOCK_LENGTH_NONE; + bit_reader::BrotliBitReaderRestoreState(br, &memento); + return false; + } + fast_mut!((s.block_length)[tree_type as usize]) = block_length_out; + } + let ringbuffer: &mut [u32] = &mut fast_mut!((s.block_type_rb)[tree_type as usize * 2;]); + if (block_type == 1) { + block_type = fast!((ringbuffer)[1]) + 1; + } else if (block_type == 0) { + block_type = fast!((ringbuffer)[0]); + } else { + block_type -= 2; + } + if (block_type >= max_block_type) { + block_type -= max_block_type; + } + fast_mut!((ringbuffer)[0]) = fast!((ringbuffer)[1]); + fast_mut!((ringbuffer)[1]) = block_type; + true +} +fn DetectTrivialLiteralBlockTypes<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>) { + for iter in s.trivial_literal_contexts.iter_mut() { + *iter = 0; + } + let mut i: usize = 0; + while i < fast!((s.block_type_length_state.num_block_types)[0]) as usize { + let offset = (i as usize) << kLiteralContextBits; + let mut error = 0usize; + let sample: usize = fast_slice!((s.context_map)[offset]) as usize; + let mut j = 0usize; + while j < ((1 as usize) << kLiteralContextBits) { + error |= fast_slice!((s.context_map)[offset + j]) as usize ^ sample; + j += 1; + error |= fast_slice!((s.context_map)[offset + j]) as usize ^ sample; + j += 1; + error |= fast_slice!((s.context_map)[offset + j]) as usize ^ sample; + j += 1; + error |= fast_slice!((s.context_map)[offset + j]) as usize ^ sample; + j += 1 + } + if error == 0 { + s.trivial_literal_contexts[i >> 5] |= ((1 as u32) << (i & 31)); + } + i += 1 + } +} +fn PrepareLiteralDecoding<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>) { + + let context_offset: u32; + let block_type = fast!((s.block_type_length_state.block_type_rb)[1]) as usize; + context_offset = (block_type << kLiteralContextBits) as u32; + s.context_map_slice_index = context_offset as usize; + let trivial = fast!((s.trivial_literal_contexts)[block_type >> 5]); + s.trivial_literal_context = ((trivial >> (block_type & 31)) & 1) as i32; + + s.literal_htree_index = fast_slice!((s.context_map)[s.context_map_slice_index]); + // s.literal_htree = fast!((s.literal_hgroup.htrees)[s.literal_htree_index]); // redundant + let context_mode_index = fast!((s.context_modes.slice())[block_type]) & 3; + s.context_lookup = &kContextLookup[context_mode_index as usize]; +} + +// Decodes the block ty +// pe and updates the state for literal context. +// Reads 3..54 bits. +fn DecodeLiteralBlockSwitchInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + + if !DecodeBlockTypeAndLength(safe, &mut s.block_type_length_state, &mut s.br, 0, input) { + return false; + } + PrepareLiteralDecoding(s); + true +} +// fn DecodeLiteralBlockSwitch< +// 'a, +// AllocU8 : alloc::Allocator<u8>, +// AllocU32 : alloc::Allocator<u32>, +// AllocHC : alloc::Allocator<HuffmanCode>> (safe : bool, +// mut s : &mut BrotliState<AllocU8, AllocU32, AllocHC>) { +// DecodeLiteralBlockSwitchInternal(false, s); +// } +// +// fn SafeDecodeLiteralBlockSwitch< +// 'a, +// AllocU8 : alloc::Allocator<u8>, +// AllocU32 : alloc::Allocator<u32>, +// AllocHC : alloc::Allocator<HuffmanCode>> (safe : bool, +// mut s : &mut BrotliState<AllocU8, AllocU32, AllocHC>) -> bool { +// return DecodeLiteralBlockSwitchInternal(true, s); +// } +// +// Block switch for insert/copy length. +// Reads 3..54 bits. +fn DecodeCommandBlockSwitchInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + if (!DecodeBlockTypeAndLength(safe, &mut s.block_type_length_state, &mut s.br, 1, input)) { + return false; + } + s.htree_command_index = fast!((s.block_type_length_state.block_type_rb)[3]) as u16; + true +} + +#[allow(dead_code)] +fn DecodeCommandBlockSwitch<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) { + DecodeCommandBlockSwitchInternal(false, s, input); +} +#[allow(dead_code)] +fn SafeDecodeCommandBlockSwitch<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + DecodeCommandBlockSwitchInternal(true, s, input) +} + +// Block switch for distance codes. +// Reads 3..54 bits. +fn DecodeDistanceBlockSwitchInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + if (!DecodeBlockTypeAndLength(safe, &mut s.block_type_length_state, &mut s.br, 2, input)) { + return false; + } + s.dist_context_map_slice_index = + (fast!((s.block_type_length_state.block_type_rb)[5]) << kDistanceContextBits) as usize; + s.dist_htree_index = fast_slice!((s.dist_context_map)[s.dist_context_map_slice_index + + s.distance_context as usize]); + true +} + +#[allow(dead_code)] +fn DecodeDistanceBlockSwitch<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) { + DecodeDistanceBlockSwitchInternal(false, s, input); +} + +#[allow(dead_code)] +fn SafeDecodeDistanceBlockSwitch<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + DecodeDistanceBlockSwitchInternal(true, s, input) +} + +fn UnwrittenBytes<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> ( + s: &BrotliState<AllocU8, AllocU32, AllocHC>, + wrap: bool, +) -> usize { + let pos = if wrap && s.pos > s.ringbuffer_size { + s.ringbuffer_size as usize + } else { + s.pos as usize + }; + let partial_pos_rb = (s.rb_roundtrips as usize * s.ringbuffer_size as usize) + pos as usize; + (partial_pos_rb - s.partial_pos_out) as usize +} +fn WriteRingBuffer<'a, + AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + available_out: &mut usize, + opt_output: Option<&mut [u8]>, + output_offset: &mut usize, + total_out: &mut usize, + force: bool, + s: &'a mut BrotliState<AllocU8, AllocU32, AllocHC>, +) -> (BrotliDecoderErrorCode, &'a [u8]) { + let to_write = UnwrittenBytes(s, true); + let mut num_written = *available_out as usize; + if (num_written > to_write) { + num_written = to_write; + } + if (s.meta_block_remaining_len < 0) { + return (BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1, &[]); + } + let start_index = (s.partial_pos_out & s.ringbuffer_mask as usize) as usize; + let start = fast_slice!((s.ringbuffer)[start_index ; start_index + num_written as usize]); + if let Some(output) = opt_output { + fast_mut!((output)[*output_offset ; *output_offset + num_written as usize]) + .clone_from_slice(start); + } + *output_offset += num_written; + *available_out -= num_written; + BROTLI_LOG_UINT!(to_write); + BROTLI_LOG_UINT!(num_written); + s.partial_pos_out += num_written as usize; + *total_out = s.partial_pos_out; + if (num_written < to_write) { + if s.ringbuffer_size == (1 << s.window_bits) || force { + return (BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT, &[]); + } else { + return (BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS, start); + } + } + if (s.ringbuffer_size == (1 << s.window_bits) && + s.pos >= s.ringbuffer_size) { + s.pos -= s.ringbuffer_size; + s.rb_roundtrips += 1; + s.should_wrap_ringbuffer = s.pos != 0; + } + (BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS, start) + } + +fn WrapRingBuffer<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, +) { + if s.should_wrap_ringbuffer { + let (ring_buffer_start, ring_buffer_end) = s.ringbuffer.slice_mut().split_at_mut(s.ringbuffer_size as usize); + let pos = s.pos as usize; + ring_buffer_start.split_at_mut(pos).0.clone_from_slice(ring_buffer_end.split_at(pos).0); + s.should_wrap_ringbuffer = false; + } + +} + +fn CopyUncompressedBlockToOutput<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (mut available_out: &mut usize, + mut output: &mut [u8], + mut output_offset: &mut usize, + mut total_out: &mut usize, + mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + // State machine + loop { + match s.substate_uncompressed { + BrotliRunningUncompressedState::BROTLI_STATE_UNCOMPRESSED_NONE => { + let mut nbytes = bit_reader::BrotliGetRemainingBytes(&s.br) as i32; + if (nbytes > s.meta_block_remaining_len) { + nbytes = s.meta_block_remaining_len; + } + if (s.pos + nbytes > s.ringbuffer_size) { + nbytes = s.ringbuffer_size - s.pos; + } + // Copy remaining bytes from s.br.buf_ to ringbuffer. + bit_reader::BrotliCopyBytes(fast_mut!((s.ringbuffer.slice_mut())[s.pos as usize;]), + &mut s.br, + nbytes as u32, + input); + s.pos += nbytes; + s.meta_block_remaining_len -= nbytes; + if s.pos < (1 << s.window_bits) { + if (s.meta_block_remaining_len == 0) { + return BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + } + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + s.substate_uncompressed = BrotliRunningUncompressedState::BROTLI_STATE_UNCOMPRESSED_WRITE; + // s.partial_pos_rb += (size_t)s.ringbuffer_size; + // No break, continue to next state by going aroudn the loop + } + BrotliRunningUncompressedState::BROTLI_STATE_UNCOMPRESSED_WRITE => { + let (result, _) = WriteRingBuffer(&mut available_out, + Some(&mut output), + &mut output_offset, + &mut total_out, + false, + &mut s); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => return result, + } + if s.ringbuffer_size == 1 << s.window_bits { + s.max_distance = s.max_backward_distance; + } + s.substate_uncompressed = BrotliRunningUncompressedState::BROTLI_STATE_UNCOMPRESSED_NONE; + } + } + } +} + +fn BrotliAllocateRingBuffer<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> bool { + // We need the slack region for the following reasons: + // - doing up to two 16-byte copies for fast backward copying + // - inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) + const kRingBufferWriteAheadSlack: i32 = 42; + let mut is_last = s.is_last_metablock; + s.ringbuffer_size = 1 << s.window_bits; + + if (s.is_uncompressed != 0) { + let next_block_header = + bit_reader::BrotliPeekByte(&mut s.br, s.meta_block_remaining_len as u32, input); + if (next_block_header != -1) && + // Peek succeeded + ((next_block_header & 3) == 3) { + // ISLAST and ISEMPTY + is_last = 1; + } + } + let max_dict_size = s.ringbuffer_size as usize - 16; + { + let custom_dict = if s.custom_dict_size as usize > max_dict_size { + let cd = fast_slice!((s.custom_dict)[(s.custom_dict_size as usize - max_dict_size); s.custom_dict_size as usize]); + s.custom_dict_size = max_dict_size as i32; + cd + } else { + fast_slice!((s.custom_dict)[0; s.custom_dict_size as usize]) + }; + + // We need at least 2 bytes of ring buffer size to get the last two + // bytes for context from there + if (is_last != 0) { + while (s.ringbuffer_size >= (s.custom_dict_size + s.meta_block_remaining_len) * 2 && s.ringbuffer_size > 32) { + s.ringbuffer_size >>= 1; + } + } + if s.ringbuffer_size > (1 << s.window_bits) { + s.ringbuffer_size = (1 << s.window_bits); + } + + s.ringbuffer_mask = s.ringbuffer_size - 1; + s.ringbuffer = s.alloc_u8 + .alloc_cell((s.ringbuffer_size as usize + kRingBufferWriteAheadSlack as usize + + kBrotliMaxDictionaryWordLength as usize)); + if (s.ringbuffer.slice().len() == 0) { + return false; + } + fast_mut!((s.ringbuffer.slice_mut())[s.ringbuffer_size as usize - 1]) = 0; + fast_mut!((s.ringbuffer.slice_mut())[s.ringbuffer_size as usize - 2]) = 0; + if custom_dict.len() != 0 { + let offset = ((-s.custom_dict_size) & s.ringbuffer_mask) as usize; + fast_mut!((s.ringbuffer.slice_mut())[offset ; offset + s.custom_dict_size as usize]).clone_from_slice(custom_dict); + } + } + if s.custom_dict.slice().len() != 0 { + s.alloc_u8.free_cell(core::mem::replace(&mut s.custom_dict, + AllocU8::AllocatedMemory::default())); + } + true +} + +// Reads 1..256 2-bit context modes. +pub fn ReadContextModes<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + + let mut i: i32 = s.loop_counter; + + for context_mode_iter in fast_mut!((s.context_modes.slice_mut())[i as usize ; + (s.block_type_length_state.num_block_types[0] + as usize)]) + .iter_mut() { + let mut bits: u32 = 0; + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 2, &mut bits, input)) { + mark_unlikely(); + s.loop_counter = i; + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + *context_mode_iter = bits as u8; + BROTLI_LOG_UINT!(i); + i += 1; + } + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS +} + +pub fn TakeDistanceFromRingBuffer<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>) { + if (s.distance_code == 0) { + s.dist_rb_idx -= 1; + s.distance_code = fast!((s.dist_rb)[(s.dist_rb_idx & 3) as usize]); + s.distance_context = 1; + } else { + let distance_code = s.distance_code << 1; + // kDistanceShortCodeIndexOffset has 2-bit values from LSB: + // 3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 + const kDistanceShortCodeIndexOffset: u32 = 0xaaafff1b; + // kDistanceShortCodeValueOffset has 2-bit values from LSB: + // -0, 0,-0, 0,-1, 1,-2, 2,-3, 3,-1, 1,-2, 2,-3, 3 + const kDistanceShortCodeValueOffset: u32 = 0xfa5fa500; + let mut v = (s.dist_rb_idx as i32 + + (kDistanceShortCodeIndexOffset as i32 >> + distance_code as i32)) as i32 & 0x3; + s.distance_code = fast!((s.dist_rb)[v as usize]); + v = (kDistanceShortCodeValueOffset >> distance_code) as i32 & 0x3; + if ((distance_code & 0x3) != 0) { + s.distance_code += v; + } else { + s.distance_code -= v; + if (s.distance_code <= 0) { + // A huge distance will cause a BROTLI_FAILURE() soon. + // This is a little faster than failing here. + s.distance_code = 0x7fffffff; + } + } + } +} + +pub fn SafeReadBits(br: &mut bit_reader::BrotliBitReader, + n_bits: u32, + val: &mut u32, + input: &[u8]) + -> bool { + if (n_bits != 0) { + bit_reader::BrotliSafeReadBits(br, n_bits, val, input) + } else { + *val = 0; + true + } +} + +// Precondition: s.distance_code < 0 +pub fn ReadDistanceInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8], + distance_hgroup: &[&[HuffmanCode]; 256]) + -> bool { + let mut distval: i32; + let mut memento = bit_reader::BrotliBitReaderState::default(); + if (!safe) { + s.distance_code = ReadSymbol(fast!((distance_hgroup)[s.dist_htree_index as usize]), + &mut s.br, + input) as i32; + } else { + let mut code: u32 = 0; + memento = bit_reader::BrotliBitReaderSaveState(&s.br); + if !SafeReadSymbol(fast!((distance_hgroup)[s.dist_htree_index as usize]), + &mut s.br, + &mut code, + input) { + return false; + } + s.distance_code = code as i32; + } + // Convert the distance code to the actual distance by possibly + // looking up past distances from the s.ringbuffer. + s.distance_context = 0; + if ((s.distance_code as u64 & 0xfffffffffffffff0) == 0) { + TakeDistanceFromRingBuffer(s); + fast_mut!((s.block_type_length_state.block_length)[2]) -= 1; + return true; + } + distval = s.distance_code - s.num_direct_distance_codes as i32; + if (distval >= 0) { + let nbits: u32; + let postfix: i32; + let offset: i32; + if (!safe && (s.distance_postfix_bits == 0)) { + nbits = (distval as u32 >> 1) + 1; + offset = ((2 + (distval & 1)) << nbits) - 4; + s.distance_code = s.num_direct_distance_codes as i32 + offset + + bit_reader::BrotliReadBits(&mut s.br, nbits, input) as i32; + } else { + // This branch also works well when s.distance_postfix_bits == 0 + let mut bits: u32 = 0; + postfix = distval & s.distance_postfix_mask; + distval >>= s.distance_postfix_bits; + nbits = (distval as u32 >> 1) + 1; + if (safe) { + if (!SafeReadBits(&mut s.br, nbits, &mut bits, input)) { + s.distance_code = -1; /* Restore precondition. */ + bit_reader::BrotliBitReaderRestoreState(&mut s.br, &memento); + return false; + } + } else { + bits = bit_reader::BrotliReadBits(&mut s.br, nbits, input); + } + offset = (((distval & 1).wrapping_add(2)) << nbits).wrapping_sub(4); + s.distance_code = ((offset + bits as i32) << s.distance_postfix_bits).wrapping_add(postfix).wrapping_add(s.num_direct_distance_codes as i32); + } + } + s.distance_code = s.distance_code.wrapping_sub(NUM_DISTANCE_SHORT_CODES as i32).wrapping_add(1); + fast_mut!((s.block_type_length_state.block_length)[2]) -= 1; + true +} + + +pub fn ReadCommandInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + insert_length: &mut i32, + input: &[u8], + insert_copy_hgroup: &[&[HuffmanCode]; 256]) + -> bool { + let mut cmd_code: u32 = 0; + let mut insert_len_extra: u32 = 0; + let mut copy_length: u32 = 0; + let v: prefix::CmdLutElement; + let mut memento = bit_reader::BrotliBitReaderState::default(); + if (!safe) { + cmd_code = ReadSymbol(fast!((insert_copy_hgroup)[s.htree_command_index as usize]), + &mut s.br, + input); + } else { + memento = bit_reader::BrotliBitReaderSaveState(&s.br); + if (!SafeReadSymbol(fast!((insert_copy_hgroup)[s.htree_command_index as usize]), + &mut s.br, + &mut cmd_code, + input)) { + return false; + } + } + v = fast!((prefix::kCmdLut)[cmd_code as usize]); + s.distance_code = v.distance_code as i32; + s.distance_context = v.context as i32; + s.dist_htree_index = fast_slice!((s.dist_context_map)[s.dist_context_map_slice_index + + s.distance_context as usize]); + *insert_length = v.insert_len_offset as i32; + if (!safe) { + if v.insert_len_extra_bits != 0 { + mark_unlikely(); + insert_len_extra = + bit_reader::BrotliReadBits(&mut s.br, v.insert_len_extra_bits as u32, input); + } + copy_length = bit_reader::BrotliReadBits(&mut s.br, v.copy_len_extra_bits as u32, input); + } else if (!SafeReadBits(&mut s.br, + v.insert_len_extra_bits as u32, + &mut insert_len_extra, + input)) || + (!SafeReadBits(&mut s.br, + v.copy_len_extra_bits as u32, + &mut copy_length, + input)) { + bit_reader::BrotliBitReaderRestoreState(&mut s.br, &memento); + return false; + } + s.copy_length = copy_length as i32 + v.copy_len_offset as i32; + fast_mut!((s.block_type_length_state.block_length)[1]) -= 1; + *insert_length += insert_len_extra as i32; + true +} + + +fn WarmupBitReader(safe: bool, br: &mut bit_reader::BrotliBitReader, input: &[u8]) -> bool { + safe || bit_reader::BrotliWarmupBitReader(br, input) +} + +fn CheckInputAmount(safe: bool, br: &bit_reader::BrotliBitReader, num: u32) -> bool { + safe || bit_reader::BrotliCheckInputAmount(br, num) +} + +#[inline(always)] +fn memmove16(data: &mut [u8], u32off_dst: u32, u32off_src: u32) { + let off_dst = u32off_dst as usize; + let off_src = u32off_src as usize; + // data[off_dst + 15] = data[off_src + 15]; + // data[off_dst + 14] = data[off_src + 14]; + // data[off_dst + 13] = data[off_src + 13]; + // data[off_dst + 12] = data[off_src + 12]; + // + // data[off_dst + 11] = data[off_src + 11]; + // data[off_dst + 10] = data[off_src + 10]; + // data[off_dst + 9] = data[off_src + 9]; + // data[off_dst + 8] = data[off_src + 8]; + // + // data[off_dst + 7] = data[off_src + 7]; + // data[off_dst + 6] = data[off_src + 6]; + // data[off_dst + 5] = data[off_src + 5]; + // data[off_dst + 4] = data[off_src + 4]; + // + // data[off_dst + 3] = data[off_src + 3]; + // data[off_dst + 2] = data[off_src + 2]; + // data[off_dst + 1] = data[off_src + 1]; + // + let mut local_array: [u8; 16] = fast_uninitialized!(16); + local_array.clone_from_slice(fast!((data)[off_src as usize ; off_src as usize + 16])); + fast_mut!((data)[off_dst as usize ; off_dst as usize + 16]).clone_from_slice(&local_array); + + +} + + +#[cfg(not(feature="unsafe"))] +fn memcpy_within_slice(data: &mut [u8], off_dst: usize, off_src: usize, size: usize) { + if off_dst > off_src { + let (src, dst) = data.split_at_mut(off_dst); + let src_slice = fast!((src)[off_src ; off_src + size]); + fast_mut!((dst)[0;size]).clone_from_slice(src_slice); + } else { + let (dst, src) = data.split_at_mut(off_src); + let src_slice = fast!((src)[0;size]); + fast_mut!((dst)[off_dst;off_dst + size]).clone_from_slice(src_slice); + } +} + +#[cfg(feature="unsafe")] +fn memcpy_within_slice(data: &mut [u8], off_dst: usize, off_src: usize, size: usize) { + let ptr = data.as_mut_ptr(); + unsafe { + let dst = ptr.offset(off_dst as isize); + let src = ptr.offset(off_src as isize); + core::ptr::copy_nonoverlapping(src, dst, size); + } +} + +pub fn BrotliDecoderHasMoreOutput<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &BrotliState<AllocU8, AllocU32, AllocHC>) -> bool { + /* After unrecoverable error remaining output is considered nonsensical. */ + if is_fatal(s.error_code) { + return false; + } + s.ringbuffer.len() != 0 && UnwrittenBytes(s, false) != 0 +} +pub fn BrotliDecoderTakeOutput<'a, + AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + s: &'a mut BrotliState<AllocU8, AllocU32, AllocHC>, + size: &mut usize, +) -> &'a [u8] { + let one:usize = 1; + let mut available_out = if *size != 0 { *size } else { one << 24 }; + let requested_out = available_out; + if (s.ringbuffer.len() == 0) || is_fatal(s.error_code) { + *size = 0; + return &[]; + } + WrapRingBuffer(s); + let mut ign = 0usize; + let mut ign2 = 0usize; + let (status, result) = WriteRingBuffer(&mut available_out, None, &mut ign,&mut ign2, true, s); + // Either WriteRingBuffer returns those "success" codes... + match status { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS | BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT => { + *size = requested_out - available_out; + }, + _ => { + // ... or stream is broken. Normally this should be caught by + // BrotliDecoderDecompressStream, this is just a safeguard. + if is_fatal(status) { + // SaveErrorCode!(s, status); //borrow checker doesn't like this + // but since it's a safeguard--ignore + } + *size = 0; + return &[]; + } + } + return result; +} + +pub fn BrotliDecoderIsUsed<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + s: &BrotliState<AllocU8, AllocU32, AllocHC>) -> bool { + if let BrotliRunningState::BROTLI_STATE_UNINITED = s.state { + false + } else { + bit_reader::BrotliGetAvailableBits(&s.br) != 0 + } +} + +pub fn BrotliDecoderIsFinished<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + s: &BrotliState<AllocU8, AllocU32, AllocHC>) -> bool { + if let BrotliRunningState::BROTLI_STATE_DONE = s.state { + !BrotliDecoderHasMoreOutput(s) + } else { + false + } +} + +pub fn BrotliDecoderGetErrorCode<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>>( + s: &BrotliState<AllocU8, AllocU32, AllocHC>) -> BrotliDecoderErrorCode { + s.error_code +} + +fn ProcessCommandsInternal<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (safe: bool, + s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + if (!CheckInputAmount(safe, &s.br, 28)) || (!WarmupBitReader(safe, &mut s.br, input)) { + mark_unlikely(); + return BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + } + let mut pos = s.pos; + let mut i: i32 = s.loop_counter; // important that this is signed + let mut result = BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + let mut saved_literal_hgroup = + core::mem::replace(&mut s.literal_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default()); + let mut saved_distance_hgroup = + core::mem::replace(&mut s.distance_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default()); + let mut saved_insert_copy_hgroup = + core::mem::replace(&mut s.insert_copy_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default()); + { + + let literal_hgroup = saved_literal_hgroup.build_hgroup_cache(); + let distance_hgroup = saved_distance_hgroup.build_hgroup_cache(); + let insert_copy_hgroup = saved_insert_copy_hgroup.build_hgroup_cache(); + + loop { + match s.state { + BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN => { + if (!CheckInputAmount(safe, &s.br, 28)) { + // 156 bits + 7 bytes + mark_unlikely(); + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; // return + } + if (fast_mut!((s.block_type_length_state.block_length)[1]) == 0) { + mark_unlikely(); + if !DecodeCommandBlockSwitchInternal(safe, s, input) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; // return + } + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN; + continue; // goto CommandBegin; + } + // Read the insert/copy length in the command + if (!ReadCommandInternal(safe, s, &mut i, input, &insert_copy_hgroup)) && safe { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; // return + } + BROTLI_LOG!("[ProcessCommandsInternal] pos = %d insert = %d copy = %d distance = %d\n", + pos, i, s.copy_length, s.distance_code); + if (i == 0) { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_DECODE_LITERALS; + continue; // goto CommandPostDecodeLiterals; + } + s.meta_block_remaining_len -= i; + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER; + } + BrotliRunningState::BROTLI_STATE_COMMAND_INNER => { + // Read the literals in the command + if (s.trivial_literal_context != 0) { + let mut bits: u32 = 0; + let mut value: u32 = 0; + let mut literal_htree = &fast!((literal_hgroup)[s.literal_htree_index as usize]); + PreloadSymbol(safe, literal_htree, &mut s.br, &mut bits, &mut value, input); + let mut inner_return: bool = false; + let mut inner_continue: bool = false; + loop { + if (!CheckInputAmount(safe, &s.br, 28)) { + // 162 bits + 7 bytes + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + if (fast!((s.block_type_length_state.block_length)[0]) == 0) { + mark_unlikely(); + if (!DecodeLiteralBlockSwitchInternal(safe, s, input)) && safe { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + literal_htree = fast_ref!((literal_hgroup)[s.literal_htree_index as usize]); + PreloadSymbol(safe, literal_htree, &mut s.br, &mut bits, &mut value, input); + if (s.trivial_literal_context == 0) { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER; + inner_continue = true; + break; // goto StateCommandInner + } + } + if (!safe) { + fast_mut!((s.ringbuffer.slice_mut())[pos as usize]) = + ReadPreloadedSymbol(literal_htree, &mut s.br, &mut bits, &mut value, input) as u8; + } else { + let mut literal: u32 = 0; + if (!SafeReadSymbol(literal_htree, &mut s.br, &mut literal, input)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + fast_mut!((s.ringbuffer.slice_mut())[pos as usize]) = literal as u8; + } + fast_mut!((s.block_type_length_state.block_length)[0]) -= 1; + BROTLI_LOG_UINT!(s.literal_htree_index); + BROTLI_LOG_ARRAY_INDEX!(s.ringbuffer.slice(), pos); + pos += 1; + if (pos == s.ringbuffer_size) { + mark_unlikely(); + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER_WRITE; + i -= 1; + inner_return = true; + break; + } + i -= 1; + if i == 0 { + break; + } + } + if inner_return { + break; // return + } + if inner_continue { + mark_unlikely(); + continue; + } + } else { + let mut p1 = fast_slice!((s.ringbuffer)[((pos - 1) & s.ringbuffer_mask) as usize]); + let mut p2 = fast_slice!((s.ringbuffer)[((pos - 2) & s.ringbuffer_mask) as usize]); + let mut inner_return: bool = false; + let mut inner_continue: bool = false; + loop { + if (!CheckInputAmount(safe, &s.br, 28)) { + // 162 bits + 7 bytes + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER; + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + if (fast!((s.block_type_length_state.block_length)[0]) == 0) { + mark_unlikely(); + if (!DecodeLiteralBlockSwitchInternal(safe, s, input)) && safe { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + if s.trivial_literal_context != 0 { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER; + inner_continue = true; + break; + } + } + let context = s.context_lookup[p1 as usize] | s.context_lookup[p2 as usize |256]; + BROTLI_LOG_UINT!(p1); + BROTLI_LOG_UINT!(p2); + BROTLI_LOG_UINT!(context); + let hc: &[HuffmanCode]; + { + let i = fast_slice!((s.context_map)[s.context_map_slice_index + context as usize]); + hc = fast!((literal_hgroup)[i as usize]); + } + p2 = p1; + if (!safe) { + p1 = ReadSymbol(hc, &mut s.br, input) as u8; + } else { + let mut literal: u32 = 0; + if (!SafeReadSymbol(hc, &mut s.br, &mut literal, input)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + inner_return = true; + break; + } + p1 = literal as u8; + } + fast_slice_mut!((s.ringbuffer)[pos as usize]) = p1; + fast_mut!((s.block_type_length_state.block_length)[0]) -= 1; + BROTLI_LOG_UINT!(s.context_map.slice()[s.context_map_slice_index as usize + + context as usize]); + BROTLI_LOG_ARRAY_INDEX!(s.ringbuffer.slice(), pos & s.ringbuffer_mask); + pos += 1; + if (pos == s.ringbuffer_size) { + mark_unlikely(); + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER_WRITE; + i -= 1; + inner_return = true; + break; + } + i -= 1; + if i == 0 { + break; + } + } + if inner_return { + break; // return + } + if inner_continue { + mark_unlikely(); + continue; + } + } + if (s.meta_block_remaining_len <= 0) { + mark_unlikely(); + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + break; // return + } + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_DECODE_LITERALS; + } + BrotliRunningState::BROTLI_STATE_COMMAND_POST_DECODE_LITERALS => { + if s.distance_code >= 0 { + let not_distance_code = if s.distance_code != 0 { 0 } else { 1 }; + s.distance_context = not_distance_code; + s.dist_rb_idx -= 1; + s.distance_code = fast!((s.dist_rb)[(s.dist_rb_idx & 3) as usize]); + // goto postReadDistance + } else { + if fast!((s.block_type_length_state.block_length)[2]) == 0 { + mark_unlikely(); + if (!DecodeDistanceBlockSwitchInternal(safe, s, input)) && safe { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; // return + } + } + if (!ReadDistanceInternal(safe, s, input, &distance_hgroup)) && safe { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; // return + } + } + // postReadDistance: + BROTLI_LOG!("[ProcessCommandsInternal] pos = %d distance = %d\n", + pos, s.distance_code); + + if (s.max_distance != s.max_backward_distance) { + if (pos < s.max_backward_distance_minus_custom_dict_size) { + s.max_distance = pos + s.custom_dict_size; + } else { + s.max_distance = s.max_backward_distance; + } + } + i = s.copy_length; + // Apply copy of LZ77 back-reference, or static dictionary reference if + // the distance is larger than the max LZ77 distance + if (s.distance_code > s.max_distance) { + if s.distance_code > kBrotliMaxAllowedDistance as i32 { + return BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_DISTANCE; + } + if (i >= kBrotliMinDictionaryWordLength as i32 && + i <= kBrotliMaxDictionaryWordLength as i32) { + let mut offset = fast!((kBrotliDictionaryOffsetsByLength)[i as usize]) as i32; + let word_id = s.distance_code - s.max_distance - 1; + let shift = fast!((kBrotliDictionarySizeBitsByLength)[i as usize]); + let mask = bit_reader::BitMask(shift as u32) as i32; + let word_idx = word_id & mask; + let transform_idx = word_id >> shift; + s.dist_rb_idx += s.distance_context; + offset += word_idx * i; + if (transform_idx < kNumTransforms) { + let mut len = i; + let word = fast!((kBrotliDictionary)[offset as usize ; (offset + len) as usize]); + if (transform_idx == 0) { + fast_slice_mut!((s.ringbuffer)[pos as usize ; ((pos + len) as usize)]) + .clone_from_slice(word); + } else { + len = TransformDictionaryWord(fast_slice_mut!((s.ringbuffer)[pos as usize;]), + word, + len, + transform_idx); + } + pos += len; + s.meta_block_remaining_len -= len; + if (pos >= s.ringbuffer_size) { + // s.partial_pos_rb += (size_t)s.ringbuffer_size; + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_1; + break; // return return + } + } else { + BROTLI_LOG!( + "Invalid backward reference. pos: %d distance: %d len: %d bytes left: %d\n", + pos, s.distance_code, i, + s.meta_block_remaining_len); + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_TRANSFORM; + break; // return + } + } else { + BROTLI_LOG!( + "Invalid backward reference. pos:%d distance:%d len:%d bytes left:%d\n", + pos, s.distance_code, i, s.meta_block_remaining_len); + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_DICTIONARY; + break; // return + } + } else { + // update the recent distances cache + fast_mut!((s.dist_rb)[(s.dist_rb_idx & 3) as usize]) = s.distance_code; + s.dist_rb_idx += 1; + s.meta_block_remaining_len -= i; + // There is 128+ bytes of slack in the ringbuffer allocation. + // Also, we have 16 short codes, that make these 16 bytes irrelevant + // in the ringbuffer. Let's copy over them as a first guess. + // + let src_start = ((pos - s.distance_code) & s.ringbuffer_mask) as u32; + let dst_start = pos as u32; + let dst_end = pos as u32 + i as u32; + let src_end = src_start + i as u32; + memmove16(&mut s.ringbuffer.slice_mut(), dst_start, src_start); + // Now check if the copy extends over the ringbuffer end, + // or if the copy overlaps with itself, if yes, do wrap-copy. + if (src_end > pos as u32 && dst_end > src_start) { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRAP_COPY; + continue; //goto CommandPostWrapCopy; + } + if (dst_end >= s.ringbuffer_size as u32 || src_end >= s.ringbuffer_size as u32) { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRAP_COPY; + continue; //goto CommandPostWrapCopy; + } + pos += i; + if (i > 16) { + if (i > 32) { + memcpy_within_slice(s.ringbuffer.slice_mut(), + dst_start as usize + 16, + src_start as usize + 16, + (i - 16) as usize); + } else { + // This branch covers about 45% cases. + // Fixed size short copy allows more compiler optimizations. + memmove16(&mut s.ringbuffer.slice_mut(), + dst_start + 16, + src_start + 16); + } + } + } + if (s.meta_block_remaining_len <= 0) { + // Next metablock, if any + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + break; // return + } else { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN; + continue; // goto CommandBegin + } + } + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRAP_COPY => { + let mut wrap_guard = s.ringbuffer_size - pos; + let mut inner_return: bool = false; + while i > 0 { + i -= 1; + fast_slice_mut!((s.ringbuffer)[pos as usize]) = + fast_slice!((s.ringbuffer)[((pos - s.distance_code) & s.ringbuffer_mask) as usize]); + pos += 1; + wrap_guard -= 1; + if (wrap_guard == 0) { + mark_unlikely(); + // s.partial_pos_rb += (size_t)s.ringbuffer_size; + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_2; + inner_return = true; + break; //return + } + } + if inner_return { + mark_unlikely(); + break; + } + i -= 1; + if (s.meta_block_remaining_len <= 0) { + // Next metablock, if any + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + break; // return + } else { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN; + continue; + } + } + _ => { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE; + break; // return + } + } + } + } + s.pos = pos; + s.loop_counter = i; + + let _ = core::mem::replace(&mut s.literal_hgroup, + core::mem::replace(&mut saved_literal_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default())); + + let _ = core::mem::replace(&mut s.distance_hgroup, + core::mem::replace(&mut saved_distance_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default())); + + let _ = core::mem::replace(&mut s.insert_copy_hgroup, + core::mem::replace(&mut saved_insert_copy_hgroup, + HuffmanTreeGroup::<AllocU32, AllocHC>::default())); + + result +} + +fn ProcessCommands<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + ProcessCommandsInternal(false, s, input) +} + +fn SafeProcessCommands<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (s: &mut BrotliState<AllocU8, AllocU32, AllocHC>, + input: &[u8]) + -> BrotliDecoderErrorCode { + ProcessCommandsInternal(true, s, input) +} + +/* Returns the maximum number of distance symbols which can only represent + distances not exceeding BROTLI_MAX_ALLOWED_DISTANCE. */ +pub fn BrotliMaxDistanceSymbol(ndirect: u32, npostfix: u32) -> u32{ + let bound:[u32;kBrotliMaxPostfix + 1] = [0, 4, 12, 28]; + let diff:[u32;kBrotliMaxPostfix + 1] = [73, 126, 228, 424]; + let postfix = 1 << npostfix; + if (ndirect < bound[npostfix as usize ]) { + return ndirect + diff[npostfix as usize] + postfix; + } else if (ndirect > bound[npostfix as usize] + postfix) { + return ndirect + diff[npostfix as usize]; + } else { + return bound[npostfix as usize] + diff[npostfix as usize] + postfix; + } +} + +pub fn BrotliDecompressStream<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> + (available_in: &mut usize, + input_offset: &mut usize, + xinput: &[u8], + mut available_out: &mut usize, + mut output_offset: &mut usize, + mut output: &mut [u8], + mut total_out: &mut usize, + mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>) + -> BrotliResult { + + let mut result = BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + + let mut saved_buffer: [u8; 8] = s.buffer; + let mut local_input: &[u8]; + if is_fatal(s.error_code) { + return BrotliResult::ResultFailure; + } + if *available_in as u64 >= (1u64 << 32) { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_INVALID_ARGUMENTS); + } + if *input_offset as u64 >= (1u64 << 32) { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_INVALID_ARGUMENTS); + } + if *input_offset + *available_in > xinput.len() { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_INVALID_ARGUMENTS); + } + if *output_offset + *available_out > output.len() { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_INVALID_ARGUMENTS); + } + if s.buffer_length == 0 { + local_input = xinput; + s.br.avail_in = *available_in as u32; + s.br.next_in = *input_offset as u32; + } else { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + let copy_len = core::cmp::min(saved_buffer.len() - s.buffer_length as usize, *available_in); + if copy_len > 0 { + fast_mut!((saved_buffer)[s.buffer_length as usize ; (s.buffer_length as usize + copy_len)]) + .clone_from_slice(fast!((xinput)[*input_offset ; copy_len + *input_offset])); + fast_mut!((s.buffer)[s.buffer_length as usize ; (s.buffer_length as usize + copy_len)]) + .clone_from_slice(fast!((xinput)[*input_offset ; copy_len + *input_offset])); + } + local_input = &saved_buffer[..]; + s.br.next_in = 0; + } + loop { + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => { + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT => { + if s.ringbuffer.slice().len() != 0 { + let (intermediate_result, _) = WriteRingBuffer(available_out, + Some(&mut output), + &mut output_offset, + &mut total_out, + true, + &mut s); + if is_fatal(intermediate_result) { + result = intermediate_result; + break; + } + } + if s.buffer_length != 0 { + // Used with internal buffer. + if s.br.avail_in == 0 { + // Successfully finished read transaction. + // Accamulator contains less than 8 bits, because internal buffer + // is expanded byte-by-byte until it is enough to complete read. + s.buffer_length = 0; + // Switch to input stream and restart. + result = BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + local_input = xinput; + s.br.avail_in = *available_in as u32; + s.br.next_in = *input_offset as u32; + continue; + } else if *available_in != 0 { + // Not enough data in buffer, but can take one more byte from + // input stream. + result = BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS; + let new_byte = fast!((xinput)[*input_offset]); + fast_mut!((s.buffer)[s.buffer_length as usize]) = new_byte; + // we did the following copy upfront, so we wouldn't have to do it here + // since saved_buffer[s.buffer_length as usize] = new_byte violates borrow rules + assert_eq!(fast!((saved_buffer)[s.buffer_length as usize]), new_byte); + s.buffer_length += 1; + s.br.avail_in = s.buffer_length; + (*input_offset) += 1; + (*available_in) -= 1; + // Retry with more data in buffer. + // we can't re-borrow the saved buffer...so we have to do this recursively + continue; + } + // Can't finish reading and no more input. + + // FIXME :: NOT SURE WHAT THIS MEANT + // saved_buffer = core::mem::replace( + // &mut s.br.input_, + // &mut[]); // clear input + break; + } else { + // Input stream doesn't contain enough input. + // Copy tail to internal buffer and return. + *input_offset = s.br.next_in as usize; + *available_in = s.br.avail_in as usize; + while *available_in != 0 { + fast_mut!((s.buffer)[s.buffer_length as usize]) = fast!((xinput)[*input_offset]); + s.buffer_length += 1; + (*input_offset) += 1; + (*available_in) -= 1; + } + break; + } + // unreachable!(); <- dead code + } + _ => { + // Fail or needs more output. + if s.buffer_length != 0 { + // Just consumed the buffered input and produced some output. Otherwise + // it would result in "needs more input". Reset internal buffer. + s.buffer_length = 0; + } else { + // Using input stream in last iteration. When decoder switches to input + // stream it has less than 8 bits in accamulator, so it is safe to + // return unused accamulator bits there. + bit_reader::BrotliBitReaderUnload(&mut s.br); + *available_in = s.br.avail_in as usize; + *input_offset = s.br.next_in as usize; + } + } + } + break; + } + } + loop { + // this emulates fallthrough behavior + match s.state { + BrotliRunningState::BROTLI_STATE_UNINITED => { + // Prepare to the first read. + if (!bit_reader::BrotliWarmupBitReader(&mut s.br, local_input)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; + } + // Decode window size. + /* Reads 1..8 bits. */ + result = DecodeWindowBits(&mut s.large_window, &mut s.window_bits, &mut s.br); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + if s.large_window { + s.state = BrotliRunningState::BROTLI_STATE_LARGE_WINDOW_BITS; + } else { + s.state = BrotliRunningState::BROTLI_STATE_INITIALIZE; + } + } + BrotliRunningState::BROTLI_STATE_LARGE_WINDOW_BITS => { + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 6, &mut s.window_bits, local_input)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; + } + if (s.window_bits < kBrotliLargeMinWbits || + s.window_bits > kBrotliLargeMaxWbits) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS; + break; + } + s.state = BrotliRunningState::BROTLI_STATE_INITIALIZE; + } + BrotliRunningState::BROTLI_STATE_INITIALIZE => { + s.max_backward_distance = (1 << s.window_bits) - kBrotliWindowGap as i32; + s.max_backward_distance_minus_custom_dict_size = s.max_backward_distance - + s.custom_dict_size; + + // (formerly) Allocate memory for both block_type_trees and block_len_trees. + s.block_type_length_state.block_type_trees = s.alloc_hc + .alloc_cell(3 * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize); + if (s.block_type_length_state.block_type_trees.slice().len() == 0) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES; + break; + } + s.block_type_length_state.block_len_trees = s.alloc_hc + .alloc_cell(3 * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize); + + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_BEGIN; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_METABLOCK_BEGIN => { + s.BrotliStateMetablockBegin(); + BROTLI_LOG_UINT!(s.pos); + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_HEADER; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_METABLOCK_HEADER => { + result = DecodeMetaBlockLength(&mut s, local_input); // Reads 2 - 31 bits. + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + BROTLI_LOG_UINT!(s.is_last_metablock); + BROTLI_LOG_UINT!(s.meta_block_remaining_len); + BROTLI_LOG_UINT!(s.is_metadata); + BROTLI_LOG_UINT!(s.is_uncompressed); + if (s.is_metadata != 0 || s.is_uncompressed != 0) && + !bit_reader::BrotliJumpToByteBoundary(&mut s.br) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_PADDING_2; + break; + } + if s.is_metadata != 0 { + s.state = BrotliRunningState::BROTLI_STATE_METADATA; + break; + } + if s.meta_block_remaining_len == 0 { + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + break; + } + if s.ringbuffer.slice().len() == 0 && !BrotliAllocateRingBuffer(&mut s, local_input) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2; + break; + } + if s.is_uncompressed != 0 { + s.state = BrotliRunningState::BROTLI_STATE_UNCOMPRESSED; + break; + } + s.loop_counter = 0; + s.state = BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_0; + break; + } + BrotliRunningState::BROTLI_STATE_UNCOMPRESSED => { + let mut _bytes_copied = s.meta_block_remaining_len; + result = CopyUncompressedBlockToOutput(&mut available_out, + &mut output, + &mut output_offset, + &mut total_out, + &mut s, + local_input); + _bytes_copied -= s.meta_block_remaining_len; + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + break; + } + BrotliRunningState::BROTLI_STATE_METADATA => { + while s.meta_block_remaining_len > 0 { + let mut bits = 0u32; + // Read one byte and ignore it. + if !bit_reader::BrotliSafeReadBits(&mut s.br, 8, &mut bits, local_input) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; + } + s.meta_block_remaining_len -= 1; + } + if let BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS = result { + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE + } + break; + } + BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_0 => { + if s.loop_counter >= 3 { + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_HEADER_2; + break; + } + // Reads 1..11 bits. + { + let index = s.loop_counter as usize; + result = + DecodeVarLenUint8(&mut s.substate_decode_uint8, + &mut s.br, + &mut fast_mut!((s.block_type_length_state.num_block_types)[index]), + local_input); + } + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + fast_mut!((s.block_type_length_state.num_block_types)[s.loop_counter as usize]) += 1; + BROTLI_LOG_UINT!(s.block_type_length_state.num_block_types[s.loop_counter as usize]); + if fast!((s.block_type_length_state.num_block_types)[s.loop_counter as usize]) < 2 { + s.loop_counter += 1; + break; + } + s.state = BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_1; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_1 => { + let tree_offset = s.loop_counter as u32 * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as u32; + let mut new_huffman_table = mem::replace(&mut s.block_type_length_state.block_type_trees, + AllocHC::AllocatedMemory::default()); + let loop_counter = s.loop_counter as usize; + let alphabet_size = fast!((s.block_type_length_state.num_block_types)[loop_counter]) + 2; + result = + ReadHuffmanCode(alphabet_size, alphabet_size, + new_huffman_table.slice_mut(), + tree_offset as usize, + None, + &mut s, + local_input); + let _ = mem::replace(&mut s.block_type_length_state.block_type_trees, + new_huffman_table); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.state = BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_2; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_2 => { + let tree_offset = s.loop_counter * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as i32; + let mut new_huffman_table = mem::replace(&mut s.block_type_length_state.block_len_trees, + AllocHC::AllocatedMemory::default()); + result = ReadHuffmanCode(kNumBlockLengthCodes, kNumBlockLengthCodes, + new_huffman_table.slice_mut(), + tree_offset as usize, + None, + &mut s, + local_input); + let _ = mem::replace(&mut s.block_type_length_state.block_len_trees, + new_huffman_table); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.state = BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_3; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_3 => { + let tree_offset = s.loop_counter * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as i32; + + let mut block_length_out: u32 = 0; + let ind_ret: (bool, u32); + + ind_ret = SafeReadBlockLengthIndex(&s.block_type_length_state.substate_read_block_length, + s.block_type_length_state.block_length_index, + fast_slice!((s.block_type_length_state.block_len_trees) + [tree_offset as usize;]), + &mut s.br, local_input); + + if !SafeReadBlockLengthFromIndex(&mut s.block_type_length_state, + &mut s.br, + &mut block_length_out, + ind_ret, + local_input) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; + } + fast_mut!((s.block_type_length_state.block_length)[s.loop_counter as usize]) = + block_length_out; + BROTLI_LOG_UINT!(s.block_type_length_state.block_length[s.loop_counter as usize]); + s.loop_counter += 1; + s.state = BrotliRunningState::BROTLI_STATE_HUFFMAN_CODE_0; + break; + } + BrotliRunningState::BROTLI_STATE_METABLOCK_HEADER_2 => { + let mut bits: u32 = 0; + if (!bit_reader::BrotliSafeReadBits(&mut s.br, 6, &mut bits, local_input)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT; + break; + } + s.distance_postfix_bits = bits & bit_reader::BitMask(2); + bits >>= 2; + s.num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES + + (bits << s.distance_postfix_bits); + BROTLI_LOG_UINT!(s.num_direct_distance_codes); + BROTLI_LOG_UINT!(s.distance_postfix_bits); + s.distance_postfix_mask = bit_reader::BitMask(s.distance_postfix_bits) as i32; + s.context_modes = s.alloc_u8 + .alloc_cell(fast!((s.block_type_length_state.num_block_types)[0]) as usize); + if (s.context_modes.slice().len() == 0) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES; + break; + } + s.loop_counter = 0; + s.state = BrotliRunningState::BROTLI_STATE_CONTEXT_MODES; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_CONTEXT_MODES => { + result = ReadContextModes(&mut s, local_input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.state = BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_1; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_1 => { + result = + DecodeContextMap((fast!((s.block_type_length_state.num_block_types)[0]) as usize) << + kLiteralContextBits as usize, + false, + &mut s, + local_input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + DetectTrivialLiteralBlockTypes(s); + s.state = BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_2; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_CONTEXT_MAP_2 => { + let num_direct_codes = + s.num_direct_distance_codes - NUM_DISTANCE_SHORT_CODES; + let num_distance_codes = BROTLI_DISTANCE_ALPHABET_SIZE( + s.distance_postfix_bits, num_direct_codes, + (if s.large_window { BROTLI_LARGE_MAX_DISTANCE_BITS } else { + BROTLI_MAX_DISTANCE_BITS})); + let max_distance_symbol = if s.large_window { + BrotliMaxDistanceSymbol( + num_direct_codes, s.distance_postfix_bits) + } else { + num_distance_codes + }; + result = + DecodeContextMap((fast!((s.block_type_length_state.num_block_types)[2]) as usize) << + kDistanceContextBits as usize, + true, + s, + local_input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.literal_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + kNumLiteralCodes, + kNumLiteralCodes, + s.num_literal_htrees as u16); + s.insert_copy_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + kNumInsertAndCopyCodes, + kNumInsertAndCopyCodes, + fast!((s.block_type_length_state.num_block_types)[1]) as u16); + s.distance_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + num_distance_codes as u16, + max_distance_symbol as u16, + s.num_dist_htrees as u16); + if (s.literal_hgroup.codes.slice().len() == 0 || + s.insert_copy_hgroup.codes.slice().len() == 0 || + s.distance_hgroup.codes.slice().len() == 0) { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE); + } + + /*{ + let num_distance_codes: u32 = s.num_direct_distance_codes + + (48u32 << s.distance_postfix_bits); + result = + DecodeContextMap((fast!((s.block_type_length_state.num_block_types)[2]) as usize) << + kDistanceContextBits as usize, + true, + s, + local_input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.literal_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + kNumLiteralCodes, + s.num_literal_htrees as u16); + s.insert_copy_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + kNumInsertAndCopyCodes, + fast!((s.block_type_length_state.num_block_types)[1]) as u16); + s.distance_hgroup.init(&mut s.alloc_u32, + &mut s.alloc_hc, + num_distance_codes as u16, + s.num_dist_htrees as u16); + if (s.literal_hgroup.codes.slice().len() == 0 || + s.insert_copy_hgroup.codes.slice().len() == 0 || + s.distance_hgroup.codes.slice().len() == 0) { + return SaveErrorCode!(s, BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS); + } + }*/ + s.loop_counter = 0; + s.state = BrotliRunningState::BROTLI_STATE_TREE_GROUP; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_TREE_GROUP => { + result = HuffmanTreeGroupDecode(s.loop_counter, &mut s, local_input); + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + s.loop_counter += 1; + if (s.loop_counter >= 3) { + PrepareLiteralDecoding(s); + s.dist_context_map_slice_index = 0; + /* + s.context_map_slice_index = 0; + let context_mode_index = fast!((s.block_type_length_state.block_type_rb)[1]); + let context_mode = fast_slice!((s.context_modes)[context_mode_index as usize]); + s.context_lookup = &kContextLookup[context_mode as usize & 3]; + */ + s.htree_command_index = 0; + // look it up each time s.literal_htree=s.literal_hgroup.htrees[s.literal_htree_index]; + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN; + } + break; + } + BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN | + BrotliRunningState::BROTLI_STATE_COMMAND_INNER | + BrotliRunningState::BROTLI_STATE_COMMAND_POST_DECODE_LITERALS | + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRAP_COPY => { + result = ProcessCommands(s, local_input); + if let BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT = result { + result = SafeProcessCommands(s, local_input) + } + break; + } + BrotliRunningState::BROTLI_STATE_COMMAND_INNER_WRITE | + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_1 | + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_2 => { + let (xresult, _) = WriteRingBuffer(&mut available_out, + Some(&mut output), + &mut output_offset, + &mut total_out, + false, + &mut s); + result = xresult; + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + WrapRingBuffer(s); + if s.ringbuffer_size == 1 << s.window_bits { + s.max_distance = s.max_backward_distance; + } + match s.state { + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_1 => { + if (s.meta_block_remaining_len <= 0) { + // Next metablock, if any + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + } else { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_BEGIN; + } + break; + } + BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRITE_2 => { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_WRAP_COPY; + } + _ => { + // BROTLI_STATE_COMMAND_INNER_WRITE + if (s.loop_counter == 0) { + if (s.meta_block_remaining_len <= 0) { + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_DONE; + } else { + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_POST_DECODE_LITERALS; + } + break; + } + s.state = BrotliRunningState::BROTLI_STATE_COMMAND_INNER; + } + } + break; + } + BrotliRunningState::BROTLI_STATE_METABLOCK_DONE => { + s.BrotliStateCleanupAfterMetablock(); + if (s.is_last_metablock == 0) { + s.state = BrotliRunningState::BROTLI_STATE_METABLOCK_BEGIN; + break; + } + if (!bit_reader::BrotliJumpToByteBoundary(&mut s.br)) { + result = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_PADDING_2; + } + if (s.buffer_length == 0) { + bit_reader::BrotliBitReaderUnload(&mut s.br); + *available_in = s.br.avail_in as usize; + *input_offset = s.br.next_in as usize; + } + s.state = BrotliRunningState::BROTLI_STATE_DONE; + // No break, continue to next state + } + BrotliRunningState::BROTLI_STATE_DONE => { + if (s.ringbuffer.slice().len() != 0) { + let (xresult, _) = WriteRingBuffer(&mut available_out, + Some(&mut output), + &mut output_offset, + &mut total_out, + true, + &mut s); + result = xresult; + match result { + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => {} + _ => break, + } + } + return SaveErrorCode!(s, result); + } + } + } + } + + SaveErrorCode!(s, result) +} + diff --git a/rust/vendor/brotli-decompressor/src/dictionary/mod.rs b/rust/vendor/brotli-decompressor/src/dictionary/mod.rs new file mode 100644 index 0000000..ae1b571 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/dictionary/mod.rs @@ -0,0 +1,7692 @@ + +#[allow(non_upper_case_globals)] +pub const kBrotliDictionaryOffsetsByLength: [u32; 25] = + [0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032, 53248, 63488, 74752, 87040, 93696, 100864, + 104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280, 122016]; + +#[allow(non_upper_case_globals)] +pub const kBrotliDictionarySizeBitsByLength: [u8; 25] = + [0, 0, 0, 0, 10, 10, 11, 11, 10, 10, 10, 10, 10, 9, 9, 8, 7, 7, 8, 7, 7, 6, 6, 5, 5]; + +#[allow(non_upper_case_globals)] +pub const kBrotliMinDictionaryWordLength: u8 = 4; + +#[allow(non_upper_case_globals)] +pub const kBrotliMaxDictionaryWordLength: u8 = 24; + +#[allow(non_upper_case_globals)] +pub static kBrotliDictionary: [u8; 122784] = + [0x74, 0x69, 0x6d, 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x69, 0x66, 0x65, 0x6c, 0x65, 0x66, 0x74, + 0x62, 0x61, 0x63, 0x6b, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x61, 0x74, 0x61, 0x73, 0x68, 0x6f, 0x77, + 0x6f, 0x6e, 0x6c, 0x79, 0x73, 0x69, 0x74, 0x65, 0x63, 0x69, 0x74, 0x79, 0x6f, 0x70, 0x65, 0x6e, + 0x6a, 0x75, 0x73, 0x74, 0x6c, 0x69, 0x6b, 0x65, 0x66, 0x72, 0x65, 0x65, 0x77, 0x6f, 0x72, 0x6b, + 0x74, 0x65, 0x78, 0x74, 0x79, 0x65, 0x61, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x64, 0x79, + 0x6c, 0x6f, 0x76, 0x65, 0x66, 0x6f, 0x72, 0x6d, 0x62, 0x6f, 0x6f, 0x6b, 0x70, 0x6c, 0x61, 0x79, + 0x6c, 0x69, 0x76, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x68, 0x65, 0x6c, 0x70, 0x68, 0x6f, 0x6d, 0x65, + 0x73, 0x69, 0x64, 0x65, 0x6d, 0x6f, 0x72, 0x65, 0x77, 0x6f, 0x72, 0x64, 0x6c, 0x6f, 0x6e, 0x67, + 0x74, 0x68, 0x65, 0x6d, 0x76, 0x69, 0x65, 0x77, 0x66, 0x69, 0x6e, 0x64, 0x70, 0x61, 0x67, 0x65, + 0x64, 0x61, 0x79, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x68, 0x65, 0x61, 0x64, 0x74, 0x65, 0x72, 0x6d, + 0x65, 0x61, 0x63, 0x68, 0x61, 0x72, 0x65, 0x61, 0x66, 0x72, 0x6f, 0x6d, 0x74, 0x72, 0x75, 0x65, + 0x6d, 0x61, 0x72, 0x6b, 0x61, 0x62, 0x6c, 0x65, 0x75, 0x70, 0x6f, 0x6e, 0x68, 0x69, 0x67, 0x68, + 0x64, 0x61, 0x74, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x6e, 0x65, 0x77, 0x73, 0x65, 0x76, 0x65, 0x6e, + 0x6e, 0x65, 0x78, 0x74, 0x63, 0x61, 0x73, 0x65, 0x62, 0x6f, 0x74, 0x68, 0x70, 0x6f, 0x73, 0x74, + 0x75, 0x73, 0x65, 0x64, 0x6d, 0x61, 0x64, 0x65, 0x68, 0x61, 0x6e, 0x64, 0x68, 0x65, 0x72, 0x65, + 0x77, 0x68, 0x61, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x6e, 0x6b, 0x62, 0x6c, 0x6f, 0x67, + 0x73, 0x69, 0x7a, 0x65, 0x62, 0x61, 0x73, 0x65, 0x68, 0x65, 0x6c, 0x64, 0x6d, 0x61, 0x6b, 0x65, + 0x6d, 0x61, 0x69, 0x6e, 0x75, 0x73, 0x65, 0x72, 0x27, 0x29, 0x20, 0x2b, 0x68, 0x6f, 0x6c, 0x64, + 0x65, 0x6e, 0x64, 0x73, 0x77, 0x69, 0x74, 0x68, 0x4e, 0x65, 0x77, 0x73, 0x72, 0x65, 0x61, 0x64, + 0x77, 0x65, 0x72, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x74, 0x61, 0x6b, 0x65, 0x68, 0x61, 0x76, 0x65, + 0x67, 0x61, 0x6d, 0x65, 0x73, 0x65, 0x65, 0x6e, 0x63, 0x61, 0x6c, 0x6c, 0x70, 0x61, 0x74, 0x68, + 0x77, 0x65, 0x6c, 0x6c, 0x70, 0x6c, 0x75, 0x73, 0x6d, 0x65, 0x6e, 0x75, 0x66, 0x69, 0x6c, 0x6d, + 0x70, 0x61, 0x72, 0x74, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x68, 0x69, 0x73, 0x6c, 0x69, 0x73, 0x74, + 0x67, 0x6f, 0x6f, 0x64, 0x6e, 0x65, 0x65, 0x64, 0x77, 0x61, 0x79, 0x73, 0x77, 0x65, 0x73, 0x74, + 0x6a, 0x6f, 0x62, 0x73, 0x6d, 0x69, 0x6e, 0x64, 0x61, 0x6c, 0x73, 0x6f, 0x6c, 0x6f, 0x67, 0x6f, + 0x72, 0x69, 0x63, 0x68, 0x75, 0x73, 0x65, 0x73, 0x6c, 0x61, 0x73, 0x74, 0x74, 0x65, 0x61, 0x6d, + 0x61, 0x72, 0x6d, 0x79, 0x66, 0x6f, 0x6f, 0x64, 0x6b, 0x69, 0x6e, 0x67, 0x77, 0x69, 0x6c, 0x6c, + 0x65, 0x61, 0x73, 0x74, 0x77, 0x61, 0x72, 0x64, 0x62, 0x65, 0x73, 0x74, 0x66, 0x69, 0x72, 0x65, + 0x50, 0x61, 0x67, 0x65, 0x6b, 0x6e, 0x6f, 0x77, 0x61, 0x77, 0x61, 0x79, 0x2e, 0x70, 0x6e, 0x67, + 0x6d, 0x6f, 0x76, 0x65, 0x74, 0x68, 0x61, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x67, 0x69, 0x76, 0x65, + 0x73, 0x65, 0x6c, 0x66, 0x6e, 0x6f, 0x74, 0x65, 0x6d, 0x75, 0x63, 0x68, 0x66, 0x65, 0x65, 0x64, + 0x6d, 0x61, 0x6e, 0x79, 0x72, 0x6f, 0x63, 0x6b, 0x69, 0x63, 0x6f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, + 0x6c, 0x6f, 0x6f, 0x6b, 0x68, 0x69, 0x64, 0x65, 0x64, 0x69, 0x65, 0x64, 0x48, 0x6f, 0x6d, 0x65, + 0x72, 0x75, 0x6c, 0x65, 0x68, 0x6f, 0x73, 0x74, 0x61, 0x6a, 0x61, 0x78, 0x69, 0x6e, 0x66, 0x6f, + 0x63, 0x6c, 0x75, 0x62, 0x6c, 0x61, 0x77, 0x73, 0x6c, 0x65, 0x73, 0x73, 0x68, 0x61, 0x6c, 0x66, + 0x73, 0x6f, 0x6d, 0x65, 0x73, 0x75, 0x63, 0x68, 0x7a, 0x6f, 0x6e, 0x65, 0x31, 0x30, 0x30, 0x25, + 0x6f, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x72, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x72, 0x61, 0x63, 0x65, + 0x62, 0x6c, 0x75, 0x65, 0x66, 0x6f, 0x75, 0x72, 0x77, 0x65, 0x65, 0x6b, 0x66, 0x61, 0x63, 0x65, + 0x68, 0x6f, 0x70, 0x65, 0x67, 0x61, 0x76, 0x65, 0x68, 0x61, 0x72, 0x64, 0x6c, 0x6f, 0x73, 0x74, + 0x77, 0x68, 0x65, 0x6e, 0x70, 0x61, 0x72, 0x6b, 0x6b, 0x65, 0x70, 0x74, 0x70, 0x61, 0x73, 0x73, + 0x73, 0x68, 0x69, 0x70, 0x72, 0x6f, 0x6f, 0x6d, 0x48, 0x54, 0x4d, 0x4c, 0x70, 0x6c, 0x61, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x64, 0x6f, 0x6e, 0x65, 0x73, 0x61, 0x76, 0x65, 0x6b, 0x65, 0x65, 0x70, + 0x66, 0x6c, 0x61, 0x67, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x6f, 0x6c, 0x64, 0x66, 0x69, 0x76, 0x65, + 0x74, 0x6f, 0x6f, 0x6b, 0x72, 0x61, 0x74, 0x65, 0x74, 0x6f, 0x77, 0x6e, 0x6a, 0x75, 0x6d, 0x70, + 0x74, 0x68, 0x75, 0x73, 0x64, 0x61, 0x72, 0x6b, 0x63, 0x61, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, + 0x66, 0x65, 0x61, 0x72, 0x73, 0x74, 0x61, 0x79, 0x6b, 0x69, 0x6c, 0x6c, 0x74, 0x68, 0x61, 0x74, + 0x66, 0x61, 0x6c, 0x6c, 0x61, 0x75, 0x74, 0x6f, 0x65, 0x76, 0x65, 0x72, 0x2e, 0x63, 0x6f, 0x6d, + 0x74, 0x61, 0x6c, 0x6b, 0x73, 0x68, 0x6f, 0x70, 0x76, 0x6f, 0x74, 0x65, 0x64, 0x65, 0x65, 0x70, + 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x65, 0x73, 0x74, 0x74, 0x75, 0x72, 0x6e, 0x62, 0x6f, 0x72, 0x6e, + 0x62, 0x61, 0x6e, 0x64, 0x66, 0x65, 0x6c, 0x6c, 0x72, 0x6f, 0x73, 0x65, 0x75, 0x72, 0x6c, 0x28, + 0x73, 0x6b, 0x69, 0x6e, 0x72, 0x6f, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x61, 0x63, 0x74, 0x73, + 0x61, 0x67, 0x65, 0x73, 0x6d, 0x65, 0x65, 0x74, 0x67, 0x6f, 0x6c, 0x64, 0x2e, 0x6a, 0x70, 0x67, + 0x69, 0x74, 0x65, 0x6d, 0x76, 0x61, 0x72, 0x79, 0x66, 0x65, 0x6c, 0x74, 0x74, 0x68, 0x65, 0x6e, + 0x73, 0x65, 0x6e, 0x64, 0x64, 0x72, 0x6f, 0x70, 0x56, 0x69, 0x65, 0x77, 0x63, 0x6f, 0x70, 0x79, + 0x31, 0x2e, 0x30, 0x22, 0x3c, 0x2f, 0x61, 0x3e, 0x73, 0x74, 0x6f, 0x70, 0x65, 0x6c, 0x73, 0x65, + 0x6c, 0x69, 0x65, 0x73, 0x74, 0x6f, 0x75, 0x72, 0x70, 0x61, 0x63, 0x6b, 0x2e, 0x67, 0x69, 0x66, + 0x70, 0x61, 0x73, 0x74, 0x63, 0x73, 0x73, 0x3f, 0x67, 0x72, 0x61, 0x79, 0x6d, 0x65, 0x61, 0x6e, + 0x26, 0x67, 0x74, 0x3b, 0x72, 0x69, 0x64, 0x65, 0x73, 0x68, 0x6f, 0x74, 0x6c, 0x61, 0x74, 0x65, + 0x73, 0x61, 0x69, 0x64, 0x72, 0x6f, 0x61, 0x64, 0x76, 0x61, 0x72, 0x20, 0x66, 0x65, 0x65, 0x6c, + 0x6a, 0x6f, 0x68, 0x6e, 0x72, 0x69, 0x63, 0x6b, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x61, 0x73, 0x74, + 0x27, 0x55, 0x41, 0x2d, 0x64, 0x65, 0x61, 0x64, 0x3c, 0x2f, 0x62, 0x3e, 0x70, 0x6f, 0x6f, 0x72, + 0x62, 0x69, 0x6c, 0x6c, 0x74, 0x79, 0x70, 0x65, 0x55, 0x2e, 0x53, 0x2e, 0x77, 0x6f, 0x6f, 0x64, + 0x6d, 0x75, 0x73, 0x74, 0x32, 0x70, 0x78, 0x3b, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x61, 0x6e, 0x6b, + 0x77, 0x69, 0x64, 0x65, 0x77, 0x61, 0x6e, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x6c, 0x65, 0x61, 0x64, + 0x5b, 0x30, 0x5d, 0x3b, 0x70, 0x61, 0x75, 0x6c, 0x77, 0x61, 0x76, 0x65, 0x73, 0x75, 0x72, 0x65, + 0x24, 0x28, 0x27, 0x23, 0x77, 0x61, 0x69, 0x74, 0x6d, 0x61, 0x73, 0x73, 0x61, 0x72, 0x6d, 0x73, + 0x67, 0x6f, 0x65, 0x73, 0x67, 0x61, 0x69, 0x6e, 0x6c, 0x61, 0x6e, 0x67, 0x70, 0x61, 0x69, 0x64, + 0x21, 0x2d, 0x2d, 0x20, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x6e, 0x69, 0x74, 0x72, 0x6f, 0x6f, 0x74, + 0x77, 0x61, 0x6c, 0x6b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x69, 0x66, 0x65, 0x78, 0x6d, 0x6c, 0x22, + 0x73, 0x6f, 0x6e, 0x67, 0x74, 0x65, 0x73, 0x74, 0x32, 0x30, 0x70, 0x78, 0x6b, 0x69, 0x6e, 0x64, + 0x72, 0x6f, 0x77, 0x73, 0x74, 0x6f, 0x6f, 0x6c, 0x66, 0x6f, 0x6e, 0x74, 0x6d, 0x61, 0x69, 0x6c, + 0x73, 0x61, 0x66, 0x65, 0x73, 0x74, 0x61, 0x72, 0x6d, 0x61, 0x70, 0x73, 0x63, 0x6f, 0x72, 0x65, + 0x72, 0x61, 0x69, 0x6e, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x61, 0x62, 0x79, 0x73, 0x70, 0x61, 0x6e, + 0x73, 0x61, 0x79, 0x73, 0x34, 0x70, 0x78, 0x3b, 0x36, 0x70, 0x78, 0x3b, 0x61, 0x72, 0x74, 0x73, + 0x66, 0x6f, 0x6f, 0x74, 0x72, 0x65, 0x61, 0x6c, 0x77, 0x69, 0x6b, 0x69, 0x68, 0x65, 0x61, 0x74, + 0x73, 0x74, 0x65, 0x70, 0x74, 0x72, 0x69, 0x70, 0x6f, 0x72, 0x67, 0x2f, 0x6c, 0x61, 0x6b, 0x65, + 0x77, 0x65, 0x61, 0x6b, 0x74, 0x6f, 0x6c, 0x64, 0x46, 0x6f, 0x72, 0x6d, 0x63, 0x61, 0x73, 0x74, + 0x66, 0x61, 0x6e, 0x73, 0x62, 0x61, 0x6e, 0x6b, 0x76, 0x65, 0x72, 0x79, 0x72, 0x75, 0x6e, 0x73, + 0x6a, 0x75, 0x6c, 0x79, 0x74, 0x61, 0x73, 0x6b, 0x31, 0x70, 0x78, 0x3b, 0x67, 0x6f, 0x61, 0x6c, + 0x67, 0x72, 0x65, 0x77, 0x73, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x67, 0x65, 0x69, 0x64, 0x3d, 0x22, + 0x73, 0x65, 0x74, 0x73, 0x35, 0x70, 0x78, 0x3b, 0x2e, 0x6a, 0x73, 0x3f, 0x34, 0x30, 0x70, 0x78, + 0x69, 0x66, 0x20, 0x28, 0x73, 0x6f, 0x6f, 0x6e, 0x73, 0x65, 0x61, 0x74, 0x6e, 0x6f, 0x6e, 0x65, + 0x74, 0x75, 0x62, 0x65, 0x7a, 0x65, 0x72, 0x6f, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x65, 0x64, + 0x66, 0x61, 0x63, 0x74, 0x69, 0x6e, 0x74, 0x6f, 0x67, 0x69, 0x66, 0x74, 0x68, 0x61, 0x72, 0x6d, + 0x31, 0x38, 0x70, 0x78, 0x63, 0x61, 0x6d, 0x65, 0x68, 0x69, 0x6c, 0x6c, 0x62, 0x6f, 0x6c, 0x64, + 0x7a, 0x6f, 0x6f, 0x6d, 0x76, 0x6f, 0x69, 0x64, 0x65, 0x61, 0x73, 0x79, 0x72, 0x69, 0x6e, 0x67, + 0x66, 0x69, 0x6c, 0x6c, 0x70, 0x65, 0x61, 0x6b, 0x69, 0x6e, 0x69, 0x74, 0x63, 0x6f, 0x73, 0x74, + 0x33, 0x70, 0x78, 0x3b, 0x6a, 0x61, 0x63, 0x6b, 0x74, 0x61, 0x67, 0x73, 0x62, 0x69, 0x74, 0x73, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x69, 0x74, 0x6b, 0x6e, 0x65, 0x77, 0x6e, 0x65, 0x61, 0x72, + 0x3c, 0x21, 0x2d, 0x2d, 0x67, 0x72, 0x6f, 0x77, 0x4a, 0x53, 0x4f, 0x4e, 0x64, 0x75, 0x74, 0x79, + 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x79, 0x6f, 0x75, 0x20, 0x6c, 0x6f, 0x74, 0x73, + 0x70, 0x61, 0x69, 0x6e, 0x6a, 0x61, 0x7a, 0x7a, 0x63, 0x6f, 0x6c, 0x64, 0x65, 0x79, 0x65, 0x73, + 0x66, 0x69, 0x73, 0x68, 0x77, 0x77, 0x77, 0x2e, 0x72, 0x69, 0x73, 0x6b, 0x74, 0x61, 0x62, 0x73, + 0x70, 0x72, 0x65, 0x76, 0x31, 0x30, 0x70, 0x78, 0x72, 0x69, 0x73, 0x65, 0x32, 0x35, 0x70, 0x78, + 0x42, 0x6c, 0x75, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x33, 0x30, 0x30, 0x2c, 0x62, 0x61, 0x6c, 0x6c, + 0x66, 0x6f, 0x72, 0x64, 0x65, 0x61, 0x72, 0x6e, 0x77, 0x69, 0x6c, 0x64, 0x62, 0x6f, 0x78, 0x2e, + 0x66, 0x61, 0x69, 0x72, 0x6c, 0x61, 0x63, 0x6b, 0x76, 0x65, 0x72, 0x73, 0x70, 0x61, 0x69, 0x72, + 0x6a, 0x75, 0x6e, 0x65, 0x74, 0x65, 0x63, 0x68, 0x69, 0x66, 0x28, 0x21, 0x70, 0x69, 0x63, 0x6b, + 0x65, 0x76, 0x69, 0x6c, 0x24, 0x28, 0x22, 0x23, 0x77, 0x61, 0x72, 0x6d, 0x6c, 0x6f, 0x72, 0x64, + 0x64, 0x6f, 0x65, 0x73, 0x70, 0x75, 0x6c, 0x6c, 0x2c, 0x30, 0x30, 0x30, 0x69, 0x64, 0x65, 0x61, + 0x64, 0x72, 0x61, 0x77, 0x68, 0x75, 0x67, 0x65, 0x73, 0x70, 0x6f, 0x74, 0x66, 0x75, 0x6e, 0x64, + 0x62, 0x75, 0x72, 0x6e, 0x68, 0x72, 0x65, 0x66, 0x63, 0x65, 0x6c, 0x6c, 0x6b, 0x65, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x6f, 0x73, 0x73, 0x66, 0x75, 0x65, 0x6c, + 0x31, 0x32, 0x70, 0x78, 0x73, 0x75, 0x69, 0x74, 0x64, 0x65, 0x61, 0x6c, 0x52, 0x53, 0x53, 0x22, + 0x61, 0x67, 0x65, 0x64, 0x67, 0x72, 0x65, 0x79, 0x47, 0x45, 0x54, 0x22, 0x65, 0x61, 0x73, 0x65, + 0x61, 0x69, 0x6d, 0x73, 0x67, 0x69, 0x72, 0x6c, 0x61, 0x69, 0x64, 0x73, 0x38, 0x70, 0x78, 0x3b, + 0x6e, 0x61, 0x76, 0x79, 0x67, 0x72, 0x69, 0x64, 0x74, 0x69, 0x70, 0x73, 0x23, 0x39, 0x39, 0x39, + 0x77, 0x61, 0x72, 0x73, 0x6c, 0x61, 0x64, 0x79, 0x63, 0x61, 0x72, 0x73, 0x29, 0x3b, 0x20, 0x7d, + 0x70, 0x68, 0x70, 0x3f, 0x68, 0x65, 0x6c, 0x6c, 0x74, 0x61, 0x6c, 0x6c, 0x77, 0x68, 0x6f, 0x6d, + 0x7a, 0x68, 0x3a, 0xe5, 0x2a, 0x2f, 0x0d, 0x0a, 0x20, 0x31, 0x30, 0x30, 0x68, 0x61, 0x6c, 0x6c, + 0x2e, 0x0a, 0x0a, 0x41, 0x37, 0x70, 0x78, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x63, 0x68, 0x61, 0x74, + 0x30, 0x70, 0x78, 0x3b, 0x63, 0x72, 0x65, 0x77, 0x2a, 0x2f, 0x3c, 0x2f, 0x68, 0x61, 0x73, 0x68, + 0x37, 0x35, 0x70, 0x78, 0x66, 0x6c, 0x61, 0x74, 0x72, 0x61, 0x72, 0x65, 0x20, 0x26, 0x26, 0x20, + 0x74, 0x65, 0x6c, 0x6c, 0x63, 0x61, 0x6d, 0x70, 0x6f, 0x6e, 0x74, 0x6f, 0x6c, 0x61, 0x69, 0x64, + 0x6d, 0x69, 0x73, 0x73, 0x73, 0x6b, 0x69, 0x70, 0x74, 0x65, 0x6e, 0x74, 0x66, 0x69, 0x6e, 0x65, + 0x6d, 0x61, 0x6c, 0x65, 0x67, 0x65, 0x74, 0x73, 0x70, 0x6c, 0x6f, 0x74, 0x34, 0x30, 0x30, 0x2c, + 0x0d, 0x0a, 0x0d, 0x0a, 0x63, 0x6f, 0x6f, 0x6c, 0x66, 0x65, 0x65, 0x74, 0x2e, 0x70, 0x68, 0x70, + 0x3c, 0x62, 0x72, 0x3e, 0x65, 0x72, 0x69, 0x63, 0x6d, 0x6f, 0x73, 0x74, 0x67, 0x75, 0x69, 0x64, + 0x62, 0x65, 0x6c, 0x6c, 0x64, 0x65, 0x73, 0x63, 0x68, 0x61, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x68, + 0x61, 0x74, 0x6f, 0x6d, 0x2f, 0x69, 0x6d, 0x67, 0x26, 0x23, 0x38, 0x32, 0x6c, 0x75, 0x63, 0x6b, + 0x63, 0x65, 0x6e, 0x74, 0x30, 0x30, 0x30, 0x3b, 0x74, 0x69, 0x6e, 0x79, 0x67, 0x6f, 0x6e, 0x65, + 0x68, 0x74, 0x6d, 0x6c, 0x73, 0x65, 0x6c, 0x6c, 0x64, 0x72, 0x75, 0x67, 0x46, 0x52, 0x45, 0x45, + 0x6e, 0x6f, 0x64, 0x65, 0x6e, 0x69, 0x63, 0x6b, 0x3f, 0x69, 0x64, 0x3d, 0x6c, 0x6f, 0x73, 0x65, + 0x6e, 0x75, 0x6c, 0x6c, 0x76, 0x61, 0x73, 0x74, 0x77, 0x69, 0x6e, 0x64, 0x52, 0x53, 0x53, 0x20, + 0x77, 0x65, 0x61, 0x72, 0x72, 0x65, 0x6c, 0x79, 0x62, 0x65, 0x65, 0x6e, 0x73, 0x61, 0x6d, 0x65, + 0x64, 0x75, 0x6b, 0x65, 0x6e, 0x61, 0x73, 0x61, 0x63, 0x61, 0x70, 0x65, 0x77, 0x69, 0x73, 0x68, + 0x67, 0x75, 0x6c, 0x66, 0x54, 0x32, 0x33, 0x3a, 0x68, 0x69, 0x74, 0x73, 0x73, 0x6c, 0x6f, 0x74, + 0x67, 0x61, 0x74, 0x65, 0x6b, 0x69, 0x63, 0x6b, 0x62, 0x6c, 0x75, 0x72, 0x74, 0x68, 0x65, 0x79, + 0x31, 0x35, 0x70, 0x78, 0x27, 0x27, 0x29, 0x3b, 0x29, 0x3b, 0x22, 0x3e, 0x6d, 0x73, 0x69, 0x65, + 0x77, 0x69, 0x6e, 0x73, 0x62, 0x69, 0x72, 0x64, 0x73, 0x6f, 0x72, 0x74, 0x62, 0x65, 0x74, 0x61, + 0x73, 0x65, 0x65, 0x6b, 0x54, 0x31, 0x38, 0x3a, 0x6f, 0x72, 0x64, 0x73, 0x74, 0x72, 0x65, 0x65, + 0x6d, 0x61, 0x6c, 0x6c, 0x36, 0x30, 0x70, 0x78, 0x66, 0x61, 0x72, 0x6d, 0xe2, 0x80, 0x99, 0x73, + 0x62, 0x6f, 0x79, 0x73, 0x5b, 0x30, 0x5d, 0x2e, 0x27, 0x29, 0x3b, 0x22, 0x50, 0x4f, 0x53, 0x54, + 0x62, 0x65, 0x61, 0x72, 0x6b, 0x69, 0x64, 0x73, 0x29, 0x3b, 0x7d, 0x7d, 0x6d, 0x61, 0x72, 0x79, + 0x74, 0x65, 0x6e, 0x64, 0x28, 0x55, 0x4b, 0x29, 0x71, 0x75, 0x61, 0x64, 0x7a, 0x68, 0x3a, 0xe6, + 0x2d, 0x73, 0x69, 0x7a, 0x2d, 0x2d, 0x2d, 0x2d, 0x70, 0x72, 0x6f, 0x70, 0x27, 0x29, 0x3b, 0x0d, + 0x6c, 0x69, 0x66, 0x74, 0x54, 0x31, 0x39, 0x3a, 0x76, 0x69, 0x63, 0x65, 0x61, 0x6e, 0x64, 0x79, + 0x64, 0x65, 0x62, 0x74, 0x3e, 0x52, 0x53, 0x53, 0x70, 0x6f, 0x6f, 0x6c, 0x6e, 0x65, 0x63, 0x6b, + 0x62, 0x6c, 0x6f, 0x77, 0x54, 0x31, 0x36, 0x3a, 0x64, 0x6f, 0x6f, 0x72, 0x65, 0x76, 0x61, 0x6c, + 0x54, 0x31, 0x37, 0x3a, 0x6c, 0x65, 0x74, 0x73, 0x66, 0x61, 0x69, 0x6c, 0x6f, 0x72, 0x61, 0x6c, + 0x70, 0x6f, 0x6c, 0x6c, 0x6e, 0x6f, 0x76, 0x61, 0x63, 0x6f, 0x6c, 0x73, 0x67, 0x65, 0x6e, 0x65, + 0x20, 0xe2, 0x80, 0x94, 0x73, 0x6f, 0x66, 0x74, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6c, 0x6c, + 0x72, 0x6f, 0x73, 0x73, 0x3c, 0x68, 0x33, 0x3e, 0x70, 0x6f, 0x75, 0x72, 0x66, 0x61, 0x64, 0x65, + 0x70, 0x69, 0x6e, 0x6b, 0x3c, 0x74, 0x72, 0x3e, 0x6d, 0x69, 0x6e, 0x69, 0x29, 0x7c, 0x21, 0x28, + 0x6d, 0x69, 0x6e, 0x65, 0x7a, 0x68, 0x3a, 0xe8, 0x62, 0x61, 0x72, 0x73, 0x68, 0x65, 0x61, 0x72, + 0x30, 0x30, 0x29, 0x3b, 0x6d, 0x69, 0x6c, 0x6b, 0x20, 0x2d, 0x2d, 0x3e, 0x69, 0x72, 0x6f, 0x6e, + 0x66, 0x72, 0x65, 0x64, 0x64, 0x69, 0x73, 0x6b, 0x77, 0x65, 0x6e, 0x74, 0x73, 0x6f, 0x69, 0x6c, + 0x70, 0x75, 0x74, 0x73, 0x2f, 0x6a, 0x73, 0x2f, 0x68, 0x6f, 0x6c, 0x79, 0x54, 0x32, 0x32, 0x3a, + 0x49, 0x53, 0x42, 0x4e, 0x54, 0x32, 0x30, 0x3a, 0x61, 0x64, 0x61, 0x6d, 0x73, 0x65, 0x65, 0x73, + 0x3c, 0x68, 0x32, 0x3e, 0x6a, 0x73, 0x6f, 0x6e, 0x27, 0x2c, 0x20, 0x27, 0x63, 0x6f, 0x6e, 0x74, + 0x54, 0x32, 0x31, 0x3a, 0x20, 0x52, 0x53, 0x53, 0x6c, 0x6f, 0x6f, 0x70, 0x61, 0x73, 0x69, 0x61, + 0x6d, 0x6f, 0x6f, 0x6e, 0x3c, 0x2f, 0x70, 0x3e, 0x73, 0x6f, 0x75, 0x6c, 0x4c, 0x49, 0x4e, 0x45, + 0x66, 0x6f, 0x72, 0x74, 0x63, 0x61, 0x72, 0x74, 0x54, 0x31, 0x34, 0x3a, 0x3c, 0x68, 0x31, 0x3e, + 0x38, 0x30, 0x70, 0x78, 0x21, 0x2d, 0x2d, 0x3c, 0x39, 0x70, 0x78, 0x3b, 0x54, 0x30, 0x34, 0x3a, + 0x6d, 0x69, 0x6b, 0x65, 0x3a, 0x34, 0x36, 0x5a, 0x6e, 0x69, 0x63, 0x65, 0x69, 0x6e, 0x63, 0x68, + 0x59, 0x6f, 0x72, 0x6b, 0x72, 0x69, 0x63, 0x65, 0x7a, 0x68, 0x3a, 0xe4, 0x27, 0x29, 0x29, 0x3b, + 0x70, 0x75, 0x72, 0x65, 0x6d, 0x61, 0x67, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x6e, 0x65, + 0x62, 0x6f, 0x6e, 0x64, 0x3a, 0x33, 0x37, 0x5a, 0x5f, 0x6f, 0x66, 0x5f, 0x27, 0x5d, 0x29, 0x3b, + 0x30, 0x30, 0x30, 0x2c, 0x7a, 0x68, 0x3a, 0xe7, 0x74, 0x61, 0x6e, 0x6b, 0x79, 0x61, 0x72, 0x64, + 0x62, 0x6f, 0x77, 0x6c, 0x62, 0x75, 0x73, 0x68, 0x3a, 0x35, 0x36, 0x5a, 0x4a, 0x61, 0x76, 0x61, + 0x33, 0x30, 0x70, 0x78, 0x0a, 0x7c, 0x7d, 0x0a, 0x25, 0x43, 0x33, 0x25, 0x3a, 0x33, 0x34, 0x5a, + 0x6a, 0x65, 0x66, 0x66, 0x45, 0x58, 0x50, 0x49, 0x63, 0x61, 0x73, 0x68, 0x76, 0x69, 0x73, 0x61, + 0x67, 0x6f, 0x6c, 0x66, 0x73, 0x6e, 0x6f, 0x77, 0x7a, 0x68, 0x3a, 0xe9, 0x71, 0x75, 0x65, 0x72, + 0x2e, 0x63, 0x73, 0x73, 0x73, 0x69, 0x63, 0x6b, 0x6d, 0x65, 0x61, 0x74, 0x6d, 0x69, 0x6e, 0x2e, + 0x62, 0x69, 0x6e, 0x64, 0x64, 0x65, 0x6c, 0x6c, 0x68, 0x69, 0x72, 0x65, 0x70, 0x69, 0x63, 0x73, + 0x72, 0x65, 0x6e, 0x74, 0x3a, 0x33, 0x36, 0x5a, 0x48, 0x54, 0x54, 0x50, 0x2d, 0x32, 0x30, 0x31, + 0x66, 0x6f, 0x74, 0x6f, 0x77, 0x6f, 0x6c, 0x66, 0x45, 0x4e, 0x44, 0x20, 0x78, 0x62, 0x6f, 0x78, + 0x3a, 0x35, 0x34, 0x5a, 0x42, 0x4f, 0x44, 0x59, 0x64, 0x69, 0x63, 0x6b, 0x3b, 0x0a, 0x7d, 0x0a, + 0x65, 0x78, 0x69, 0x74, 0x3a, 0x33, 0x35, 0x5a, 0x76, 0x61, 0x72, 0x73, 0x62, 0x65, 0x61, 0x74, + 0x27, 0x7d, 0x29, 0x3b, 0x64, 0x69, 0x65, 0x74, 0x39, 0x39, 0x39, 0x3b, 0x61, 0x6e, 0x6e, 0x65, + 0x7d, 0x7d, 0x3c, 0x2f, 0x5b, 0x69, 0x5d, 0x2e, 0x4c, 0x61, 0x6e, 0x67, 0x6b, 0x6d, 0xc2, 0xb2, + 0x77, 0x69, 0x72, 0x65, 0x74, 0x6f, 0x79, 0x73, 0x61, 0x64, 0x64, 0x73, 0x73, 0x65, 0x61, 0x6c, + 0x61, 0x6c, 0x65, 0x78, 0x3b, 0x0a, 0x09, 0x7d, 0x65, 0x63, 0x68, 0x6f, 0x6e, 0x69, 0x6e, 0x65, + 0x2e, 0x6f, 0x72, 0x67, 0x30, 0x30, 0x35, 0x29, 0x74, 0x6f, 0x6e, 0x79, 0x6a, 0x65, 0x77, 0x73, + 0x73, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x67, 0x73, 0x72, 0x6f, 0x6f, 0x66, 0x30, 0x30, 0x30, 0x29, + 0x20, 0x32, 0x30, 0x30, 0x77, 0x69, 0x6e, 0x65, 0x67, 0x65, 0x61, 0x72, 0x64, 0x6f, 0x67, 0x73, + 0x62, 0x6f, 0x6f, 0x74, 0x67, 0x61, 0x72, 0x79, 0x63, 0x75, 0x74, 0x73, 0x74, 0x79, 0x6c, 0x65, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x78, 0x6d, 0x6c, 0x63, 0x6f, 0x63, 0x6b, + 0x67, 0x61, 0x6e, 0x67, 0x24, 0x28, 0x27, 0x2e, 0x35, 0x30, 0x70, 0x78, 0x50, 0x68, 0x2e, 0x44, + 0x6d, 0x69, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x6e, 0x6c, 0x6f, 0x61, 0x6e, 0x64, 0x65, 0x73, 0x6b, + 0x6d, 0x69, 0x6c, 0x65, 0x72, 0x79, 0x61, 0x6e, 0x75, 0x6e, 0x69, 0x78, 0x64, 0x69, 0x73, 0x63, + 0x29, 0x3b, 0x7d, 0x0a, 0x64, 0x75, 0x73, 0x74, 0x63, 0x6c, 0x69, 0x70, 0x29, 0x2e, 0x0a, 0x0a, + 0x37, 0x30, 0x70, 0x78, 0x2d, 0x32, 0x30, 0x30, 0x44, 0x56, 0x44, 0x73, 0x37, 0x5d, 0x3e, 0x3c, + 0x74, 0x61, 0x70, 0x65, 0x64, 0x65, 0x6d, 0x6f, 0x69, 0x2b, 0x2b, 0x29, 0x77, 0x61, 0x67, 0x65, + 0x65, 0x75, 0x72, 0x6f, 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x70, 0x74, 0x73, 0x68, 0x6f, 0x6c, 0x65, + 0x46, 0x41, 0x51, 0x73, 0x61, 0x73, 0x69, 0x6e, 0x2d, 0x32, 0x36, 0x54, 0x6c, 0x61, 0x62, 0x73, + 0x70, 0x65, 0x74, 0x73, 0x55, 0x52, 0x4c, 0x20, 0x62, 0x75, 0x6c, 0x6b, 0x63, 0x6f, 0x6f, 0x6b, + 0x3b, 0x7d, 0x0d, 0x0a, 0x48, 0x45, 0x41, 0x44, 0x5b, 0x30, 0x5d, 0x29, 0x61, 0x62, 0x62, 0x72, + 0x6a, 0x75, 0x61, 0x6e, 0x28, 0x31, 0x39, 0x38, 0x6c, 0x65, 0x73, 0x68, 0x74, 0x77, 0x69, 0x6e, + 0x3c, 0x2f, 0x69, 0x3e, 0x73, 0x6f, 0x6e, 0x79, 0x67, 0x75, 0x79, 0x73, 0x66, 0x75, 0x63, 0x6b, + 0x70, 0x69, 0x70, 0x65, 0x7c, 0x2d, 0x0a, 0x21, 0x30, 0x30, 0x32, 0x29, 0x6e, 0x64, 0x6f, 0x77, + 0x5b, 0x31, 0x5d, 0x3b, 0x5b, 0x5d, 0x3b, 0x0a, 0x4c, 0x6f, 0x67, 0x20, 0x73, 0x61, 0x6c, 0x74, + 0x0d, 0x0a, 0x09, 0x09, 0x62, 0x61, 0x6e, 0x67, 0x74, 0x72, 0x69, 0x6d, 0x62, 0x61, 0x74, 0x68, + 0x29, 0x7b, 0x0d, 0x0a, 0x30, 0x30, 0x70, 0x78, 0x0a, 0x7d, 0x29, 0x3b, 0x6b, 0x6f, 0x3a, 0xec, + 0x66, 0x65, 0x65, 0x73, 0x61, 0x64, 0x3e, 0x0d, 0x73, 0x3a, 0x2f, 0x2f, 0x20, 0x5b, 0x5d, 0x3b, + 0x74, 0x6f, 0x6c, 0x6c, 0x70, 0x6c, 0x75, 0x67, 0x28, 0x29, 0x7b, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, + 0x2e, 0x6a, 0x73, 0x27, 0x32, 0x30, 0x30, 0x70, 0x64, 0x75, 0x61, 0x6c, 0x62, 0x6f, 0x61, 0x74, + 0x2e, 0x4a, 0x50, 0x47, 0x29, 0x3b, 0x0a, 0x7d, 0x71, 0x75, 0x6f, 0x74, 0x29, 0x3b, 0x0a, 0x0a, + 0x27, 0x29, 0x3b, 0x0a, 0x0d, 0x0a, 0x7d, 0x0d, 0x32, 0x30, 0x31, 0x34, 0x32, 0x30, 0x31, 0x35, + 0x32, 0x30, 0x31, 0x36, 0x32, 0x30, 0x31, 0x37, 0x32, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, + 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x31, 0x32, 0x30, 0x32, 0x32, 0x32, 0x30, 0x32, 0x33, + 0x32, 0x30, 0x32, 0x34, 0x32, 0x30, 0x32, 0x35, 0x32, 0x30, 0x32, 0x36, 0x32, 0x30, 0x32, 0x37, + 0x32, 0x30, 0x32, 0x38, 0x32, 0x30, 0x32, 0x39, 0x32, 0x30, 0x33, 0x30, 0x32, 0x30, 0x33, 0x31, + 0x32, 0x30, 0x33, 0x32, 0x32, 0x30, 0x33, 0x33, 0x32, 0x30, 0x33, 0x34, 0x32, 0x30, 0x33, 0x35, + 0x32, 0x30, 0x33, 0x36, 0x32, 0x30, 0x33, 0x37, 0x32, 0x30, 0x31, 0x33, 0x32, 0x30, 0x31, 0x32, + 0x32, 0x30, 0x31, 0x31, 0x32, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x38, + 0x32, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x34, + 0x32, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x30, 0x30, + 0x31, 0x39, 0x39, 0x39, 0x31, 0x39, 0x39, 0x38, 0x31, 0x39, 0x39, 0x37, 0x31, 0x39, 0x39, 0x36, + 0x31, 0x39, 0x39, 0x35, 0x31, 0x39, 0x39, 0x34, 0x31, 0x39, 0x39, 0x33, 0x31, 0x39, 0x39, 0x32, + 0x31, 0x39, 0x39, 0x31, 0x31, 0x39, 0x39, 0x30, 0x31, 0x39, 0x38, 0x39, 0x31, 0x39, 0x38, 0x38, + 0x31, 0x39, 0x38, 0x37, 0x31, 0x39, 0x38, 0x36, 0x31, 0x39, 0x38, 0x35, 0x31, 0x39, 0x38, 0x34, + 0x31, 0x39, 0x38, 0x33, 0x31, 0x39, 0x38, 0x32, 0x31, 0x39, 0x38, 0x31, 0x31, 0x39, 0x38, 0x30, + 0x31, 0x39, 0x37, 0x39, 0x31, 0x39, 0x37, 0x38, 0x31, 0x39, 0x37, 0x37, 0x31, 0x39, 0x37, 0x36, + 0x31, 0x39, 0x37, 0x35, 0x31, 0x39, 0x37, 0x34, 0x31, 0x39, 0x37, 0x33, 0x31, 0x39, 0x37, 0x32, + 0x31, 0x39, 0x37, 0x31, 0x31, 0x39, 0x37, 0x30, 0x31, 0x39, 0x36, 0x39, 0x31, 0x39, 0x36, 0x38, + 0x31, 0x39, 0x36, 0x37, 0x31, 0x39, 0x36, 0x36, 0x31, 0x39, 0x36, 0x35, 0x31, 0x39, 0x36, 0x34, + 0x31, 0x39, 0x36, 0x33, 0x31, 0x39, 0x36, 0x32, 0x31, 0x39, 0x36, 0x31, 0x31, 0x39, 0x36, 0x30, + 0x31, 0x39, 0x35, 0x39, 0x31, 0x39, 0x35, 0x38, 0x31, 0x39, 0x35, 0x37, 0x31, 0x39, 0x35, 0x36, + 0x31, 0x39, 0x35, 0x35, 0x31, 0x39, 0x35, 0x34, 0x31, 0x39, 0x35, 0x33, 0x31, 0x39, 0x35, 0x32, + 0x31, 0x39, 0x35, 0x31, 0x31, 0x39, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x34, + 0x31, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, 0x39, 0x39, 0x63, 0x6f, 0x6d, 0x6f, + 0x6d, 0xc3, 0xa1, 0x73, 0x65, 0x73, 0x74, 0x65, 0x65, 0x73, 0x74, 0x61, 0x70, 0x65, 0x72, 0x6f, + 0x74, 0x6f, 0x64, 0x6f, 0x68, 0x61, 0x63, 0x65, 0x63, 0x61, 0x64, 0x61, 0x61, 0xc3, 0xb1, 0x6f, + 0x62, 0x69, 0x65, 0x6e, 0x64, 0xc3, 0xad, 0x61, 0x61, 0x73, 0xc3, 0xad, 0x76, 0x69, 0x64, 0x61, + 0x63, 0x61, 0x73, 0x6f, 0x6f, 0x74, 0x72, 0x6f, 0x66, 0x6f, 0x72, 0x6f, 0x73, 0x6f, 0x6c, 0x6f, + 0x6f, 0x74, 0x72, 0x61, 0x63, 0x75, 0x61, 0x6c, 0x64, 0x69, 0x6a, 0x6f, 0x73, 0x69, 0x64, 0x6f, + 0x67, 0x72, 0x61, 0x6e, 0x74, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6d, 0x61, 0x64, 0x65, 0x62, 0x65, + 0x61, 0x6c, 0x67, 0x6f, 0x71, 0x75, 0xc3, 0xa9, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x61, 0x64, 0x61, + 0x74, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x63, 0x6f, 0x63, 0x61, 0x73, 0x61, 0x62, 0x61, 0x6a, 0x6f, + 0x74, 0x6f, 0x64, 0x61, 0x73, 0x69, 0x6e, 0x6f, 0x61, 0x67, 0x75, 0x61, 0x70, 0x75, 0x65, 0x73, + 0x75, 0x6e, 0x6f, 0x73, 0x61, 0x6e, 0x74, 0x65, 0x64, 0x69, 0x63, 0x65, 0x6c, 0x75, 0x69, 0x73, + 0x65, 0x6c, 0x6c, 0x61, 0x6d, 0x61, 0x79, 0x6f, 0x7a, 0x6f, 0x6e, 0x61, 0x61, 0x6d, 0x6f, 0x72, + 0x70, 0x69, 0x73, 0x6f, 0x6f, 0x62, 0x72, 0x61, 0x63, 0x6c, 0x69, 0x63, 0x65, 0x6c, 0x6c, 0x6f, + 0x64, 0x69, 0x6f, 0x73, 0x68, 0x6f, 0x72, 0x61, 0x63, 0x61, 0x73, 0x69, 0xd0, 0xb7, 0xd0, 0xb0, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x80, 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x83, + 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xbe, 0xd1, 0x82, + 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, + 0xd0, 0xb6, 0xd0, 0xb5, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x85, 0xd0, 0x9d, 0xd0, 0xb0, + 0xd0, 0xb5, 0xd0, 0xb5, 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xbc, 0xd1, 0x8b, 0xd0, 0x92, 0xd1, 0x8b, + 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x8b, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0x9d, 0xd0, 0xbe, + 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0x9f, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb8, 0xd0, 0xbd, 0xd0, 0xb8, + 0xd0, 0xa0, 0xd0, 0xa4, 0xd0, 0x9d, 0xd0, 0xb5, 0xd0, 0x9c, 0xd1, 0x8b, 0xd1, 0x82, 0xd1, 0x8b, + 0xd0, 0x9e, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0x97, 0xd0, 0xb0, + 0xd0, 0x94, 0xd0, 0xb0, 0xd0, 0x9d, 0xd1, 0x83, 0xd0, 0x9e, 0xd0, 0xb1, 0xd1, 0x82, 0xd0, 0xb5, + 0xd0, 0x98, 0xd0, 0xb7, 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0xbd, 0xd1, 0x83, 0xd0, 0xbc, 0xd0, 0xbc, + 0xd0, 0xa2, 0xd1, 0x8b, 0xd1, 0x83, 0xd0, 0xb6, 0xd9, 0x81, 0xd9, 0x8a, 0xd8, 0xa3, 0xd9, 0x86, + 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xb9, 0xd9, 0x83, 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x88, + 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x81, 0xd9, 0x89, 0xd9, 0x87, 0xd9, 0x88, + 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x84, 0xd9, 0x83, 0xd8, 0xa7, 0xd9, 0x88, 0xd9, 0x84, 0xd9, 0x87, + 0xd8, 0xa8, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa5, 0xd9, 0x86, 0xd9, 0x87, 0xd9, 0x8a, + 0xd8, 0xa3, 0xd9, 0x8a, 0xd9, 0x82, 0xd8, 0xaf, 0xd9, 0x87, 0xd9, 0x84, 0xd8, 0xab, 0xd9, 0x85, + 0xd8, 0xa8, 0xd9, 0x87, 0xd9, 0x84, 0xd9, 0x88, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xa8, 0xd9, 0x84, + 0xd8, 0xa7, 0xd9, 0x8a, 0xd8, 0xa8, 0xd9, 0x83, 0xd8, 0xb4, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x85, + 0xd8, 0xa3, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xa8, 0xd9, 0x8a, 0xd9, 0x84, 0xd9, 0x86, + 0xd8, 0xad, 0xd8, 0xa8, 0xd9, 0x87, 0xd9, 0x85, 0xd9, 0x85, 0xd8, 0xb4, 0xd9, 0x88, 0xd8, 0xb4, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x77, + 0x6f, 0x72, 0x6c, 0x64, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x77, 0x68, 0x69, 0x74, 0x65, 0x63, 0x6c, + 0x6f, 0x73, 0x65, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x6d, 0x61, + 0x6c, 0x6c, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x75, 0x73, 0x69, + 0x63, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x62, + 0x6f, 0x61, 0x72, 0x64, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x77, 0x6f, + 0x72, 0x6b, 0x73, 0x79, 0x65, 0x61, 0x72, 0x73, 0x73, 0x74, 0x61, 0x74, 0x65, 0x74, 0x6f, 0x64, + 0x61, 0x79, 0x77, 0x61, 0x74, 0x65, 0x72, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x64, 0x65, 0x61, 0x74, 0x68, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x70, 0x68, 0x6f, 0x6e, 0x65, + 0x6e, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x61, + 0x62, 0x6f, 0x75, 0x74, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x74, 0x6f, + 0x6f, 0x6c, 0x73, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x67, 0x61, 0x6d, 0x65, + 0x73, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x73, 0x70, 0x61, 0x63, 0x65, 0x66, 0x6f, 0x63, 0x75, 0x73, + 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x72, 0x61, 0x64, 0x69, 0x6f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x77, 0x6f, + 0x6d, 0x65, 0x6e, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x79, 0x6f, 0x75, 0x6e, 0x67, 0x6c, 0x69, 0x6e, 0x65, + 0x73, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x72, 0x65, 0x65, 0x6e, + 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x77, 0x61, 0x74, 0x63, 0x68, 0x66, + 0x6f, 0x72, 0x63, 0x65, 0x70, 0x72, 0x69, 0x63, 0x65, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x62, 0x65, + 0x67, 0x69, 0x6e, 0x61, 0x66, 0x74, 0x65, 0x72, 0x76, 0x69, 0x73, 0x69, 0x74, 0x69, 0x73, 0x73, + 0x75, 0x65, 0x61, 0x72, 0x65, 0x61, 0x73, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x70, 0x72, 0x69, 0x6e, 0x74, 0x70, 0x72, 0x65, 0x73, 0x73, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x6c, + 0x69, 0x6e, 0x6b, 0x73, 0x73, 0x70, 0x65, 0x65, 0x64, 0x73, 0x74, 0x75, 0x64, 0x79, 0x74, 0x72, + 0x61, 0x64, 0x65, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x65, 0x6e, 0x73, 0x65, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x73, 0x68, 0x6f, 0x77, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x72, 0x61, 0x6e, 0x67, + 0x65, 0x61, 0x64, 0x64, 0x65, 0x64, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x6d, 0x6f, 0x76, 0x65, 0x64, + 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x66, + 0x69, 0x78, 0x65, 0x64, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x76, 0x69, + 0x65, 0x77, 0x73, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x72, 0x69, 0x76, + 0x65, 0x72, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x73, 0x68, 0x61, 0x70, + 0x65, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x65, 0x78, 0x69, 0x73, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, + 0x6d, 0x6f, 0x76, 0x69, 0x65, 0x74, 0x68, 0x69, 0x72, 0x64, 0x62, 0x61, 0x73, 0x69, 0x63, 0x70, + 0x65, 0x61, 0x63, 0x65, 0x73, 0x74, 0x61, 0x67, 0x65, 0x77, 0x69, 0x64, 0x74, 0x68, 0x6c, 0x6f, + 0x67, 0x69, 0x6e, 0x69, 0x64, 0x65, 0x61, 0x73, 0x77, 0x72, 0x6f, 0x74, 0x65, 0x70, 0x61, 0x67, + 0x65, 0x73, 0x75, 0x73, 0x65, 0x72, 0x73, 0x64, 0x72, 0x69, 0x76, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x65, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x73, 0x6f, 0x75, 0x74, 0x68, 0x76, 0x6f, 0x69, 0x63, 0x65, + 0x73, 0x69, 0x74, 0x65, 0x73, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x77, 0x68, 0x65, 0x72, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x77, 0x68, 0x69, 0x63, 0x68, 0x65, 0x61, 0x72, 0x74, 0x68, 0x66, 0x6f, + 0x72, 0x75, 0x6d, 0x74, 0x68, 0x72, 0x65, 0x65, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x70, 0x61, 0x72, + 0x74, 0x79, 0x43, 0x6c, 0x69, 0x63, 0x6b, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x6c, 0x69, 0x76, 0x65, + 0x73, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x72, 0x79, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x75, 0x73, 0x61, 0x67, 0x65, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x63, + 0x6f, 0x75, 0x72, 0x74, 0x79, 0x6f, 0x75, 0x72, 0x20, 0x62, 0x69, 0x72, 0x74, 0x68, 0x70, 0x6f, + 0x70, 0x75, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x75, 0x70, 0x70, 0x65, 0x72, 0x6e, 0x6f, 0x74, 0x65, + 0x73, 0x65, 0x76, 0x65, 0x72, 0x79, 0x73, 0x68, 0x6f, 0x77, 0x73, 0x6d, 0x65, 0x61, 0x6e, 0x73, + 0x65, 0x78, 0x74, 0x72, 0x61, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x62, 0x65, 0x67, 0x61, 0x6e, 0x73, 0x75, + 0x70, 0x65, 0x72, 0x70, 0x61, 0x70, 0x65, 0x72, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x6c, 0x65, 0x61, + 0x72, 0x6e, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x65, 0x6e, 0x64, 0x65, + 0x64, 0x54, 0x65, 0x72, 0x6d, 0x73, 0x70, 0x61, 0x72, 0x74, 0x73, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x62, 0x72, 0x61, 0x6e, 0x64, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x77, 0x6f, 0x6d, 0x61, 0x6e, 0x66, + 0x61, 0x6c, 0x73, 0x65, 0x72, 0x65, 0x61, 0x64, 0x79, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x74, 0x61, + 0x6b, 0x65, 0x73, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x76, + 0x65, 0x64, 0x63, 0x61, 0x73, 0x65, 0x73, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x63, 0x68, 0x69, 0x6c, + 0x64, 0x67, 0x72, 0x65, 0x61, 0x74, 0x6a, 0x75, 0x64, 0x67, 0x65, 0x74, 0x68, 0x6f, 0x73, 0x65, + 0x75, 0x6e, 0x69, 0x74, 0x73, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, + 0x6f, 0x61, 0x73, 0x74, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x66, 0x69, + 0x6c, 0x65, 0x73, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x65, 0x70, 0x6c, 0x61, + 0x6e, 0x73, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x77, 0x72, 0x69, 0x74, 0x65, 0x71, 0x75, 0x65, 0x65, + 0x6e, 0x70, 0x69, 0x65, 0x63, 0x65, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x66, 0x72, 0x61, 0x6d, 0x65, + 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x63, 0x69, 0x76, 0x69, 0x6c, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x65, 0x6e, + 0x74, 0x65, 0x72, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x74, 0x6f, 0x75, + 0x63, 0x68, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x72, 0x6f, 0x79, 0x61, 0x6c, 0x61, 0x73, 0x6b, 0x65, + 0x64, 0x77, 0x68, 0x6f, 0x6c, 0x65, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x73, 0x74, 0x6f, 0x63, 0x6b, + 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x61, 0x69, 0x74, 0x68, 0x68, 0x65, 0x61, 0x72, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x6f, 0x77, + 0x6e, 0x65, 0x64, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x61, 0x6c, 0x62, 0x75, 0x6d, 0x74, 0x68, 0x69, + 0x6e, 0x6b, 0x62, 0x6c, 0x6f, 0x6f, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x6d, 0x61, 0x6a, 0x6f, + 0x72, 0x74, 0x72, 0x75, 0x73, 0x74, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x75, 0x6e, 0x69, 0x6f, 0x6e, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x53, + 0x74, 0x79, 0x6c, 0x65, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x68, 0x61, 0x70, 0x70, 0x79, 0x6f, 0x63, + 0x63, 0x75, 0x72, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x66, 0x72, 0x65, 0x73, 0x68, 0x71, 0x75, 0x69, + 0x74, 0x65, 0x66, 0x69, 0x6c, 0x6d, 0x73, 0x67, 0x72, 0x61, 0x64, 0x65, 0x6e, 0x65, 0x65, 0x64, + 0x73, 0x75, 0x72, 0x62, 0x61, 0x6e, 0x66, 0x69, 0x67, 0x68, 0x74, 0x62, 0x61, 0x73, 0x69, 0x73, + 0x68, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x75, 0x74, 0x6f, 0x3b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, + 0x68, 0x74, 0x6d, 0x6c, 0x6d, 0x69, 0x78, 0x65, 0x64, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x59, 0x6f, + 0x75, 0x72, 0x20, 0x73, 0x6c, 0x69, 0x64, 0x65, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x62, 0x72, 0x6f, + 0x77, 0x6e, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x72, 0x61, 0x77, 0x6e, 0x73, 0x70, 0x6c, 0x69, + 0x74, 0x72, 0x65, 0x61, 0x63, 0x68, 0x52, 0x69, 0x67, 0x68, 0x74, 0x64, 0x61, 0x74, 0x65, 0x73, + 0x6d, 0x61, 0x72, 0x63, 0x68, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x67, 0x6f, 0x6f, 0x64, 0x73, 0x4c, + 0x69, 0x6e, 0x6b, 0x73, 0x64, 0x6f, 0x75, 0x62, 0x74, 0x61, 0x73, 0x79, 0x6e, 0x63, 0x74, 0x68, + 0x75, 0x6d, 0x62, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x63, 0x68, 0x69, 0x65, 0x66, 0x79, 0x6f, 0x75, + 0x74, 0x68, 0x6e, 0x6f, 0x76, 0x65, 0x6c, 0x31, 0x30, 0x70, 0x78, 0x3b, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x53, 0x70, 0x61, 0x63, 0x65, 0x71, 0x75, 0x65, 0x72, 0x79, 0x6a, 0x61, 0x6d, 0x65, 0x73, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x74, 0x77, 0x69, 0x63, 0x65, 0x30, 0x2c, 0x30, 0x30, 0x30, 0x53, 0x74, + 0x61, 0x72, 0x74, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x67, 0x73, 0x72, 0x6f, 0x75, + 0x6e, 0x64, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x69, 0x66, 0x74, 0x77, 0x6f, 0x72, 0x74, + 0x68, 0x70, 0x6f, 0x73, 0x74, 0x73, 0x6c, 0x65, 0x61, 0x64, 0x73, 0x77, 0x65, 0x65, 0x6b, 0x73, + 0x61, 0x76, 0x6f, 0x69, 0x64, 0x74, 0x68, 0x65, 0x73, 0x65, 0x6d, 0x69, 0x6c, 0x65, 0x73, 0x70, + 0x6c, 0x61, 0x6e, 0x65, 0x73, 0x6d, 0x61, 0x72, 0x74, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x70, 0x6c, + 0x61, 0x6e, 0x74, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x72, 0x61, 0x74, 0x65, 0x73, 0x70, 0x6c, 0x61, + 0x79, 0x73, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x74, 0x65, 0x78, 0x74, + 0x73, 0x73, 0x74, 0x61, 0x72, 0x73, 0x77, 0x72, 0x6f, 0x6e, 0x67, 0x3c, 0x2f, 0x68, 0x33, 0x3e, + 0x74, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x68, + 0x65, 0x61, 0x72, 0x64, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x28, 0x74, 0x68, 0x69, 0x73, 0x62, 0x72, 0x69, + 0x6e, 0x67, 0x73, 0x68, 0x69, 0x70, 0x73, 0x73, 0x74, 0x61, 0x66, 0x66, 0x74, 0x72, 0x69, 0x65, + 0x64, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x66, 0x61, 0x63, 0x74, 0x73, + 0x61, 0x67, 0x65, 0x6e, 0x74, 0x54, 0x68, 0x69, 0x73, 0x20, 0x2f, 0x2f, 0x2d, 0x2d, 0x3e, 0x61, + 0x64, 0x6d, 0x69, 0x6e, 0x65, 0x67, 0x79, 0x70, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x31, 0x35, + 0x70, 0x78, 0x3b, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x74, 0x72, 0x75, 0x65, 0x22, 0x63, 0x72, 0x6f, + 0x73, 0x73, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x62, 0x6c, 0x6f, 0x67, 0x73, 0x62, 0x6f, 0x78, 0x22, + 0x3e, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x63, 0x68, 0x69, 0x6e, 0x61, + 0x73, 0x69, 0x7a, 0x65, 0x73, 0x67, 0x75, 0x65, 0x73, 0x74, 0x3c, 0x2f, 0x68, 0x34, 0x3e, 0x72, + 0x6f, 0x62, 0x6f, 0x74, 0x68, 0x65, 0x61, 0x76, 0x79, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x73, 0x65, + 0x76, 0x65, 0x6e, 0x67, 0x72, 0x61, 0x6e, 0x64, 0x63, 0x72, 0x69, 0x6d, 0x65, 0x73, 0x69, 0x67, + 0x6e, 0x73, 0x61, 0x77, 0x61, 0x72, 0x65, 0x64, 0x61, 0x6e, 0x63, 0x65, 0x70, 0x68, 0x61, 0x73, + 0x65, 0x3e, 0x3c, 0x21, 0x2d, 0x2d, 0x65, 0x6e, 0x5f, 0x55, 0x53, 0x26, 0x23, 0x33, 0x39, 0x3b, + 0x32, 0x30, 0x30, 0x70, 0x78, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x65, + 0x6e, 0x6a, 0x6f, 0x79, 0x61, 0x6a, 0x61, 0x78, 0x2e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x6d, + 0x69, 0x74, 0x68, 0x55, 0x2e, 0x53, 0x2e, 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x70, 0x65, 0x74, + 0x65, 0x72, 0x69, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x76, 0x22, 0x3e, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x64, 0x6f, 0x69, 0x6e, 0x67, + 0x70, 0x72, 0x69, 0x6f, 0x72, 0x53, 0x68, 0x61, 0x72, 0x65, 0x31, 0x39, 0x39, 0x30, 0x73, 0x72, + 0x6f, 0x6d, 0x61, 0x6e, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x6a, 0x61, 0x70, 0x61, 0x6e, 0x66, 0x61, + 0x6c, 0x6c, 0x73, 0x74, 0x72, 0x69, 0x61, 0x6c, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x61, 0x67, 0x72, + 0x65, 0x65, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x61, 0x62, 0x75, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x72, + 0x74, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x22, 0x2d, 0x2f, 0x2f, 0x57, 0x63, 0x61, 0x72, 0x64, 0x73, + 0x68, 0x69, 0x6c, 0x6c, 0x73, 0x74, 0x65, 0x61, 0x6d, 0x73, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x74, + 0x72, 0x75, 0x74, 0x68, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x2e, 0x70, 0x68, 0x70, 0x3f, 0x73, 0x61, + 0x69, 0x6e, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x6f, 0x75, 0x69, 0x73, 0x6d, 0x65, 0x61, + 0x6e, 0x74, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x62, 0x72, 0x69, 0x65, 0x66, 0x72, 0x6f, 0x77, 0x22, + 0x3e, 0x67, 0x65, 0x6e, 0x72, 0x65, 0x74, 0x72, 0x75, 0x63, 0x6b, 0x6c, 0x6f, 0x6f, 0x6b, 0x73, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x2d, + 0x2d, 0x3e, 0x0a, 0x3c, 0x74, 0x72, 0x79, 0x20, 0x7b, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x61, + 0x6b, 0x65, 0x73, 0x63, 0x6f, 0x73, 0x74, 0x73, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x61, 0x64, 0x75, + 0x6c, 0x74, 0x71, 0x75, 0x65, 0x73, 0x74, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x6c, 0x61, 0x62, 0x6f, + 0x72, 0x68, 0x65, 0x6c, 0x70, 0x73, 0x63, 0x61, 0x75, 0x73, 0x65, 0x6d, 0x61, 0x67, 0x69, 0x63, + 0x6d, 0x6f, 0x74, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x69, 0x72, 0x32, 0x35, 0x30, 0x70, 0x78, 0x6c, + 0x65, 0x61, 0x73, 0x74, 0x73, 0x74, 0x65, 0x70, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x63, 0x6f, + 0x75, 0x6c, 0x64, 0x67, 0x6c, 0x61, 0x73, 0x73, 0x73, 0x69, 0x64, 0x65, 0x73, 0x66, 0x75, 0x6e, + 0x64, 0x73, 0x68, 0x6f, 0x74, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x64, 0x6d, 0x6f, 0x75, 0x74, + 0x68, 0x6d, 0x6f, 0x76, 0x65, 0x73, 0x70, 0x61, 0x72, 0x69, 0x73, 0x67, 0x69, 0x76, 0x65, 0x73, + 0x64, 0x75, 0x74, 0x63, 0x68, 0x74, 0x65, 0x78, 0x61, 0x73, 0x66, 0x72, 0x75, 0x69, 0x74, 0x6e, + 0x75, 0x6c, 0x6c, 0x2c, 0x7c, 0x7c, 0x5b, 0x5d, 0x3b, 0x74, 0x6f, 0x70, 0x22, 0x3e, 0x0a, 0x3c, + 0x21, 0x2d, 0x2d, 0x50, 0x4f, 0x53, 0x54, 0x22, 0x6f, 0x63, 0x65, 0x61, 0x6e, 0x3c, 0x62, 0x72, + 0x2f, 0x3e, 0x66, 0x6c, 0x6f, 0x6f, 0x72, 0x73, 0x70, 0x65, 0x61, 0x6b, 0x64, 0x65, 0x70, 0x74, + 0x68, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x62, 0x61, 0x6e, 0x6b, 0x73, 0x63, 0x61, 0x74, 0x63, 0x68, + 0x63, 0x68, 0x61, 0x72, 0x74, 0x32, 0x30, 0x70, 0x78, 0x3b, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x64, + 0x65, 0x61, 0x6c, 0x73, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x35, 0x30, 0x70, 0x78, 0x3b, 0x75, 0x72, + 0x6c, 0x3d, 0x22, 0x70, 0x61, 0x72, 0x6b, 0x73, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x4d, 0x6f, 0x73, + 0x74, 0x20, 0x2e, 0x2e, 0x2e, 0x3c, 0x2f, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x62, 0x72, 0x61, 0x69, + 0x6e, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x62, 0x61, 0x73, 0x65, 0x64, + 0x63, 0x61, 0x72, 0x72, 0x79, 0x64, 0x72, 0x61, 0x66, 0x74, 0x72, 0x65, 0x66, 0x65, 0x72, 0x70, + 0x61, 0x67, 0x65, 0x5f, 0x68, 0x6f, 0x6d, 0x65, 0x2e, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x64, 0x65, + 0x6c, 0x61, 0x79, 0x64, 0x72, 0x65, 0x61, 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x6a, 0x6f, 0x69, + 0x6e, 0x74, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x64, 0x72, 0x75, 0x67, 0x73, 0x3c, 0x21, 0x2d, 0x2d, + 0x20, 0x61, 0x70, 0x72, 0x69, 0x6c, 0x69, 0x64, 0x65, 0x61, 0x6c, 0x61, 0x6c, 0x6c, 0x65, 0x6e, + 0x65, 0x78, 0x61, 0x63, 0x74, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x6c, + 0x6f, 0x67, 0x69, 0x63, 0x56, 0x69, 0x65, 0x77, 0x20, 0x73, 0x65, 0x65, 0x6d, 0x73, 0x62, 0x6c, + 0x61, 0x6e, 0x6b, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x28, 0x32, 0x30, 0x30, 0x73, 0x61, 0x76, + 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x67, 0x6f, 0x61, 0x6c, 0x73, 0x67, 0x72, 0x61, 0x6e, + 0x74, 0x67, 0x72, 0x65, 0x65, 0x6b, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x72, 0x69, 0x6e, 0x67, 0x73, + 0x72, 0x61, 0x74, 0x65, 0x64, 0x33, 0x30, 0x70, 0x78, 0x3b, 0x77, 0x68, 0x6f, 0x73, 0x65, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x28, 0x29, 0x3b, 0x22, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x6c, 0x69, + 0x6e, 0x75, 0x78, 0x6a, 0x6f, 0x6e, 0x65, 0x73, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x27, 0x29, 0x3b, + 0x22, 0x3e, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x64, 0x61, 0x76, 0x69, + 0x64, 0x68, 0x6f, 0x72, 0x73, 0x65, 0x46, 0x6f, 0x63, 0x75, 0x73, 0x72, 0x61, 0x69, 0x73, 0x65, + 0x62, 0x6f, 0x78, 0x65, 0x73, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x3c, + 0x2f, 0x65, 0x6d, 0x3e, 0x62, 0x61, 0x72, 0x22, 0x3e, 0x2e, 0x73, 0x72, 0x63, 0x3d, 0x74, 0x6f, + 0x77, 0x65, 0x72, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x68, 0x65, 0x6e, + 0x72, 0x79, 0x32, 0x34, 0x70, 0x78, 0x3b, 0x73, 0x65, 0x74, 0x75, 0x70, 0x69, 0x74, 0x61, 0x6c, + 0x79, 0x73, 0x68, 0x61, 0x72, 0x70, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x74, 0x61, 0x73, 0x74, 0x65, + 0x77, 0x61, 0x6e, 0x74, 0x73, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x65, 0x74, 0x77, + 0x68, 0x65, 0x65, 0x6c, 0x67, 0x69, 0x72, 0x6c, 0x73, 0x2f, 0x63, 0x73, 0x73, 0x2f, 0x31, 0x30, + 0x30, 0x25, 0x3b, 0x63, 0x6c, 0x75, 0x62, 0x73, 0x73, 0x74, 0x75, 0x66, 0x66, 0x62, 0x69, 0x62, + 0x6c, 0x65, 0x76, 0x6f, 0x74, 0x65, 0x73, 0x20, 0x31, 0x30, 0x30, 0x30, 0x6b, 0x6f, 0x72, 0x65, + 0x61, 0x7d, 0x29, 0x3b, 0x0d, 0x0a, 0x62, 0x61, 0x6e, 0x64, 0x73, 0x71, 0x75, 0x65, 0x75, 0x65, + 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x38, 0x30, 0x70, 0x78, 0x3b, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x7b, + 0x0d, 0x0a, 0x09, 0x09, 0x61, 0x68, 0x65, 0x61, 0x64, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x69, 0x72, + 0x69, 0x73, 0x68, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x73, 0x74, 0x61, + 0x74, 0x73, 0x46, 0x6f, 0x72, 0x6d, 0x22, 0x79, 0x61, 0x68, 0x6f, 0x6f, 0x29, 0x5b, 0x30, 0x5d, + 0x3b, 0x41, 0x62, 0x6f, 0x75, 0x74, 0x66, 0x69, 0x6e, 0x64, 0x73, 0x3c, 0x2f, 0x68, 0x31, 0x3e, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x55, 0x52, 0x4c, 0x20, 0x3d, 0x63, + 0x65, 0x6c, 0x6c, 0x73, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x31, 0x32, 0x70, 0x78, 0x3b, 0x70, 0x72, + 0x69, 0x6d, 0x65, 0x74, 0x65, 0x6c, 0x6c, 0x73, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x30, 0x78, 0x36, + 0x30, 0x30, 0x2e, 0x6a, 0x70, 0x67, 0x22, 0x73, 0x70, 0x61, 0x69, 0x6e, 0x62, 0x65, 0x61, 0x63, + 0x68, 0x74, 0x61, 0x78, 0x65, 0x73, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x61, 0x6e, 0x67, 0x65, 0x6c, + 0x2d, 0x2d, 0x3e, 0x3c, 0x2f, 0x67, 0x69, 0x66, 0x74, 0x73, 0x73, 0x74, 0x65, 0x76, 0x65, 0x2d, + 0x6c, 0x69, 0x6e, 0x6b, 0x62, 0x6f, 0x64, 0x79, 0x2e, 0x7d, 0x29, 0x3b, 0x0a, 0x09, 0x6d, 0x6f, + 0x75, 0x6e, 0x74, 0x20, 0x28, 0x31, 0x39, 0x39, 0x46, 0x41, 0x51, 0x3c, 0x2f, 0x72, 0x6f, 0x67, + 0x65, 0x72, 0x66, 0x72, 0x61, 0x6e, 0x6b, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x32, 0x38, 0x70, 0x78, + 0x3b, 0x66, 0x65, 0x65, 0x64, 0x73, 0x3c, 0x68, 0x31, 0x3e, 0x3c, 0x73, 0x63, 0x6f, 0x74, 0x74, + 0x74, 0x65, 0x73, 0x74, 0x73, 0x32, 0x32, 0x70, 0x78, 0x3b, 0x64, 0x72, 0x69, 0x6e, 0x6b, 0x29, + 0x20, 0x7c, 0x7c, 0x20, 0x6c, 0x65, 0x77, 0x69, 0x73, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x23, 0x30, + 0x33, 0x39, 0x3b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x76, 0x65, 0x64, 0x77, 0x61, 0x73, + 0x74, 0x65, 0x30, 0x30, 0x70, 0x78, 0x3b, 0x6a, 0x61, 0x3a, 0xe3, 0x82, 0x73, 0x69, 0x6d, 0x6f, + 0x6e, 0x3c, 0x66, 0x6f, 0x6e, 0x74, 0x72, 0x65, 0x70, 0x6c, 0x79, 0x6d, 0x65, 0x65, 0x74, 0x73, + 0x75, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x68, 0x65, 0x61, 0x70, 0x74, 0x69, 0x67, 0x68, 0x74, 0x42, + 0x72, 0x61, 0x6e, 0x64, 0x29, 0x20, 0x21, 0x3d, 0x20, 0x64, 0x72, 0x65, 0x73, 0x73, 0x63, 0x6c, + 0x69, 0x70, 0x73, 0x72, 0x6f, 0x6f, 0x6d, 0x73, 0x6f, 0x6e, 0x6b, 0x65, 0x79, 0x6d, 0x6f, 0x62, + 0x69, 0x6c, 0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x70, 0x6c, 0x61, 0x74, + 0x65, 0x66, 0x75, 0x6e, 0x6e, 0x79, 0x74, 0x72, 0x65, 0x65, 0x73, 0x63, 0x6f, 0x6d, 0x2f, 0x22, + 0x31, 0x2e, 0x6a, 0x70, 0x67, 0x77, 0x6d, 0x6f, 0x64, 0x65, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x53, + 0x54, 0x41, 0x52, 0x54, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x2c, 0x20, + 0x32, 0x30, 0x31, 0x29, 0x3b, 0x0a, 0x7d, 0x0a, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x76, 0x69, 0x72, + 0x75, 0x73, 0x63, 0x68, 0x61, 0x69, 0x72, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x77, 0x6f, 0x72, 0x73, + 0x74, 0x50, 0x61, 0x67, 0x65, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x61, 0x74, 0x63, 0x68, + 0x3c, 0x21, 0x2d, 0x2d, 0x0a, 0x6f, 0x2d, 0x63, 0x61, 0x63, 0x66, 0x69, 0x72, 0x6d, 0x73, 0x74, + 0x6f, 0x75, 0x72, 0x73, 0x2c, 0x30, 0x30, 0x30, 0x20, 0x61, 0x73, 0x69, 0x61, 0x6e, 0x69, 0x2b, + 0x2b, 0x29, 0x7b, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x27, 0x29, 0x5b, 0x30, 0x5d, 0x69, 0x64, 0x3d, + 0x31, 0x30, 0x62, 0x6f, 0x74, 0x68, 0x3b, 0x6d, 0x65, 0x6e, 0x75, 0x20, 0x2e, 0x32, 0x2e, 0x6d, + 0x69, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x6b, 0x65, 0x76, 0x69, 0x6e, 0x63, 0x6f, 0x61, 0x63, 0x68, + 0x43, 0x68, 0x69, 0x6c, 0x64, 0x62, 0x72, 0x75, 0x63, 0x65, 0x32, 0x2e, 0x6a, 0x70, 0x67, 0x55, + 0x52, 0x4c, 0x29, 0x2b, 0x2e, 0x6a, 0x70, 0x67, 0x7c, 0x73, 0x75, 0x69, 0x74, 0x65, 0x73, 0x6c, + 0x69, 0x63, 0x65, 0x68, 0x61, 0x72, 0x72, 0x79, 0x31, 0x32, 0x30, 0x22, 0x20, 0x73, 0x77, 0x65, + 0x65, 0x74, 0x74, 0x72, 0x3e, 0x0d, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x64, 0x69, 0x65, 0x67, + 0x6f, 0x70, 0x61, 0x67, 0x65, 0x20, 0x73, 0x77, 0x69, 0x73, 0x73, 0x2d, 0x2d, 0x3e, 0x0a, 0x0a, + 0x23, 0x66, 0x66, 0x66, 0x3b, 0x22, 0x3e, 0x4c, 0x6f, 0x67, 0x2e, 0x63, 0x6f, 0x6d, 0x22, 0x74, + 0x72, 0x65, 0x61, 0x74, 0x73, 0x68, 0x65, 0x65, 0x74, 0x29, 0x20, 0x26, 0x26, 0x20, 0x31, 0x34, + 0x70, 0x78, 0x3b, 0x73, 0x6c, 0x65, 0x65, 0x70, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x66, 0x69, 0x6c, + 0x65, 0x64, 0x6a, 0x61, 0x3a, 0xe3, 0x83, 0x69, 0x64, 0x3d, 0x22, 0x63, 0x4e, 0x61, 0x6d, 0x65, + 0x22, 0x77, 0x6f, 0x72, 0x73, 0x65, 0x73, 0x68, 0x6f, 0x74, 0x73, 0x2d, 0x62, 0x6f, 0x78, 0x2d, + 0x64, 0x65, 0x6c, 0x74, 0x61, 0x0a, 0x26, 0x6c, 0x74, 0x3b, 0x62, 0x65, 0x61, 0x72, 0x73, 0x3a, + 0x34, 0x38, 0x5a, 0x3c, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x72, 0x75, 0x72, 0x61, 0x6c, 0x3c, 0x2f, + 0x61, 0x3e, 0x20, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x62, 0x61, 0x6b, 0x65, 0x72, 0x73, 0x68, 0x6f, + 0x70, 0x73, 0x3d, 0x20, 0x22, 0x22, 0x3b, 0x70, 0x68, 0x70, 0x22, 0x3e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x31, 0x33, 0x70, 0x78, 0x3b, 0x62, 0x72, 0x69, 0x61, 0x6e, 0x68, 0x65, 0x6c, 0x6c, 0x6f, + 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x6f, 0x3d, 0x25, 0x32, 0x46, 0x20, 0x6a, 0x6f, 0x69, 0x6e, 0x6d, + 0x61, 0x79, 0x62, 0x65, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x69, 0x6d, 0x67, 0x22, 0x3e, 0x2c, 0x20, + 0x66, 0x6a, 0x73, 0x69, 0x6d, 0x67, 0x22, 0x20, 0x22, 0x29, 0x5b, 0x30, 0x5d, 0x4d, 0x54, 0x6f, + 0x70, 0x42, 0x54, 0x79, 0x70, 0x65, 0x22, 0x6e, 0x65, 0x77, 0x6c, 0x79, 0x44, 0x61, 0x6e, 0x73, + 0x6b, 0x63, 0x7a, 0x65, 0x63, 0x68, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x6b, 0x6e, 0x6f, 0x77, 0x73, + 0x3c, 0x2f, 0x68, 0x35, 0x3e, 0x66, 0x61, 0x71, 0x22, 0x3e, 0x7a, 0x68, 0x2d, 0x63, 0x6e, 0x31, + 0x30, 0x29, 0x3b, 0x0a, 0x2d, 0x31, 0x22, 0x29, 0x3b, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x62, 0x6c, + 0x75, 0x65, 0x73, 0x74, 0x72, 0x75, 0x6c, 0x79, 0x64, 0x61, 0x76, 0x69, 0x73, 0x2e, 0x6a, 0x73, + 0x27, 0x3b, 0x3e, 0x0d, 0x0a, 0x3c, 0x21, 0x73, 0x74, 0x65, 0x65, 0x6c, 0x20, 0x79, 0x6f, 0x75, + 0x20, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6a, 0x65, 0x73, 0x75, 0x73, + 0x31, 0x30, 0x30, 0x25, 0x20, 0x6d, 0x65, 0x6e, 0x75, 0x2e, 0x0d, 0x0a, 0x09, 0x0d, 0x0a, 0x77, + 0x61, 0x6c, 0x65, 0x73, 0x72, 0x69, 0x73, 0x6b, 0x73, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x64, 0x64, + 0x69, 0x6e, 0x67, 0x62, 0x2d, 0x6c, 0x69, 0x6b, 0x74, 0x65, 0x61, 0x63, 0x68, 0x67, 0x69, 0x66, + 0x22, 0x20, 0x76, 0x65, 0x67, 0x61, 0x73, 0x64, 0x61, 0x6e, 0x73, 0x6b, 0x65, 0x65, 0x73, 0x74, + 0x69, 0x73, 0x68, 0x71, 0x69, 0x70, 0x73, 0x75, 0x6f, 0x6d, 0x69, 0x73, 0x6f, 0x62, 0x72, 0x65, + 0x64, 0x65, 0x73, 0x64, 0x65, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x74, 0x6f, 0x64, 0x6f, 0x73, 0x70, + 0x75, 0x65, 0x64, 0x65, 0x61, 0xc3, 0xb1, 0x6f, 0x73, 0x65, 0x73, 0x74, 0xc3, 0xa1, 0x74, 0x69, + 0x65, 0x6e, 0x65, 0x68, 0x61, 0x73, 0x74, 0x61, 0x6f, 0x74, 0x72, 0x6f, 0x73, 0x70, 0x61, 0x72, + 0x74, 0x65, 0x64, 0x6f, 0x6e, 0x64, 0x65, 0x6e, 0x75, 0x65, 0x76, 0x6f, 0x68, 0x61, 0x63, 0x65, + 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6d, 0x69, 0x73, 0x6d, 0x6f, 0x6d, 0x65, 0x6a, 0x6f, 0x72, + 0x6d, 0x75, 0x6e, 0x64, 0x6f, 0x61, 0x71, 0x75, 0xc3, 0xad, 0x64, 0xc3, 0xad, 0x61, 0x73, 0x73, + 0xc3, 0xb3, 0x6c, 0x6f, 0x61, 0x79, 0x75, 0x64, 0x61, 0x66, 0x65, 0x63, 0x68, 0x61, 0x74, 0x6f, + 0x64, 0x61, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x6f, 0x6d, 0x65, 0x6e, 0x6f, 0x73, 0x64, 0x61, 0x74, + 0x6f, 0x73, 0x6f, 0x74, 0x72, 0x61, 0x73, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6d, 0x75, 0x63, 0x68, + 0x6f, 0x61, 0x68, 0x6f, 0x72, 0x61, 0x6c, 0x75, 0x67, 0x61, 0x72, 0x6d, 0x61, 0x79, 0x6f, 0x72, + 0x65, 0x73, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x72, 0x61, 0x73, 0x74, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x6e, 0x74, 0x65, 0x73, 0x66, 0x6f, 0x74, 0x6f, 0x73, 0x65, 0x73, 0x74, 0x61, 0x73, 0x70, 0x61, + 0xc3, 0xad, 0x73, 0x6e, 0x75, 0x65, 0x76, 0x61, 0x73, 0x61, 0x6c, 0x75, 0x64, 0x66, 0x6f, 0x72, + 0x6f, 0x73, 0x6d, 0x65, 0x64, 0x69, 0x6f, 0x71, 0x75, 0x69, 0x65, 0x6e, 0x6d, 0x65, 0x73, 0x65, + 0x73, 0x70, 0x6f, 0x64, 0x65, 0x72, 0x63, 0x68, 0x69, 0x6c, 0x65, 0x73, 0x65, 0x72, 0xc3, 0xa1, + 0x76, 0x65, 0x63, 0x65, 0x73, 0x64, 0x65, 0x63, 0x69, 0x72, 0x6a, 0x6f, 0x73, 0xc3, 0xa9, 0x65, + 0x73, 0x74, 0x61, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x72, 0x75, 0x70, 0x6f, 0x68, 0x65, + 0x63, 0x68, 0x6f, 0x65, 0x6c, 0x6c, 0x6f, 0x73, 0x74, 0x65, 0x6e, 0x67, 0x6f, 0x61, 0x6d, 0x69, + 0x67, 0x6f, 0x63, 0x6f, 0x73, 0x61, 0x73, 0x6e, 0x69, 0x76, 0x65, 0x6c, 0x67, 0x65, 0x6e, 0x74, + 0x65, 0x6d, 0x69, 0x73, 0x6d, 0x61, 0x61, 0x69, 0x72, 0x65, 0x73, 0x6a, 0x75, 0x6c, 0x69, 0x6f, + 0x74, 0x65, 0x6d, 0x61, 0x73, 0x68, 0x61, 0x63, 0x69, 0x61, 0x66, 0x61, 0x76, 0x6f, 0x72, 0x6a, + 0x75, 0x6e, 0x69, 0x6f, 0x6c, 0x69, 0x62, 0x72, 0x65, 0x70, 0x75, 0x6e, 0x74, 0x6f, 0x62, 0x75, + 0x65, 0x6e, 0x6f, 0x61, 0x75, 0x74, 0x6f, 0x72, 0x61, 0x62, 0x72, 0x69, 0x6c, 0x62, 0x75, 0x65, + 0x6e, 0x61, 0x74, 0x65, 0x78, 0x74, 0x6f, 0x6d, 0x61, 0x72, 0x7a, 0x6f, 0x73, 0x61, 0x62, 0x65, + 0x72, 0x6c, 0x69, 0x73, 0x74, 0x61, 0x6c, 0x75, 0x65, 0x67, 0x6f, 0x63, 0xc3, 0xb3, 0x6d, 0x6f, + 0x65, 0x6e, 0x65, 0x72, 0x6f, 0x6a, 0x75, 0x65, 0x67, 0x6f, 0x70, 0x65, 0x72, 0xc3, 0xba, 0x68, + 0x61, 0x62, 0x65, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x79, 0x6e, 0x75, 0x6e, 0x63, 0x61, 0x6d, 0x75, + 0x6a, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x6f, 0x72, 0x66, 0x75, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x62, + 0x72, 0x6f, 0x67, 0x75, 0x73, 0x74, 0x61, 0x69, 0x67, 0x75, 0x61, 0x6c, 0x76, 0x6f, 0x74, 0x6f, + 0x73, 0x63, 0x61, 0x73, 0x6f, 0x73, 0x67, 0x75, 0xc3, 0xad, 0x61, 0x70, 0x75, 0x65, 0x64, 0x6f, + 0x73, 0x6f, 0x6d, 0x6f, 0x73, 0x61, 0x76, 0x69, 0x73, 0x6f, 0x75, 0x73, 0x74, 0x65, 0x64, 0x64, + 0x65, 0x62, 0x65, 0x6e, 0x6e, 0x6f, 0x63, 0x68, 0x65, 0x62, 0x75, 0x73, 0x63, 0x61, 0x66, 0x61, + 0x6c, 0x74, 0x61, 0x65, 0x75, 0x72, 0x6f, 0x73, 0x73, 0x65, 0x72, 0x69, 0x65, 0x64, 0x69, 0x63, + 0x68, 0x6f, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x63, 0x6c, 0x61, 0x76, 0x65, 0x63, 0x61, 0x73, 0x61, + 0x73, 0x6c, 0x65, 0xc3, 0xb3, 0x6e, 0x70, 0x6c, 0x61, 0x7a, 0x6f, 0x6c, 0x61, 0x72, 0x67, 0x6f, + 0x6f, 0x62, 0x72, 0x61, 0x73, 0x76, 0x69, 0x73, 0x74, 0x61, 0x61, 0x70, 0x6f, 0x79, 0x6f, 0x6a, + 0x75, 0x6e, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x74, 0x61, 0x76, 0x69, 0x73, 0x74, 0x6f, 0x63, 0x72, + 0x65, 0x61, 0x72, 0x63, 0x61, 0x6d, 0x70, 0x6f, 0x68, 0x65, 0x6d, 0x6f, 0x73, 0x63, 0x69, 0x6e, + 0x63, 0x6f, 0x63, 0x61, 0x72, 0x67, 0x6f, 0x70, 0x69, 0x73, 0x6f, 0x73, 0x6f, 0x72, 0x64, 0x65, + 0x6e, 0x68, 0x61, 0x63, 0x65, 0x6e, 0xc3, 0xa1, 0x72, 0x65, 0x61, 0x64, 0x69, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x64, 0x72, 0x6f, 0x63, 0x65, 0x72, 0x63, 0x61, 0x70, 0x75, 0x65, 0x64, 0x61, 0x70, + 0x61, 0x70, 0x65, 0x6c, 0x6d, 0x65, 0x6e, 0x6f, 0x72, 0xc3, 0xba, 0x74, 0x69, 0x6c, 0x63, 0x6c, + 0x61, 0x72, 0x6f, 0x6a, 0x6f, 0x72, 0x67, 0x65, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x70, 0x6f, 0x6e, + 0x65, 0x72, 0x74, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x61, 0x64, 0x69, 0x65, 0x6d, 0x61, 0x72, 0x63, + 0x61, 0x73, 0x69, 0x67, 0x75, 0x65, 0x65, 0x6c, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6c, 0x6f, + 0x63, 0x6f, 0x63, 0x68, 0x65, 0x6d, 0x6f, 0x74, 0x6f, 0x73, 0x6d, 0x61, 0x64, 0x72, 0x65, 0x63, + 0x6c, 0x61, 0x73, 0x65, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x69, 0xc3, 0xb1, 0x6f, 0x71, 0x75, + 0x65, 0x64, 0x61, 0x70, 0x61, 0x73, 0x61, 0x72, 0x62, 0x61, 0x6e, 0x63, 0x6f, 0x68, 0x69, 0x6a, + 0x6f, 0x73, 0x76, 0x69, 0x61, 0x6a, 0x65, 0x70, 0x61, 0x62, 0x6c, 0x6f, 0xc3, 0xa9, 0x73, 0x74, + 0x65, 0x76, 0x69, 0x65, 0x6e, 0x65, 0x72, 0x65, 0x69, 0x6e, 0x6f, 0x64, 0x65, 0x6a, 0x61, 0x72, + 0x66, 0x6f, 0x6e, 0x64, 0x6f, 0x63, 0x61, 0x6e, 0x61, 0x6c, 0x6e, 0x6f, 0x72, 0x74, 0x65, 0x6c, + 0x65, 0x74, 0x72, 0x61, 0x63, 0x61, 0x75, 0x73, 0x61, 0x74, 0x6f, 0x6d, 0x61, 0x72, 0x6d, 0x61, + 0x6e, 0x6f, 0x73, 0x6c, 0x75, 0x6e, 0x65, 0x73, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x76, 0x69, 0x6c, + 0x6c, 0x61, 0x76, 0x65, 0x6e, 0x64, 0x6f, 0x70, 0x65, 0x73, 0x61, 0x72, 0x74, 0x69, 0x70, 0x6f, + 0x73, 0x74, 0x65, 0x6e, 0x67, 0x61, 0x6d, 0x61, 0x72, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x76, 0x61, + 0x70, 0x61, 0x64, 0x72, 0x65, 0x75, 0x6e, 0x69, 0x64, 0x6f, 0x76, 0x61, 0x6d, 0x6f, 0x73, 0x7a, + 0x6f, 0x6e, 0x61, 0x73, 0x61, 0x6d, 0x62, 0x6f, 0x73, 0x62, 0x61, 0x6e, 0x64, 0x61, 0x6d, 0x61, + 0x72, 0x69, 0x61, 0x61, 0x62, 0x75, 0x73, 0x6f, 0x6d, 0x75, 0x63, 0x68, 0x61, 0x73, 0x75, 0x62, + 0x69, 0x72, 0x72, 0x69, 0x6f, 0x6a, 0x61, 0x76, 0x69, 0x76, 0x69, 0x72, 0x67, 0x72, 0x61, 0x64, + 0x6f, 0x63, 0x68, 0x69, 0x63, 0x61, 0x61, 0x6c, 0x6c, 0xc3, 0xad, 0x6a, 0x6f, 0x76, 0x65, 0x6e, + 0x64, 0x69, 0x63, 0x68, 0x61, 0x65, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x61, 0x6c, 0x65, 0x73, 0x73, + 0x61, 0x6c, 0x69, 0x72, 0x73, 0x75, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x6f, 0x73, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x6c, 0x6c, 0x61, 0x6d, 0x61, 0x62, 0x75, 0x73, 0x63, 0x6f, 0xc3, 0xa9, 0x73, + 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6e, 0x65, 0x67, 0x72, 0x6f, 0x70, 0x6c, 0x61, 0x7a, + 0x61, 0x68, 0x75, 0x6d, 0x6f, 0x72, 0x70, 0x61, 0x67, 0x61, 0x72, 0x6a, 0x75, 0x6e, 0x74, 0x61, + 0x64, 0x6f, 0x62, 0x6c, 0x65, 0x69, 0x73, 0x6c, 0x61, 0x73, 0x62, 0x6f, 0x6c, 0x73, 0x61, 0x62, + 0x61, 0xc3, 0xb1, 0x6f, 0x68, 0x61, 0x62, 0x6c, 0x61, 0x6c, 0x75, 0x63, 0x68, 0x61, 0xc3, 0x81, + 0x72, 0x65, 0x61, 0x64, 0x69, 0x63, 0x65, 0x6e, 0x6a, 0x75, 0x67, 0x61, 0x72, 0x6e, 0x6f, 0x74, + 0x61, 0x73, 0x76, 0x61, 0x6c, 0x6c, 0x65, 0x61, 0x6c, 0x6c, 0xc3, 0xa1, 0x63, 0x61, 0x72, 0x67, + 0x61, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x6f, 0x65, 0x73, 0x74, 0xc3, 0xa9, + 0x67, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x6d, 0x61, 0x72, 0x69, 0x6f, 0x66, + 0x69, 0x72, 0x6d, 0x61, 0x63, 0x6f, 0x73, 0x74, 0x6f, 0x66, 0x69, 0x63, 0x68, 0x61, 0x70, 0x6c, + 0x61, 0x74, 0x61, 0x68, 0x6f, 0x67, 0x61, 0x72, 0x61, 0x72, 0x74, 0x65, 0x73, 0x6c, 0x65, 0x79, + 0x65, 0x73, 0x61, 0x71, 0x75, 0x65, 0x6c, 0x6d, 0x75, 0x73, 0x65, 0x6f, 0x62, 0x61, 0x73, 0x65, + 0x73, 0x70, 0x6f, 0x63, 0x6f, 0x73, 0x6d, 0x69, 0x74, 0x61, 0x64, 0x63, 0x69, 0x65, 0x6c, 0x6f, + 0x63, 0x68, 0x69, 0x63, 0x6f, 0x6d, 0x69, 0x65, 0x64, 0x6f, 0x67, 0x61, 0x6e, 0x61, 0x72, 0x73, + 0x61, 0x6e, 0x74, 0x6f, 0x65, 0x74, 0x61, 0x70, 0x61, 0x64, 0x65, 0x62, 0x65, 0x73, 0x70, 0x6c, + 0x61, 0x79, 0x61, 0x72, 0x65, 0x64, 0x65, 0x73, 0x73, 0x69, 0x65, 0x74, 0x65, 0x63, 0x6f, 0x72, + 0x74, 0x65, 0x63, 0x6f, 0x72, 0x65, 0x61, 0x64, 0x75, 0x64, 0x61, 0x73, 0x64, 0x65, 0x73, 0x65, + 0x6f, 0x76, 0x69, 0x65, 0x6a, 0x6f, 0x64, 0x65, 0x73, 0x65, 0x61, 0x61, 0x67, 0x75, 0x61, 0x73, + 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x6d, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x62, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x73, 0x63, 0x72, 0x6f, + 0x6c, 0x6c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x6d, 0x65, + 0x64, 0x69, 0x75, 0x6d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x6e, 0x6f, + 0x72, 0x6d, 0x61, 0x6c, 0x74, 0x72, 0x61, 0x76, 0x65, 0x6c, 0x69, 0x73, 0x73, 0x75, 0x65, 0x73, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x70, 0x72, 0x69, + 0x6e, 0x67, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x73, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x73, 0x6f, 0x63, 0x69, + 0x61, 0x6c, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x72, 0x65, + 0x63, 0x6f, 0x72, 0x64, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, + 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x66, 0x61, 0x6d, 0x69, + 0x6c, 0x79, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x6c, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x61, 0x75, + 0x74, 0x68, 0x6f, 0x72, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, + 0x73, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x70, 0x6c, 0x61, 0x79, + 0x65, 0x64, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x70, 0x6f, + 0x6c, 0x69, 0x63, 0x79, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x70, 0x65, 0x72, 0x73, + 0x6f, 0x6e, 0x6c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x6f, + 0x6e, 0x74, 0x68, 0x73, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x73, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x65, 0x6e, 0x65, 0x72, + 0x67, 0x79, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, + 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x77, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, + 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x73, 0x73, 0x63, 0x68, 0x6f, + 0x6f, 0x6c, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x64, 0x65, + 0x62, 0x61, 0x74, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x6c, 0x65, 0x61, 0x67, + 0x75, 0x65, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x65, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6e, 0x6f, + 0x74, 0x69, 0x63, 0x65, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x6c, 0x69, + 0x6e, 0x65, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x73, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, + 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x77, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x46, 0x72, 0x61, 0x6e, + 0x63, 0x65, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x72, 0x65, + 0x70, 0x65, 0x61, 0x74, 0x4c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x65, 0x63, 0x75, + 0x72, 0x65, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x73, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, + 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x79, 0x65, 0x6c, 0x6c, + 0x6f, 0x77, 0x61, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x66, 0x6c, + 0x69, 0x67, 0x68, 0x74, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x69, 0x6e, 0x66, 0x6f, 0x22, 0x3e, + 0x6f, 0x70, 0x65, 0x6e, 0x65, 0x64, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x76, 0x61, 0x6c, 0x6c, + 0x65, 0x79, 0x63, 0x61, 0x75, 0x73, 0x65, 0x73, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x64, 0x61, 0x6d, 0x61, 0x67, 0x65, + 0x73, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x72, 0x61, 0x74, 0x69, + 0x6e, 0x67, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x65, 0x66, + 0x66, 0x65, 0x63, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, + 0x6f, 0x66, 0x66, 0x69, 0x63, 0x65, 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x65, 0x64, 0x69, 0x74, + 0x6f, 0x72, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x6d, 0x75, + 0x73, 0x65, 0x75, 0x6d, 0x6d, 0x6f, 0x76, 0x69, 0x65, 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6d, 0x6f, 0x73, 0x74, 0x6c, 0x79, 0x6d, 0x6f, 0x74, 0x68, + 0x65, 0x72, 0x22, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x67, 0x72, + 0x6f, 0x75, 0x6e, 0x64, 0x63, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x75, 0x72, 0x76, 0x65, 0x79, + 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x6d, 0x6f, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x70, 0x65, 0x65, 0x63, 0x68, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, + 0x73, 0x69, 0x64, 0x65, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x6d, 0x69, 0x64, 0x64, + 0x6c, 0x65, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x67, 0x72, 0x6f, 0x77, 0x74, 0x68, 0x6c, 0x65, + 0x67, 0x61, 0x63, 0x79, 0x6d, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x65, 0x6e, 0x6f, 0x75, 0x67, 0x68, + 0x63, 0x61, 0x72, 0x65, 0x65, 0x72, 0x61, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x6f, 0x72, 0x69, 0x67, + 0x69, 0x6e, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, + 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x66, 0x61, 0x74, 0x68, + 0x65, 0x72, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0x72, 0x61, + 0x69, 0x73, 0x65, 0x64, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x6f, 0x73, 0x65, 0x6e, + 0x63, 0x68, 0x75, 0x72, 0x63, 0x68, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x65, + 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x64, 0x75, 0x72, 0x69, + 0x6e, 0x67, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x73, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x6b, 0x69, + 0x6c, 0x6c, 0x65, 0x64, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, + 0x73, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x73, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, + 0x77, 0x69, 0x64, 0x67, 0x65, 0x74, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x62, 0x75, 0x64, 0x67, + 0x65, 0x74, 0x6e, 0x6f, 0x77, 0x72, 0x61, 0x70, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x63, 0x6c, + 0x61, 0x69, 0x6d, 0x73, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x73, 0x61, 0x66, 0x65, 0x74, 0x79, + 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x70, 0x69, 0x72, 0x69, 0x74, 0x2d, 0x73, 0x74, 0x79, + 0x6c, 0x65, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x6d, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x6e, 0x65, + 0x65, 0x64, 0x65, 0x64, 0x72, 0x75, 0x73, 0x73, 0x69, 0x61, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x62, 0x72, 0x6f, 0x6b, + 0x65, 0x6e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x64, 0x69, + 0x76, 0x69, 0x64, 0x65, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x2d, 0x62, 0x61, 0x73, 0x65, 0x64, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x79, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x64, 0x68, 0x65, + 0x6c, 0x70, 0x65, 0x64, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x6c, 0x6f, 0x67, 0x6f, + 0x22, 0x20, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x3e, 0x29, 0x7b, + 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x6f, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28, 0x63, 0x6f, 0x75, 0x70, + 0x6c, 0x65, 0x67, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x6c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x6c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x61, 0x74, 0x69, + 0x6e, 0x67, 0x42, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x62, 0x65, 0x61, 0x75, 0x74, 0x79, 0x74, 0x68, + 0x65, 0x6d, 0x65, 0x73, 0x66, 0x6f, 0x72, 0x67, 0x6f, 0x74, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x61, 0x6c, 0x6d, 0x6f, 0x73, 0x74, 0x6c, 0x6f, 0x61, 0x64, + 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, + 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x53, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x76, 0x69, 0x65, 0x77, 0x65, 0x64, 0x26, 0x6e, + 0x62, 0x73, 0x70, 0x3b, 0x63, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x41, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x69, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x63, 0x6f, 0x6f, 0x6b, + 0x69, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x61, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x6d, 0x6f, + 0x64, 0x65, 0x72, 0x6e, 0x61, 0x64, 0x76, 0x69, 0x63, 0x65, 0x69, 0x6e, 0x3c, 0x2f, 0x61, 0x3e, + 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x69, 0x61, 0x6c, 0x6f, 0x67, 0x68, 0x6f, 0x75, 0x73, + 0x65, 0x73, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x73, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x73, 0x45, 0x6d, 0x70, 0x69, 0x72, 0x65, 0x53, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x65, 0x66, + 0x66, 0x6f, 0x72, 0x74, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6e, 0x65, 0x61, 0x72, 0x6c, 0x79, + 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x4f, + 0x6e, 0x65, 0x6a, 0x6f, 0x69, 0x6e, 0x65, 0x64, 0x6d, 0x65, 0x6e, 0x75, 0x22, 0x3e, 0x50, 0x68, + 0x69, 0x6c, 0x69, 0x70, 0x61, 0x77, 0x61, 0x72, 0x64, 0x73, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x66, 0x66, 0x69, 0x63, 0x65, 0x72, 0x65, 0x67, 0x61, + 0x72, 0x64, 0x73, 0x6b, 0x69, 0x6c, 0x6c, 0x73, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, + 0x6f, 0x72, 0x74, 0x73, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x77, 0x65, 0x65, 0x6b, 0x6c, 0x79, + 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x64, 0x6f, 0x63, 0x74, + 0x6f, 0x72, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x75, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x3c, 0x2f, + 0x62, 0x3e, 0x3c, 0x2f, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x73, 0x70, 0x6c, 0x61, 0x6e, 0x74, 0x73, + 0x61, 0x73, 0x73, 0x69, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x69, 0x73, 0x73, 0x75, + 0x65, 0x64, 0x33, 0x30, 0x30, 0x70, 0x78, 0x7c, 0x63, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x61, 0x67, + 0x65, 0x6e, 0x63, 0x79, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, + 0x42, 0x72, 0x61, 0x7a, 0x69, 0x6c, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x6c, 0x6f, 0x67, 0x6f, + 0x22, 0x3e, 0x62, 0x65, 0x79, 0x6f, 0x6e, 0x64, 0x2d, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x61, 0x63, + 0x63, 0x65, 0x70, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x6d, 0x61, 0x72, 0x69, 0x6e, 0x65, + 0x46, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x3c, 0x2f, 0x68, 0x31, + 0x3e, 0x0a, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x22, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x73, 0x74, + 0x72, 0x65, 0x73, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x0d, 0x0a, 0x2e, 0x67, 0x69, 0x66, 0x22, 0x20, + 0x6f, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x72, 0x4f, 0x78, 0x66, 0x6f, + 0x72, 0x64, 0x73, 0x69, 0x73, 0x74, 0x65, 0x72, 0x73, 0x75, 0x72, 0x76, 0x69, 0x76, 0x6c, 0x69, + 0x73, 0x74, 0x65, 0x6e, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x69, 0x67, 0x6e, + 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x22, 0x61, 0x70, 0x70, 0x65, 0x61, 0x6c, 0x74, 0x65, 0x78, 0x74, + 0x22, 0x3e, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x73, 0x74, 0x68, 0x61, 0x6e, 0x6b, 0x73, 0x68, 0x69, + 0x67, 0x68, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x61, 0x6e, 0x69, 0x6d, 0x61, 0x6c, + 0x61, 0x6e, 0x79, 0x6f, 0x6e, 0x65, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x61, 0x67, 0x72, 0x65, + 0x65, 0x64, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x50, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x3c, 0x62, + 0x72, 0x20, 0x2f, 0x3e, 0x77, 0x6f, 0x6e, 0x64, 0x65, 0x72, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, + 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x7c, 0x7c, 0x20, 0x7b, 0x7d, 0x3b, 0x6d, 0x61, 0x69, 0x6e, + 0x22, 0x3e, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x75, 0x6e, 0x64, 0x61, 0x79, 0x77, 0x72, + 0x61, 0x70, 0x22, 0x3e, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x63, 0x65, 0x6e, 0x73, 0x75, 0x73, + 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x71, 0x75, 0x6f, 0x74, + 0x65, 0x73, 0x31, 0x35, 0x30, 0x70, 0x78, 0x7c, 0x65, 0x73, 0x74, 0x61, 0x74, 0x65, 0x72, 0x65, + 0x6d, 0x6f, 0x74, 0x65, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x22, 0x6c, 0x69, 0x6e, 0x6b, 0x65, 0x64, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3b, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x6c, 0x31, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x73, 0x69, 0x67, 0x6e, 0x75, 0x70, 0x70, 0x72, + 0x69, 0x6e, 0x63, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x20, + 0x66, 0x6f, 0x72, 0x75, 0x6d, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x70, 0x61, 0x70, 0x65, + 0x72, 0x73, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x48, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x6c, 0x69, 0x64, 0x65, 0x72, 0x55, 0x54, 0x46, 0x2d, 0x38, 0x22, + 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x2e, 0x20, 0x57, 0x69, + 0x74, 0x68, 0x73, 0x74, 0x75, 0x64, 0x69, 0x6f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x6d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x74, 0x6a, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x61, 0x6e, 0x6e, 0x75, 0x61, 0x6c, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x62, 0x6f, 0x75, 0x67, + 0x68, 0x74, 0x66, 0x61, 0x6d, 0x6f, 0x75, 0x73, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x6c, 0x6f, + 0x6e, 0x67, 0x65, 0x72, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x7b, 0x69, 0x73, 0x72, 0x61, 0x65, 0x6c, + 0x73, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x64, 0x65, 0x63, 0x69, 0x64, 0x65, 0x68, 0x6f, 0x6d, 0x65, + 0x22, 0x3e, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x62, 0x72, + 0x61, 0x6e, 0x63, 0x68, 0x70, 0x69, 0x65, 0x63, 0x65, 0x73, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x64, 0x74, 0x6f, 0x70, 0x22, 0x3e, 0x3c, 0x72, 0x61, 0x63, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x69, 0x7a, 0x65, 0x2d, 0x2d, 0x26, 0x67, 0x74, 0x3b, 0x70, 0x61, + 0x63, 0x69, 0x74, 0x79, 0x73, 0x65, 0x78, 0x75, 0x61, 0x6c, 0x62, 0x75, 0x72, 0x65, 0x61, 0x75, + 0x2e, 0x6a, 0x70, 0x67, 0x22, 0x20, 0x31, 0x30, 0x2c, 0x30, 0x30, 0x30, 0x6f, 0x62, 0x74, 0x61, + 0x69, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x73, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x2c, 0x20, + 0x49, 0x6e, 0x63, 0x2e, 0x63, 0x6f, 0x6d, 0x65, 0x64, 0x79, 0x6d, 0x65, 0x6e, 0x75, 0x22, 0x20, + 0x6c, 0x79, 0x72, 0x69, 0x63, 0x73, 0x74, 0x6f, 0x64, 0x61, 0x79, 0x2e, 0x69, 0x6e, 0x64, 0x65, + 0x65, 0x64, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x5f, 0x6c, 0x6f, 0x67, 0x6f, 0x2e, 0x46, 0x61, + 0x6d, 0x69, 0x6c, 0x79, 0x6c, 0x6f, 0x6f, 0x6b, 0x65, 0x64, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, + 0x6c, 0x73, 0x65, 0x20, 0x69, 0x66, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x74, 0x75, 0x72, 0x6b, + 0x65, 0x79, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x67, 0x69, + 0x76, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x67, + 0x3c, 0x2f, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x2e, 0x66, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x73, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, + 0x31, 0x30, 0x70, 0x78, 0x20, 0x30, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x66, 0x72, 0x69, 0x64, + 0x61, 0x79, 0x6a, 0x75, 0x6e, 0x69, 0x6f, 0x72, 0x64, 0x6f, 0x6c, 0x6c, 0x61, 0x72, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x64, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x73, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x35, 0x2c, 0x30, 0x30, 0x30, 0x20, 0x70, 0x61, 0x67, 0x65, 0x22, 0x3e, 0x62, 0x6f, 0x73, 0x74, + 0x6f, 0x6e, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x28, 0x61, 0x76, 0x61, 0x74, 0x61, 0x72, 0x74, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x66, 0x6f, 0x72, 0x75, 0x6d, 0x73, + 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x66, 0x69, 0x6c, 0x6c, + 0x65, 0x64, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x72, 0x65, 0x61, 0x64, 0x65, 0x72, 0x61, 0x6c, + 0x65, 0x72, 0x74, 0x28, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, + 0x6c, 0x69, 0x6e, 0x65, 0x22, 0x3e, 0x62, 0x6f, 0x64, 0x79, 0x22, 0x3e, 0x0a, 0x2a, 0x20, 0x54, + 0x68, 0x65, 0x54, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x73, 0x65, 0x65, 0x69, 0x6e, 0x67, 0x6a, 0x65, + 0x72, 0x73, 0x65, 0x79, 0x4e, 0x65, 0x77, 0x73, 0x3c, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, + 0x65, 0x78, 0x70, 0x65, 0x72, 0x74, 0x69, 0x6e, 0x6a, 0x75, 0x72, 0x79, 0x77, 0x69, 0x64, 0x74, + 0x68, 0x3d, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x53, 0x54, 0x41, 0x52, 0x54, 0x20, 0x61, 0x63, + 0x72, 0x6f, 0x73, 0x73, 0x5f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, + 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x70, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x62, 0x6f, 0x78, 0x22, + 0x3e, 0x0a, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x44, 0x61, 0x76, 0x69, 0x64, 0x63, 0x61, + 0x6e, 0x63, 0x65, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, + 0x41, 0x70, 0x72, 0x69, 0x6c, 0x20, 0x72, 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x64, 0x72, 0x69, 0x76, + 0x65, 0x72, 0x69, 0x74, 0x65, 0x6d, 0x22, 0x3e, 0x6d, 0x6f, 0x72, 0x65, 0x22, 0x3e, 0x62, 0x6f, + 0x61, 0x72, 0x64, 0x73, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x73, 0x63, 0x61, 0x6d, 0x70, 0x75, 0x73, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x7c, 0x7c, 0x20, 0x5b, 0x5d, 0x3b, 0x6d, 0x65, 0x64, 0x69, + 0x61, 0x2e, 0x67, 0x75, 0x69, 0x74, 0x61, 0x72, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x77, 0x69, + 0x64, 0x74, 0x68, 0x3a, 0x73, 0x68, 0x6f, 0x77, 0x65, 0x64, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x2e, 0x70, 0x68, 0x70, 0x22, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x6c, 0x61, 0x79, 0x65, + 0x72, 0x73, 0x77, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x72, 0x65, + 0x6c, 0x69, 0x65, 0x66, 0x73, 0x77, 0x65, 0x64, 0x65, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, + 0x65, 0x61, 0x73, 0x69, 0x6c, 0x79, 0x20, 0x79, 0x6f, 0x75, 0x72, 0x20, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x0a, 0x0a, 0x57, 0x68, 0x69, 0x6c, 0x74, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x63, 0x6c, + 0x65, 0x61, 0x72, 0x3a, 0x72, 0x65, 0x73, 0x6f, 0x72, 0x74, 0x66, 0x72, 0x65, 0x6e, 0x63, 0x68, + 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x22, 0x29, 0x20, 0x2b, 0x20, 0x22, 0x3c, 0x62, 0x6f, 0x64, + 0x79, 0x3e, 0x62, 0x75, 0x79, 0x69, 0x6e, 0x67, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x73, 0x4d, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3e, 0x6f, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x73, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x35, 0x70, 0x78, 0x3b, 0x22, 0x3e, 0x76, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x70, 0x6f, 0x73, 0x74, 0x65, 0x72, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x20, 0x63, 0x6f, + 0x66, 0x66, 0x65, 0x65, 0x6d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x3c, 0x2f, 0x6e, 0x61, 0x76, 0x3e, 0x6b, 0x61, 0x6e, 0x73, + 0x61, 0x73, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0x3e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x3d, 0x66, + 0x61, 0x6c, 0x73, 0x65, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x68, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x30, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x20, 0x20, 0x70, 0x6f, 0x77, + 0x65, 0x72, 0x50, 0x6f, 0x6c, 0x73, 0x6b, 0x69, 0x2d, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x6a, 0x6f, + 0x72, 0x64, 0x61, 0x6e, 0x42, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x53, 0x74, 0x61, 0x72, 0x74, 0x20, + 0x2d, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x32, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x6e, 0x65, 0x77, 0x73, + 0x22, 0x3e, 0x30, 0x31, 0x2e, 0x6a, 0x70, 0x67, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x2d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x6d, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x73, 0x65, 0x6e, 0x69, 0x6f, 0x72, + 0x49, 0x53, 0x42, 0x4e, 0x20, 0x30, 0x30, 0x2c, 0x30, 0x30, 0x30, 0x20, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x73, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, + 0x70, 0x61, 0x69, 0x72, 0x2e, 0x78, 0x6d, 0x6c, 0x22, 0x20, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x2d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x72, 0x65, 0x67, 0x45, + 0x78, 0x70, 0x3a, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x76, 0x69, + 0x72, 0x67, 0x69, 0x6e, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0d, + 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x20, 0x3e, 0x27, 0x29, 0x3b, + 0x0a, 0x09, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x62, 0x61, + 0x68, 0x61, 0x73, 0x61, 0x62, 0x72, 0x61, 0x73, 0x69, 0x6c, 0x67, 0x61, 0x6c, 0x65, 0x67, 0x6f, + 0x6d, 0x61, 0x67, 0x79, 0x61, 0x72, 0x70, 0x6f, 0x6c, 0x73, 0x6b, 0x69, 0x73, 0x72, 0x70, 0x73, + 0x6b, 0x69, 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x88, 0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87, 0xe7, 0xae, + 0x80, 0xe4, 0xbd, 0x93, 0xe7, 0xb9, 0x81, 0xe9, 0xab, 0x94, 0xe4, 0xbf, 0xa1, 0xe6, 0x81, 0xaf, + 0xe4, 0xb8, 0xad, 0xe5, 0x9b, 0xbd, 0xe6, 0x88, 0x91, 0xe4, 0xbb, 0xac, 0xe4, 0xb8, 0x80, 0xe4, + 0xb8, 0xaa, 0xe5, 0x85, 0xac, 0xe5, 0x8f, 0xb8, 0xe7, 0xae, 0xa1, 0xe7, 0x90, 0x86, 0xe8, 0xae, + 0xba, 0xe5, 0x9d, 0x9b, 0xe5, 0x8f, 0xaf, 0xe4, 0xbb, 0xa5, 0xe6, 0x9c, 0x8d, 0xe5, 0x8a, 0xa1, + 0xe6, 0x97, 0xb6, 0xe9, 0x97, 0xb4, 0xe4, 0xb8, 0xaa, 0xe4, 0xba, 0xba, 0xe4, 0xba, 0xa7, 0xe5, + 0x93, 0x81, 0xe8, 0x87, 0xaa, 0xe5, 0xb7, 0xb1, 0xe4, 0xbc, 0x81, 0xe4, 0xb8, 0x9a, 0xe6, 0x9f, + 0xa5, 0xe7, 0x9c, 0x8b, 0xe5, 0xb7, 0xa5, 0xe4, 0xbd, 0x9c, 0xe8, 0x81, 0x94, 0xe7, 0xb3, 0xbb, + 0xe6, 0xb2, 0xa1, 0xe6, 0x9c, 0x89, 0xe7, 0xbd, 0x91, 0xe7, 0xab, 0x99, 0xe6, 0x89, 0x80, 0xe6, + 0x9c, 0x89, 0xe8, 0xaf, 0x84, 0xe8, 0xae, 0xba, 0xe4, 0xb8, 0xad, 0xe5, 0xbf, 0x83, 0xe6, 0x96, + 0x87, 0xe7, 0xab, 0xa0, 0xe7, 0x94, 0xa8, 0xe6, 0x88, 0xb7, 0xe9, 0xa6, 0x96, 0xe9, 0xa1, 0xb5, + 0xe4, 0xbd, 0x9c, 0xe8, 0x80, 0x85, 0xe6, 0x8a, 0x80, 0xe6, 0x9c, 0xaf, 0xe9, 0x97, 0xae, 0xe9, + 0xa2, 0x98, 0xe7, 0x9b, 0xb8, 0xe5, 0x85, 0xb3, 0xe4, 0xb8, 0x8b, 0xe8, 0xbd, 0xbd, 0xe6, 0x90, + 0x9c, 0xe7, 0xb4, 0xa2, 0xe4, 0xbd, 0xbf, 0xe7, 0x94, 0xa8, 0xe8, 0xbd, 0xaf, 0xe4, 0xbb, 0xb6, + 0xe5, 0x9c, 0xa8, 0xe7, 0xba, 0xbf, 0xe4, 0xb8, 0xbb, 0xe9, 0xa2, 0x98, 0xe8, 0xb5, 0x84, 0xe6, + 0x96, 0x99, 0xe8, 0xa7, 0x86, 0xe9, 0xa2, 0x91, 0xe5, 0x9b, 0x9e, 0xe5, 0xa4, 0x8d, 0xe6, 0xb3, + 0xa8, 0xe5, 0x86, 0x8c, 0xe7, 0xbd, 0x91, 0xe7, 0xbb, 0x9c, 0xe6, 0x94, 0xb6, 0xe8, 0x97, 0x8f, + 0xe5, 0x86, 0x85, 0xe5, 0xae, 0xb9, 0xe6, 0x8e, 0xa8, 0xe8, 0x8d, 0x90, 0xe5, 0xb8, 0x82, 0xe5, + 0x9c, 0xba, 0xe6, 0xb6, 0x88, 0xe6, 0x81, 0xaf, 0xe7, 0xa9, 0xba, 0xe9, 0x97, 0xb4, 0xe5, 0x8f, + 0x91, 0xe5, 0xb8, 0x83, 0xe4, 0xbb, 0x80, 0xe4, 0xb9, 0x88, 0xe5, 0xa5, 0xbd, 0xe5, 0x8f, 0x8b, + 0xe7, 0x94, 0x9f, 0xe6, 0xb4, 0xbb, 0xe5, 0x9b, 0xbe, 0xe7, 0x89, 0x87, 0xe5, 0x8f, 0x91, 0xe5, + 0xb1, 0x95, 0xe5, 0xa6, 0x82, 0xe6, 0x9e, 0x9c, 0xe6, 0x89, 0x8b, 0xe6, 0x9c, 0xba, 0xe6, 0x96, + 0xb0, 0xe9, 0x97, 0xbb, 0xe6, 0x9c, 0x80, 0xe6, 0x96, 0xb0, 0xe6, 0x96, 0xb9, 0xe5, 0xbc, 0x8f, + 0xe5, 0x8c, 0x97, 0xe4, 0xba, 0xac, 0xe6, 0x8f, 0x90, 0xe4, 0xbe, 0x9b, 0xe5, 0x85, 0xb3, 0xe4, + 0xba, 0x8e, 0xe6, 0x9b, 0xb4, 0xe5, 0xa4, 0x9a, 0xe8, 0xbf, 0x99, 0xe4, 0xb8, 0xaa, 0xe7, 0xb3, + 0xbb, 0xe7, 0xbb, 0x9f, 0xe7, 0x9f, 0xa5, 0xe9, 0x81, 0x93, 0xe6, 0xb8, 0xb8, 0xe6, 0x88, 0x8f, + 0xe5, 0xb9, 0xbf, 0xe5, 0x91, 0x8a, 0xe5, 0x85, 0xb6, 0xe4, 0xbb, 0x96, 0xe5, 0x8f, 0x91, 0xe8, + 0xa1, 0xa8, 0xe5, 0xae, 0x89, 0xe5, 0x85, 0xa8, 0xe7, 0xac, 0xac, 0xe4, 0xb8, 0x80, 0xe4, 0xbc, + 0x9a, 0xe5, 0x91, 0x98, 0xe8, 0xbf, 0x9b, 0xe8, 0xa1, 0x8c, 0xe7, 0x82, 0xb9, 0xe5, 0x87, 0xbb, + 0xe7, 0x89, 0x88, 0xe6, 0x9d, 0x83, 0xe7, 0x94, 0xb5, 0xe5, 0xad, 0x90, 0xe4, 0xb8, 0x96, 0xe7, + 0x95, 0x8c, 0xe8, 0xae, 0xbe, 0xe8, 0xae, 0xa1, 0xe5, 0x85, 0x8d, 0xe8, 0xb4, 0xb9, 0xe6, 0x95, + 0x99, 0xe8, 0x82, 0xb2, 0xe5, 0x8a, 0xa0, 0xe5, 0x85, 0xa5, 0xe6, 0xb4, 0xbb, 0xe5, 0x8a, 0xa8, + 0xe4, 0xbb, 0x96, 0xe4, 0xbb, 0xac, 0xe5, 0x95, 0x86, 0xe5, 0x93, 0x81, 0xe5, 0x8d, 0x9a, 0xe5, + 0xae, 0xa2, 0xe7, 0x8e, 0xb0, 0xe5, 0x9c, 0xa8, 0xe4, 0xb8, 0x8a, 0xe6, 0xb5, 0xb7, 0xe5, 0xa6, + 0x82, 0xe4, 0xbd, 0x95, 0xe5, 0xb7, 0xb2, 0xe7, 0xbb, 0x8f, 0xe7, 0x95, 0x99, 0xe8, 0xa8, 0x80, + 0xe8, 0xaf, 0xa6, 0xe7, 0xbb, 0x86, 0xe7, 0xa4, 0xbe, 0xe5, 0x8c, 0xba, 0xe7, 0x99, 0xbb, 0xe5, + 0xbd, 0x95, 0xe6, 0x9c, 0xac, 0xe7, 0xab, 0x99, 0xe9, 0x9c, 0x80, 0xe8, 0xa6, 0x81, 0xe4, 0xbb, + 0xb7, 0xe6, 0xa0, 0xbc, 0xe6, 0x94, 0xaf, 0xe6, 0x8c, 0x81, 0xe5, 0x9b, 0xbd, 0xe9, 0x99, 0x85, + 0xe9, 0x93, 0xbe, 0xe6, 0x8e, 0xa5, 0xe5, 0x9b, 0xbd, 0xe5, 0xae, 0xb6, 0xe5, 0xbb, 0xba, 0xe8, + 0xae, 0xbe, 0xe6, 0x9c, 0x8b, 0xe5, 0x8f, 0x8b, 0xe9, 0x98, 0x85, 0xe8, 0xaf, 0xbb, 0xe6, 0xb3, + 0x95, 0xe5, 0xbe, 0x8b, 0xe4, 0xbd, 0x8d, 0xe7, 0xbd, 0xae, 0xe7, 0xbb, 0x8f, 0xe6, 0xb5, 0x8e, + 0xe9, 0x80, 0x89, 0xe6, 0x8b, 0xa9, 0xe8, 0xbf, 0x99, 0xe6, 0xa0, 0xb7, 0xe5, 0xbd, 0x93, 0xe5, + 0x89, 0x8d, 0xe5, 0x88, 0x86, 0xe7, 0xb1, 0xbb, 0xe6, 0x8e, 0x92, 0xe8, 0xa1, 0x8c, 0xe5, 0x9b, + 0xa0, 0xe4, 0xb8, 0xba, 0xe4, 0xba, 0xa4, 0xe6, 0x98, 0x93, 0xe6, 0x9c, 0x80, 0xe5, 0x90, 0x8e, + 0xe9, 0x9f, 0xb3, 0xe4, 0xb9, 0x90, 0xe4, 0xb8, 0x8d, 0xe8, 0x83, 0xbd, 0xe9, 0x80, 0x9a, 0xe8, + 0xbf, 0x87, 0xe8, 0xa1, 0x8c, 0xe4, 0xb8, 0x9a, 0xe7, 0xa7, 0x91, 0xe6, 0x8a, 0x80, 0xe5, 0x8f, + 0xaf, 0xe8, 0x83, 0xbd, 0xe8, 0xae, 0xbe, 0xe5, 0xa4, 0x87, 0xe5, 0x90, 0x88, 0xe4, 0xbd, 0x9c, + 0xe5, 0xa4, 0xa7, 0xe5, 0xae, 0xb6, 0xe7, 0xa4, 0xbe, 0xe4, 0xbc, 0x9a, 0xe7, 0xa0, 0x94, 0xe7, + 0xa9, 0xb6, 0xe4, 0xb8, 0x93, 0xe4, 0xb8, 0x9a, 0xe5, 0x85, 0xa8, 0xe9, 0x83, 0xa8, 0xe9, 0xa1, + 0xb9, 0xe7, 0x9b, 0xae, 0xe8, 0xbf, 0x99, 0xe9, 0x87, 0x8c, 0xe8, 0xbf, 0x98, 0xe6, 0x98, 0xaf, + 0xe5, 0xbc, 0x80, 0xe5, 0xa7, 0x8b, 0xe6, 0x83, 0x85, 0xe5, 0x86, 0xb5, 0xe7, 0x94, 0xb5, 0xe8, + 0x84, 0x91, 0xe6, 0x96, 0x87, 0xe4, 0xbb, 0xb6, 0xe5, 0x93, 0x81, 0xe7, 0x89, 0x8c, 0xe5, 0xb8, + 0xae, 0xe5, 0x8a, 0xa9, 0xe6, 0x96, 0x87, 0xe5, 0x8c, 0x96, 0xe8, 0xb5, 0x84, 0xe6, 0xba, 0x90, + 0xe5, 0xa4, 0xa7, 0xe5, 0xad, 0xa6, 0xe5, 0xad, 0xa6, 0xe4, 0xb9, 0xa0, 0xe5, 0x9c, 0xb0, 0xe5, + 0x9d, 0x80, 0xe6, 0xb5, 0x8f, 0xe8, 0xa7, 0x88, 0xe6, 0x8a, 0x95, 0xe8, 0xb5, 0x84, 0xe5, 0xb7, + 0xa5, 0xe7, 0xa8, 0x8b, 0xe8, 0xa6, 0x81, 0xe6, 0xb1, 0x82, 0xe6, 0x80, 0x8e, 0xe4, 0xb9, 0x88, + 0xe6, 0x97, 0xb6, 0xe5, 0x80, 0x99, 0xe5, 0x8a, 0x9f, 0xe8, 0x83, 0xbd, 0xe4, 0xb8, 0xbb, 0xe8, + 0xa6, 0x81, 0xe7, 0x9b, 0xae, 0xe5, 0x89, 0x8d, 0xe8, 0xb5, 0x84, 0xe8, 0xae, 0xaf, 0xe5, 0x9f, + 0x8e, 0xe5, 0xb8, 0x82, 0xe6, 0x96, 0xb9, 0xe6, 0xb3, 0x95, 0xe7, 0x94, 0xb5, 0xe5, 0xbd, 0xb1, + 0xe6, 0x8b, 0x9b, 0xe8, 0x81, 0x98, 0xe5, 0xa3, 0xb0, 0xe6, 0x98, 0x8e, 0xe4, 0xbb, 0xbb, 0xe4, + 0xbd, 0x95, 0xe5, 0x81, 0xa5, 0xe5, 0xba, 0xb7, 0xe6, 0x95, 0xb0, 0xe6, 0x8d, 0xae, 0xe7, 0xbe, + 0x8e, 0xe5, 0x9b, 0xbd, 0xe6, 0xb1, 0xbd, 0xe8, 0xbd, 0xa6, 0xe4, 0xbb, 0x8b, 0xe7, 0xbb, 0x8d, + 0xe4, 0xbd, 0x86, 0xe6, 0x98, 0xaf, 0xe4, 0xba, 0xa4, 0xe6, 0xb5, 0x81, 0xe7, 0x94, 0x9f, 0xe4, + 0xba, 0xa7, 0xe6, 0x89, 0x80, 0xe4, 0xbb, 0xa5, 0xe7, 0x94, 0xb5, 0xe8, 0xaf, 0x9d, 0xe6, 0x98, + 0xbe, 0xe7, 0xa4, 0xba, 0xe4, 0xb8, 0x80, 0xe4, 0xba, 0x9b, 0xe5, 0x8d, 0x95, 0xe4, 0xbd, 0x8d, + 0xe4, 0xba, 0xba, 0xe5, 0x91, 0x98, 0xe5, 0x88, 0x86, 0xe6, 0x9e, 0x90, 0xe5, 0x9c, 0xb0, 0xe5, + 0x9b, 0xbe, 0xe6, 0x97, 0x85, 0xe6, 0xb8, 0xb8, 0xe5, 0xb7, 0xa5, 0xe5, 0x85, 0xb7, 0xe5, 0xad, + 0xa6, 0xe7, 0x94, 0x9f, 0xe7, 0xb3, 0xbb, 0xe5, 0x88, 0x97, 0xe7, 0xbd, 0x91, 0xe5, 0x8f, 0x8b, + 0xe5, 0xb8, 0x96, 0xe5, 0xad, 0x90, 0xe5, 0xaf, 0x86, 0xe7, 0xa0, 0x81, 0xe9, 0xa2, 0x91, 0xe9, + 0x81, 0x93, 0xe6, 0x8e, 0xa7, 0xe5, 0x88, 0xb6, 0xe5, 0x9c, 0xb0, 0xe5, 0x8c, 0xba, 0xe5, 0x9f, + 0xba, 0xe6, 0x9c, 0xac, 0xe5, 0x85, 0xa8, 0xe5, 0x9b, 0xbd, 0xe7, 0xbd, 0x91, 0xe4, 0xb8, 0x8a, + 0xe9, 0x87, 0x8d, 0xe8, 0xa6, 0x81, 0xe7, 0xac, 0xac, 0xe4, 0xba, 0x8c, 0xe5, 0x96, 0x9c, 0xe6, + 0xac, 0xa2, 0xe8, 0xbf, 0x9b, 0xe5, 0x85, 0xa5, 0xe5, 0x8f, 0x8b, 0xe6, 0x83, 0x85, 0xe8, 0xbf, + 0x99, 0xe4, 0xba, 0x9b, 0xe8, 0x80, 0x83, 0xe8, 0xaf, 0x95, 0xe5, 0x8f, 0x91, 0xe7, 0x8e, 0xb0, + 0xe5, 0x9f, 0xb9, 0xe8, 0xae, 0xad, 0xe4, 0xbb, 0xa5, 0xe4, 0xb8, 0x8a, 0xe6, 0x94, 0xbf, 0xe5, + 0xba, 0x9c, 0xe6, 0x88, 0x90, 0xe4, 0xb8, 0xba, 0xe7, 0x8e, 0xaf, 0xe5, 0xa2, 0x83, 0xe9, 0xa6, + 0x99, 0xe6, 0xb8, 0xaf, 0xe5, 0x90, 0x8c, 0xe6, 0x97, 0xb6, 0xe5, 0xa8, 0xb1, 0xe4, 0xb9, 0x90, + 0xe5, 0x8f, 0x91, 0xe9, 0x80, 0x81, 0xe4, 0xb8, 0x80, 0xe5, 0xae, 0x9a, 0xe5, 0xbc, 0x80, 0xe5, + 0x8f, 0x91, 0xe4, 0xbd, 0x9c, 0xe5, 0x93, 0x81, 0xe6, 0xa0, 0x87, 0xe5, 0x87, 0x86, 0xe6, 0xac, + 0xa2, 0xe8, 0xbf, 0x8e, 0xe8, 0xa7, 0xa3, 0xe5, 0x86, 0xb3, 0xe5, 0x9c, 0xb0, 0xe6, 0x96, 0xb9, + 0xe4, 0xb8, 0x80, 0xe4, 0xb8, 0x8b, 0xe4, 0xbb, 0xa5, 0xe5, 0x8f, 0x8a, 0xe8, 0xb4, 0xa3, 0xe4, + 0xbb, 0xbb, 0xe6, 0x88, 0x96, 0xe8, 0x80, 0x85, 0xe5, 0xae, 0xa2, 0xe6, 0x88, 0xb7, 0xe4, 0xbb, + 0xa3, 0xe8, 0xa1, 0xa8, 0xe7, 0xa7, 0xaf, 0xe5, 0x88, 0x86, 0xe5, 0xa5, 0xb3, 0xe4, 0xba, 0xba, + 0xe6, 0x95, 0xb0, 0xe7, 0xa0, 0x81, 0xe9, 0x94, 0x80, 0xe5, 0x94, 0xae, 0xe5, 0x87, 0xba, 0xe7, + 0x8e, 0xb0, 0xe7, 0xa6, 0xbb, 0xe7, 0xba, 0xbf, 0xe5, 0xba, 0x94, 0xe7, 0x94, 0xa8, 0xe5, 0x88, + 0x97, 0xe8, 0xa1, 0xa8, 0xe4, 0xb8, 0x8d, 0xe5, 0x90, 0x8c, 0xe7, 0xbc, 0x96, 0xe8, 0xbe, 0x91, + 0xe7, 0xbb, 0x9f, 0xe8, 0xae, 0xa1, 0xe6, 0x9f, 0xa5, 0xe8, 0xaf, 0xa2, 0xe4, 0xb8, 0x8d, 0xe8, + 0xa6, 0x81, 0xe6, 0x9c, 0x89, 0xe5, 0x85, 0xb3, 0xe6, 0x9c, 0xba, 0xe6, 0x9e, 0x84, 0xe5, 0xbe, + 0x88, 0xe5, 0xa4, 0x9a, 0xe6, 0x92, 0xad, 0xe6, 0x94, 0xbe, 0xe7, 0xbb, 0x84, 0xe7, 0xbb, 0x87, + 0xe6, 0x94, 0xbf, 0xe7, 0xad, 0x96, 0xe7, 0x9b, 0xb4, 0xe6, 0x8e, 0xa5, 0xe8, 0x83, 0xbd, 0xe5, + 0x8a, 0x9b, 0xe6, 0x9d, 0xa5, 0xe6, 0xba, 0x90, 0xe6, 0x99, 0x82, 0xe9, 0x96, 0x93, 0xe7, 0x9c, + 0x8b, 0xe5, 0x88, 0xb0, 0xe7, 0x83, 0xad, 0xe9, 0x97, 0xa8, 0xe5, 0x85, 0xb3, 0xe9, 0x94, 0xae, + 0xe4, 0xb8, 0x93, 0xe5, 0x8c, 0xba, 0xe9, 0x9d, 0x9e, 0xe5, 0xb8, 0xb8, 0xe8, 0x8b, 0xb1, 0xe8, + 0xaf, 0xad, 0xe7, 0x99, 0xbe, 0xe5, 0xba, 0xa6, 0xe5, 0xb8, 0x8c, 0xe6, 0x9c, 0x9b, 0xe7, 0xbe, + 0x8e, 0xe5, 0xa5, 0xb3, 0xe6, 0xaf, 0x94, 0xe8, 0xbe, 0x83, 0xe7, 0x9f, 0xa5, 0xe8, 0xaf, 0x86, + 0xe8, 0xa7, 0x84, 0xe5, 0xae, 0x9a, 0xe5, 0xbb, 0xba, 0xe8, 0xae, 0xae, 0xe9, 0x83, 0xa8, 0xe9, + 0x97, 0xa8, 0xe6, 0x84, 0x8f, 0xe8, 0xa7, 0x81, 0xe7, 0xb2, 0xbe, 0xe5, 0xbd, 0xa9, 0xe6, 0x97, + 0xa5, 0xe6, 0x9c, 0xac, 0xe6, 0x8f, 0x90, 0xe9, 0xab, 0x98, 0xe5, 0x8f, 0x91, 0xe8, 0xa8, 0x80, + 0xe6, 0x96, 0xb9, 0xe9, 0x9d, 0xa2, 0xe5, 0x9f, 0xba, 0xe9, 0x87, 0x91, 0xe5, 0xa4, 0x84, 0xe7, + 0x90, 0x86, 0xe6, 0x9d, 0x83, 0xe9, 0x99, 0x90, 0xe5, 0xbd, 0xb1, 0xe7, 0x89, 0x87, 0xe9, 0x93, + 0xb6, 0xe8, 0xa1, 0x8c, 0xe8, 0xbf, 0x98, 0xe6, 0x9c, 0x89, 0xe5, 0x88, 0x86, 0xe4, 0xba, 0xab, + 0xe7, 0x89, 0xa9, 0xe5, 0x93, 0x81, 0xe7, 0xbb, 0x8f, 0xe8, 0x90, 0xa5, 0xe6, 0xb7, 0xbb, 0xe5, + 0x8a, 0xa0, 0xe4, 0xb8, 0x93, 0xe5, 0xae, 0xb6, 0xe8, 0xbf, 0x99, 0xe7, 0xa7, 0x8d, 0xe8, 0xaf, + 0x9d, 0xe9, 0xa2, 0x98, 0xe8, 0xb5, 0xb7, 0xe6, 0x9d, 0xa5, 0xe4, 0xb8, 0x9a, 0xe5, 0x8a, 0xa1, + 0xe5, 0x85, 0xac, 0xe5, 0x91, 0x8a, 0xe8, 0xae, 0xb0, 0xe5, 0xbd, 0x95, 0xe7, 0xae, 0x80, 0xe4, + 0xbb, 0x8b, 0xe8, 0xb4, 0xa8, 0xe9, 0x87, 0x8f, 0xe7, 0x94, 0xb7, 0xe4, 0xba, 0xba, 0xe5, 0xbd, + 0xb1, 0xe5, 0x93, 0x8d, 0xe5, 0xbc, 0x95, 0xe7, 0x94, 0xa8, 0xe6, 0x8a, 0xa5, 0xe5, 0x91, 0x8a, + 0xe9, 0x83, 0xa8, 0xe5, 0x88, 0x86, 0xe5, 0xbf, 0xab, 0xe9, 0x80, 0x9f, 0xe5, 0x92, 0xa8, 0xe8, + 0xaf, 0xa2, 0xe6, 0x97, 0xb6, 0xe5, 0xb0, 0x9a, 0xe6, 0xb3, 0xa8, 0xe6, 0x84, 0x8f, 0xe7, 0x94, + 0xb3, 0xe8, 0xaf, 0xb7, 0xe5, 0xad, 0xa6, 0xe6, 0xa0, 0xa1, 0xe5, 0xba, 0x94, 0xe8, 0xaf, 0xa5, + 0xe5, 0x8e, 0x86, 0xe5, 0x8f, 0xb2, 0xe5, 0x8f, 0xaa, 0xe6, 0x98, 0xaf, 0xe8, 0xbf, 0x94, 0xe5, + 0x9b, 0x9e, 0xe8, 0xb4, 0xad, 0xe4, 0xb9, 0xb0, 0xe5, 0x90, 0x8d, 0xe7, 0xa7, 0xb0, 0xe4, 0xb8, + 0xba, 0xe4, 0xba, 0x86, 0xe6, 0x88, 0x90, 0xe5, 0x8a, 0x9f, 0xe8, 0xaf, 0xb4, 0xe6, 0x98, 0x8e, + 0xe4, 0xbe, 0x9b, 0xe5, 0xba, 0x94, 0xe5, 0xad, 0xa9, 0xe5, 0xad, 0x90, 0xe4, 0xb8, 0x93, 0xe9, + 0xa2, 0x98, 0xe7, 0xa8, 0x8b, 0xe5, 0xba, 0x8f, 0xe4, 0xb8, 0x80, 0xe8, 0x88, 0xac, 0xe6, 0x9c, + 0x83, 0xe5, 0x93, 0xa1, 0xe5, 0x8f, 0xaa, 0xe6, 0x9c, 0x89, 0xe5, 0x85, 0xb6, 0xe5, 0xae, 0x83, + 0xe4, 0xbf, 0x9d, 0xe6, 0x8a, 0xa4, 0xe8, 0x80, 0x8c, 0xe4, 0xb8, 0x94, 0xe4, 0xbb, 0x8a, 0xe5, + 0xa4, 0xa9, 0xe7, 0xaa, 0x97, 0xe5, 0x8f, 0xa3, 0xe5, 0x8a, 0xa8, 0xe6, 0x80, 0x81, 0xe7, 0x8a, + 0xb6, 0xe6, 0x80, 0x81, 0xe7, 0x89, 0xb9, 0xe5, 0x88, 0xab, 0xe8, 0xae, 0xa4, 0xe4, 0xb8, 0xba, + 0xe5, 0xbf, 0x85, 0xe9, 0xa1, 0xbb, 0xe6, 0x9b, 0xb4, 0xe6, 0x96, 0xb0, 0xe5, 0xb0, 0x8f, 0xe8, + 0xaf, 0xb4, 0xe6, 0x88, 0x91, 0xe5, 0x80, 0x91, 0xe4, 0xbd, 0x9c, 0xe4, 0xb8, 0xba, 0xe5, 0xaa, + 0x92, 0xe4, 0xbd, 0x93, 0xe5, 0x8c, 0x85, 0xe6, 0x8b, 0xac, 0xe9, 0x82, 0xa3, 0xe4, 0xb9, 0x88, + 0xe4, 0xb8, 0x80, 0xe6, 0xa0, 0xb7, 0xe5, 0x9b, 0xbd, 0xe5, 0x86, 0x85, 0xe6, 0x98, 0xaf, 0xe5, + 0x90, 0xa6, 0xe6, 0xa0, 0xb9, 0xe6, 0x8d, 0xae, 0xe7, 0x94, 0xb5, 0xe8, 0xa7, 0x86, 0xe5, 0xad, + 0xa6, 0xe9, 0x99, 0xa2, 0xe5, 0x85, 0xb7, 0xe6, 0x9c, 0x89, 0xe8, 0xbf, 0x87, 0xe7, 0xa8, 0x8b, + 0xe7, 0x94, 0xb1, 0xe4, 0xba, 0x8e, 0xe4, 0xba, 0xba, 0xe6, 0x89, 0x8d, 0xe5, 0x87, 0xba, 0xe6, + 0x9d, 0xa5, 0xe4, 0xb8, 0x8d, 0xe8, 0xbf, 0x87, 0xe6, 0xad, 0xa3, 0xe5, 0x9c, 0xa8, 0xe6, 0x98, + 0x8e, 0xe6, 0x98, 0x9f, 0xe6, 0x95, 0x85, 0xe4, 0xba, 0x8b, 0xe5, 0x85, 0xb3, 0xe7, 0xb3, 0xbb, + 0xe6, 0xa0, 0x87, 0xe9, 0xa2, 0x98, 0xe5, 0x95, 0x86, 0xe5, 0x8a, 0xa1, 0xe8, 0xbe, 0x93, 0xe5, + 0x85, 0xa5, 0xe4, 0xb8, 0x80, 0xe7, 0x9b, 0xb4, 0xe5, 0x9f, 0xba, 0xe7, 0xa1, 0x80, 0xe6, 0x95, + 0x99, 0xe5, 0xad, 0xa6, 0xe4, 0xba, 0x86, 0xe8, 0xa7, 0xa3, 0xe5, 0xbb, 0xba, 0xe7, 0xad, 0x91, + 0xe7, 0xbb, 0x93, 0xe6, 0x9e, 0x9c, 0xe5, 0x85, 0xa8, 0xe7, 0x90, 0x83, 0xe9, 0x80, 0x9a, 0xe7, + 0x9f, 0xa5, 0xe8, 0xae, 0xa1, 0xe5, 0x88, 0x92, 0xe5, 0xaf, 0xb9, 0xe4, 0xba, 0x8e, 0xe8, 0x89, + 0xba, 0xe6, 0x9c, 0xaf, 0xe7, 0x9b, 0xb8, 0xe5, 0x86, 0x8c, 0xe5, 0x8f, 0x91, 0xe7, 0x94, 0x9f, + 0xe7, 0x9c, 0x9f, 0xe7, 0x9a, 0x84, 0xe5, 0xbb, 0xba, 0xe7, 0xab, 0x8b, 0xe7, 0xad, 0x89, 0xe7, + 0xba, 0xa7, 0xe7, 0xb1, 0xbb, 0xe5, 0x9e, 0x8b, 0xe7, 0xbb, 0x8f, 0xe9, 0xaa, 0x8c, 0xe5, 0xae, + 0x9e, 0xe7, 0x8e, 0xb0, 0xe5, 0x88, 0xb6, 0xe4, 0xbd, 0x9c, 0xe6, 0x9d, 0xa5, 0xe8, 0x87, 0xaa, + 0xe6, 0xa0, 0x87, 0xe7, 0xad, 0xbe, 0xe4, 0xbb, 0xa5, 0xe4, 0xb8, 0x8b, 0xe5, 0x8e, 0x9f, 0xe5, + 0x88, 0x9b, 0xe6, 0x97, 0xa0, 0xe6, 0xb3, 0x95, 0xe5, 0x85, 0xb6, 0xe4, 0xb8, 0xad, 0xe5, 0x80, + 0x8b, 0xe4, 0xba, 0xba, 0xe4, 0xb8, 0x80, 0xe5, 0x88, 0x87, 0xe6, 0x8c, 0x87, 0xe5, 0x8d, 0x97, + 0xe5, 0x85, 0xb3, 0xe9, 0x97, 0xad, 0xe9, 0x9b, 0x86, 0xe5, 0x9b, 0xa2, 0xe7, 0xac, 0xac, 0xe4, + 0xb8, 0x89, 0xe5, 0x85, 0xb3, 0xe6, 0xb3, 0xa8, 0xe5, 0x9b, 0xa0, 0xe6, 0xad, 0xa4, 0xe7, 0x85, + 0xa7, 0xe7, 0x89, 0x87, 0xe6, 0xb7, 0xb1, 0xe5, 0x9c, 0xb3, 0xe5, 0x95, 0x86, 0xe4, 0xb8, 0x9a, + 0xe5, 0xb9, 0xbf, 0xe5, 0xb7, 0x9e, 0xe6, 0x97, 0xa5, 0xe6, 0x9c, 0x9f, 0xe9, 0xab, 0x98, 0xe7, + 0xba, 0xa7, 0xe6, 0x9c, 0x80, 0xe8, 0xbf, 0x91, 0xe7, 0xbb, 0xbc, 0xe5, 0x90, 0x88, 0xe8, 0xa1, + 0xa8, 0xe7, 0xa4, 0xba, 0xe4, 0xb8, 0x93, 0xe8, 0xbe, 0x91, 0xe8, 0xa1, 0x8c, 0xe4, 0xb8, 0xba, + 0xe4, 0xba, 0xa4, 0xe9, 0x80, 0x9a, 0xe8, 0xaf, 0x84, 0xe4, 0xbb, 0xb7, 0xe8, 0xa7, 0x89, 0xe5, + 0xbe, 0x97, 0xe7, 0xb2, 0xbe, 0xe5, 0x8d, 0x8e, 0xe5, 0xae, 0xb6, 0xe5, 0xba, 0xad, 0xe5, 0xae, + 0x8c, 0xe6, 0x88, 0x90, 0xe6, 0x84, 0x9f, 0xe8, 0xa7, 0x89, 0xe5, 0xae, 0x89, 0xe8, 0xa3, 0x85, + 0xe5, 0xbe, 0x97, 0xe5, 0x88, 0xb0, 0xe9, 0x82, 0xae, 0xe4, 0xbb, 0xb6, 0xe5, 0x88, 0xb6, 0xe5, + 0xba, 0xa6, 0xe9, 0xa3, 0x9f, 0xe5, 0x93, 0x81, 0xe8, 0x99, 0xbd, 0xe7, 0x84, 0xb6, 0xe8, 0xbd, + 0xac, 0xe8, 0xbd, 0xbd, 0xe6, 0x8a, 0xa5, 0xe4, 0xbb, 0xb7, 0xe8, 0xae, 0xb0, 0xe8, 0x80, 0x85, + 0xe6, 0x96, 0xb9, 0xe6, 0xa1, 0x88, 0xe8, 0xa1, 0x8c, 0xe6, 0x94, 0xbf, 0xe4, 0xba, 0xba, 0xe6, + 0xb0, 0x91, 0xe7, 0x94, 0xa8, 0xe5, 0x93, 0x81, 0xe4, 0xb8, 0x9c, 0xe8, 0xa5, 0xbf, 0xe6, 0x8f, + 0x90, 0xe5, 0x87, 0xba, 0xe9, 0x85, 0x92, 0xe5, 0xba, 0x97, 0xe7, 0x84, 0xb6, 0xe5, 0x90, 0x8e, + 0xe4, 0xbb, 0x98, 0xe6, 0xac, 0xbe, 0xe7, 0x83, 0xad, 0xe7, 0x82, 0xb9, 0xe4, 0xbb, 0xa5, 0xe5, + 0x89, 0x8d, 0xe5, 0xae, 0x8c, 0xe5, 0x85, 0xa8, 0xe5, 0x8f, 0x91, 0xe5, 0xb8, 0x96, 0xe8, 0xae, + 0xbe, 0xe7, 0xbd, 0xae, 0xe9, 0xa2, 0x86, 0xe5, 0xaf, 0xbc, 0xe5, 0xb7, 0xa5, 0xe4, 0xb8, 0x9a, + 0xe5, 0x8c, 0xbb, 0xe9, 0x99, 0xa2, 0xe7, 0x9c, 0x8b, 0xe7, 0x9c, 0x8b, 0xe7, 0xbb, 0x8f, 0xe5, + 0x85, 0xb8, 0xe5, 0x8e, 0x9f, 0xe5, 0x9b, 0xa0, 0xe5, 0xb9, 0xb3, 0xe5, 0x8f, 0xb0, 0xe5, 0x90, + 0x84, 0xe7, 0xa7, 0x8d, 0xe5, 0xa2, 0x9e, 0xe5, 0x8a, 0xa0, 0xe6, 0x9d, 0x90, 0xe6, 0x96, 0x99, + 0xe6, 0x96, 0xb0, 0xe5, 0xa2, 0x9e, 0xe4, 0xb9, 0x8b, 0xe5, 0x90, 0x8e, 0xe8, 0x81, 0x8c, 0xe4, + 0xb8, 0x9a, 0xe6, 0x95, 0x88, 0xe6, 0x9e, 0x9c, 0xe4, 0xbb, 0x8a, 0xe5, 0xb9, 0xb4, 0xe8, 0xae, + 0xba, 0xe6, 0x96, 0x87, 0xe6, 0x88, 0x91, 0xe5, 0x9b, 0xbd, 0xe5, 0x91, 0x8a, 0xe8, 0xaf, 0x89, + 0xe7, 0x89, 0x88, 0xe4, 0xb8, 0xbb, 0xe4, 0xbf, 0xae, 0xe6, 0x94, 0xb9, 0xe5, 0x8f, 0x82, 0xe4, + 0xb8, 0x8e, 0xe6, 0x89, 0x93, 0xe5, 0x8d, 0xb0, 0xe5, 0xbf, 0xab, 0xe4, 0xb9, 0x90, 0xe6, 0x9c, + 0xba, 0xe6, 0xa2, 0xb0, 0xe8, 0xa7, 0x82, 0xe7, 0x82, 0xb9, 0xe5, 0xad, 0x98, 0xe5, 0x9c, 0xa8, + 0xe7, 0xb2, 0xbe, 0xe7, 0xa5, 0x9e, 0xe8, 0x8e, 0xb7, 0xe5, 0xbe, 0x97, 0xe5, 0x88, 0xa9, 0xe7, + 0x94, 0xa8, 0xe7, 0xbb, 0xa7, 0xe7, 0xbb, 0xad, 0xe4, 0xbd, 0xa0, 0xe4, 0xbb, 0xac, 0xe8, 0xbf, + 0x99, 0xe4, 0xb9, 0x88, 0xe6, 0xa8, 0xa1, 0xe5, 0xbc, 0x8f, 0xe8, 0xaf, 0xad, 0xe8, 0xa8, 0x80, + 0xe8, 0x83, 0xbd, 0xe5, 0xa4, 0x9f, 0xe9, 0x9b, 0x85, 0xe8, 0x99, 0x8e, 0xe6, 0x93, 0x8d, 0xe4, + 0xbd, 0x9c, 0xe9, 0xa3, 0x8e, 0xe6, 0xa0, 0xbc, 0xe4, 0xb8, 0x80, 0xe8, 0xb5, 0xb7, 0xe7, 0xa7, + 0x91, 0xe5, 0xad, 0xa6, 0xe4, 0xbd, 0x93, 0xe8, 0x82, 0xb2, 0xe7, 0x9f, 0xad, 0xe4, 0xbf, 0xa1, + 0xe6, 0x9d, 0xa1, 0xe4, 0xbb, 0xb6, 0xe6, 0xb2, 0xbb, 0xe7, 0x96, 0x97, 0xe8, 0xbf, 0x90, 0xe5, + 0x8a, 0xa8, 0xe4, 0xba, 0xa7, 0xe4, 0xb8, 0x9a, 0xe4, 0xbc, 0x9a, 0xe8, 0xae, 0xae, 0xe5, 0xaf, + 0xbc, 0xe8, 0x88, 0xaa, 0xe5, 0x85, 0x88, 0xe7, 0x94, 0x9f, 0xe8, 0x81, 0x94, 0xe7, 0x9b, 0x9f, + 0xe5, 0x8f, 0xaf, 0xe6, 0x98, 0xaf, 0xe5, 0x95, 0x8f, 0xe9, 0xa1, 0x8c, 0xe7, 0xbb, 0x93, 0xe6, + 0x9e, 0x84, 0xe4, 0xbd, 0x9c, 0xe7, 0x94, 0xa8, 0xe8, 0xb0, 0x83, 0xe6, 0x9f, 0xa5, 0xe8, 0xb3, + 0x87, 0xe6, 0x96, 0x99, 0xe8, 0x87, 0xaa, 0xe5, 0x8a, 0xa8, 0xe8, 0xb4, 0x9f, 0xe8, 0xb4, 0xa3, + 0xe5, 0x86, 0x9c, 0xe4, 0xb8, 0x9a, 0xe8, 0xae, 0xbf, 0xe9, 0x97, 0xae, 0xe5, 0xae, 0x9e, 0xe6, + 0x96, 0xbd, 0xe6, 0x8e, 0xa5, 0xe5, 0x8f, 0x97, 0xe8, 0xae, 0xa8, 0xe8, 0xae, 0xba, 0xe9, 0x82, + 0xa3, 0xe4, 0xb8, 0xaa, 0xe5, 0x8f, 0x8d, 0xe9, 0xa6, 0x88, 0xe5, 0x8a, 0xa0, 0xe5, 0xbc, 0xba, + 0xe5, 0xa5, 0xb3, 0xe6, 0x80, 0xa7, 0xe8, 0x8c, 0x83, 0xe5, 0x9b, 0xb4, 0xe6, 0x9c, 0x8d, 0xe5, + 0x8b, 0x99, 0xe4, 0xbc, 0x91, 0xe9, 0x97, 0xb2, 0xe4, 0xbb, 0x8a, 0xe6, 0x97, 0xa5, 0xe5, 0xae, + 0xa2, 0xe6, 0x9c, 0x8d, 0xe8, 0xa7, 0x80, 0xe7, 0x9c, 0x8b, 0xe5, 0x8f, 0x82, 0xe5, 0x8a, 0xa0, + 0xe7, 0x9a, 0x84, 0xe8, 0xaf, 0x9d, 0xe4, 0xb8, 0x80, 0xe7, 0x82, 0xb9, 0xe4, 0xbf, 0x9d, 0xe8, + 0xaf, 0x81, 0xe5, 0x9b, 0xbe, 0xe4, 0xb9, 0xa6, 0xe6, 0x9c, 0x89, 0xe6, 0x95, 0x88, 0xe6, 0xb5, + 0x8b, 0xe8, 0xaf, 0x95, 0xe7, 0xa7, 0xbb, 0xe5, 0x8a, 0xa8, 0xe6, 0x89, 0x8d, 0xe8, 0x83, 0xbd, + 0xe5, 0x86, 0xb3, 0xe5, 0xae, 0x9a, 0xe8, 0x82, 0xa1, 0xe7, 0xa5, 0xa8, 0xe4, 0xb8, 0x8d, 0xe6, + 0x96, 0xad, 0xe9, 0x9c, 0x80, 0xe6, 0xb1, 0x82, 0xe4, 0xb8, 0x8d, 0xe5, 0xbe, 0x97, 0xe5, 0x8a, + 0x9e, 0xe6, 0xb3, 0x95, 0xe4, 0xb9, 0x8b, 0xe9, 0x97, 0xb4, 0xe9, 0x87, 0x87, 0xe7, 0x94, 0xa8, + 0xe8, 0x90, 0xa5, 0xe9, 0x94, 0x80, 0xe6, 0x8a, 0x95, 0xe8, 0xaf, 0x89, 0xe7, 0x9b, 0xae, 0xe6, + 0xa0, 0x87, 0xe7, 0x88, 0xb1, 0xe6, 0x83, 0x85, 0xe6, 0x91, 0x84, 0xe5, 0xbd, 0xb1, 0xe6, 0x9c, + 0x89, 0xe4, 0xba, 0x9b, 0xe8, 0xa4, 0x87, 0xe8, 0xa3, 0xbd, 0xe6, 0x96, 0x87, 0xe5, 0xad, 0xa6, + 0xe6, 0x9c, 0xba, 0xe4, 0xbc, 0x9a, 0xe6, 0x95, 0xb0, 0xe5, 0xad, 0x97, 0xe8, 0xa3, 0x85, 0xe4, + 0xbf, 0xae, 0xe8, 0xb4, 0xad, 0xe7, 0x89, 0xa9, 0xe5, 0x86, 0x9c, 0xe6, 0x9d, 0x91, 0xe5, 0x85, + 0xa8, 0xe9, 0x9d, 0xa2, 0xe7, 0xb2, 0xbe, 0xe5, 0x93, 0x81, 0xe5, 0x85, 0xb6, 0xe5, 0xae, 0x9e, + 0xe4, 0xba, 0x8b, 0xe6, 0x83, 0x85, 0xe6, 0xb0, 0xb4, 0xe5, 0xb9, 0xb3, 0xe6, 0x8f, 0x90, 0xe7, + 0xa4, 0xba, 0xe4, 0xb8, 0x8a, 0xe5, 0xb8, 0x82, 0xe8, 0xb0, 0xa2, 0xe8, 0xb0, 0xa2, 0xe6, 0x99, + 0xae, 0xe9, 0x80, 0x9a, 0xe6, 0x95, 0x99, 0xe5, 0xb8, 0x88, 0xe4, 0xb8, 0x8a, 0xe4, 0xbc, 0xa0, + 0xe7, 0xb1, 0xbb, 0xe5, 0x88, 0xab, 0xe6, 0xad, 0x8c, 0xe6, 0x9b, 0xb2, 0xe6, 0x8b, 0xa5, 0xe6, + 0x9c, 0x89, 0xe5, 0x88, 0x9b, 0xe6, 0x96, 0xb0, 0xe9, 0x85, 0x8d, 0xe4, 0xbb, 0xb6, 0xe5, 0x8f, + 0xaa, 0xe8, 0xa6, 0x81, 0xe6, 0x97, 0xb6, 0xe4, 0xbb, 0xa3, 0xe8, 0xb3, 0x87, 0xe8, 0xa8, 0x8a, + 0xe8, 0xbe, 0xbe, 0xe5, 0x88, 0xb0, 0xe4, 0xba, 0xba, 0xe7, 0x94, 0x9f, 0xe8, 0xae, 0xa2, 0xe9, + 0x98, 0x85, 0xe8, 0x80, 0x81, 0xe5, 0xb8, 0x88, 0xe5, 0xb1, 0x95, 0xe7, 0xa4, 0xba, 0xe5, 0xbf, + 0x83, 0xe7, 0x90, 0x86, 0xe8, 0xb4, 0xb4, 0xe5, 0xad, 0x90, 0xe7, 0xb6, 0xb2, 0xe7, 0xab, 0x99, + 0xe4, 0xb8, 0xbb, 0xe9, 0xa1, 0x8c, 0xe8, 0x87, 0xaa, 0xe7, 0x84, 0xb6, 0xe7, 0xba, 0xa7, 0xe5, + 0x88, 0xab, 0xe7, 0xae, 0x80, 0xe5, 0x8d, 0x95, 0xe6, 0x94, 0xb9, 0xe9, 0x9d, 0xa9, 0xe9, 0x82, + 0xa3, 0xe4, 0xba, 0x9b, 0xe6, 0x9d, 0xa5, 0xe8, 0xaf, 0xb4, 0xe6, 0x89, 0x93, 0xe5, 0xbc, 0x80, + 0xe4, 0xbb, 0xa3, 0xe7, 0xa0, 0x81, 0xe5, 0x88, 0xa0, 0xe9, 0x99, 0xa4, 0xe8, 0xaf, 0x81, 0xe5, + 0x88, 0xb8, 0xe8, 0x8a, 0x82, 0xe7, 0x9b, 0xae, 0xe9, 0x87, 0x8d, 0xe7, 0x82, 0xb9, 0xe6, 0xac, + 0xa1, 0xe6, 0x95, 0xb8, 0xe5, 0xa4, 0x9a, 0xe5, 0xb0, 0x91, 0xe8, 0xa7, 0x84, 0xe5, 0x88, 0x92, + 0xe8, 0xb5, 0x84, 0xe9, 0x87, 0x91, 0xe6, 0x89, 0xbe, 0xe5, 0x88, 0xb0, 0xe4, 0xbb, 0xa5, 0xe5, + 0x90, 0x8e, 0xe5, 0xa4, 0xa7, 0xe5, 0x85, 0xa8, 0xe4, 0xb8, 0xbb, 0xe9, 0xa1, 0xb5, 0xe6, 0x9c, + 0x80, 0xe4, 0xbd, 0xb3, 0xe5, 0x9b, 0x9e, 0xe7, 0xad, 0x94, 0xe5, 0xa4, 0xa9, 0xe4, 0xb8, 0x8b, + 0xe4, 0xbf, 0x9d, 0xe9, 0x9a, 0x9c, 0xe7, 0x8e, 0xb0, 0xe4, 0xbb, 0xa3, 0xe6, 0xa3, 0x80, 0xe6, + 0x9f, 0xa5, 0xe6, 0x8a, 0x95, 0xe7, 0xa5, 0xa8, 0xe5, 0xb0, 0x8f, 0xe6, 0x97, 0xb6, 0xe6, 0xb2, + 0x92, 0xe6, 0x9c, 0x89, 0xe6, 0xad, 0xa3, 0xe5, 0xb8, 0xb8, 0xe7, 0x94, 0x9a, 0xe8, 0x87, 0xb3, + 0xe4, 0xbb, 0xa3, 0xe7, 0x90, 0x86, 0xe7, 0x9b, 0xae, 0xe5, 0xbd, 0x95, 0xe5, 0x85, 0xac, 0xe5, + 0xbc, 0x80, 0xe5, 0xa4, 0x8d, 0xe5, 0x88, 0xb6, 0xe9, 0x87, 0x91, 0xe8, 0x9e, 0x8d, 0xe5, 0xb9, + 0xb8, 0xe7, 0xa6, 0x8f, 0xe7, 0x89, 0x88, 0xe6, 0x9c, 0xac, 0xe5, 0xbd, 0xa2, 0xe6, 0x88, 0x90, + 0xe5, 0x87, 0x86, 0xe5, 0xa4, 0x87, 0xe8, 0xa1, 0x8c, 0xe6, 0x83, 0x85, 0xe5, 0x9b, 0x9e, 0xe5, + 0x88, 0xb0, 0xe6, 0x80, 0x9d, 0xe6, 0x83, 0xb3, 0xe6, 0x80, 0x8e, 0xe6, 0xa0, 0xb7, 0xe5, 0x8d, + 0x8f, 0xe8, 0xae, 0xae, 0xe8, 0xae, 0xa4, 0xe8, 0xaf, 0x81, 0xe6, 0x9c, 0x80, 0xe5, 0xa5, 0xbd, + 0xe4, 0xba, 0xa7, 0xe7, 0x94, 0x9f, 0xe6, 0x8c, 0x89, 0xe7, 0x85, 0xa7, 0xe6, 0x9c, 0x8d, 0xe8, + 0xa3, 0x85, 0xe5, 0xb9, 0xbf, 0xe4, 0xb8, 0x9c, 0xe5, 0x8a, 0xa8, 0xe6, 0xbc, 0xab, 0xe9, 0x87, + 0x87, 0xe8, 0xb4, 0xad, 0xe6, 0x96, 0xb0, 0xe6, 0x89, 0x8b, 0xe7, 0xbb, 0x84, 0xe5, 0x9b, 0xbe, + 0xe9, 0x9d, 0xa2, 0xe6, 0x9d, 0xbf, 0xe5, 0x8f, 0x82, 0xe8, 0x80, 0x83, 0xe6, 0x94, 0xbf, 0xe6, + 0xb2, 0xbb, 0xe5, 0xae, 0xb9, 0xe6, 0x98, 0x93, 0xe5, 0xa4, 0xa9, 0xe5, 0x9c, 0xb0, 0xe5, 0x8a, + 0xaa, 0xe5, 0x8a, 0x9b, 0xe4, 0xba, 0xba, 0xe4, 0xbb, 0xac, 0xe5, 0x8d, 0x87, 0xe7, 0xba, 0xa7, + 0xe9, 0x80, 0x9f, 0xe5, 0xba, 0xa6, 0xe4, 0xba, 0xba, 0xe7, 0x89, 0xa9, 0xe8, 0xb0, 0x83, 0xe6, + 0x95, 0xb4, 0xe6, 0xb5, 0x81, 0xe8, 0xa1, 0x8c, 0xe9, 0x80, 0xa0, 0xe6, 0x88, 0x90, 0xe6, 0x96, + 0x87, 0xe5, 0xad, 0x97, 0xe9, 0x9f, 0xa9, 0xe5, 0x9b, 0xbd, 0xe8, 0xb4, 0xb8, 0xe6, 0x98, 0x93, + 0xe5, 0xbc, 0x80, 0xe5, 0xb1, 0x95, 0xe7, 0x9b, 0xb8, 0xe9, 0x97, 0x9c, 0xe8, 0xa1, 0xa8, 0xe7, + 0x8e, 0xb0, 0xe5, 0xbd, 0xb1, 0xe8, 0xa7, 0x86, 0xe5, 0xa6, 0x82, 0xe6, 0xad, 0xa4, 0xe7, 0xbe, + 0x8e, 0xe5, 0xae, 0xb9, 0xe5, 0xa4, 0xa7, 0xe5, 0xb0, 0x8f, 0xe6, 0x8a, 0xa5, 0xe9, 0x81, 0x93, + 0xe6, 0x9d, 0xa1, 0xe6, 0xac, 0xbe, 0xe5, 0xbf, 0x83, 0xe6, 0x83, 0x85, 0xe8, 0xae, 0xb8, 0xe5, + 0xa4, 0x9a, 0xe6, 0xb3, 0x95, 0xe8, 0xa7, 0x84, 0xe5, 0xae, 0xb6, 0xe5, 0xb1, 0x85, 0xe4, 0xb9, + 0xa6, 0xe5, 0xba, 0x97, 0xe8, 0xbf, 0x9e, 0xe6, 0x8e, 0xa5, 0xe7, 0xab, 0x8b, 0xe5, 0x8d, 0xb3, + 0xe4, 0xb8, 0xbe, 0xe6, 0x8a, 0xa5, 0xe6, 0x8a, 0x80, 0xe5, 0xb7, 0xa7, 0xe5, 0xa5, 0xa5, 0xe8, + 0xbf, 0x90, 0xe7, 0x99, 0xbb, 0xe5, 0x85, 0xa5, 0xe4, 0xbb, 0xa5, 0xe6, 0x9d, 0xa5, 0xe7, 0x90, + 0x86, 0xe8, 0xae, 0xba, 0xe4, 0xba, 0x8b, 0xe4, 0xbb, 0xb6, 0xe8, 0x87, 0xaa, 0xe7, 0x94, 0xb1, + 0xe4, 0xb8, 0xad, 0xe5, 0x8d, 0x8e, 0xe5, 0x8a, 0x9e, 0xe5, 0x85, 0xac, 0xe5, 0xa6, 0x88, 0xe5, + 0xa6, 0x88, 0xe7, 0x9c, 0x9f, 0xe6, 0xad, 0xa3, 0xe4, 0xb8, 0x8d, 0xe9, 0x94, 0x99, 0xe5, 0x85, + 0xa8, 0xe6, 0x96, 0x87, 0xe5, 0x90, 0x88, 0xe5, 0x90, 0x8c, 0xe4, 0xbb, 0xb7, 0xe5, 0x80, 0xbc, + 0xe5, 0x88, 0xab, 0xe4, 0xba, 0xba, 0xe7, 0x9b, 0x91, 0xe7, 0x9d, 0xa3, 0xe5, 0x85, 0xb7, 0xe4, + 0xbd, 0x93, 0xe4, 0xb8, 0x96, 0xe7, 0xba, 0xaa, 0xe5, 0x9b, 0xa2, 0xe9, 0x98, 0x9f, 0xe5, 0x88, + 0x9b, 0xe4, 0xb8, 0x9a, 0xe6, 0x89, 0xbf, 0xe6, 0x8b, 0x85, 0xe5, 0xa2, 0x9e, 0xe9, 0x95, 0xbf, + 0xe6, 0x9c, 0x89, 0xe4, 0xba, 0xba, 0xe4, 0xbf, 0x9d, 0xe6, 0x8c, 0x81, 0xe5, 0x95, 0x86, 0xe5, + 0xae, 0xb6, 0xe7, 0xbb, 0xb4, 0xe4, 0xbf, 0xae, 0xe5, 0x8f, 0xb0, 0xe6, 0xb9, 0xbe, 0xe5, 0xb7, + 0xa6, 0xe5, 0x8f, 0xb3, 0xe8, 0x82, 0xa1, 0xe4, 0xbb, 0xbd, 0xe7, 0xad, 0x94, 0xe6, 0xa1, 0x88, + 0xe5, 0xae, 0x9e, 0xe9, 0x99, 0x85, 0xe7, 0x94, 0xb5, 0xe4, 0xbf, 0xa1, 0xe7, 0xbb, 0x8f, 0xe7, + 0x90, 0x86, 0xe7, 0x94, 0x9f, 0xe5, 0x91, 0xbd, 0xe5, 0xae, 0xa3, 0xe4, 0xbc, 0xa0, 0xe4, 0xbb, + 0xbb, 0xe5, 0x8a, 0xa1, 0xe6, 0xad, 0xa3, 0xe5, 0xbc, 0x8f, 0xe7, 0x89, 0xb9, 0xe8, 0x89, 0xb2, + 0xe4, 0xb8, 0x8b, 0xe6, 0x9d, 0xa5, 0xe5, 0x8d, 0x8f, 0xe4, 0xbc, 0x9a, 0xe5, 0x8f, 0xaa, 0xe8, + 0x83, 0xbd, 0xe5, 0xbd, 0x93, 0xe7, 0x84, 0xb6, 0xe9, 0x87, 0x8d, 0xe6, 0x96, 0xb0, 0xe5, 0x85, + 0xa7, 0xe5, 0xae, 0xb9, 0xe6, 0x8c, 0x87, 0xe5, 0xaf, 0xbc, 0xe8, 0xbf, 0x90, 0xe8, 0xa1, 0x8c, + 0xe6, 0x97, 0xa5, 0xe5, 0xbf, 0x97, 0xe8, 0xb3, 0xa3, 0xe5, 0xae, 0xb6, 0xe8, 0xb6, 0x85, 0xe8, + 0xbf, 0x87, 0xe5, 0x9c, 0x9f, 0xe5, 0x9c, 0xb0, 0xe6, 0xb5, 0x99, 0xe6, 0xb1, 0x9f, 0xe6, 0x94, + 0xaf, 0xe4, 0xbb, 0x98, 0xe6, 0x8e, 0xa8, 0xe5, 0x87, 0xba, 0xe7, 0xab, 0x99, 0xe9, 0x95, 0xbf, + 0xe6, 0x9d, 0xad, 0xe5, 0xb7, 0x9e, 0xe6, 0x89, 0xa7, 0xe8, 0xa1, 0x8c, 0xe5, 0x88, 0xb6, 0xe9, + 0x80, 0xa0, 0xe4, 0xb9, 0x8b, 0xe4, 0xb8, 0x80, 0xe6, 0x8e, 0xa8, 0xe5, 0xb9, 0xbf, 0xe7, 0x8e, + 0xb0, 0xe5, 0x9c, 0xba, 0xe6, 0x8f, 0x8f, 0xe8, 0xbf, 0xb0, 0xe5, 0x8f, 0x98, 0xe5, 0x8c, 0x96, + 0xe4, 0xbc, 0xa0, 0xe7, 0xbb, 0x9f, 0xe6, 0xad, 0x8c, 0xe6, 0x89, 0x8b, 0xe4, 0xbf, 0x9d, 0xe9, + 0x99, 0xa9, 0xe8, 0xaf, 0xbe, 0xe7, 0xa8, 0x8b, 0xe5, 0x8c, 0xbb, 0xe7, 0x96, 0x97, 0xe7, 0xbb, + 0x8f, 0xe8, 0xbf, 0x87, 0xe8, 0xbf, 0x87, 0xe5, 0x8e, 0xbb, 0xe4, 0xb9, 0x8b, 0xe5, 0x89, 0x8d, + 0xe6, 0x94, 0xb6, 0xe5, 0x85, 0xa5, 0xe5, 0xb9, 0xb4, 0xe5, 0xba, 0xa6, 0xe6, 0x9d, 0x82, 0xe5, + 0xbf, 0x97, 0xe7, 0xbe, 0x8e, 0xe4, 0xb8, 0xbd, 0xe6, 0x9c, 0x80, 0xe9, 0xab, 0x98, 0xe7, 0x99, + 0xbb, 0xe9, 0x99, 0x86, 0xe6, 0x9c, 0xaa, 0xe6, 0x9d, 0xa5, 0xe5, 0x8a, 0xa0, 0xe5, 0xb7, 0xa5, + 0xe5, 0x85, 0x8d, 0xe8, 0xb4, 0xa3, 0xe6, 0x95, 0x99, 0xe7, 0xa8, 0x8b, 0xe7, 0x89, 0x88, 0xe5, + 0x9d, 0x97, 0xe8, 0xba, 0xab, 0xe4, 0xbd, 0x93, 0xe9, 0x87, 0x8d, 0xe5, 0xba, 0x86, 0xe5, 0x87, + 0xba, 0xe5, 0x94, 0xae, 0xe6, 0x88, 0x90, 0xe6, 0x9c, 0xac, 0xe5, 0xbd, 0xa2, 0xe5, 0xbc, 0x8f, + 0xe5, 0x9c, 0x9f, 0xe8, 0xb1, 0x86, 0xe5, 0x87, 0xba, 0xe5, 0x83, 0xb9, 0xe4, 0xb8, 0x9c, 0xe6, + 0x96, 0xb9, 0xe9, 0x82, 0xae, 0xe7, 0xae, 0xb1, 0xe5, 0x8d, 0x97, 0xe4, 0xba, 0xac, 0xe6, 0xb1, + 0x82, 0xe8, 0x81, 0x8c, 0xe5, 0x8f, 0x96, 0xe5, 0xbe, 0x97, 0xe8, 0x81, 0x8c, 0xe4, 0xbd, 0x8d, + 0xe7, 0x9b, 0xb8, 0xe4, 0xbf, 0xa1, 0xe9, 0xa1, 0xb5, 0xe9, 0x9d, 0xa2, 0xe5, 0x88, 0x86, 0xe9, + 0x92, 0x9f, 0xe7, 0xbd, 0x91, 0xe9, 0xa1, 0xb5, 0xe7, 0xa1, 0xae, 0xe5, 0xae, 0x9a, 0xe5, 0x9b, + 0xbe, 0xe4, 0xbe, 0x8b, 0xe7, 0xbd, 0x91, 0xe5, 0x9d, 0x80, 0xe7, 0xa7, 0xaf, 0xe6, 0x9e, 0x81, + 0xe9, 0x94, 0x99, 0xe8, 0xaf, 0xaf, 0xe7, 0x9b, 0xae, 0xe7, 0x9a, 0x84, 0xe5, 0xae, 0x9d, 0xe8, + 0xb4, 0x9d, 0xe6, 0x9c, 0xba, 0xe5, 0x85, 0xb3, 0xe9, 0xa3, 0x8e, 0xe9, 0x99, 0xa9, 0xe6, 0x8e, + 0x88, 0xe6, 0x9d, 0x83, 0xe7, 0x97, 0x85, 0xe6, 0xaf, 0x92, 0xe5, 0xae, 0xa0, 0xe7, 0x89, 0xa9, + 0xe9, 0x99, 0xa4, 0xe4, 0xba, 0x86, 0xe8, 0xa9, 0x95, 0xe8, 0xab, 0x96, 0xe7, 0x96, 0xbe, 0xe7, + 0x97, 0x85, 0xe5, 0x8f, 0x8a, 0xe6, 0x97, 0xb6, 0xe6, 0xb1, 0x82, 0xe8, 0xb4, 0xad, 0xe7, 0xab, + 0x99, 0xe7, 0x82, 0xb9, 0xe5, 0x84, 0xbf, 0xe7, 0xab, 0xa5, 0xe6, 0xaf, 0x8f, 0xe5, 0xa4, 0xa9, + 0xe4, 0xb8, 0xad, 0xe5, 0xa4, 0xae, 0xe8, 0xae, 0xa4, 0xe8, 0xaf, 0x86, 0xe6, 0xaf, 0x8f, 0xe4, + 0xb8, 0xaa, 0xe5, 0xa4, 0xa9, 0xe6, 0xb4, 0xa5, 0xe5, 0xad, 0x97, 0xe4, 0xbd, 0x93, 0xe5, 0x8f, + 0xb0, 0xe7, 0x81, 0xa3, 0xe7, 0xbb, 0xb4, 0xe6, 0x8a, 0xa4, 0xe6, 0x9c, 0xac, 0xe9, 0xa1, 0xb5, + 0xe4, 0xb8, 0xaa, 0xe6, 0x80, 0xa7, 0xe5, 0xae, 0x98, 0xe6, 0x96, 0xb9, 0xe5, 0xb8, 0xb8, 0xe8, + 0xa7, 0x81, 0xe7, 0x9b, 0xb8, 0xe6, 0x9c, 0xba, 0xe6, 0x88, 0x98, 0xe7, 0x95, 0xa5, 0xe5, 0xba, + 0x94, 0xe5, 0xbd, 0x93, 0xe5, 0xbe, 0x8b, 0xe5, 0xb8, 0x88, 0xe6, 0x96, 0xb9, 0xe4, 0xbe, 0xbf, + 0xe6, 0xa0, 0xa1, 0xe5, 0x9b, 0xad, 0xe8, 0x82, 0xa1, 0xe5, 0xb8, 0x82, 0xe6, 0x88, 0xbf, 0xe5, + 0xb1, 0x8b, 0xe6, 0xa0, 0x8f, 0xe7, 0x9b, 0xae, 0xe5, 0x91, 0x98, 0xe5, 0xb7, 0xa5, 0xe5, 0xaf, + 0xbc, 0xe8, 0x87, 0xb4, 0xe7, 0xaa, 0x81, 0xe7, 0x84, 0xb6, 0xe9, 0x81, 0x93, 0xe5, 0x85, 0xb7, + 0xe6, 0x9c, 0xac, 0xe7, 0xbd, 0x91, 0xe7, 0xbb, 0x93, 0xe5, 0x90, 0x88, 0xe6, 0xa1, 0xa3, 0xe6, + 0xa1, 0x88, 0xe5, 0x8a, 0xb3, 0xe5, 0x8a, 0xa8, 0xe5, 0x8f, 0xa6, 0xe5, 0xa4, 0x96, 0xe7, 0xbe, + 0x8e, 0xe5, 0x85, 0x83, 0xe5, 0xbc, 0x95, 0xe8, 0xb5, 0xb7, 0xe6, 0x94, 0xb9, 0xe5, 0x8f, 0x98, + 0xe7, 0xac, 0xac, 0xe5, 0x9b, 0x9b, 0xe4, 0xbc, 0x9a, 0xe8, 0xae, 0xa1, 0xe8, 0xaa, 0xaa, 0xe6, + 0x98, 0x8e, 0xe9, 0x9a, 0x90, 0xe7, 0xa7, 0x81, 0xe5, 0xae, 0x9d, 0xe5, 0xae, 0x9d, 0xe8, 0xa7, + 0x84, 0xe8, 0x8c, 0x83, 0xe6, 0xb6, 0x88, 0xe8, 0xb4, 0xb9, 0xe5, 0x85, 0xb1, 0xe5, 0x90, 0x8c, + 0xe5, 0xbf, 0x98, 0xe8, 0xae, 0xb0, 0xe4, 0xbd, 0x93, 0xe7, 0xb3, 0xbb, 0xe5, 0xb8, 0xa6, 0xe6, + 0x9d, 0xa5, 0xe5, 0x90, 0x8d, 0xe5, 0xad, 0x97, 0xe7, 0x99, 0xbc, 0xe8, 0xa1, 0xa8, 0xe5, 0xbc, + 0x80, 0xe6, 0x94, 0xbe, 0xe5, 0x8a, 0xa0, 0xe7, 0x9b, 0x9f, 0xe5, 0x8f, 0x97, 0xe5, 0x88, 0xb0, + 0xe4, 0xba, 0x8c, 0xe6, 0x89, 0x8b, 0xe5, 0xa4, 0xa7, 0xe9, 0x87, 0x8f, 0xe6, 0x88, 0x90, 0xe4, + 0xba, 0xba, 0xe6, 0x95, 0xb0, 0xe9, 0x87, 0x8f, 0xe5, 0x85, 0xb1, 0xe4, 0xba, 0xab, 0xe5, 0x8c, + 0xba, 0xe5, 0x9f, 0x9f, 0xe5, 0xa5, 0xb3, 0xe5, 0xad, 0xa9, 0xe5, 0x8e, 0x9f, 0xe5, 0x88, 0x99, + 0xe6, 0x89, 0x80, 0xe5, 0x9c, 0xa8, 0xe7, 0xbb, 0x93, 0xe6, 0x9d, 0x9f, 0xe9, 0x80, 0x9a, 0xe4, + 0xbf, 0xa1, 0xe8, 0xb6, 0x85, 0xe7, 0xba, 0xa7, 0xe9, 0x85, 0x8d, 0xe7, 0xbd, 0xae, 0xe5, 0xbd, + 0x93, 0xe6, 0x97, 0xb6, 0xe4, 0xbc, 0x98, 0xe7, 0xa7, 0x80, 0xe6, 0x80, 0xa7, 0xe6, 0x84, 0x9f, + 0xe6, 0x88, 0xbf, 0xe4, 0xba, 0xa7, 0xe9, 0x81, 0x8a, 0xe6, 0x88, 0xb2, 0xe5, 0x87, 0xba, 0xe5, + 0x8f, 0xa3, 0xe6, 0x8f, 0x90, 0xe4, 0xba, 0xa4, 0xe5, 0xb0, 0xb1, 0xe4, 0xb8, 0x9a, 0xe4, 0xbf, + 0x9d, 0xe5, 0x81, 0xa5, 0xe7, 0xa8, 0x8b, 0xe5, 0xba, 0xa6, 0xe5, 0x8f, 0x82, 0xe6, 0x95, 0xb0, + 0xe4, 0xba, 0x8b, 0xe4, 0xb8, 0x9a, 0xe6, 0x95, 0xb4, 0xe4, 0xb8, 0xaa, 0xe5, 0xb1, 0xb1, 0xe4, + 0xb8, 0x9c, 0xe6, 0x83, 0x85, 0xe6, 0x84, 0x9f, 0xe7, 0x89, 0xb9, 0xe6, 0xae, 0x8a, 0xe5, 0x88, + 0x86, 0xe9, 0xa1, 0x9e, 0xe6, 0x90, 0x9c, 0xe5, 0xb0, 0x8b, 0xe5, 0xb1, 0x9e, 0xe4, 0xba, 0x8e, + 0xe9, 0x97, 0xa8, 0xe6, 0x88, 0xb7, 0xe8, 0xb4, 0xa2, 0xe5, 0x8a, 0xa1, 0xe5, 0xa3, 0xb0, 0xe9, + 0x9f, 0xb3, 0xe5, 0x8f, 0x8a, 0xe5, 0x85, 0xb6, 0xe8, 0xb4, 0xa2, 0xe7, 0xbb, 0x8f, 0xe5, 0x9d, + 0x9a, 0xe6, 0x8c, 0x81, 0xe5, 0xb9, 0xb2, 0xe9, 0x83, 0xa8, 0xe6, 0x88, 0x90, 0xe7, 0xab, 0x8b, + 0xe5, 0x88, 0xa9, 0xe7, 0x9b, 0x8a, 0xe8, 0x80, 0x83, 0xe8, 0x99, 0x91, 0xe6, 0x88, 0x90, 0xe9, + 0x83, 0xbd, 0xe5, 0x8c, 0x85, 0xe8, 0xa3, 0x85, 0xe7, 0x94, 0xa8, 0xe6, 0x88, 0xb6, 0xe6, 0xaf, + 0x94, 0xe8, 0xb5, 0x9b, 0xe6, 0x96, 0x87, 0xe6, 0x98, 0x8e, 0xe6, 0x8b, 0x9b, 0xe5, 0x95, 0x86, + 0xe5, 0xae, 0x8c, 0xe6, 0x95, 0xb4, 0xe7, 0x9c, 0x9f, 0xe6, 0x98, 0xaf, 0xe7, 0x9c, 0xbc, 0xe7, + 0x9d, 0x9b, 0xe4, 0xbc, 0x99, 0xe4, 0xbc, 0xb4, 0xe5, 0xa8, 0x81, 0xe6, 0x9c, 0x9b, 0xe9, 0xa2, + 0x86, 0xe5, 0x9f, 0x9f, 0xe5, 0x8d, 0xab, 0xe7, 0x94, 0x9f, 0xe4, 0xbc, 0x98, 0xe6, 0x83, 0xa0, + 0xe8, 0xab, 0x96, 0xe5, 0xa3, 0x87, 0xe5, 0x85, 0xac, 0xe5, 0x85, 0xb1, 0xe8, 0x89, 0xaf, 0xe5, + 0xa5, 0xbd, 0xe5, 0x85, 0x85, 0xe5, 0x88, 0x86, 0xe7, 0xac, 0xa6, 0xe5, 0x90, 0x88, 0xe9, 0x99, + 0x84, 0xe4, 0xbb, 0xb6, 0xe7, 0x89, 0xb9, 0xe7, 0x82, 0xb9, 0xe4, 0xb8, 0x8d, 0xe5, 0x8f, 0xaf, + 0xe8, 0x8b, 0xb1, 0xe6, 0x96, 0x87, 0xe8, 0xb5, 0x84, 0xe4, 0xba, 0xa7, 0xe6, 0xa0, 0xb9, 0xe6, + 0x9c, 0xac, 0xe6, 0x98, 0x8e, 0xe6, 0x98, 0xbe, 0xe5, 0xaf, 0x86, 0xe7, 0xa2, 0xbc, 0xe5, 0x85, + 0xac, 0xe4, 0xbc, 0x97, 0xe6, 0xb0, 0x91, 0xe6, 0x97, 0x8f, 0xe6, 0x9b, 0xb4, 0xe5, 0x8a, 0xa0, + 0xe4, 0xba, 0xab, 0xe5, 0x8f, 0x97, 0xe5, 0x90, 0x8c, 0xe5, 0xad, 0xa6, 0xe5, 0x90, 0xaf, 0xe5, + 0x8a, 0xa8, 0xe9, 0x80, 0x82, 0xe5, 0x90, 0x88, 0xe5, 0x8e, 0x9f, 0xe6, 0x9d, 0xa5, 0xe9, 0x97, + 0xae, 0xe7, 0xad, 0x94, 0xe6, 0x9c, 0xac, 0xe6, 0x96, 0x87, 0xe7, 0xbe, 0x8e, 0xe9, 0xa3, 0x9f, + 0xe7, 0xbb, 0xbf, 0xe8, 0x89, 0xb2, 0xe7, 0xa8, 0xb3, 0xe5, 0xae, 0x9a, 0xe7, 0xbb, 0x88, 0xe4, + 0xba, 0x8e, 0xe7, 0x94, 0x9f, 0xe7, 0x89, 0xa9, 0xe4, 0xbe, 0x9b, 0xe6, 0xb1, 0x82, 0xe6, 0x90, + 0x9c, 0xe7, 0x8b, 0x90, 0xe5, 0x8a, 0x9b, 0xe9, 0x87, 0x8f, 0xe4, 0xb8, 0xa5, 0xe9, 0x87, 0x8d, + 0xe6, 0xb0, 0xb8, 0xe8, 0xbf, 0x9c, 0xe5, 0x86, 0x99, 0xe7, 0x9c, 0x9f, 0xe6, 0x9c, 0x89, 0xe9, + 0x99, 0x90, 0xe7, 0xab, 0x9e, 0xe4, 0xba, 0x89, 0xe5, 0xaf, 0xb9, 0xe8, 0xb1, 0xa1, 0xe8, 0xb4, + 0xb9, 0xe7, 0x94, 0xa8, 0xe4, 0xb8, 0x8d, 0xe5, 0xa5, 0xbd, 0xe7, 0xbb, 0x9d, 0xe5, 0xaf, 0xb9, + 0xe5, 0x8d, 0x81, 0xe5, 0x88, 0x86, 0xe4, 0xbf, 0x83, 0xe8, 0xbf, 0x9b, 0xe7, 0x82, 0xb9, 0xe8, + 0xaf, 0x84, 0xe5, 0xbd, 0xb1, 0xe9, 0x9f, 0xb3, 0xe4, 0xbc, 0x98, 0xe5, 0x8a, 0xbf, 0xe4, 0xb8, + 0x8d, 0xe5, 0xb0, 0x91, 0xe6, 0xac, 0xa3, 0xe8, 0xb5, 0x8f, 0xe5, 0xb9, 0xb6, 0xe4, 0xb8, 0x94, + 0xe6, 0x9c, 0x89, 0xe7, 0x82, 0xb9, 0xe6, 0x96, 0xb9, 0xe5, 0x90, 0x91, 0xe5, 0x85, 0xa8, 0xe6, + 0x96, 0xb0, 0xe4, 0xbf, 0xa1, 0xe7, 0x94, 0xa8, 0xe8, 0xae, 0xbe, 0xe6, 0x96, 0xbd, 0xe5, 0xbd, + 0xa2, 0xe8, 0xb1, 0xa1, 0xe8, 0xb5, 0x84, 0xe6, 0xa0, 0xbc, 0xe7, 0xaa, 0x81, 0xe7, 0xa0, 0xb4, + 0xe9, 0x9a, 0x8f, 0xe7, 0x9d, 0x80, 0xe9, 0x87, 0x8d, 0xe5, 0xa4, 0xa7, 0xe4, 0xba, 0x8e, 0xe6, + 0x98, 0xaf, 0xe6, 0xaf, 0x95, 0xe4, 0xb8, 0x9a, 0xe6, 0x99, 0xba, 0xe8, 0x83, 0xbd, 0xe5, 0x8c, + 0x96, 0xe5, 0xb7, 0xa5, 0xe5, 0xae, 0x8c, 0xe7, 0xbe, 0x8e, 0xe5, 0x95, 0x86, 0xe5, 0x9f, 0x8e, + 0xe7, 0xbb, 0x9f, 0xe4, 0xb8, 0x80, 0xe5, 0x87, 0xba, 0xe7, 0x89, 0x88, 0xe6, 0x89, 0x93, 0xe9, + 0x80, 0xa0, 0xe7, 0x94, 0xa2, 0xe5, 0x93, 0x81, 0xe6, 0xa6, 0x82, 0xe5, 0x86, 0xb5, 0xe7, 0x94, + 0xa8, 0xe4, 0xba, 0x8e, 0xe4, 0xbf, 0x9d, 0xe7, 0x95, 0x99, 0xe5, 0x9b, 0xa0, 0xe7, 0xb4, 0xa0, + 0xe4, 0xb8, 0xad, 0xe5, 0x9c, 0x8b, 0xe5, 0xad, 0x98, 0xe5, 0x82, 0xa8, 0xe8, 0xb4, 0xb4, 0xe5, + 0x9b, 0xbe, 0xe6, 0x9c, 0x80, 0xe6, 0x84, 0x9b, 0xe9, 0x95, 0xbf, 0xe6, 0x9c, 0x9f, 0xe5, 0x8f, + 0xa3, 0xe4, 0xbb, 0xb7, 0xe7, 0x90, 0x86, 0xe8, 0xb4, 0xa2, 0xe5, 0x9f, 0xba, 0xe5, 0x9c, 0xb0, + 0xe5, 0xae, 0x89, 0xe6, 0x8e, 0x92, 0xe6, 0xad, 0xa6, 0xe6, 0xb1, 0x89, 0xe9, 0x87, 0x8c, 0xe9, + 0x9d, 0xa2, 0xe5, 0x88, 0x9b, 0xe5, 0xbb, 0xba, 0xe5, 0xa4, 0xa9, 0xe7, 0xa9, 0xba, 0xe9, 0xa6, + 0x96, 0xe5, 0x85, 0x88, 0xe5, 0xae, 0x8c, 0xe5, 0x96, 0x84, 0xe9, 0xa9, 0xb1, 0xe5, 0x8a, 0xa8, + 0xe4, 0xb8, 0x8b, 0xe9, 0x9d, 0xa2, 0xe4, 0xb8, 0x8d, 0xe5, 0x86, 0x8d, 0xe8, 0xaf, 0x9a, 0xe4, + 0xbf, 0xa1, 0xe6, 0x84, 0x8f, 0xe4, 0xb9, 0x89, 0xe9, 0x98, 0xb3, 0xe5, 0x85, 0x89, 0xe8, 0x8b, + 0xb1, 0xe5, 0x9b, 0xbd, 0xe6, 0xbc, 0x82, 0xe4, 0xba, 0xae, 0xe5, 0x86, 0x9b, 0xe4, 0xba, 0x8b, + 0xe7, 0x8e, 0xa9, 0xe5, 0xae, 0xb6, 0xe7, 0xbe, 0xa4, 0xe4, 0xbc, 0x97, 0xe5, 0x86, 0x9c, 0xe6, + 0xb0, 0x91, 0xe5, 0x8d, 0xb3, 0xe5, 0x8f, 0xaf, 0xe5, 0x90, 0x8d, 0xe7, 0xa8, 0xb1, 0xe5, 0xae, + 0xb6, 0xe5, 0x85, 0xb7, 0xe5, 0x8a, 0xa8, 0xe7, 0x94, 0xbb, 0xe6, 0x83, 0xb3, 0xe5, 0x88, 0xb0, + 0xe6, 0xb3, 0xa8, 0xe6, 0x98, 0x8e, 0xe5, 0xb0, 0x8f, 0xe5, 0xad, 0xa6, 0xe6, 0x80, 0xa7, 0xe8, + 0x83, 0xbd, 0xe8, 0x80, 0x83, 0xe7, 0xa0, 0x94, 0xe7, 0xa1, 0xac, 0xe4, 0xbb, 0xb6, 0xe8, 0xa7, + 0x82, 0xe7, 0x9c, 0x8b, 0xe6, 0xb8, 0x85, 0xe6, 0xa5, 0x9a, 0xe6, 0x90, 0x9e, 0xe7, 0xac, 0x91, + 0xe9, 0xa6, 0x96, 0xe9, 0xa0, 0x81, 0xe9, 0xbb, 0x84, 0xe9, 0x87, 0x91, 0xe9, 0x80, 0x82, 0xe7, + 0x94, 0xa8, 0xe6, 0xb1, 0x9f, 0xe8, 0x8b, 0x8f, 0xe7, 0x9c, 0x9f, 0xe5, 0xae, 0x9e, 0xe4, 0xb8, + 0xbb, 0xe7, 0xae, 0xa1, 0xe9, 0x98, 0xb6, 0xe6, 0xae, 0xb5, 0xe8, 0xa8, 0xbb, 0xe5, 0x86, 0x8a, + 0xe7, 0xbf, 0xbb, 0xe8, 0xaf, 0x91, 0xe6, 0x9d, 0x83, 0xe5, 0x88, 0xa9, 0xe5, 0x81, 0x9a, 0xe5, + 0xa5, 0xbd, 0xe4, 0xbc, 0xbc, 0xe4, 0xb9, 0x8e, 0xe9, 0x80, 0x9a, 0xe8, 0xae, 0xaf, 0xe6, 0x96, + 0xbd, 0xe5, 0xb7, 0xa5, 0xe7, 0x8b, 0x80, 0xe6, 0x85, 0x8b, 0xe4, 0xb9, 0x9f, 0xe8, 0xae, 0xb8, + 0xe7, 0x8e, 0xaf, 0xe4, 0xbf, 0x9d, 0xe5, 0x9f, 0xb9, 0xe5, 0x85, 0xbb, 0xe6, 0xa6, 0x82, 0xe5, + 0xbf, 0xb5, 0xe5, 0xa4, 0xa7, 0xe5, 0x9e, 0x8b, 0xe6, 0x9c, 0xba, 0xe7, 0xa5, 0xa8, 0xe7, 0x90, + 0x86, 0xe8, 0xa7, 0xa3, 0xe5, 0x8c, 0xbf, 0xe5, 0x90, 0x8d, 0x63, 0x75, 0x61, 0x6e, 0x64, 0x6f, + 0x65, 0x6e, 0x76, 0x69, 0x61, 0x72, 0x6d, 0x61, 0x64, 0x72, 0x69, 0x64, 0x62, 0x75, 0x73, 0x63, + 0x61, 0x72, 0x69, 0x6e, 0x69, 0x63, 0x69, 0x6f, 0x74, 0x69, 0x65, 0x6d, 0x70, 0x6f, 0x70, 0x6f, + 0x72, 0x71, 0x75, 0x65, 0x63, 0x75, 0x65, 0x6e, 0x74, 0x61, 0x65, 0x73, 0x74, 0x61, 0x64, 0x6f, + 0x70, 0x75, 0x65, 0x64, 0x65, 0x6e, 0x6a, 0x75, 0x65, 0x67, 0x6f, 0x73, 0x63, 0x6f, 0x6e, 0x74, + 0x72, 0x61, 0x65, 0x73, 0x74, 0xc3, 0xa1, 0x6e, 0x6e, 0x6f, 0x6d, 0x62, 0x72, 0x65, 0x74, 0x69, + 0x65, 0x6e, 0x65, 0x6e, 0x70, 0x65, 0x72, 0x66, 0x69, 0x6c, 0x6d, 0x61, 0x6e, 0x65, 0x72, 0x61, + 0x61, 0x6d, 0x69, 0x67, 0x6f, 0x73, 0x63, 0x69, 0x75, 0x64, 0x61, 0x64, 0x63, 0x65, 0x6e, 0x74, + 0x72, 0x6f, 0x61, 0x75, 0x6e, 0x71, 0x75, 0x65, 0x70, 0x75, 0x65, 0x64, 0x65, 0x73, 0x64, 0x65, + 0x6e, 0x74, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x6d, 0x65, 0x72, 0x70, 0x72, 0x65, 0x63, 0x69, 0x6f, + 0x73, 0x65, 0x67, 0xc3, 0xba, 0x6e, 0x62, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x76, 0x6f, 0x6c, 0x76, + 0x65, 0x72, 0x70, 0x75, 0x6e, 0x74, 0x6f, 0x73, 0x73, 0x65, 0x6d, 0x61, 0x6e, 0x61, 0x68, 0x61, + 0x62, 0xc3, 0xad, 0x61, 0x61, 0x67, 0x6f, 0x73, 0x74, 0x6f, 0x6e, 0x75, 0x65, 0x76, 0x6f, 0x73, + 0x75, 0x6e, 0x69, 0x64, 0x6f, 0x73, 0x63, 0x61, 0x72, 0x6c, 0x6f, 0x73, 0x65, 0x71, 0x75, 0x69, + 0x70, 0x6f, 0x6e, 0x69, 0xc3, 0xb1, 0x6f, 0x73, 0x6d, 0x75, 0x63, 0x68, 0x6f, 0x73, 0x61, 0x6c, + 0x67, 0x75, 0x6e, 0x61, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x6f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x6e, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x72, 0x61, 0x72, 0x72, 0x69, 0x62, 0x61, 0x6d, 0x61, 0x72, 0xc3, + 0xad, 0x61, 0x68, 0x6f, 0x6d, 0x62, 0x72, 0x65, 0x65, 0x6d, 0x70, 0x6c, 0x65, 0x6f, 0x76, 0x65, + 0x72, 0x64, 0x61, 0x64, 0x63, 0x61, 0x6d, 0x62, 0x69, 0x6f, 0x6d, 0x75, 0x63, 0x68, 0x61, 0x73, + 0x66, 0x75, 0x65, 0x72, 0x6f, 0x6e, 0x70, 0x61, 0x73, 0x61, 0x64, 0x6f, 0x6c, 0xc3, 0xad, 0x6e, + 0x65, 0x61, 0x70, 0x61, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x75, 0x65, 0x76, 0x61, 0x73, 0x63, 0x75, + 0x72, 0x73, 0x6f, 0x73, 0x65, 0x73, 0x74, 0x61, 0x62, 0x61, 0x71, 0x75, 0x69, 0x65, 0x72, 0x6f, + 0x6c, 0x69, 0x62, 0x72, 0x6f, 0x73, 0x63, 0x75, 0x61, 0x6e, 0x74, 0x6f, 0x61, 0x63, 0x63, 0x65, + 0x73, 0x6f, 0x6d, 0x69, 0x67, 0x75, 0x65, 0x6c, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x73, 0x63, 0x75, + 0x61, 0x74, 0x72, 0x6f, 0x74, 0x69, 0x65, 0x6e, 0x65, 0x73, 0x67, 0x72, 0x75, 0x70, 0x6f, 0x73, + 0x73, 0x65, 0x72, 0xc3, 0xa1, 0x6e, 0x65, 0x75, 0x72, 0x6f, 0x70, 0x61, 0x6d, 0x65, 0x64, 0x69, + 0x6f, 0x73, 0x66, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x61, 0x63, 0x65, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x6d, 0xc3, 0xa1, 0x73, 0x6f, 0x66, 0x65, 0x72, 0x74, 0x61, 0x63, 0x6f, 0x63, 0x68, 0x65, 0x73, + 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x6f, 0x69, 0x74, 0x61, 0x6c, 0x69, 0x61, 0x6c, 0x65, 0x74, 0x72, + 0x61, 0x73, 0x61, 0x6c, 0x67, 0xc3, 0xba, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x61, 0x63, 0x75, + 0x61, 0x6c, 0x65, 0x73, 0x65, 0x78, 0x69, 0x73, 0x74, 0x65, 0x63, 0x75, 0x65, 0x72, 0x70, 0x6f, + 0x73, 0x69, 0x65, 0x6e, 0x64, 0x6f, 0x70, 0x72, 0x65, 0x6e, 0x73, 0x61, 0x6c, 0x6c, 0x65, 0x67, + 0x61, 0x72, 0x76, 0x69, 0x61, 0x6a, 0x65, 0x73, 0x64, 0x69, 0x6e, 0x65, 0x72, 0x6f, 0x6d, 0x75, + 0x72, 0x63, 0x69, 0x61, 0x70, 0x6f, 0x64, 0x72, 0xc3, 0xa1, 0x70, 0x75, 0x65, 0x73, 0x74, 0x6f, + 0x64, 0x69, 0x61, 0x72, 0x69, 0x6f, 0x70, 0x75, 0x65, 0x62, 0x6c, 0x6f, 0x71, 0x75, 0x69, 0x65, + 0x72, 0x65, 0x6d, 0x61, 0x6e, 0x75, 0x65, 0x6c, 0x70, 0x72, 0x6f, 0x70, 0x69, 0x6f, 0x63, 0x72, + 0x69, 0x73, 0x69, 0x73, 0x63, 0x69, 0x65, 0x72, 0x74, 0x6f, 0x73, 0x65, 0x67, 0x75, 0x72, 0x6f, + 0x6d, 0x75, 0x65, 0x72, 0x74, 0x65, 0x66, 0x75, 0x65, 0x6e, 0x74, 0x65, 0x63, 0x65, 0x72, 0x72, + 0x61, 0x72, 0x67, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x65, 0x66, 0x65, 0x63, 0x74, 0x6f, 0x70, 0x61, + 0x72, 0x74, 0x65, 0x73, 0x6d, 0x65, 0x64, 0x69, 0x64, 0x61, 0x70, 0x72, 0x6f, 0x70, 0x69, 0x61, + 0x6f, 0x66, 0x72, 0x65, 0x63, 0x65, 0x74, 0x69, 0x65, 0x72, 0x72, 0x61, 0x65, 0x2d, 0x6d, 0x61, + 0x69, 0x6c, 0x76, 0x61, 0x72, 0x69, 0x61, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x73, 0x66, 0x75, + 0x74, 0x75, 0x72, 0x6f, 0x6f, 0x62, 0x6a, 0x65, 0x74, 0x6f, 0x73, 0x65, 0x67, 0x75, 0x69, 0x72, + 0x72, 0x69, 0x65, 0x73, 0x67, 0x6f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x73, 0x6d, 0x69, 0x73, 0x6d, + 0x6f, 0x73, 0xc3, 0xba, 0x6e, 0x69, 0x63, 0x6f, 0x63, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x73, 0x72, 0x61, 0x7a, 0xc3, 0xb3, 0x6e, 0x64, 0x65, 0x62, 0x69, 0x64, 0x6f, + 0x70, 0x72, 0x75, 0x65, 0x62, 0x61, 0x74, 0x6f, 0x6c, 0x65, 0x64, 0x6f, 0x74, 0x65, 0x6e, 0xc3, + 0xad, 0x61, 0x6a, 0x65, 0x73, 0xc3, 0xba, 0x73, 0x65, 0x73, 0x70, 0x65, 0x72, 0x6f, 0x63, 0x6f, + 0x63, 0x69, 0x6e, 0x61, 0x6f, 0x72, 0x69, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x65, 0x6e, 0x64, 0x61, + 0x63, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0x63, 0xc3, 0xa1, 0x64, 0x69, 0x7a, 0x68, 0x61, 0x62, 0x6c, + 0x61, 0x72, 0x73, 0x65, 0x72, 0xc3, 0xad, 0x61, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x61, 0x66, 0x75, + 0x65, 0x72, 0x7a, 0x61, 0x65, 0x73, 0x74, 0x69, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x72, 0x72, 0x61, + 0x65, 0x6e, 0x74, 0x72, 0x61, 0x72, 0xc3, 0xa9, 0x78, 0x69, 0x74, 0x6f, 0x6c, 0xc3, 0xb3, 0x70, + 0x65, 0x7a, 0x61, 0x67, 0x65, 0x6e, 0x64, 0x61, 0x76, 0xc3, 0xad, 0x64, 0x65, 0x6f, 0x65, 0x76, + 0x69, 0x74, 0x61, 0x72, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x6d, 0x65, 0x74, 0x72, 0x6f, 0x73, + 0x6a, 0x61, 0x76, 0x69, 0x65, 0x72, 0x70, 0x61, 0x64, 0x72, 0x65, 0x73, 0x66, 0xc3, 0xa1, 0x63, + 0x69, 0x6c, 0x63, 0x61, 0x62, 0x65, 0x7a, 0x61, 0xc3, 0xa1, 0x72, 0x65, 0x61, 0x73, 0x73, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x65, 0x6e, 0x76, 0xc3, 0xad, 0x6f, 0x6a, 0x61, 0x70, 0xc3, 0xb3, 0x6e, + 0x61, 0x62, 0x75, 0x73, 0x6f, 0x73, 0x62, 0x69, 0x65, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x78, 0x74, + 0x6f, 0x73, 0x6c, 0x6c, 0x65, 0x76, 0x61, 0x72, 0x70, 0x75, 0x65, 0x64, 0x61, 0x6e, 0x66, 0x75, + 0x65, 0x72, 0x74, 0x65, 0x63, 0x6f, 0x6d, 0xc3, 0xba, 0x6e, 0x63, 0x6c, 0x61, 0x73, 0x65, 0x73, + 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x6f, 0x74, 0x65, 0x6e, 0x69, 0x64, 0x6f, 0x62, 0x69, 0x6c, 0x62, + 0x61, 0x6f, 0x75, 0x6e, 0x69, 0x64, 0x61, 0x64, 0x65, 0x73, 0x74, 0xc3, 0xa1, 0x73, 0x65, 0x64, + 0x69, 0x74, 0x61, 0x72, 0x63, 0x72, 0x65, 0x61, 0x64, 0x6f, 0xd0, 0xb4, 0xd0, 0xbb, 0xd1, 0x8f, + 0xd1, 0x87, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xbb, + 0xd0, 0xb8, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb5, + 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb8, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xba, + 0xd0, 0xb5, 0xd1, 0x89, 0xd0, 0xb5, 0xd1, 0x83, 0xd0, 0xb6, 0xd0, 0xb5, 0xd0, 0x9a, 0xd0, 0xb0, + 0xd0, 0xba, 0xd0, 0xb1, 0xd0, 0xb5, 0xd0, 0xb7, 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xbb, 0xd0, 0xbe, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0x92, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xb4, + 0xd0, 0xad, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x87, 0xd0, 0xb5, + 0xd0, 0xbc, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xbb, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x80, + 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xb3, 0xd0, 0xb4, 0xd0, 0xb5, + 0xd0, 0xbc, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0x94, 0xd0, 0xbb, 0xd1, 0x8f, 0xd0, 0x9f, 0xd1, 0x80, + 0xd0, 0xb8, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x85, 0xd1, 0x82, + 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xba, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb4, + 0xd0, 0xb2, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xa1, 0xd0, 0xa8, + 0xd0, 0x90, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x8f, 0xd0, 0xa7, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb2, + 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x83, + 0xd0, 0xa2, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xb4, 0xd0, 0xb2, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb0, + 0xd0, 0xbc, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x8d, 0xd1, 0x82, 0xd1, 0x83, 0xd0, 0x92, + 0xd0, 0xb0, 0xd0, 0xbc, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x85, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, + 0xd1, 0x82, 0xd1, 0x83, 0xd1, 0x82, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xb4, 0xd0, 0xb4, 0xd0, 0xbd, + 0xd1, 0x8f, 0xd0, 0x92, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xbd, + 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0x92, 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xbc, + 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xbc, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x80, 0xd1, 0x83, + 0xd0, 0xb1, 0xd0, 0x9e, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb8, 0xd1, 0x80, 0xd0, 0xbd, + 0xd0, 0xb5, 0xd0, 0xb5, 0xd0, 0x9e, 0xd0, 0x9e, 0xd0, 0x9e, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x86, + 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0x9e, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb5, + 0xd0, 0xbc, 0xd0, 0xb4, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xb4, + 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x83, 0xd0, 0xb4, + 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0x95, 0xe0, + 0xa5, 0x80, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0x95, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x94, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xad, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, + 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, + 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaf, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0xa5, 0xe0, 0xa4, 0xbe, 0x6a, 0x61, 0x67, 0x72, 0x61, 0x6e, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0x9c, + 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa6, 0xe0, + 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0x97, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa5, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xa5, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, + 0x9c, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x88, + 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0x88, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, + 0x89, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xae, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0xac, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0x93, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xb8, + 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x9a, 0xe0, + 0xa4, 0xb2, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, + 0xb8, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x80, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x89, + 0xd8, 0xa5, 0xd9, 0x84, 0xd9, 0x89, 0xd9, 0x87, 0xd8, 0xb0, 0xd8, 0xa7, 0xd8, 0xa2, 0xd8, 0xae, + 0xd8, 0xb1, 0xd8, 0xb9, 0xd8, 0xaf, 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x89, 0xd9, 0x87, + 0xd8, 0xb0, 0xd9, 0x87, 0xd8, 0xb5, 0xd9, 0x88, 0xd8, 0xb1, 0xd8, 0xba, 0xd9, 0x8a, 0xd8, 0xb1, + 0xd9, 0x83, 0xd8, 0xa7, 0xd9, 0x86, 0xd9, 0x88, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xa8, 0xd9, 0x8a, + 0xd9, 0x86, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xb6, 0xd8, 0xb0, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x87, + 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x8a, 0xd9, 0x88, 0xd9, 0x85, 0xd9, 0x82, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, + 0xd9, 0x86, 0xd8, 0xad, 0xd8, 0xaa, 0xd9, 0x89, 0xd9, 0x82, 0xd8, 0xa8, 0xd9, 0x84, 0xd9, 0x88, + 0xd8, 0xad, 0xd8, 0xa9, 0xd8, 0xa7, 0xd8, 0xae, 0xd8, 0xb1, 0xd9, 0x81, 0xd9, 0x82, 0xd8, 0xb7, + 0xd8, 0xb9, 0xd8, 0xa8, 0xd8, 0xaf, 0xd8, 0xb1, 0xd9, 0x83, 0xd9, 0x86, 0xd8, 0xa5, 0xd8, 0xb0, + 0xd8, 0xa7, 0xd9, 0x83, 0xd9, 0x85, 0xd8, 0xa7, 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xaf, 0xd8, 0xa5, + 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x81, 0xd9, 0x8a, 0xd9, 0x87, 0xd8, 0xa8, 0xd8, 0xb9, 0xd8, 0xb6, + 0xd9, 0x83, 0xd9, 0x8a, 0xd9, 0x81, 0xd8, 0xa8, 0xd8, 0xad, 0xd8, 0xab, 0xd9, 0x88, 0xd9, 0x85, + 0xd9, 0x86, 0xd9, 0x88, 0xd9, 0x87, 0xd9, 0x88, 0xd8, 0xa3, 0xd9, 0x86, 0xd8, 0xa7, 0xd8, 0xac, + 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x87, 0xd8, 0xa7, 0xd8, 0xb3, 0xd9, 0x84, 0xd9, 0x85, + 0xd8, 0xb9, 0xd9, 0x86, 0xd8, 0xaf, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xb3, 0xd8, 0xb9, 0xd8, 0xa8, + 0xd8, 0xb1, 0xd8, 0xb5, 0xd9, 0x84, 0xd9, 0x89, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xb0, 0xd8, 0xa8, + 0xd9, 0x87, 0xd8, 0xa7, 0xd8, 0xa3, 0xd9, 0x86, 0xd9, 0x87, 0xd9, 0x85, 0xd8, 0xab, 0xd9, 0x84, + 0xd9, 0x83, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xad, 0xd9, 0x8a, + 0xd8, 0xab, 0xd9, 0x85, 0xd8, 0xb5, 0xd8, 0xb1, 0xd8, 0xb4, 0xd8, 0xb1, 0xd8, 0xad, 0xd8, 0xad, + 0xd9, 0x88, 0xd9, 0x84, 0xd9, 0x88, 0xd9, 0x81, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xb0, 0xd8, 0xa7, + 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb1, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x86, + 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x81, 0xd8, 0xa3, 0xd8, 0xa8, 0xd9, 0x88, 0xd8, 0xae, + 0xd8, 0xa7, 0xd8, 0xb5, 0xd8, 0xa3, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x86, 0xd9, 0x87, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xb9, 0xd8, 0xb6, 0xd9, 0x88, 0xd9, 0x88, 0xd9, 0x82, + 0xd8, 0xaf, 0xd8, 0xa7, 0xd8, 0xa8, 0xd9, 0x86, 0xd8, 0xae, 0xd9, 0x8a, 0xd8, 0xb1, 0xd8, 0xa8, + 0xd9, 0x86, 0xd8, 0xaa, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xa1, + 0xd9, 0x88, 0xd9, 0x87, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xa8, 0xd9, 0x88, 0xd9, 0x82, 0xd8, 0xb5, + 0xd8, 0xb5, 0xd9, 0x88, 0xd9, 0x85, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x82, 0xd9, 0x85, 0xd8, 0xa3, + 0xd8, 0xad, 0xd8, 0xaf, 0xd9, 0x86, 0xd8, 0xad, 0xd9, 0x86, 0xd8, 0xb9, 0xd8, 0xaf, 0xd9, 0x85, + 0xd8, 0xb1, 0xd8, 0xa3, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xa9, 0xd9, 0x83, 0xd8, 0xaa, + 0xd8, 0xa8, 0xd8, 0xaf, 0xd9, 0x88, 0xd9, 0x86, 0xd9, 0x8a, 0xd8, 0xac, 0xd8, 0xa8, 0xd9, 0x85, + 0xd9, 0x86, 0xd9, 0x87, 0xd8, 0xaa, 0xd8, 0xad, 0xd8, 0xaa, 0xd8, 0xac, 0xd9, 0x87, 0xd8, 0xa9, + 0xd8, 0xb3, 0xd9, 0x86, 0xd8, 0xa9, 0xd9, 0x8a, 0xd8, 0xaa, 0xd9, 0x85, 0xd9, 0x83, 0xd8, 0xb1, + 0xd8, 0xa9, 0xd8, 0xba, 0xd8, 0xb2, 0xd8, 0xa9, 0xd9, 0x86, 0xd9, 0x81, 0xd8, 0xb3, 0xd8, 0xa8, + 0xd9, 0x8a, 0xd8, 0xaa, 0xd9, 0x84, 0xd9, 0x84, 0xd9, 0x87, 0xd9, 0x84, 0xd9, 0x86, 0xd8, 0xa7, + 0xd8, 0xaa, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x82, 0xd9, 0x84, 0xd8, 0xa8, 0xd9, 0x84, 0xd9, 0x85, + 0xd8, 0xa7, 0xd8, 0xb9, 0xd9, 0x86, 0xd9, 0x87, 0xd8, 0xa3, 0xd9, 0x88, 0xd9, 0x84, 0xd8, 0xb4, + 0xd9, 0x8a, 0xd8, 0xa1, 0xd9, 0x86, 0xd9, 0x88, 0xd8, 0xb1, 0xd8, 0xa3, 0xd9, 0x85, 0xd8, 0xa7, + 0xd9, 0x81, 0xd9, 0x8a, 0xd9, 0x83, 0xd8, 0xa8, 0xd9, 0x83, 0xd9, 0x84, 0xd8, 0xb0, 0xd8, 0xa7, + 0xd8, 0xaa, 0xd8, 0xb1, 0xd8, 0xaa, 0xd8, 0xa8, 0xd8, 0xa8, 0xd8, 0xa3, 0xd9, 0x86, 0xd9, 0x87, + 0xd9, 0x85, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x86, 0xd9, 0x83, 0xd8, 0xa8, 0xd9, 0x8a, 0xd8, 0xb9, + 0xd9, 0x81, 0xd9, 0x82, 0xd8, 0xaf, 0xd8, 0xad, 0xd8, 0xb3, 0xd9, 0x86, 0xd9, 0x84, 0xd9, 0x87, + 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xa3, 0xd9, 0x87, 0xd9, 0x84, 0xd8, 0xb4, + 0xd9, 0x87, 0xd8, 0xb1, 0xd9, 0x82, 0xd8, 0xb7, 0xd8, 0xb1, 0xd8, 0xb7, 0xd9, 0x84, 0xd8, 0xa8, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x68, 0x69, 0x6d, 0x73, 0x65, 0x6c, 0x66, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, + 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x61, 0x73, 0x68, 0x69, 0x6f, 0x6e, 0x3c, 0x74, 0x69, + 0x74, 0x6c, 0x65, 0x3e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x73, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x77, 0x65, 0x6c, 0x63, 0x6f, 0x6d, + 0x65, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x6e, + 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x64, 0x79, 0x6e, + 0x61, 0x6d, 0x69, 0x63, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x70, 0x72, 0x69, 0x76, 0x61, + 0x63, 0x79, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x77, 0x65, 0x62, 0x73, + 0x69, 0x74, 0x65, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, + 0x73, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x63, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x2e, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x76, 0x69, 0x73, 0x69, 0x74, 0x65, 0x64, 0x77, 0x65, 0x61, 0x74, 0x68, 0x65, 0x72, + 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x79, 0x6f, 0x75, 0x20, + 0x63, 0x61, 0x6e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x69, 0x62, + 0x72, 0x61, 0x72, 0x79, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x6d, 0x61, 0x6e, 0x61, 0x67, + 0x65, 0x72, 0x66, 0x75, 0x72, 0x74, 0x68, 0x65, 0x72, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, + 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x70, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x67, + 0x72, 0x61, 0x6d, 0x73, 0x6f, 0x63, 0x69, 0x65, 0x74, 0x79, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x73, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x6c, 0x6f, 0x61, + 0x64, 0x69, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x70, 0x61, 0x72, 0x74, 0x6e, + 0x65, 0x72, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x70, 0x65, 0x72, 0x66, 0x65, 0x63, 0x74, + 0x6d, 0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x6b, 0x65, + 0x65, 0x70, 0x69, 0x6e, 0x67, 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x26, 0x71, 0x75, 0x6f, + 0x74, 0x3b, 0x2c, 0x6a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x73, 0x75, 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x73, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, + 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x61, 0x76, + 0x65, 0x72, 0x61, 0x67, 0x65, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x76, 0x69, 0x6c, 0x6c, + 0x61, 0x67, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x69, 0x73, 0x68, 0x67, 0x61, 0x6c, 0x6c, 0x65, 0x72, + 0x79, 0x64, 0x65, 0x63, 0x6c, 0x69, 0x6e, 0x65, 0x6d, 0x65, 0x65, 0x74, 0x69, 0x6e, 0x67, 0x6d, + 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x71, 0x75, 0x61, + 0x6c, 0x69, 0x74, 0x79, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x70, 0x65, 0x63, 0x69, 0x65, 0x73, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x72, 0x73, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x72, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x73, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x73, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x73, 0x70, 0x75, 0x74, 0x65, 0x65, + 0x61, 0x72, 0x6c, 0x69, 0x65, 0x72, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x64, 0x69, 0x67, + 0x69, 0x74, 0x61, 0x6c, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x41, 0x6e, 0x6f, 0x74, 0x68, + 0x65, 0x72, 0x6d, 0x61, 0x72, 0x72, 0x69, 0x65, 0x64, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, + 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x63, 0x65, + 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x76, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x73, 0x2f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x73, 0x74, 0x75, 0x64, 0x69, 0x65, + 0x73, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x73, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x73, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x65, 0x70, 0x69, 0x73, 0x6f, + 0x64, 0x65, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, + 0x6f, 0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x79, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 0x2f, 0x75, 0x6c, + 0x3e, 0x0d, 0x0a, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, + 0x79, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x73, + 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x64, 0x65, 0x73, + 0x6b, 0x74, 0x6f, 0x70, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x70, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x75, 0x6e, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, + 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x57, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x66, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x72, 0x65, 0x64, 0x75, + 0x63, 0x65, 0x64, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x64, 0x65, 0x63, 0x61, 0x64, 0x65, + 0x73, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x20, 0x61, + 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x41, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x6d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x73, 0x6e, 0x6f, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, + 0x63, 0x61, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x73, 0x63, 0x61, + 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x6c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x45, 0x6e, 0x67, 0x6c, 0x61, 0x6e, + 0x64, 0x3d, 0x31, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, + 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x53, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x4e, 0x65, 0x74, 0x77, 0x6f, + 0x72, 0x6b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, + 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x67, 0x65, 0x74, 0x6f, + 0x6f, 0x6c, 0x62, 0x61, 0x72, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x62, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x44, 0x65, 0x75, 0x74, 0x73, 0x63, + 0x68, 0x66, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x71, + 0x75, 0x69, 0x63, 0x6b, 0x6c, 0x79, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x65, 0x78, 0x61, + 0x63, 0x74, 0x6c, 0x79, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x73, 0x65, 0x61, + 0x73, 0x65, 0x53, 0x6f, 0x63, 0x69, 0x65, 0x74, 0x79, 0x77, 0x65, 0x61, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x78, 0x68, 0x69, 0x62, 0x69, 0x74, 0x26, 0x6c, 0x74, 0x3b, 0x21, 0x2d, 0x2d, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x63, 0x6f, 0x76, 0x65, + 0x72, 0x65, 0x64, 0x6f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x74, 0x74, 0x61, 0x63, 0x6b, + 0x73, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x28, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x70, + 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x4d, 0x6f, 0x62, + 0x69, 0x6c, 0x65, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x68, 0x6f, 0x77, 0x69, + 0x6e, 0x67, 0x49, 0x74, 0x61, 0x6c, 0x69, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, + 0x68, 0x65, 0x61, 0x76, 0x69, 0x6c, 0x79, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x2d, 0x31, + 0x27, 0x5d, 0x29, 0x3b, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x74, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x68, 0x61, 0x72, 0x69, 0x6e, + 0x67, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x64, 0x72, 0x61, 0x77, 0x69, 0x6e, 0x67, 0x62, + 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x65, 0x64, 0x47, 0x65, 0x72, + 0x6d, 0x61, 0x6e, 0x79, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x3c, 0x2f, 0x66, 0x6f, 0x72, + 0x6d, 0x3e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x53, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x63, 0x61, + 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x41, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x62, 0x75, 0x74, 0x74, + 0x6f, 0x6e, 0x73, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, + 0x6d, 0x6a, 0x6f, 0x75, 0x72, 0x6e, 0x65, 0x79, 0x73, 0x69, 0x64, 0x65, 0x62, 0x61, 0x72, 0x43, + 0x68, 0x69, 0x63, 0x61, 0x67, 0x6f, 0x68, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x79, 0x47, 0x65, 0x6e, + 0x65, 0x72, 0x61, 0x6c, 0x70, 0x61, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x26, 0x71, 0x75, 0x6f, + 0x74, 0x3b, 0x61, 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x66, 0x65, 0x65, 0x6c, 0x69, 0x6e, 0x67, + 0x61, 0x72, 0x72, 0x69, 0x76, 0x65, 0x64, 0x70, 0x61, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x6e, 0x61, + 0x74, 0x75, 0x72, 0x61, 0x6c, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x54, + 0x68, 0x65, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x64, 0x65, 0x6e, 0x73, 0x69, 0x74, + 0x79, 0x42, 0x72, 0x69, 0x74, 0x61, 0x69, 0x6e, 0x43, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x65, 0x6c, + 0x61, 0x63, 0x6b, 0x20, 0x6f, 0x66, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x49, 0x72, 0x65, + 0x6c, 0x61, 0x6e, 0x64, 0x22, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x66, 0x61, 0x63, 0x74, 0x6f, + 0x72, 0x73, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, + 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x68, 0x75, 0x73, 0x62, 0x61, 0x6e, 0x64, 0x69, 0x6e, + 0x20, 0x66, 0x61, 0x63, 0x74, 0x61, 0x66, 0x66, 0x61, 0x69, 0x72, 0x73, 0x43, 0x68, 0x61, 0x72, + 0x6c, 0x65, 0x73, 0x72, 0x61, 0x64, 0x69, 0x63, 0x61, 0x6c, 0x62, 0x72, 0x6f, 0x75, 0x67, 0x68, + 0x74, 0x66, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x3a, + 0x6c, 0x61, 0x6e, 0x67, 0x3d, 0x22, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x73, 0x70, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x70, 0x72, 0x65, 0x6d, 0x69, + 0x75, 0x6d, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, + 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5d, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3d, 0x22, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, + 0x67, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x73, + 0x6d, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x2d, 0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x72, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x73, 0x77, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x6b, 0x69, 0x6e, 0x64, 0x20, + 0x6f, 0x66, 0x46, 0x69, 0x72, 0x65, 0x66, 0x6f, 0x78, 0x79, 0x6f, 0x75, 0x20, 0x61, 0x72, 0x65, + 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x73, 0x74, 0x75, 0x64, 0x69, 0x65, 0x64, 0x6d, 0x61, + 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x68, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x72, 0x61, 0x70, 0x69, + 0x64, 0x6c, 0x79, 0x63, 0x6c, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6b, 0x69, 0x6e, 0x67, 0x64, 0x6f, + 0x6d, 0x65, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x64, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x66, + 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x70, 0x69, 0x6f, 0x6e, 0x65, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x6d, 0x75, 0x6c, 0x61, 0x64, 0x79, 0x6e, 0x61, 0x73, 0x74, 0x79, 0x68, 0x6f, 0x77, 0x20, 0x74, + 0x6f, 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x75, 0x65, + 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x62, 0x72, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, 0x6f, 0x6c, 0x64, 0x69, 0x65, 0x72, 0x6c, 0x61, 0x72, 0x67, + 0x65, 0x6c, 0x79, 0x63, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x2e, 0x26, 0x71, 0x75, 0x6f, 0x74, + 0x3b, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x20, 0x73, + 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x20, 0x65, 0x66, 0x66, + 0x6f, 0x72, 0x74, 0x73, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6e, + 0x65, 0x64, 0x75, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x77, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x73, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x65, 0x64, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x61, 0x73, 0x73, 0x69, 0x76, + 0x65, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x64, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x74, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x62, 0x69, 0x67, 0x67, 0x65, 0x73, 0x74, 0x62, 0x65, 0x6e, + 0x65, 0x66, 0x69, 0x74, 0x64, 0x72, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x75, 0x64, 0x69, + 0x65, 0x73, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x70, 0x65, 0x72, 0x68, 0x61, 0x70, 0x73, + 0x6d, 0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x69, 0x73, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x6e, 0x74, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, + 0x67, 0x61, 0x63, 0x68, 0x69, 0x65, 0x76, 0x65, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x73, + 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x65, 0x6f, 0x6e, 0x65, 0x65, 0x78, 0x74, + 0x72, 0x65, 0x6d, 0x65, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x62, 0x6f, 0x74, 0x74, 0x6f, + 0x6d, 0x3a, 0x65, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x69, 0x74, 0x65, 0x6d, 0x61, 0x70, 0x65, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x77, 0x61, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x20, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x73, 0x79, 0x6d, 0x62, + 0x6f, 0x6c, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, + 0x73, 0x6d, 0x75, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x0d, 0x0a, 0x70, 0x61, 0x79, + 0x6d, 0x65, 0x6e, 0x74, 0x74, 0x72, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x65, + 0x70, 0x74, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, + 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x73, 0x6d, 0x6f, + 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x27, 0x27, 0x54, 0x68, 0x65, 0x20, 0x77, 0x69, 0x6e, 0x6e, + 0x69, 0x6e, 0x67, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x72, 0x65, 0x61, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x64, 0x47, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x79, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x61, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x65, 0x6e, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x63, 0x61, 0x72, + 0x65, 0x65, 0x72, 0x73, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x61, 0x6e, 0x63, 0x69, 0x65, 0x6e, 0x74, + 0x65, 0x78, 0x69, 0x73, 0x74, 0x65, 0x64, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x20, 0x68, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x63, 0x6f, 0x6e, 0x73, + 0x6f, 0x6c, 0x65, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x73, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x69, + 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x6e, 0x65, 0x75, 0x74, 0x72, 0x61, 0x6c, 0x73, 0x75, 0x67, + 0x67, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x69, 0x67, 0x6e, 0x69, + 0x6e, 0x67, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, + 0x77, 0x65, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x63, 0x61, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x2d, 0x77, + 0x65, 0x62, 0x6b, 0x69, 0x74, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x4a, 0x75, 0x73, 0x74, + 0x69, 0x63, 0x65, 0x63, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x76, 0x69, 0x63, 0x74, 0x69, 0x6d, + 0x73, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x20, 0x6d, 0x6f, 0x7a, 0x69, 0x6c, 0x6c, 0x61, 0x70, + 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x70, 0x61, 0x72, 0x74, 0x69, 0x65, 0x73, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, + 0x65, 0x2c, 0x68, 0x75, 0x6e, 0x64, 0x72, 0x65, 0x64, 0x4f, 0x6c, 0x79, 0x6d, 0x70, 0x69, 0x63, + 0x5f, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, 0x72, 0x65, + 0x61, 0x63, 0x68, 0x65, 0x64, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x64, 0x65, 0x6d, 0x61, + 0x6e, 0x64, 0x73, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, + 0x74, 0x61, 0x64, 0x6f, 0x70, 0x74, 0x65, 0x64, 0x70, 0x72, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x67, 0x72, 0x65, 0x61, 0x74, 0x6c, 0x79, 0x67, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x69, 0x6d, 0x70, 0x72, 0x6f, + 0x76, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x77, 0x6f, 0x72, 0x73, 0x68, 0x69, 0x70, 0x66, 0x75, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x68, 0x69, 0x67, 0x68, + 0x65, 0x73, 0x74, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x74, + 0x79, 0x71, 0x75, 0x61, 0x72, 0x74, 0x65, 0x72, 0x43, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x74, + 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x65, 0x78, 0x70, + 0x6f, 0x73, 0x65, 0x64, 0x42, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x6c, 0x69, 0x62, 0x65, 0x72, + 0x61, 0x6c, 0x7d, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x68, 0x69, 0x64, 0x65, 0x28, 0x29, 0x3b, 0x46, 0x6c, + 0x6f, 0x72, 0x69, 0x64, 0x61, 0x61, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x65, 0x72, 0x6f, 0x72, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x73, + 0x65, 0x73, 0x65, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x66, 0x72, 0x65, 0x65, 0x64, 0x6f, 0x6d, 0x53, + 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x2d, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x46, 0x75, 0x72, + 0x74, 0x68, 0x65, 0x72, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x21, 0x3d, 0x20, 0x6e, 0x75, + 0x6c, 0x6c, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x6e, 0x6d, 0x61, 0x72, 0x6b, + 0x76, 0x6f, 0x69, 0x64, 0x28, 0x30, 0x29, 0x2f, 0x61, 0x6c, 0x6c, 0x2e, 0x6a, 0x73, 0x70, 0x72, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, 0x74, 0x65, 0x70, + 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x62, 0x6f, 0x72, + 0x64, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x46, 0x6f, 0x72, 0x20, 0x0a, 0x0a, 0x4d, 0x61, 0x6e, + 0x79, 0x20, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x73, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x65, 0x64, + 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x66, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x6f, 0x66, 0x6d, 0x65, 0x64, 0x69, 0x63, 0x61, 0x6c, 0x74, 0x69, 0x63, 0x6b, + 0x65, 0x74, 0x73, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x63, 0x69, + 0x6c, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x63, 0x65, 0x47, + 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x42, 0x65, 0x6c, 0x67, 0x69, 0x75, 0x6d, 0x2e, 0x2e, 0x2e, + 0x3c, 0x2f, 0x61, 0x3e, 0x74, 0x77, 0x69, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x6f, 0x74, 0x61, 0x62, + 0x6c, 0x79, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x77, 0x61, 0x72, 0x66, 0x61, 0x72, 0x65, + 0x20, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x69, 0x6e, 0x67, 0x70, 0x68, + 0x72, 0x61, 0x73, 0x65, 0x73, 0x6d, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x72, 0x76, + 0x69, 0x76, 0x65, 0x73, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x72, 0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a, + 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x6c, + 0x6f, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x6a, 0x75, 0x73, 0x74, 0x20, 0x61, 0x73, 0x47, 0x65, 0x6f, + 0x72, 0x67, 0x69, 0x61, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x3c, 0x68, 0x65, 0x61, 0x64, + 0x3e, 0x3c, 0x73, 0x74, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x31, 0x27, 0x5d, 0x29, 0x3b, 0x0d, 0x0a, + 0x69, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x6e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x62, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x3a, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x63, 0x61, 0x72, 0x72, + 0x69, 0x65, 0x64, 0x31, 0x30, 0x30, 0x2c, 0x30, 0x30, 0x30, 0x3c, 0x2f, 0x68, 0x33, 0x3e, 0x0a, + 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x77, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x30, 0x30, 0x2e, + 0x68, 0x74, 0x6d, 0x6c, 0x6d, 0x6f, 0x6e, 0x61, 0x72, 0x63, 0x68, 0x6f, 0x66, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x74, 0x65, 0x61, 0x63, 0x68, 0x65, 0x72, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x79, 0x20, + 0x62, 0x69, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x6c, 0x69, 0x66, 0x65, 0x20, 0x6f, 0x66, 0x6f, 0x72, + 0x20, 0x65, 0x76, 0x65, 0x6e, 0x72, 0x69, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x26, 0x72, 0x61, 0x71, + 0x75, 0x6f, 0x3b, 0x70, 0x6c, 0x75, 0x73, 0x6f, 0x6e, 0x65, 0x68, 0x75, 0x6e, 0x74, 0x69, 0x6e, + 0x67, 0x28, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x6a, + 0x6f, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x63, 0x69, 0x72, 0x63, 0x6c, 0x65, 0x73, 0x46, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x41, 0x6e, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x56, 0x69, 0x65, 0x74, 0x6e, + 0x61, 0x6d, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, + 0x63, 0x72, 0x79, 0x73, 0x74, 0x61, 0x6c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x65, 0x6e, 0x6a, 0x6f, 0x79, 0x65, 0x64, 0x61, 0x20, 0x73, 0x6d, + 0x61, 0x6c, 0x6c, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x3c, 0x61, 0x20, 0x69, 0x64, 0x3d, + 0x22, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x72, 0x69, 0x68, + 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x72, 0x65, 0x74, + 0x69, 0x72, 0x65, 0x64, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x68, 0x69, 0x64, 0x64, 0x65, + 0x6e, 0x3b, 0x62, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x65, 0x6b, 0x69, 0x6e, 0x67, + 0x63, 0x61, 0x62, 0x69, 0x6e, 0x65, 0x74, 0x77, 0x61, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x6c, 0x6f, + 0x6f, 0x6b, 0x20, 0x61, 0x74, 0x63, 0x6f, 0x6e, 0x64, 0x75, 0x63, 0x74, 0x67, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, + 0x73, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x61, 0x3a, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x4f, + 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x46, 0x72, 0x65, 0x6e, 0x63, 0x68, 0x20, 0x6c, 0x61, 0x63, + 0x6b, 0x69, 0x6e, 0x67, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x63, 0x74, 0x65, 0x6e, 0x65, 0x6d, 0x69, 0x65, 0x73, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x66, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x64, 0x65, 0x63, 0x69, 0x64, 0x65, 0x64, 0x61, 0x72, + 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x2f, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x62, 0x65, 0x6c, 0x69, + 0x65, 0x66, 0x73, 0x2d, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x3a, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, + 0x64, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x2e, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x22, 0x3e, 0x63, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x65, 0x72, 0x65, 0x64, 0x66, 0x69, 0x72, 0x73, 0x74, 0x22, 0x3e, 0x63, 0x69, 0x72, 0x63, 0x75, + 0x69, 0x74, 0x46, 0x69, 0x6e, 0x6c, 0x61, 0x6e, 0x64, 0x63, 0x68, 0x65, 0x6d, 0x69, 0x73, 0x74, + 0x73, 0x68, 0x65, 0x20, 0x77, 0x61, 0x73, 0x31, 0x30, 0x70, 0x78, 0x3b, 0x22, 0x3e, 0x61, 0x73, + 0x20, 0x73, 0x75, 0x63, 0x68, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x64, 0x3c, 0x2f, 0x73, 0x70, + 0x61, 0x6e, 0x3e, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x61, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x6d, 0x79, 0x73, 0x74, 0x65, 0x72, 0x79, 0x2f, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x66, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x64, 0x75, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x72, 0x61, 0x69, 0x6c, 0x77, 0x61, 0x79, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x67, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x72, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6e, 0x75, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x4a, 0x65, + 0x77, 0x69, 0x73, 0x68, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x74, + 0x69, 0x73, 0x68, 0x66, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, + 0x74, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x20, 0x77, + 0x68, 0x6f, 0x20, 0x77, 0x61, 0x73, 0x6c, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x69, 0x6e, 0x73, + 0x74, 0x61, 0x6e, 0x74, 0x73, 0x75, 0x69, 0x63, 0x69, 0x64, 0x65, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x69, 0x63, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x73, + 0x53, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x63, 0x6f, + 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x77, 0x69, 0x6e, 0x6e, + 0x65, 0x72, 0x73, 0x3c, 0x62, 0x72, 0x20, 0x2f, 0x3e, 0x3c, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x4e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x50, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x63, + 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x73, 0x6f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x72, 0x65, 0x73, + 0x6f, 0x6c, 0x76, 0x65, 0x53, 0x77, 0x65, 0x64, 0x69, 0x73, 0x68, 0x62, 0x72, 0x69, 0x65, 0x66, + 0x6c, 0x79, 0x50, 0x65, 0x72, 0x73, 0x69, 0x61, 0x6e, 0x73, 0x6f, 0x20, 0x6d, 0x75, 0x63, 0x68, + 0x43, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x64, 0x65, 0x70, 0x69, 0x63, 0x74, 0x73, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x68, 0x6f, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x73, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6f, 0x62, 0x65, 0x61, 0x72, 0x69, 0x6e, + 0x67, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x76, 0x69, 0x73, 0x65, 0x64, 0x6a, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x28, 0x2d, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x74, 0x69, 0x74, + 0x6c, 0x65, 0x22, 0x3e, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x53, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x73, 0x54, 0x75, 0x72, 0x6b, 0x69, 0x73, 0x68, + 0x79, 0x6f, 0x75, 0x6e, 0x67, 0x65, 0x72, 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x28, 0x7d, 0x29, + 0x28, 0x29, 0x3b, 0x0a, 0x0a, 0x62, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x73, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x3d, 0x52, 0x69, 0x63, 0x68, 0x61, 0x72, 0x64, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x6c, 0x79, 0x70, + 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3c, 0x2f, 0x74, + 0x72, 0x3e, 0x0d, 0x0a, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x75, 0x6c, 0x20, 0x69, 0x64, + 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x73, 0x65, 0x73, 0x73, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, + 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x73, 0x66, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x73, 0x74, 0x6c, 0x69, 0x6e, 0x6b, + 0x20, 0x74, 0x6f, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x3c, 0x62, 0x72, 0x20, 0x2f, 0x3e, + 0x0a, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x63, 0x68, 0x61, 0x72, 0x74, 0x65, 0x72, 0x74, + 0x6f, 0x75, 0x72, 0x69, 0x73, 0x6d, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x70, 0x72, 0x6f, + 0x63, 0x65, 0x65, 0x64, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x3c, 0x2f, 0x68, 0x31, 0x3e, + 0x0d, 0x0a, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x2e, 0x3f, 0x78, 0x6d, 0x6c, 0x20, 0x76, 0x65, + 0x68, 0x65, 0x6c, 0x70, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x61, 0x69, 0x72, 0x6c, 0x69, 0x6e, 0x65, 0x65, 0x6e, 0x64, 0x20, + 0x2d, 0x2d, 0x3e, 0x29, 0x2e, 0x61, 0x74, 0x74, 0x72, 0x28, 0x72, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x73, 0x68, 0x6f, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x72, + 0x65, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x73, 0x69, 0x67, + 0x6e, 0x61, 0x6c, 0x73, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x50, 0x72, 0x6f, 0x64, 0x75, + 0x63, 0x74, 0x64, 0x65, 0x73, 0x70, 0x69, 0x74, 0x65, 0x64, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, + 0x74, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x68, 0x65, + 0x6c, 0x64, 0x20, 0x69, 0x6e, 0x4a, 0x6f, 0x73, 0x65, 0x70, 0x68, 0x20, 0x74, 0x68, 0x65, 0x61, + 0x74, 0x72, 0x65, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x3c, 0x73, 0x74, 0x79, 0x6c, 0x65, + 0x3e, 0x61, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x6c, + 0x61, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x66, 0x61, 0x76, + 0x69, 0x63, 0x6f, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x75, 0x6e, 0x67, 0x61, + 0x72, 0x79, 0x41, 0x69, 0x72, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x53, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x73, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x73, 0x2c, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x65, 0x26, 0x71, 0x75, 0x6f, 0x74, + 0x3b, 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x66, 0x74, 0x22, 0x3e, 0x0a, 0x70, + 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x73, 0x47, 0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x20, 0x41, 0x66, 0x66, + 0x61, 0x69, 0x72, 0x73, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x61, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x69, + 0x6e, 0x67, 0x64, 0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x69, 0x64, 0x65, 0x61, 0x20, 0x6f, 0x66, + 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, 0x2e, 0x73, 0x72, 0x63, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x72, 0x74, + 0x6f, 0x6f, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x73, 0x4d, 0x75, 0x73, 0x6c, 0x69, 0x6d, 0x73, 0x57, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x69, + 0x6e, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x6d, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x76, + 0x65, 0x61, 0x6c, 0x73, 0x49, 0x6e, 0x64, 0x65, 0x65, 0x64, 0x2c, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x6c, 0x79, 0x2f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x61, 0x6f, 0x75, 0x74, 0x64, 0x6f, 0x6f, 0x72, + 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x28, 0x41, 0x75, 0x73, 0x74, 0x72, 0x69, 0x61, 0x67, 0x65, + 0x6e, 0x65, 0x74, 0x69, 0x63, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2c, 0x49, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x48, 0x65, 0x20, 0x61, 0x6c, 0x73, + 0x6f, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x79, 0x0a, + 0x09, 0x09, 0x3c, 0x21, 0x2d, 0x2d, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x20, 0x62, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3e, 0x69, 0x6d, 0x70, 0x6f, 0x73, + 0x65, 0x64, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x41, 0x62, 0x72, 0x61, 0x68, 0x61, 0x6d, + 0x28, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x7b, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x70, 0x75, + 0x74, 0x74, 0x69, 0x6e, 0x67, 0x29, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x28, 0x7c, 0x7c, 0x20, 0x5b, + 0x5d, 0x3b, 0x0a, 0x44, 0x41, 0x54, 0x41, 0x5b, 0x20, 0x2a, 0x6b, 0x69, 0x74, 0x63, 0x68, 0x65, + 0x6e, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x64, + 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x6d, 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x20, 0x5f, 0x62, 0x6c, + 0x61, 0x6e, 0x6b, 0x27, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x78, 0x70, 0x65, 0x72, + 0x74, 0x73, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x49, 0x74, 0x20, 0x61, 0x6c, 0x73, 0x6f, + 0x26, 0x63, 0x6f, 0x70, 0x79, 0x3b, 0x20, 0x22, 0x3e, 0x54, 0x65, 0x72, 0x6d, 0x73, 0x62, 0x6f, + 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x61, 0x73, 0x74, + 0x65, 0x72, 0x6e, 0x74, 0x61, 0x6c, 0x6b, 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, + 0x6e, 0x67, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x6a, + 0x75, 0x73, 0x74, 0x69, 0x66, 0x79, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x73, 0x66, 0x61, 0x63, + 0x74, 0x6f, 0x72, 0x79, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x77, 0x6e, 0x61, 0x73, 0x73, 0x61, 0x75, + 0x6c, 0x74, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x64, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x68, 0x69, 0x73, 0x20, 0x6f, 0x77, 0x6e, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x22, 0x20, + 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x63, 0x6f, 0x6e, 0x63, + 0x65, 0x72, 0x74, 0x64, 0x69, 0x61, 0x67, 0x72, 0x61, 0x6d, 0x64, 0x6f, 0x6c, 0x6c, 0x61, 0x72, + 0x73, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x70, 0x68, 0x70, 0x3f, 0x69, 0x64, 0x3d, 0x61, + 0x6c, 0x63, 0x6f, 0x68, 0x6f, 0x6c, 0x29, 0x3b, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x75, 0x73, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x76, 0x65, 0x73, 0x73, 0x65, + 0x6c, 0x73, 0x72, 0x65, 0x76, 0x69, 0x76, 0x61, 0x6c, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x61, 0x6d, 0x61, 0x74, 0x65, 0x75, 0x72, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x61, 0x6c, + 0x6c, 0x65, 0x67, 0x65, 0x64, 0x69, 0x6c, 0x6c, 0x6e, 0x65, 0x73, 0x73, 0x77, 0x61, 0x6c, 0x6b, + 0x69, 0x6e, 0x67, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, + 0x79, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x65, + 0x78, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x44, 0x65, 0x66, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x69, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x0a, 0x09, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x73, 0x6c, 0x69, 0x6e, 0x6b, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x20, + 0x42, 0x6f, 0x6f, 0x6b, 0x20, 0x6f, 0x66, 0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x6d, 0x69, + 0x6e, 0x2e, 0x6a, 0x73, 0x3f, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6b, 0x6f, 0x6e, 0x74, + 0x61, 0x6b, 0x74, 0x74, 0x6f, 0x64, 0x61, 0x79, 0x27, 0x73, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, + 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x77, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x41, + 0x6c, 0x6c, 0x20, 0x52, 0x69, 0x67, 0x3b, 0x0a, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x72, 0x61, 0x69, + 0x73, 0x69, 0x6e, 0x67, 0x20, 0x41, 0x6c, 0x73, 0x6f, 0x2c, 0x20, 0x63, 0x72, 0x75, 0x63, 0x69, + 0x61, 0x6c, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x22, 0x3e, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, + 0x2d, 0x2d, 0x3e, 0x0a, 0x3c, 0x73, 0x63, 0x66, 0x69, 0x72, 0x65, 0x66, 0x6f, 0x78, 0x61, 0x73, + 0x20, 0x6d, 0x75, 0x63, 0x68, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x2c, 0x20, 0x73, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x3d, + 0x20, 0x0a, 0x0d, 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x74, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, + 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, + 0x65, 0x69, 0x67, 0x6e, 0x50, 0x72, 0x65, 0x6d, 0x69, 0x65, 0x72, 0x63, 0x68, 0x6f, 0x69, 0x63, + 0x65, 0x73, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, + 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x65, 0x64, 0x69, 0x6e, + 0x6c, 0x69, 0x6e, 0x65, 0x3b, 0x70, 0x6f, 0x76, 0x65, 0x72, 0x74, 0x79, 0x63, 0x68, 0x61, 0x6d, + 0x62, 0x65, 0x72, 0x4c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x73, 0x41, 0x6e, 0x74, 0x68, 0x6f, 0x6e, 0x79, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x22, 0x20, 0x52, + 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x45, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x79, 0x72, 0x65, 0x61, + 0x63, 0x68, 0x65, 0x73, 0x63, 0x75, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x67, 0x72, 0x61, 0x76, 0x69, + 0x74, 0x79, 0x6c, 0x69, 0x66, 0x65, 0x20, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2d, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x4e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3c, 0x2f, + 0x74, 0x64, 0x3e, 0x0d, 0x0a, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x74, 0x61, 0x64, + 0x69, 0x75, 0x6d, 0x77, 0x69, 0x64, 0x67, 0x65, 0x74, 0x73, 0x76, 0x61, 0x72, 0x79, 0x69, 0x6e, + 0x67, 0x74, 0x72, 0x61, 0x76, 0x65, 0x6c, 0x73, 0x68, 0x65, 0x6c, 0x64, 0x20, 0x62, 0x79, 0x77, + 0x68, 0x6f, 0x20, 0x61, 0x72, 0x65, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x69, 0x6e, 0x66, 0x61, 0x63, + 0x75, 0x6c, 0x74, 0x79, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x77, 0x68, 0x6f, 0x20, 0x68, + 0x61, 0x64, 0x61, 0x69, 0x72, 0x70, 0x6f, 0x72, 0x74, 0x74, 0x6f, 0x77, 0x6e, 0x20, 0x6f, 0x66, + 0x0a, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x27, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x27, 0x63, 0x68, + 0x61, 0x72, 0x67, 0x65, 0x73, 0x6b, 0x65, 0x79, 0x77, 0x6f, 0x72, 0x64, 0x69, 0x74, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x63, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x29, + 0x3b, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x33, 0x30, 0x30, + 0x70, 0x78, 0x3b, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x3d, 0x22, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, + 0x68, 0x65, 0x72, 0x73, 0x65, 0x6c, 0x66, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x65, + 0x64, 0x65, 0x72, 0x61, 0x6c, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x65, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x73, 0x68, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x61, 0x63, 0x74, 0x72, 0x65, 0x73, 0x73, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x66, + 0x69, 0x6e, 0x67, 0x65, 0x72, 0x73, 0x44, 0x75, 0x6b, 0x65, 0x20, 0x6f, 0x66, 0x70, 0x65, 0x6f, + 0x70, 0x6c, 0x65, 0x2c, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x69, 0x74, 0x77, 0x68, 0x61, 0x74, 0x20, + 0x69, 0x73, 0x68, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x79, 0x61, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, + 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x69, 0x6e, 0x20, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, + 0x6e, 0x75, 0x22, 0x3e, 0x0a, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x6c, 0x79, 0x6f, 0x66, 0x66, 0x69, + 0x63, 0x65, 0x72, 0x63, 0x6f, 0x75, 0x6e, 0x63, 0x69, 0x6c, 0x67, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x64, + 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x6c, 0x6f, 0x79, 0x61, 0x6c, 0x74, 0x79, 0x66, 0x69, 0x74, + 0x6e, 0x65, 0x73, 0x73, 0x61, 0x6e, 0x64, 0x20, 0x77, 0x61, 0x73, 0x65, 0x6d, 0x70, 0x65, 0x72, + 0x6f, 0x72, 0x73, 0x75, 0x70, 0x72, 0x65, 0x6d, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, + 0x68, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x73, 0x73, 0x69, 0x61, 0x6e, 0x6c, 0x6f, + 0x6e, 0x67, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x61, 0x6c, 0x61, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x22, + 0x3e, 0x2e, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x64, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x66, + 0x65, 0x64, 0x65, 0x72, 0x61, 0x6c, 0x62, 0x61, 0x6e, 0x6b, 0x20, 0x6f, 0x66, 0x62, 0x65, 0x6e, + 0x65, 0x61, 0x74, 0x68, 0x44, 0x65, 0x73, 0x70, 0x69, 0x74, 0x65, 0x43, 0x61, 0x70, 0x69, 0x74, + 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x29, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x63, 0x6c, + 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x49, 0x6e, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x66, 0x69, 0x66, 0x74, 0x65, 0x65, 0x6e, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, + 0x6c, 0x2e, 0x79, 0x61, 0x68, 0x6f, 0x6f, 0x2e, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x66, + 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x6f, 0x62, 0x73, 0x63, 0x75, 0x72, 0x65, 0x72, 0x65, 0x66, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x63, 0x3d, 0x20, 0x4d, 0x61, 0x74, + 0x68, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, + 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x61, 0x20, 0x77, 0x68, 0x6f, 0x6c, 0x65, 0x6f, 0x6e, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x79, 0x65, 0x61, 0x72, 0x20, 0x6f, 0x66, 0x65, 0x6e, 0x64, 0x20, + 0x6f, 0x66, 0x20, 0x62, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, + 0x74, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x72, + 0x65, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x73, 0x74, 0x72, + 0x6f, 0x6e, 0x67, 0x3e, 0x68, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x66, 0x72, 0x77, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, + 0x4d, 0x61, 0x72, 0x63, 0x68, 0x20, 0x31, 0x6b, 0x6e, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x69, 0x6e, + 0x20, 0x70, 0x61, 0x72, 0x74, 0x42, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6c, 0x65, 0x73, 0x73, + 0x6f, 0x6e, 0x73, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x73, 0x74, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, + 0x6c, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x22, 0x3e, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x65, 0x64, 0x45, + 0x4e, 0x44, 0x20, 0x2d, 0x2d, 0x3e, 0x66, 0x61, 0x6d, 0x6f, 0x75, 0x73, 0x20, 0x61, 0x77, 0x61, + 0x72, 0x64, 0x65, 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x6c, 0x74, + 0x68, 0x20, 0x66, 0x61, 0x69, 0x72, 0x6c, 0x79, 0x20, 0x77, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, + 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x63, 0x6f, + 0x6d, 0x70, 0x65, 0x74, 0x65, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x3e, 0x73, 0x69, 0x6e, 0x67, + 0x69, 0x6e, 0x67, 0x66, 0x61, 0x72, 0x6d, 0x65, 0x72, 0x73, 0x42, 0x72, 0x61, 0x73, 0x69, 0x6c, + 0x29, 0x64, 0x69, 0x73, 0x63, 0x75, 0x73, 0x73, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x47, + 0x72, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x66, 0x6f, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x70, 0x75, 0x72, + 0x73, 0x75, 0x65, 0x64, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x6d, 0x61, 0x6b, 0x65, 0x20, + 0x75, 0x70, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x6f, 0x66, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x73, 0x61, 0x77, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x66, + 0x66, 0x69, 0x63, 0x65, 0x73, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x73, 0x69, 0x66, 0x28, 0x64, + 0x6f, 0x63, 0x75, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x68, 0x65, 0x65, 0x6e, 0x66, 0x6f, 0x72, 0x63, + 0x65, 0x70, 0x75, 0x73, 0x68, 0x28, 0x66, 0x75, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x20, 0x55, + 0x54, 0x46, 0x2d, 0x38, 0x22, 0x3e, 0x46, 0x61, 0x6e, 0x74, 0x61, 0x73, 0x79, 0x69, 0x6e, 0x20, + 0x6d, 0x6f, 0x73, 0x74, 0x69, 0x6e, 0x6a, 0x75, 0x72, 0x65, 0x64, 0x55, 0x73, 0x75, 0x61, 0x6c, + 0x6c, 0x79, 0x66, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x63, 0x65, 0x75, 0x73, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x4d, 0x65, 0x64, 0x69, 0x63, 0x61, 0x6c, 0x3c, 0x62, 0x6f, 0x64, + 0x79, 0x3e, 0x0a, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x6b, 0x65, 0x79, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x69, 0x78, 0x74, 0x65, 0x65, 0x6e, 0x49, + 0x73, 0x6c, 0x61, 0x6d, 0x69, 0x63, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x6e, 0x74, + 0x69, 0x72, 0x65, 0x20, 0x77, 0x69, 0x64, 0x65, 0x6c, 0x79, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, + 0x65, 0x20, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x6f, 0x6e, 0x65, 0x20, 0x63, 0x61, 0x6e, + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x73, 0x70, 0x65, 0x61, 0x6b, 0x65, 0x72, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x64, 0x73, 0x50, 0x68, 0x79, 0x73, 0x69, 0x63, 0x73, 0x74, 0x65, 0x72, 0x72, + 0x61, 0x69, 0x6e, 0x3c, 0x74, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x66, 0x75, 0x6e, 0x65, 0x72, 0x61, + 0x6c, 0x76, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x20, 0x63, + 0x72, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x70, 0x72, 0x6f, 0x70, 0x68, 0x65, 0x74, 0x73, 0x68, 0x69, + 0x66, 0x74, 0x65, 0x64, 0x64, 0x6f, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x75, 0x73, 0x73, 0x65, + 0x6c, 0x6c, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x61, 0x6c, 0x67, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x2d, 0x62, 0x75, + 0x6c, 0x6b, 0x20, 0x6f, 0x66, 0x6d, 0x61, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x3c, 0x2f, 0x74, 0x64, + 0x3e, 0x0a, 0x20, 0x68, 0x65, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x29, 0x2e, 0x76, 0x61, 0x6c, 0x28, + 0x29, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x29, 0x3b, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x62, + 0x61, 0x6e, 0x6b, 0x69, 0x6e, 0x67, 0x68, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x6e, 0x61, 0x6d, + 0x69, 0x6e, 0x67, 0x20, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x63, 0x72, 0x65, 0x64, 0x69, + 0x74, 0x73, 0x29, 0x3b, 0x0a, 0x7d, 0x29, 0x3b, 0x0a, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x72, + 0x69, 0x6e, 0x20, 0x74, 0x75, 0x72, 0x6e, 0x43, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x73, 0x62, 0x65, + 0x66, 0x6f, 0x72, 0x65, 0x20, 0x42, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x63, 0x68, 0x61, 0x72, + 0x67, 0x65, 0x64, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3e, 0x43, 0x61, 0x70, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x64, 0x67, 0x6f, 0x64, 0x64, 0x65, 0x73, 0x73, 0x54, + 0x61, 0x67, 0x20, 0x2d, 0x2d, 0x3e, 0x41, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x62, 0x75, 0x74, + 0x20, 0x77, 0x61, 0x73, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x74, 0x69, 0x65, + 0x6e, 0x74, 0x62, 0x61, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x26, + 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x77, 0x65, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x65, 0x72, 0x4a, 0x75, 0x64, 0x61, 0x69, 0x73, 0x6d, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x27, 0x5d, 0x29, 0x3b, 0x0a, 0x20, + 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x27, 0x2c, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x69, 0x6e, 0x6e, 0x6f, 0x74, + 0x20, 0x61, 0x6c, 0x6c, 0x0a, 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x69, + 0x6e, 0x67, 0x68, 0x61, 0x72, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, + 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x73, 0x74, + 0x72, 0x65, 0x65, 0x74, 0x73, 0x42, 0x65, 0x72, 0x6e, 0x61, 0x72, 0x64, 0x61, 0x73, 0x73, 0x65, + 0x72, 0x74, 0x73, 0x74, 0x65, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x66, 0x61, 0x6e, 0x74, 0x61, 0x73, + 0x79, 0x64, 0x6f, 0x77, 0x6e, 0x20, 0x69, 0x6e, 0x68, 0x61, 0x72, 0x62, 0x6f, 0x75, 0x72, 0x46, + 0x72, 0x65, 0x65, 0x64, 0x6f, 0x6d, 0x6a, 0x65, 0x77, 0x65, 0x6c, 0x72, 0x79, 0x2f, 0x61, 0x62, + 0x6f, 0x75, 0x74, 0x2e, 0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x6c, 0x65, 0x67, 0x65, 0x6e, + 0x64, 0x73, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x22, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x20, 0x70, 0x61, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x72, 0x61, 0x72, 0x65, 0x6c, 0x79, + 0x20, 0x61, 0x63, 0x72, 0x6f, 0x6e, 0x79, 0x6d, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x30, 0x30, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x61, 0x73, 0x20, + 0x6d, 0x61, 0x6e, 0x79, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x2f, 0x2a, 0x20, 0x3c, 0x21, + 0x5b, 0x43, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x20, 0x3d, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x70, 0x69, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x65, 0x73, + 0x63, 0x61, 0x70, 0x65, 0x64, 0x75, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x70, 0x65, 0x6f, 0x70, + 0x6c, 0x65, 0x73, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4d, 0x61, 0x74, 0x74, 0x68, 0x65, + 0x77, 0x74, 0x61, 0x63, 0x74, 0x69, 0x63, 0x73, 0x64, 0x61, 0x6d, 0x61, 0x67, 0x65, 0x64, 0x77, + 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x6c, 0x61, 0x77, 0x73, 0x20, 0x6f, 0x66, 0x65, 0x61, 0x73, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x74, 0x72, 0x6f, 0x6e, + 0x67, 0x20, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, + 0x73, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x68, 0x69, 0x6e, 0x66, 0x6f, 0x62, 0x6f, 0x78, 0x77, 0x65, + 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x70, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x63, 0x69, 0x74, 0x69, + 0x7a, 0x65, 0x6e, 0x49, 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x72, 0x65, 0x74, 0x72, 0x65, 0x61, + 0x74, 0x2e, 0x20, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x77, 0x77, 0x2e, 0x22, 0x29, 0x3b, 0x0a, 0x62, + 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x69, 0x6c, 0x74, 0x6f, 0x3a, 0x6d, 0x61, 0x64, + 0x65, 0x20, 0x69, 0x6e, 0x2e, 0x20, 0x4d, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, + 0x65, 0x73, 0x7c, 0x7c, 0x7b, 0x7d, 0x3b, 0x77, 0x69, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x6f, 0x66, + 0x73, 0x79, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x64, 0x65, 0x66, 0x65, 0x61, 0x74, 0x73, 0x66, 0x61, + 0x76, 0x6f, 0x72, 0x65, 0x64, 0x6f, 0x70, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x70, 0x61, 0x67, 0x65, + 0x54, 0x72, 0x61, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x66, 0x74, 0x22, 0x3e, 0x3c, 0x63, 0x6f, 0x6d, 0x53, 0x63, 0x6f, 0x72, 0x41, + 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x6a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x74, 0x6f, 0x75, + 0x72, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x66, 0x61, 0x6c, 0x73, 0x65, + 0x22, 0x20, 0x57, 0x69, 0x6c, 0x68, 0x65, 0x6c, 0x6d, 0x73, 0x75, 0x62, 0x75, 0x72, 0x62, 0x73, + 0x67, 0x65, 0x6e, 0x75, 0x69, 0x6e, 0x65, 0x62, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x73, 0x2e, 0x73, + 0x70, 0x6c, 0x69, 0x74, 0x28, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x66, 0x6f, 0x6c, 0x6c, + 0x6f, 0x77, 0x73, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x66, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, + 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x73, 0x65, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, + 0x65, 0x66, 0x74, 0x20, 0x74, 0x6f, 0x63, 0x68, 0x69, 0x65, 0x66, 0x6c, 0x79, 0x2d, 0x68, 0x69, + 0x64, 0x64, 0x65, 0x6e, 0x2d, 0x62, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, + 0x0a, 0x0a, 0x2e, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x62, 0x6f, 0x74, 0x68, + 0x64, 0x69, 0x73, 0x6d, 0x69, 0x73, 0x73, 0x45, 0x78, 0x70, 0x6c, 0x6f, 0x72, 0x65, 0x61, 0x6c, + 0x77, 0x61, 0x79, 0x73, 0x20, 0x76, 0x69, 0x61, 0x20, 0x74, 0x68, 0x65, 0x73, 0x70, 0x61, 0xc3, + 0xb1, 0x6f, 0x6c, 0x77, 0x65, 0x6c, 0x66, 0x61, 0x72, 0x65, 0x72, 0x75, 0x6c, 0x69, 0x6e, 0x67, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x63, 0x61, 0x70, 0x74, 0x61, 0x69, 0x6e, 0x68, + 0x69, 0x73, 0x20, 0x73, 0x6f, 0x6e, 0x72, 0x75, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x68, 0x65, 0x20, + 0x74, 0x6f, 0x6f, 0x6b, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2c, 0x3d, 0x30, 0x26, 0x61, 0x6d, + 0x70, 0x3b, 0x28, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, + 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x61, 0x67, 0x4d, 0x61, + 0x72, 0x74, 0x69, 0x6e, 0x20, 0x4b, 0x65, 0x6e, 0x6e, 0x65, 0x64, 0x79, 0x61, 0x63, 0x63, 0x65, + 0x70, 0x74, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x64, 0x42, 0x65, 0x73, 0x69, 0x64, 0x65, 0x73, 0x2f, 0x2f, 0x2d, 0x2d, 0x3e, 0x3c, 0x2f, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x65, 0x73, 0x73, + 0x65, 0x6e, 0x63, 0x65, 0x68, 0x69, 0x6d, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x73, 0x20, 0x62, + 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x61, 0x6c, + 0x74, 0x6f, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x77, 0x61, 0x79, 0x73, 0x20, 0x74, 0x6f, 0x73, 0x2e, + 0x6f, 0x72, 0x67, 0x2f, 0x6c, 0x61, 0x64, 0x76, 0x69, 0x73, 0x65, 0x64, 0x70, 0x65, 0x6e, 0x61, + 0x6c, 0x74, 0x79, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x3a, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x79, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x73, 0x61, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x48, + 0x65, 0x72, 0x62, 0x65, 0x72, 0x74, 0x73, 0x74, 0x72, 0x69, 0x6b, 0x65, 0x73, 0x20, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x66, 0x6c, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x70, 0x73, 0x6c, 0x6f, 0x77, 0x6c, 0x79, 0x20, + 0x6c, 0x65, 0x73, 0x73, 0x65, 0x72, 0x20, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x3c, 0x2f, + 0x70, 0x3e, 0x0a, 0x09, 0x09, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x72, 0x61, 0x6e, 0x6b, + 0x65, 0x64, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x75, 0x6c, 0x3e, 0x0d, 0x0a, 0x20, + 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x70, 0x61, 0x69, 0x72, 0x20, 0x6f, 0x66, 0x6d, + 0x61, 0x6b, 0x65, 0x20, 0x69, 0x74, 0x4b, 0x6f, 0x6e, 0x74, 0x61, 0x6b, 0x74, 0x41, 0x6e, 0x74, + 0x6f, 0x6e, 0x69, 0x6f, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, + 0x74, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x22, 0x29, 0x2e, 0x63, 0x73, 0x73, 0x28, 0x68, 0x6f, + 0x73, 0x74, 0x69, 0x6c, 0x65, 0x6c, 0x65, 0x61, 0x64, 0x20, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x74, + 0x6c, 0x65, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x2c, 0x50, 0x69, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x2d, 0x2d, 0x3e, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x3d, 0x22, 0x20, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x3c, 0x66, 0x6f, + 0x6f, 0x74, 0x65, 0x72, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x56, 0x3e, 0x3c, 0x5c, 0x2f, 0x73, + 0x63, 0x72, 0x73, 0x6f, 0x6c, 0x76, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6d, 0x62, 0x65, 0x72, + 0x73, 0x6c, 0x61, 0x76, 0x65, 0x72, 0x79, 0x77, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x61, 0x73, 0x21, 0x3d, 0x20, 0x27, 0x75, 0x6e, 0x64, 0x66, 0x6f, 0x72, 0x20, + 0x61, 0x6c, 0x6c, 0x70, 0x61, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x41, 0x72, 0x61, 0x62, 0x69, 0x61, 0x6e, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x63, + 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x75, 0x6e, 0x69, 0x74, 0x20, 0x6f, 0x66, 0x6d, 0x6f, 0x62, + 0x69, 0x6c, 0x65, 0x2d, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2c, 0x69, 0x73, 0x20, 0x68, 0x6f, + 0x6d, 0x65, 0x72, 0x69, 0x73, 0x6b, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, + 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x63, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x61, 0x67, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x65, + 0x20, 0x6f, 0x66, 0x70, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, + 0x20, 0x65, 0x61, 0x64, 0x27, 0x29, 0x5b, 0x30, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x73, 0x73, + 0x74, 0x75, 0x64, 0x69, 0x6f, 0x73, 0x3e, 0x26, 0x63, 0x6f, 0x70, 0x79, 0x3b, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x22, 0x3e, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x6d, 0x61, 0x6b, 0x69, 0x6e, + 0x67, 0x20, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x77, 0x69, 0x64, 0x67, 0x65, 0x74, 0x2e, + 0x70, 0x73, 0x3a, 0x22, 0x20, 0x3f, 0x20, 0x72, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x62, 0x79, + 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x20, 0x65, 0x64, 0x69, 0x74, + 0x6f, 0x72, 0x73, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, + 0x63, 0x68, 0x61, 0x64, 0x20, 0x74, 0x68, 0x65, 0x70, 0x75, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x62, 0x75, 0x74, 0x20, 0x61, 0x72, 0x65, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x62, 0x79, 0x6c, 0x6f, 0x6e, 0x62, 0x6f, 0x74, 0x74, 0x6f, + 0x6d, 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x69, 0x74, 0x73, 0x20, 0x75, 0x73, 0x65, 0x41, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x63, 0x6f, + 0x75, 0x72, 0x73, 0x65, 0x73, 0x61, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x64, 0x65, 0x6e, 0x6f, + 0x74, 0x65, 0x73, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x69, 0x6e, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, + 0x6e, 0x32, 0x30, 0x70, 0x78, 0x3b, 0x22, 0x3e, 0x61, 0x63, 0x63, 0x75, 0x73, 0x65, 0x64, 0x64, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x20, 0x67, 0x6f, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x46, 0x61, 0x6d, + 0x6f, 0x75, 0x73, 0x20, 0x29, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x70, 0x72, 0x69, 0x65, 0x73, + 0x74, 0x73, 0x20, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x69, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x79, + 0x73, 0x74, 0x20, 0x2b, 0x20, 0x22, 0x67, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6c, 0x74, 0x64, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x68, 0x65, 0x6c, 0x70, 0x66, 0x75, 0x6c, 0x72, 0x65, 0x76, 0x69, + 0x76, 0x65, 0x64, 0x69, 0x73, 0x20, 0x76, 0x65, 0x72, 0x79, 0x72, 0x27, 0x2b, 0x27, 0x69, 0x70, + 0x74, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65, 0x73, 0x69, + 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x64, 0x61, 0x79, + 0x73, 0x20, 0x6f, 0x66, 0x61, 0x72, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x66, 0x75, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x3c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x66, 0x6f, 0x72, 0x63, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x09, 0x09, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x69, 0x73, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x62, 0x61, 0x6c, 0x6c, 0x6f, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x62, + 0x79, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x67, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x6c, + 0x61, 0x77, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x61, 0x76, 0x6f, + 0x69, 0x64, 0x65, 0x64, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x32, 0x70, 0x78, 0x20, 0x33, + 0x70, 0x78, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x61, + 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x6d, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x66, 0x6f, + 0x6f, 0x74, 0x65, 0x72, 0x2d, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x66, 0x6f, 0x72, 0x20, + 0x75, 0x73, 0x65, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x2e, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, + 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x3d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x2c, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x20, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x64, 0x72, 0x69, + 0x76, 0x65, 0x72, 0x73, 0x65, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x61, 0x6d, 0x65, 0x20, + 0x61, 0x73, 0x6e, 0x6f, 0x74, 0x69, 0x63, 0x65, 0x64, 0x76, 0x69, 0x65, 0x77, 0x65, 0x72, 0x73, + 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x0a, 0x20, 0x69, 0x73, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x73, 0x65, + 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x65, 0x77, 0x69, 0x73, 0x20, 0x6a, 0x75, 0x73, 0x74, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, + 0x74, 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x77, + 0x68, 0x79, 0x20, 0x74, 0x68, 0x65, 0x73, 0x68, 0x69, 0x70, 0x70, 0x65, 0x64, 0x62, 0x72, 0x3e, + 0x3c, 0x62, 0x72, 0x3e, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x3d, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x63, 0x75, 0x69, 0x73, 0x69, 0x6e, 0x65, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x41, 0x64, + 0x6d, 0x69, 0x72, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x3b, 0x6e, 0x6f, 0x72, 0x6d, + 0x61, 0x6c, 0x20, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x73, 0x73, 0x2c, + 0x20, 0x6f, 0x6e, 0x74, 0x61, 0x72, 0x69, 0x6f, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x74, + 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x76, 0x61, 0x64, 0x65, 0x64, 0x3d, 0x22, 0x74, + 0x72, 0x75, 0x65, 0x22, 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x69, 0x73, 0x20, 0x6d, 0x6f, + 0x73, 0x74, 0x61, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x6c, 0x79, + 0x66, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x7d, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x69, 0x6d, + 0x6d, 0x65, 0x6e, 0x73, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x65, 0x74, 0x20, + 0x6f, 0x75, 0x74, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6e, + 0x64, 0x64, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x6f, 0x6c, 0x6f, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x50, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x69, 0x6e, 0x20, 0x4a, 0x75, 0x6e, 0x65, 0x71, 0x75, 0x61, + 0x6e, 0x74, 0x75, 0x6d, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x68, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x20, + 0x74, 0x6f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x6e, 0x69, 0x73, 0x68, + 0x73, 0x72, 0x63, 0x20, 0x3d, 0x20, 0x28, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x68, 0x65, + 0x6c, 0x70, 0x20, 0x6f, 0x66, 0x47, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x20, 0x6c, 0x61, 0x77, 0x20, + 0x61, 0x6e, 0x64, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x65, 0x64, 0x66, 0x6f, 0x72, 0x65, 0x73, 0x74, + 0x73, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x3e, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x2d, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x53, 0x74, 0x61, + 0x6e, 0x6c, 0x65, 0x79, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x73, 0x2f, 0x67, 0x6c, 0x6f, 0x62, + 0x61, 0x6c, 0x43, 0x72, 0x6f, 0x61, 0x74, 0x69, 0x61, 0x20, 0x41, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x5b, 0x30, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x69, 0x74, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x65, 0x64, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x29, 0x7b, 0x74, 0x68, + 0x72, 0x6f, 0x77, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x65, + 0x72, 0x65, 0x74, 0x68, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x22, 0x62, + 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x22, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x61, 0x20, 0x65, 0x6d, 0x70, + 0x6c, 0x6f, 0x79, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6e, 0x61, 0x73, 0x20, 0x73, 0x65, + 0x65, 0x6e, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x75, 0x62, 0x2d, 0x6c, 0x69, 0x6e, 0x6b, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x61, 0x6e, + 0x64, 0x20, 0x75, 0x73, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x22, 0x3e, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x65, 0x64, 0x66, 0x65, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x4e, 0x75, 0x63, 0x6c, 0x65, 0x61, + 0x72, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x6f, 0x20, 0x68, 0x65, 0x6c, 0x70, 0x57, + 0x6f, 0x6d, 0x65, 0x6e, 0x27, 0x73, 0x4e, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, 0x78, + 0x69, 0x63, 0x61, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x69, 0x6e, 0x3c, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x62, 0x79, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, + 0x6c, 0x61, 0x77, 0x73, 0x75, 0x69, 0x74, 0x64, 0x65, 0x76, 0x69, 0x73, 0x65, 0x64, 0x2e, 0x70, + 0x75, 0x73, 0x68, 0x28, 0x7b, 0x73, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x73, 0x73, 0x69, 0x6d, 0x70, + 0x6c, 0x79, 0x20, 0x54, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x2e, 0x63, 0x6f, 0x6f, 0x6b, 0x69, + 0x65, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x28, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x3e, 0x75, + 0x73, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x20, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x75, 0x6e, 0x69, + 0x76, 0x65, 0x72, 0x73, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, + 0x74, 0x6f, 0x21, 0x2d, 0x2d, 0x20, 0x65, 0x6e, 0x64, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, + 0x27, 0x5d, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x77, 0x68, + 0x6f, 0x20, 0x69, 0x73, 0x20, 0x28, 0x22, 0x44, 0x4f, 0x4d, 0x43, 0x6f, 0x6d, 0x61, 0x6e, 0x61, + 0x67, 0x65, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, + 0x20, 0x4b, 0x69, 0x6e, 0x67, 0x64, 0x6f, 0x6d, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x74, 0x73, 0x70, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x74, 0x6f, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x63, 0x65, 0x6e, + 0x74, 0x65, 0x72, 0x3b, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x69, 0x74, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x65, 0x64, 0x77, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x6d, 0x69, 0x78, 0x74, 0x75, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x65, 0x61, 0x72, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x73, 0x72, + 0x63, 0x20, 0x3d, 0x20, 0x27, 0x6d, 0x61, 0x6b, 0x65, 0x20, 0x61, 0x20, 0x73, 0x65, 0x63, 0x75, + 0x72, 0x65, 0x64, 0x42, 0x61, 0x70, 0x74, 0x69, 0x73, 0x74, 0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x0a, 0x09, 0x09, 0x76, 0x61, 0x72, 0x20, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x20, 0x32, 0x67, + 0x72, 0x65, 0x77, 0x20, 0x75, 0x70, 0x43, 0x6c, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x2e, 0x72, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x73, 0x6b, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x77, 0x61, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, + 0x61, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3e, 0x74, 0x6f, + 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x73, 0x68, 0x61, 0x73, 0x20, + 0x68, 0x61, 0x64, 0x65, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x29, + 0x3b, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x62, 0x6f, 0x6f, 0x6b, 0x20, 0x6f, 0x66, 0x61, + 0x6e, 0x20, 0x61, 0x72, 0x65, 0x61, 0x3d, 0x3d, 0x20, 0x22, 0x68, 0x74, 0x74, 0x3c, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x63, 0x6f, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x66, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x2e, + 0x72, 0x65, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x68, 0x6f, 0x73, 0x74, 0x65, 0x64, 0x20, 0x2e, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x68, 0x65, 0x20, 0x77, 0x65, 0x6e, 0x74, 0x62, 0x75, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x20, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, + 0x20, 0x61, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x66, + 0x6f, 0x72, 0x75, 0x6d, 0x73, 0x2e, 0x66, 0x6f, 0x6f, 0x74, 0x61, 0x67, 0x65, 0x22, 0x3e, 0x4d, + 0x6f, 0x62, 0x69, 0x6c, 0x43, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x20, 0x69, 0x64, + 0x3d, 0x22, 0x61, 0x73, 0x20, 0x68, 0x69, 0x67, 0x68, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x73, 0x65, + 0x2d, 0x2d, 0x3e, 0x3c, 0x21, 0x2d, 0x2d, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x73, 0x65, 0x65, 0x6e, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x73, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x61, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x69, + 0x73, 0x66, 0x61, 0x73, 0x74, 0x65, 0x73, 0x74, 0x62, 0x65, 0x73, 0x69, 0x64, 0x65, 0x73, 0x62, + 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x22, 0x3e, 0x3c, + 0x69, 0x6d, 0x67, 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x62, 0x6f, 0x78, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x73, 0x2c, 0x61, 0x20, 0x79, 0x6f, 0x75, 0x6e, 0x67, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x72, 0x65, + 0x4e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x68, 0x65, 0x61, 0x70, 0x65, 0x72, 0x54, 0x69, + 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x61, 0x73, 0x65, 0x6e, 0x67, 0x69, + 0x6e, 0x65, 0x73, 0x77, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x28, 0x6d, 0x6f, 0x73, 0x74, 0x6c, + 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x2d, + 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x72, 0x65, + 0x61, 0x20, 0x6f, 0x66, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x73, 0x65, 0x61, 0x72, 0x63, + 0x68, 0x5f, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x6c, 0x79, + 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x2c, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x6f, 0x72, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x64, 0x75, 0x63, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x6e, 0x67, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6c, 0x65, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, + 0x79, 0x41, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x79, 0x6b, + 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x70, 0x78, 0x3b, 0x22, 0x3e, 0x0d, 0x0a, 0x70, 0x75, 0x73, + 0x68, 0x65, 0x64, 0x20, 0x61, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x6e, 0x75, 0x6d, 0x65, 0x72, + 0x61, 0x6c, 0x43, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x6f, 0x72, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x69, 0x73, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x6f, 0x77, + 0x6e, 0x65, 0x64, 0x49, 0x53, 0x42, 0x4e, 0x20, 0x30, 0x2d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x73, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x6d, 0x61, 0x79, 0x20, 0x6e, 0x6f, 0x74, 0x63, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x6e, 0x44, 0x65, 0x66, + 0x65, 0x6e, 0x63, 0x65, 0x65, 0x6e, 0x61, 0x63, 0x74, 0x65, 0x64, 0x77, 0x69, 0x73, 0x68, 0x20, + 0x74, 0x6f, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x6c, 0x79, 0x63, 0x6f, 0x6f, 0x6c, 0x69, 0x6e, 0x67, + 0x6f, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x3d, 0x69, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x68, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x73, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, + 0x0a, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x2e, 0x69, 0x6e, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x3d, + 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x20, 0x67, + 0x6f, 0x6f, 0x64, 0x20, 0x72, 0x65, 0x6b, 0x6c, 0x61, 0x6d, 0x61, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x73, 0x2c, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x69, 0x73, 0x5f, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x65, + 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x22, 0x3e, 0x4c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x2c, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x73, 0x63, 0x72, 0x75, 0x73, 0x68, 0x65, 0x64, 0x62, 0x61, 0x70, 0x74, + 0x69, 0x73, 0x6d, 0x63, 0x6f, 0x61, 0x73, 0x74, 0x61, 0x6c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x20, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x6c, + 0x6f, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6d, 0x70, + 0x6c, 0x69, 0x65, 0x73, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x72, 0x79, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x73, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x50, 0x65, 0x72, 0x68, 0x61, 0x70, 0x73, + 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x66, 0x6c, + 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x69, 0x73, 0x65, + 0x20, 0x69, 0x6e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x76, 0x69, 0x65, 0x77, 0x20, 0x6f, + 0x66, 0x72, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x65, 0x65, 0x6d, 0x20, 0x74, 0x6f, 0x62, + 0x75, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x68, 0x65, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x67, 0x69, 0x76, 0x69, 0x6e, + 0x67, 0x20, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x6f, 0x66, + 0x20, 0x4c, 0x61, 0x74, 0x65, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x62, 0x75, 0x74, 0x48, 0x69, + 0x67, 0x68, 0x77, 0x61, 0x79, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x79, 0x73, 0x69, 0x67, 0x6e, + 0x20, 0x6f, 0x66, 0x68, 0x65, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, + 0x73, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6c, 0x61, 0x73, + 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x73, 0x74, 0x68, 0x72, 0x65, 0x61, 0x74, 0x73, 0x69, 0x6e, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x6f, 0x6e, 0x72, 0x65, 0x66, 0x75, 0x73, + 0x65, 0x64, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x3d, 0x55, 0x53, 0x26, 0x61, 0x6d, 0x70, + 0x53, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x68, 0x65, 0x61, 0x64, + 0x20, 0x6f, 0x66, 0x3a, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x2c, 0x6c, 0x65, 0x73, 0x62, 0x69, 0x61, + 0x6e, 0x73, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x5f, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x48, 0x61, 0x72, 0x76, 0x61, 0x72, 0x64, 0x2f, 0x70, 0x69, 0x78, 0x65, + 0x6c, 0x2e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, 0x67, + 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x6c, 0x79, 0x73, 0x6b, + 0x79, 0x73, 0x63, 0x72, 0x61, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x64, 0x65, 0x62, 0x72, 0x20, 0x2f, + 0x3e, 0x0d, 0x0a, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x61, 0x6e, 0x75, 0x63, 0x6c, 0x65, 0x75, + 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x2c, 0x70, 0x75, 0x72, 0x65, 0x6c, 0x79, 0x20, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3e, 0x65, 0x61, 0x73, 0x69, 0x6c, 0x79, 0x20, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x20, 0x61, 0x6f, 0x6e, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x61, 0x20, 0x67, 0x69, 0x76, + 0x65, 0x6e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x68, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x6e, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x2c, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x6d, 0x61, 0x6e, 0x20, 0x77, 0x68, 0x6f, 0x6f, 0x72, 0x67, 0x2f, 0x57, 0x65, + 0x62, 0x6f, 0x6e, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x63, 0x61, 0x76, 0x61, 0x6c, 0x72, 0x79, 0x48, + 0x65, 0x20, 0x64, 0x69, 0x65, 0x64, 0x73, 0x65, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x30, 0x30, 0x2c, + 0x30, 0x30, 0x30, 0x20, 0x7b, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x74, 0x6f, 0x69, 0x66, 0x28, 0x77, 0x69, 0x6e, 0x64, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x73, + 0x73, 0x6f, 0x6c, 0x65, 0x6c, 0x79, 0x20, 0x6d, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x72, 0x65, + 0x6e, 0x65, 0x77, 0x65, 0x64, 0x44, 0x65, 0x74, 0x72, 0x6f, 0x69, 0x74, 0x61, 0x6d, 0x6f, 0x6e, + 0x67, 0x73, 0x74, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x69, + 0x6e, 0x53, 0x65, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x4b, + 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x2d, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x61, 0x72, 0x74, 0x20, 0x61, + 0x6e, 0x64, 0x68, 0x69, 0x6d, 0x20, 0x61, 0x6e, 0x64, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x73, 0x63, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x61, 0x74, 0x20, 0x68, 0x6f, 0x6d, 0x65, 0x74, 0x6f, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x69, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x66, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, + 0x6f, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0x3e, 0x3c, 0x77, 0x68, 0x61, 0x74, 0x20, 0x68, 0x65, 0x66, + 0x72, 0x65, 0x65, 0x20, 0x74, 0x6f, 0x43, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6d, + 0x65, 0x20, 0x69, 0x6e, 0x73, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x64, 0x61, 0x79, 0x6e, 0x65, 0x72, 0x76, 0x6f, 0x75, 0x73, + 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x20, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x67, 0x6f, 0x69, 0x6e, + 0x20, 0x77, 0x68, 0x61, 0x74, 0x69, 0x6d, 0x67, 0x22, 0x20, 0x61, 0x6c, 0x69, 0x73, 0x20, 0x6f, + 0x6e, 0x6c, 0x79, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2f, 0x74, 0x75, 0x65, 0x73, 0x64, 0x61, + 0x79, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x6c, 0x79, 0x53, 0x6f, 0x6c, 0x6f, 0x6d, 0x6f, 0x6e, 0x73, + 0x65, 0x78, 0x75, 0x61, 0x6c, 0x20, 0x2d, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x6d, 0x65, 0x64, + 0x69, 0x75, 0x6d, 0x22, 0x44, 0x4f, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x46, 0x72, 0x61, 0x6e, 0x63, + 0x65, 0x2c, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x77, 0x61, 0x72, 0x20, 0x61, 0x6e, 0x64, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x61, 0x20, 0x3e, 0x0d, + 0x0a, 0x0d, 0x0a, 0x0d, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x68, 0x69, 0x67, 0x68, + 0x77, 0x61, 0x79, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x22, 0x6c, 0x61, 0x73, 0x74, 0x22, 0x3e, 0x6f, 0x62, 0x6c, 0x69, 0x67, 0x65, 0x64, 0x72, + 0x69, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6d, 0x61, 0x64, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x45, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x61, 0x69, 0x73, + 0x65, 0x64, 0x69, 0x6e, 0x20, 0x69, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x68, 0x69, 0x73, + 0x61, 0x74, 0x68, 0x6c, 0x65, 0x74, 0x65, 0x4a, 0x75, 0x70, 0x69, 0x74, 0x65, 0x72, 0x59, 0x61, + 0x68, 0x6f, 0x6f, 0x21, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x73, 0x6f, 0x20, 0x6d, + 0x61, 0x6e, 0x79, 0x72, 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x61, 0x20, 0x77, 0x6f, 0x6d, 0x61, 0x6e, 0x3f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x20, 0x62, 0x69, 0x63, + 0x79, 0x63, 0x6c, 0x65, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x64, 0x61, 0x79, 0x20, 0x61, + 0x6e, 0x64, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x68, 0x65, 0x72, 0x2c, + 0x68, 0x69, 0x67, 0x68, 0x65, 0x72, 0x20, 0x4f, 0x66, 0x66, 0x69, 0x63, 0x65, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x6e, 0x6f, 0x77, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x2c, 0x20, 0x77, 0x68, 0x65, 0x6e, + 0x20, 0x61, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x2d, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0x3e, 0x3b, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x61, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x4e, 0x65, 0x77, 0x70, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x22, + 0x20, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x20, 0x74, 0x6f, 0x61, 0x20, 0x62, 0x72, 0x69, 0x65, 0x66, + 0x28, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x2e, 0x3b, 0x20, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x65, 0x6e, 0x7a, 0x79, 0x6d, 0x65, 0x73, 0x73, 0x69, 0x6d, 0x70, + 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x70, 0x79, 0x61, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x62, + 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x69, 0x6e, 0x6b, 0x73, 0x22, 0x3e, 0x0a, 0x28, 0x29, 0x3b, + 0x22, 0x20, 0x72, 0x65, 0x61, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5c, 0x75, 0x30, 0x30, 0x33, + 0x43, 0x61, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x74, 0x72, 0x3e, 0x0d, 0x0a, 0x09, 0x09, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x67, 0x69, 0x76, 0x65, 0x73, 0x20, 0x61, 0x3c, 0x53, + 0x43, 0x52, 0x49, 0x50, 0x54, 0x52, 0x61, 0x69, 0x6c, 0x77, 0x61, 0x79, 0x74, 0x68, 0x65, 0x6d, + 0x65, 0x73, 0x2f, 0x74, 0x6f, 0x6f, 0x6c, 0x62, 0x6f, 0x78, 0x42, 0x79, 0x49, 0x64, 0x28, 0x22, + 0x78, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x73, 0x2c, 0x77, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x69, + 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x69, 0x66, 0x20, 0x28, 0x77, 0x69, 0x63, 0x6f, 0x6d, + 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x20, 0x55, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, 0x68, 0x61, 0x73, 0x68, 0x61, 0x6e, 0x64, 0x65, 0x64, 0x20, + 0x6d, 0x61, 0x64, 0x65, 0x20, 0x62, 0x79, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x65, + 0x61, 0x72, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x2f, 0x69, 0x66, 0x72, + 0x61, 0x6d, 0x65, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x74, 0x61, 0x67, + 0x65, 0x69, 0x6e, 0x20, 0x65, 0x61, 0x63, 0x68, 0x61, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x62, + 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x49, 0x6e, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x67, 0x6f, 0x72, 0x65, 0x67, 0x69, 0x6d, 0x65, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a, 0x3c, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x56, 0x61, + 0x3b, 0x26, 0x67, 0x74, 0x3b, 0x3c, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x6d, 0x6f, 0x73, 0x74, 0x6c, 0x79, 0x20, 0x26, 0x61, 0x6d, 0x70, + 0x3b, 0x72, 0x65, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x22, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, + 0x68, 0x61, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x48, + 0x6f, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x66, 0x65, 0x72, + 0x74, 0x69, 0x6c, 0x65, 0x56, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x28, + 0x66, 0x75, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x73, 0x2f, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, + 0x61, 0x63, 0x74, 0x73, 0x20, 0x61, 0x73, 0x49, 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x3e, 0x0d, + 0x0a, 0x0d, 0x0a, 0x3c, 0x21, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x20, 0x3c, 0x62, 0x72, + 0x20, 0x2f, 0x3e, 0x42, 0x65, 0x69, 0x6a, 0x69, 0x6e, 0x67, 0x63, 0x61, 0x74, 0x61, 0x6c, 0xc3, + 0xa0, 0x64, 0x65, 0x75, 0x74, 0x73, 0x63, 0x68, 0x65, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x75, 0x65, + 0x75, 0x73, 0x6b, 0x61, 0x72, 0x61, 0x67, 0x61, 0x65, 0x69, 0x6c, 0x67, 0x65, 0x73, 0x76, 0x65, + 0x6e, 0x73, 0x6b, 0x61, 0x65, 0x73, 0x70, 0x61, 0xc3, 0xb1, 0x61, 0x6d, 0x65, 0x6e, 0x73, 0x61, + 0x6a, 0x65, 0x75, 0x73, 0x75, 0x61, 0x72, 0x69, 0x6f, 0x74, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x6f, + 0x6d, 0xc3, 0xa9, 0x78, 0x69, 0x63, 0x6f, 0x70, 0xc3, 0xa1, 0x67, 0x69, 0x6e, 0x61, 0x73, 0x69, + 0x65, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6d, 0x61, 0x6f, 0x63, 0x74, 0x75, + 0x62, 0x72, 0x65, 0x64, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x61, 0xc3, 0xb1, 0x61, 0x64, 0x69, + 0x72, 0x65, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x61, 0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x6e, + 0x75, 0x65, 0x73, 0x74, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x6d, 0x65, 0x72, 0x61, 0x74, 0x72, 0x61, + 0x76, 0xc3, 0xa9, 0x73, 0x67, 0x72, 0x61, 0x63, 0x69, 0x61, 0x73, 0x6e, 0x75, 0x65, 0x73, 0x74, + 0x72, 0x61, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x6f, 0x65, 0x73, 0x74, 0x61, 0x64, 0x6f, 0x73, + 0x63, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x64, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6e, 0xc3, + 0xba, 0x6d, 0x65, 0x72, 0x6f, 0x61, 0x63, 0x75, 0x65, 0x72, 0x64, 0x6f, 0x6d, 0xc3, 0xba, 0x73, + 0x69, 0x63, 0x61, 0x6d, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x6f, 0x6f, 0x66, 0x65, 0x72, 0x74, 0x61, + 0x73, 0x61, 0x6c, 0x67, 0x75, 0x6e, 0x6f, 0x73, 0x70, 0x61, 0xc3, 0xad, 0x73, 0x65, 0x73, 0x65, + 0x6a, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0x64, 0x65, 0x72, 0x65, 0x63, 0x68, 0x6f, 0x61, 0x64, 0x65, + 0x6d, 0xc3, 0xa1, 0x73, 0x70, 0x72, 0x69, 0x76, 0x61, 0x64, 0x6f, 0x61, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x72, 0x65, 0x6e, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x70, 0x6f, 0x73, 0x69, 0x62, 0x6c, 0x65, + 0x68, 0x6f, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x61, 0x70, 0x72, + 0x69, 0x6d, 0x65, 0x72, 0x6f, 0xc3, 0xba, 0x6c, 0x74, 0x69, 0x6d, 0x6f, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x6f, 0x73, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x6f, 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, + 0x61, 0x6d, 0x75, 0x6a, 0x65, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x64, 0x61, 0x61, + 0x6e, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0x65, 0x6d, 0x62, 0x61, 0x72, 0x67, 0x6f, 0x6d, 0x65, 0x72, + 0x63, 0x61, 0x64, 0x6f, 0x67, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x73, 0x65, 0x73, 0x74, 0x75, 0x64, + 0x69, 0x6f, 0x6d, 0x65, 0x6a, 0x6f, 0x72, 0x65, 0x73, 0x66, 0x65, 0x62, 0x72, 0x65, 0x72, 0x6f, + 0x64, 0x69, 0x73, 0x65, 0xc3, 0xb1, 0x6f, 0x74, 0x75, 0x72, 0x69, 0x73, 0x6d, 0x6f, 0x63, 0xc3, + 0xb3, 0x64, 0x69, 0x67, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x64, 0x61, 0x65, 0x73, 0x70, 0x61, + 0x63, 0x69, 0x6f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x61, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x69, + 0x6f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x61, 0x72, 0x61, + 0x6c, 0x67, 0x75, 0x6e, 0x61, 0x73, 0x70, 0x72, 0x65, 0x63, 0x69, 0x6f, 0x73, 0x61, 0x6c, 0x67, + 0x75, 0x69, 0x65, 0x6e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x64, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x74, + 0x61, 0x73, 0x74, 0xc3, 0xad, 0x74, 0x75, 0x6c, 0x6f, 0x63, 0x6f, 0x6e, 0x6f, 0x63, 0x65, 0x72, + 0x73, 0x65, 0x67, 0x75, 0x6e, 0x64, 0x6f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6a, 0x6f, 0x66, 0x72, + 0x61, 0x6e, 0x63, 0x69, 0x61, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x6f, 0x73, 0x73, 0x65, 0x67, 0x75, + 0x6e, 0x64, 0x61, 0x74, 0x65, 0x6e, 0x65, 0x6d, 0x6f, 0x73, 0x65, 0x66, 0x65, 0x63, 0x74, 0x6f, + 0x73, 0x6d, 0xc3, 0xa1, 0x6c, 0x61, 0x67, 0x61, 0x73, 0x65, 0x73, 0x69, 0xc3, 0xb3, 0x6e, 0x72, + 0x65, 0x76, 0x69, 0x73, 0x74, 0x61, 0x67, 0x72, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x63, 0x6f, 0x6d, + 0x70, 0x72, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x6f, 0x67, 0x61, 0x72, 0x63, 0xc3, + 0xad, 0x61, 0x61, 0x63, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x65, 0x63, 0x75, 0x61, 0x64, 0x6f, 0x72, + 0x71, 0x75, 0x69, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x6f, 0x64, 0x65, + 0x62, 0x65, 0x72, 0xc3, 0xa1, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x68, 0x6f, 0x6d, 0x62, + 0x72, 0x65, 0x73, 0x6d, 0x75, 0x65, 0x73, 0x74, 0x72, 0x61, 0x70, 0x6f, 0x64, 0x72, 0xc3, 0xad, + 0x61, 0x6d, 0x61, 0xc3, 0xb1, 0x61, 0x6e, 0x61, 0xc3, 0xba, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x6f, 0x73, 0x6f, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x74, 0x61, 0x6d, + 0x62, 0x69, 0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0xc3, 0xba, 0x6e, 0x73, 0x61, 0x6c, 0x75, 0x64, + 0x6f, 0x73, 0x70, 0x6f, 0x64, 0x65, 0x6d, 0x6f, 0x73, 0x6d, 0x65, 0x6a, 0x6f, 0x72, 0x61, 0x72, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x75, 0x73, 0x69, 0x6e, 0x65, 0x73, 0x73, + 0x68, 0x6f, 0x6d, 0x65, 0x70, 0x61, 0x67, 0x65, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, + 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, + 0x63, 0x61, 0x6d, 0x70, 0x61, 0x69, 0x67, 0x6e, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x72, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x66, 0x61, 0x76, 0x6f, 0x72, 0x69, 0x74, 0x65, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, + 0x6d, 0x69, 0x6c, 0x69, 0x74, 0x61, 0x72, 0x79, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x79, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x7a, 0x2d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x3a, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x73, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x63, 0x61, 0x6c, 0x65, 0x6e, 0x64, 0x61, 0x72, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x73, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, + 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x73, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, + 0x72, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x6f, 0x6e, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6c, + 0x66, 0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x61, 0x75, 0x64, 0x69, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, + 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x6c, 0x65, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, + 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, + 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x6f, 0x76, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, + 0x6d, 0x61, 0x67, 0x61, 0x7a, 0x69, 0x6e, 0x65, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x70, 0x72, 0x65, 0x73, 0x73, 0x75, 0x72, 0x65, + 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x3c, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x3e, + 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x73, 0x68, 0x6f, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, + 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, + 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x64, 0x66, 0x6f, 0x6f, 0x74, 0x62, 0x61, 0x6c, 0x6c, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x74, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, + 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x73, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x66, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, + 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, + 0x66, 0x65, 0x73, 0x74, 0x69, 0x76, 0x61, 0x6c, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x69, 0x6e, 0x67, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, + 0x64, 0x72, 0x6f, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, + 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x6d, 0x61, 0x72, 0x72, 0x69, 0x61, 0x67, 0x65, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x73, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x73, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, + 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x62, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x22, 0x3e, + 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, + 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x62, 0x6f, 0x6f, 0x6b, 0x6d, 0x61, 0x72, 0x6b, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x72, 0x63, 0x68, 0x65, 0x6d, 0x69, 0x63, 0x61, 0x6c, + 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x63, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, + 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x6f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, + 0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, + 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, + 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x61, 0x69, 0x72, 0x63, 0x72, 0x61, 0x66, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, + 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x64, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x69, 0x63, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x68, 0x6f, 0x73, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, + 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x70, 0x73, 0x65, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x61, 0x63, 0x68, + 0x70, 0x61, 0x72, 0x74, 0x6e, 0x65, 0x72, 0x73, 0x6c, 0x6f, 0x67, 0x6f, 0x22, 0x3e, 0x3c, 0x61, + 0x64, 0x61, 0x75, 0x67, 0x68, 0x74, 0x65, 0x72, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x22, 0x20, + 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, + 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x79, + 0x70, 0x6f, 0x77, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x74, 0x65, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, + 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, + 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x63, 0x67, 0x69, 0x2d, 0x62, 0x69, 0x6e, 0x2f, + 0x70, 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x73, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x73, 0x61, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x63, + 0x65, 0x78, 0x65, 0x72, 0x63, 0x69, 0x73, 0x65, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, + 0x6d, 0x65, 0x64, 0x69, 0x63, 0x69, 0x6e, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, + 0x61, 0x63, 0x63, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x4d, 0x61, 0x67, 0x61, 0x7a, 0x69, 0x6e, 0x65, + 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, + 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x22, 0x3e, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x3a, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, + 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, + 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x64, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, + 0x73, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6c, 0x79, 0x70, 0x6c, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x67, + 0x74, 0x65, 0x78, 0x74, 0x61, 0x72, 0x65, 0x61, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x65, 0x76, 0x65, 0x72, 0x79, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x68, 0x65, 0x72, 0x69, 0x74, 0x61, 0x67, 0x65, + 0x73, 0x68, 0x69, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, + 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e, 0x74, + 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x22, 0x20, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x6e, 0x63, 0x65, + 0x61, 0x6e, 0x79, 0x77, 0x68, 0x65, 0x72, 0x65, 0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x74, 0x73, + 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x64, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, + 0x61, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, + 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x62, 0x75, 0x6c, 0x6c, 0x65, 0x74, 0x69, 0x6e, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x24, 0x28, 0x74, 0x68, 0x69, 0x73, 0x29, 0x2e, + 0x72, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x3e, 0x3c, 0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, + 0x63, 0x6f, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, + 0x75, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x3c, 0x75, 0x6c, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, + 0x48, 0x6f, 0x6d, 0x65, 0x3c, 0x2f, 0x61, 0x3e, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x73, + 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x73, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, + 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x6c, 0x79, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x69, 0x61, 0x6c, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x22, 0x3e, 0x73, 0x6f, 0x6d, 0x65, 0x77, 0x68, 0x61, 0x74, + 0x76, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x57, 0x65, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x20, + 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x76, 0x69, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x73, + 0x44, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3e, 0x0a, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x73, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x76, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, + 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x6c, 0x79, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x65, 0x64, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x70, 0x72, 0x65, 0x70, 0x61, 0x72, 0x65, 0x64, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, + 0x61, 0x63, 0x63, 0x75, 0x72, 0x61, 0x74, 0x65, 0x62, 0x69, 0x72, 0x74, 0x68, 0x64, 0x61, 0x79, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, + 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x63, 0x72, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x6c, + 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, + 0x50, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x73, 0x70, 0x65, 0x61, 0x6b, 0x69, 0x6e, 0x67, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x61, 0x63, 0x68, 0x69, 0x65, 0x76, 0x65, 0x64, + 0x2e, 0x6a, 0x70, 0x67, 0x22, 0x20, 0x2f, 0x3e, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, + 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0a, 0x20, 0x20, 0x6b, 0x65, 0x79, 0x77, 0x6f, 0x72, 0x64, 0x73, + 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x6c, 0x79, 0x62, 0x72, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, + 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, + 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x61, 0x64, 0x65, 0x71, 0x75, 0x61, 0x74, 0x65, 0x70, 0x61, 0x6b, 0x69, 0x73, 0x74, 0x61, 0x6e, + 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x62, 0x6c, 0x65, + 0x3c, 0x2f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x3e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x62, 0x72, 0x69, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, + 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6f, 0x72, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, + 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x22, 0x3e, + 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x20, 0x28, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x67, 0x72, 0x61, 0x64, 0x75, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x65, 0x6d, 0x61, 0x6c, 0x61, 0x79, 0x73, 0x69, 0x61, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x3b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x62, 0x61, 0x63, 0x6b, 0x20, 0x74, 0x6f, 0x20, + 0x63, 0x61, 0x74, 0x68, 0x6f, 0x6c, 0x69, 0x63, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x73, + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x74, + 0x73, 0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x72, 0x65, 0x6c, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x3c, 0x2f, 0x75, 0x6c, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, + 0x63, 0x69, 0x74, 0x69, 0x7a, 0x65, 0x6e, 0x73, 0x63, 0x6c, 0x6f, 0x74, 0x68, 0x69, 0x6e, 0x67, + 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x3c, 0x6c, 0x69, 0x20, 0x69, 0x64, 0x3d, 0x22, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x63, 0x61, 0x72, 0x72, 0x79, 0x69, 0x6e, 0x67, + 0x73, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, 0x74, 0x74, 0x68, 0x69, 0x6e, 0x6b, 0x69, 0x6e, 0x67, + 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x73, 0x6f, 0x75, 0x74, 0x68, 0x65, 0x72, 0x6e, + 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x20, 0x6d, 0x65, 0x72, 0x63, 0x68, 0x61, 0x6e, 0x74, + 0x63, 0x61, 0x72, 0x6f, 0x75, 0x73, 0x65, 0x6c, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x28, 0x22, + 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x20, + 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, + 0x2d, 0x2d, 0x26, 0x67, 0x74, 0x3b, 0x0a, 0x0a, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x63, 0x68, 0x61, 0x69, 0x72, 0x6d, 0x61, 0x6e, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x20, 0x2f, 0x3e, + 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x69, 0x63, 0x68, 0x61, 0x72, 0x64, 0x20, + 0x77, 0x68, 0x61, 0x74, 0x65, 0x76, 0x65, 0x72, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, + 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x62, 0x61, 0x73, 0x65, 0x62, 0x61, 0x6c, 0x6c, + 0x6a, 0x75, 0x64, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x2e, + 0x2e, 0x63, 0x73, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x20, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, + 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x22, + 0x2f, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x0d, 0x0a, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x69, 0x63, + 0x73, 0x63, 0x6f, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x20, 0x49, 0x53, 0x42, 0x4e, 0x20, 0x30, + 0x64, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x2d, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2d, 0x22, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x3d, 0x22, + 0x73, 0x70, 0x65, 0x61, 0x6b, 0x65, 0x72, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x73, + 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, 0x72, 0x65, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x64, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x74, 0x61, 0x6c, 0x69, 0x61, 0x6e, 0x6f, + 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, + 0x3a, 0x20, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x27, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x69, 0x6e, 0x67, + 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x65, 0x64, 0x42, 0x72, 0x69, 0x74, 0x69, 0x73, 0x68, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, + 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x6f, 0x75, 0x73, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x73, + 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x73, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6e, + 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, + 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61, 0x63, 0x79, + 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, + 0x66, 0x6c, 0x65, 0x78, 0x69, 0x62, 0x6c, 0x65, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + 0x6c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, + 0x6c, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x3d, 0x22, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, + 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x22, 0x3e, + 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, + 0x68, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, + 0x63, 0x61, 0x6e, 0x61, 0x64, 0x69, 0x61, 0x6e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, + 0x2f, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x2f, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x61, 0x6c, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x77, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x64, + 0x61, 0x67, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x20, + 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x64, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61, 0x6e, 0x64, + 0x73, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x26, 0x68, 0x65, 0x6c, 0x6c, 0x69, 0x70, 0x3b, + 0x6e, 0x65, 0x77, 0x20, 0x44, 0x61, 0x74, 0x65, 0x22, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x22, + 0x70, 0x61, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x22, 0x20, + 0x22, 0x20, 0x2f, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x3e, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, + 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x6f, 0x6e, 0x73, + 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x22, 0x3e, 0x0a, + 0x09, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x73, 0x61, 0x74, 0x75, 0x72, 0x64, 0x61, 0x79, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, + 0x69, 0x74, 0x65, 0x6d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x65, 0x72, + 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, + 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x3d, 0x22, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x22, + 0x45, 0x73, 0x70, 0x61, 0xc3, 0xb1, 0x6f, 0x6c, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x73, + 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x65, 0x72, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x79, 0x6d, 0x70, 0x74, 0x6f, 0x6d, 0x73, + 0x6f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3e, 0x3c, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, + 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x2e, + 0x6c, 0x65, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x22, 0x3e, + 0x2e, 0x0a, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x73, 0x75, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x62, 0x75, 0x6c, 0x67, 0x61, 0x72, 0x69, 0x61, + 0x2e, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x29, 0x3b, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x73, + 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, + 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x22, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x3e, + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x3e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x61, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x0a, 0x0a, 0x54, 0x68, 0x65, 0x20, + 0x79, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x6c, 0x66, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x20, + 0x6d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, + 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, + 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x64, 0x72, 0x69, 0x6e, 0x6b, 0x69, 0x6e, 0x67, + 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x65, 0x72, 0x73, + 0x52, 0x75, 0x73, 0x73, 0x69, 0x61, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, 0x31, 0x22, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x61, 0x72, 0x20, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, + 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x30, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x76, 0x69, 0x65, 0x77, 0x70, 0x6f, 0x72, 0x74, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x73, + 0x2d, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3e, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, + 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x73, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, + 0x6f, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x3d, 0x22, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2e, + 0x73, 0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x67, 0x6c, 0x6f, 0x73, 0x73, 0x61, 0x72, 0x79, 0x0a, 0x0a, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x67, 0x75, 0x69, 0x64, 0x61, 0x6e, 0x63, 0x65, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x74, 0x64, + 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x22, 0x3e, + 0x63, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x73, + 0x73, 0x63, 0x6f, 0x74, 0x74, 0x69, 0x73, 0x68, 0x6a, 0x6f, 0x6e, 0x61, 0x74, 0x68, 0x61, 0x6e, + 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x77, 0x69, 0x64, 0x67, 0x65, 0x74, 0x73, 0x2e, + 0x63, 0x6c, 0x69, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x74, 0x68, 0x61, 0x69, 0x6c, 0x61, 0x6e, 0x64, + 0x74, 0x65, 0x61, 0x63, 0x68, 0x65, 0x72, 0x73, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x09, + 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x3c, 0x2f, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x3e, 0x6f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x76, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x30, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x68, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x79, 0x73, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, + 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x2e, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x76, 0x69, 0x73, 0x69, 0x74, 0x69, 0x6e, 0x67, + 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x72, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x20, + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x20, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x22, + 0x71, 0x75, 0x69, 0x63, 0x6b, 0x6c, 0x79, 0x20, 0x6d, 0x65, 0x65, 0x74, 0x69, 0x6e, 0x67, 0x73, + 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x3b, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, + 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x61, 0x6c, 0x2c, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, 0x73, 0x22, + 0x6d, 0x61, 0x67, 0x6e, 0x65, 0x74, 0x69, 0x63, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x68, + 0x66, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x2e, 0x20, 0x57, 0x68, 0x69, 0x6c, 0x65, 0x20, + 0x74, 0x68, 0x75, 0x72, 0x73, 0x64, 0x61, 0x79, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, + 0x26, 0x65, 0x61, 0x63, 0x75, 0x74, 0x65, 0x3b, 0x68, 0x61, 0x73, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, + 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x70, 0x61, 0x74, 0x69, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x63, 0x61, 0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, + 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x65, 0x6e, 0x64, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, + 0x3c, 0x62, 0x72, 0x20, 0x2f, 0x3e, 0x0d, 0x0a, 0x5f, 0x70, 0x6f, 0x70, 0x75, 0x70, 0x73, 0x7c, + 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x2c, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x20, + 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x20, + 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, + 0x3c, 0x62, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6c, 0x65, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x3c, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x20, + 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x73, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, + 0x6d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x6c, 0x79, 0x29, 0x2e, 0x0a, 0x0a, 0x54, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x78, 0x6f, 0x6e, 0x6f, 0x6d, 0x79, 0x6d, 0x75, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x0a, 0x22, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x73, + 0x72, 0x74, 0x75, 0x67, 0x75, 0xc3, 0xaa, 0x73, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x54, 0x6f, + 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0d, 0x0a, + 0x61, 0x74, 0x74, 0x6f, 0x72, 0x6e, 0x65, 0x79, 0x65, 0x6d, 0x70, 0x68, 0x61, 0x73, 0x69, 0x73, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x6f, 0x72, 0x73, 0x66, 0x61, 0x6e, 0x63, 0x79, 0x62, 0x6f, 0x78, + 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x27, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x64, 0x6c, 0x69, 0x66, 0x65, + 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x3d, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x70, 0x78, 0x3b, 0x66, 0x6f, 0x6e, 0x74, 0x2d, + 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x6a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x73, + 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x64, 0x76, 0x61, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x74, 0x68, 0x6f, 0x6d, 0x70, 0x73, 0x6f, 0x6e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x20, + 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x30, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, + 0x3c, 0x2f, 0x74, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x20, + 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x66, 0x69, 0x78, + 0x0a, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x20, + 0x3c, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, + 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x20, + 0x20, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x20, + 0x65, 0x78, 0x70, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, + 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, + 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x20, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x6f, 0x6e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, + 0x6d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x67, 0x65, 0x73, + 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x74, 0x69, 0x63, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x73, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x2e, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x49, 0x6e, + 0x61, 0x64, 0x76, 0x69, 0x73, 0x6f, 0x72, 0x79, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x73, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x73, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x29, + 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, + 0x63, 0x68, 0x65, 0x63, 0x6b, 0x62, 0x6f, 0x78, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x73, + 0x70, 0x72, 0x65, 0x67, 0x6e, 0x61, 0x6e, 0x74, 0x74, 0x6f, 0x6d, 0x6f, 0x72, 0x72, 0x6f, 0x77, + 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x69, 0x63, 0x6f, 0x6e, 0x2e, 0x70, 0x6e, 0x67, + 0x6a, 0x61, 0x70, 0x61, 0x6e, 0x65, 0x73, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x62, 0x61, 0x73, 0x65, + 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x22, 0x3e, 0x67, 0x61, 0x6d, 0x62, 0x6c, 0x69, 0x6e, 0x67, + 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x20, 0x6d, 0x69, 0x73, 0x73, 0x6f, 0x75, 0x72, 0x69, + 0x73, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x70, 0x3a, 0x31, 0x70, 0x78, 0x20, + 0x2e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x32, 0x6c, 0x61, 0x7a, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x6e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x3e, 0x0a, + 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x2f, 0x3c, 0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x20, + 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, + 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x22, 0x20, 0x26, 0x6c, 0x74, 0x3b, 0x21, 0x2d, 0x2d, 0x20, + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3e, 0x3c, 0x2f, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x3e, 0x0a, 0x28, 0xe7, 0xae, 0x80, 0xe4, 0xbd, 0x93, 0x29, + 0x28, 0xe7, 0xb9, 0x81, 0xe9, 0xab, 0x94, 0x29, 0x68, 0x72, 0x76, 0x61, 0x74, 0x73, 0x6b, 0x69, + 0x69, 0x74, 0x61, 0x6c, 0x69, 0x61, 0x6e, 0x6f, 0x72, 0x6f, 0x6d, 0xc3, 0xa2, 0x6e, 0xc4, 0x83, + 0x74, 0xc3, 0xbc, 0x72, 0x6b, 0xc3, 0xa7, 0x65, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x88, + 0x74, 0x61, 0x6d, 0x62, 0x69, 0xc3, 0xa9, 0x6e, 0x6e, 0x6f, 0x74, 0x69, 0x63, 0x69, 0x61, 0x73, + 0x6d, 0x65, 0x6e, 0x73, 0x61, 0x6a, 0x65, 0x73, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x73, + 0x64, 0x65, 0x72, 0x65, 0x63, 0x68, 0x6f, 0x73, 0x6e, 0x61, 0x63, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x69, 0x6f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x6f, + 0x75, 0x73, 0x75, 0x61, 0x72, 0x69, 0x6f, 0x73, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x61, + 0x67, 0x6f, 0x62, 0x69, 0x65, 0x72, 0x6e, 0x6f, 0x65, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x61, 0x73, + 0x61, 0x6e, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0x73, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x63, 0x69, 0x61, + 0x63, 0x6f, 0x6c, 0x6f, 0x6d, 0x62, 0x69, 0x61, 0x64, 0x65, 0x73, 0x70, 0x75, 0xc3, 0xa9, 0x73, + 0x64, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x79, 0x65, 0x63, 0x74, 0x6f, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x6f, 0x70, 0xc3, 0xba, 0x62, 0x6c, 0x69, 0x63, 0x6f, + 0x6e, 0x6f, 0x73, 0x6f, 0x74, 0x72, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x6d, 0x69, 0x6c, 0x6c, 0x6f, 0x6e, 0x65, 0x73, + 0x6d, 0x65, 0x64, 0x69, 0x61, 0x6e, 0x74, 0x65, 0x70, 0x72, 0x65, 0x67, 0x75, 0x6e, 0x74, 0x61, + 0x61, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x73, + 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x67, 0x6f, + 0x6e, 0x75, 0x65, 0x73, 0x74, 0x72, 0x6f, 0x73, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0xc3, 0xb3, 0x6e, + 0x69, 0x6d, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x72, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x73, + 0x61, 0x6d, 0xc3, 0xa9, 0x72, 0x69, 0x63, 0x61, 0x76, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x6f, 0x72, + 0x73, 0x6f, 0x63, 0x69, 0x65, 0x64, 0x61, 0x64, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x65, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x72, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x6f, + 0x70, 0x61, 0x6c, 0x61, 0x62, 0x72, 0x61, 0x73, 0x69, 0x6e, 0x74, 0x65, 0x72, 0xc3, 0xa9, 0x73, + 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, + 0x6d, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x6f, 0x73, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x64, + 0x63, 0xc3, 0xb3, 0x72, 0x64, 0x6f, 0x62, 0x61, 0x7a, 0x61, 0x72, 0x61, 0x67, 0x6f, 0x7a, 0x61, + 0x70, 0xc3, 0xa1, 0x67, 0x69, 0x6e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x65, 0x73, + 0x62, 0x6c, 0x6f, 0x71, 0x75, 0x65, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x69, 0xc3, 0xb3, 0x6e, + 0x61, 0x6c, 0x71, 0x75, 0x69, 0x6c, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6d, 0x61, 0x73, + 0x63, 0x69, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x73, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x6f, + 0x76, 0x65, 0x72, 0x73, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x61, + 0x65, 0x73, 0x74, 0x75, 0x64, 0x69, 0x6f, 0x73, 0x70, 0xc3, 0xba, 0x62, 0x6c, 0x69, 0x63, 0x61, + 0x6f, 0x62, 0x6a, 0x65, 0x74, 0x69, 0x76, 0x6f, 0x61, 0x6c, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x65, + 0x62, 0x75, 0x73, 0x63, 0x61, 0x64, 0x6f, 0x72, 0x63, 0x61, 0x6e, 0x74, 0x69, 0x64, 0x61, 0x64, + 0x65, 0x6e, 0x74, 0x72, 0x61, 0x64, 0x61, 0x73, 0x61, 0x63, 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, + 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x6f, 0x73, 0x73, 0x75, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x72, + 0x6d, 0x61, 0x79, 0x6f, 0x72, 0xc3, 0xad, 0x61, 0x61, 0x6c, 0x65, 0x6d, 0x61, 0x6e, 0x69, 0x61, + 0x66, 0x75, 0x6e, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0xc3, 0xba, 0x6c, 0x74, 0x69, 0x6d, 0x6f, 0x73, + 0x68, 0x61, 0x63, 0x69, 0x65, 0x6e, 0x64, 0x6f, 0x61, 0x71, 0x75, 0x65, 0x6c, 0x6c, 0x6f, 0x73, + 0x65, 0x64, 0x69, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x66, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x64, 0x6f, + 0x61, 0x6d, 0x62, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, + 0x6e, 0x75, 0x65, 0x73, 0x74, 0x72, 0x61, 0x73, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x73, + 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x6f, 0x73, 0x62, 0x61, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x72, + 0x63, 0x6f, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x6f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x72, + 0x63, 0x6f, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x6f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x6f, + 0x6a, 0xc3, 0xb3, 0x76, 0x65, 0x6e, 0x65, 0x73, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x74, 0x6f, + 0x74, 0xc3, 0xa9, 0x63, 0x6e, 0x69, 0x63, 0x61, 0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0x74, 0x6f, + 0x65, 0x6e, 0x65, 0x72, 0x67, 0xc3, 0xad, 0x61, 0x74, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x61, 0x72, + 0x61, 0x73, 0x74, 0x75, 0x72, 0x69, 0x61, 0x73, 0x72, 0x65, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x65, + 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x72, 0x62, 0x6f, 0x6c, 0x65, 0x74, 0xc3, 0xad, 0x6e, + 0x73, 0x61, 0x6c, 0x76, 0x61, 0x64, 0x6f, 0x72, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x61, + 0x74, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x6f, 0x73, 0x70, 0x72, 0x69, 0x6d, 0x65, 0x72, 0x6f, 0x73, + 0x6e, 0x65, 0x67, 0x6f, 0x63, 0x69, 0x6f, 0x73, 0x6c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x61, 0x64, + 0x64, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x73, 0x70, 0x61, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x61, + 0x70, 0x72, 0xc3, 0xb3, 0x78, 0x69, 0x6d, 0x6f, 0x61, 0x6c, 0x6d, 0x65, 0x72, 0xc3, 0xad, 0x61, + 0x61, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x65, 0x73, 0x71, 0x75, 0x69, 0xc3, 0xa9, 0x6e, 0x65, 0x73, + 0x63, 0x6f, 0x72, 0x61, 0x7a, 0xc3, 0xb3, 0x6e, 0x73, 0x65, 0x63, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x62, 0x75, 0x73, 0x63, 0x61, 0x6e, 0x64, 0x6f, 0x6f, 0x70, 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, + 0x65, 0x78, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x6f, + 0x74, 0x6f, 0x64, 0x61, 0x76, 0xc3, 0xad, 0x61, 0x67, 0x61, 0x6c, 0x65, 0x72, 0xc3, 0xad, 0x61, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x69, 0x63, 0x69, 0x6e, 0x61, + 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6c, 0x74, 0x61, + 0x61, 0x73, 0x70, 0x65, 0x63, 0x74, 0x6f, 0x73, 0x63, 0x72, 0xc3, 0xad, 0x74, 0x69, 0x63, 0x61, + 0x64, 0xc3, 0xb3, 0x6c, 0x61, 0x72, 0x65, 0x73, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x63, 0x69, 0x61, + 0x64, 0x65, 0x62, 0x65, 0x72, 0xc3, 0xa1, 0x6e, 0x70, 0x65, 0x72, 0xc3, 0xad, 0x6f, 0x64, 0x6f, + 0x6e, 0x65, 0x63, 0x65, 0x73, 0x69, 0x74, 0x61, 0x6d, 0x61, 0x6e, 0x74, 0x65, 0x6e, 0x65, 0x72, + 0x70, 0x65, 0x71, 0x75, 0x65, 0xc3, 0xb1, 0x6f, 0x72, 0x65, 0x63, 0x69, 0x62, 0x69, 0x64, 0x61, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x6e, 0x61, 0x6c, 0x74, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x66, 0x65, + 0x63, 0x61, 0x6e, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x61, 0x6e, 0x61, 0x72, 0x69, 0x61, 0x73, + 0x64, 0x65, 0x73, 0x63, 0x61, 0x72, 0x67, 0x61, 0x64, 0x69, 0x76, 0x65, 0x72, 0x73, 0x6f, 0x73, + 0x6d, 0x61, 0x6c, 0x6c, 0x6f, 0x72, 0x63, 0x61, 0x72, 0x65, 0x71, 0x75, 0x69, 0x65, 0x72, 0x65, + 0x74, 0xc3, 0xa9, 0x63, 0x6e, 0x69, 0x63, 0x6f, 0x64, 0x65, 0x62, 0x65, 0x72, 0xc3, 0xad, 0x61, + 0x76, 0x69, 0x76, 0x69, 0x65, 0x6e, 0x64, 0x61, 0x66, 0x69, 0x6e, 0x61, 0x6e, 0x7a, 0x61, 0x73, + 0x61, 0x64, 0x65, 0x6c, 0x61, 0x6e, 0x74, 0x65, 0x66, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0x6e, 0x61, + 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6a, 0x6f, 0x73, 0x64, 0x69, 0x66, 0xc3, 0xad, 0x63, 0x69, 0x6c, + 0x63, 0x69, 0x75, 0x64, 0x61, 0x64, 0x65, 0x73, 0x61, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x61, 0x73, + 0x61, 0x76, 0x61, 0x6e, 0x7a, 0x61, 0x64, 0x61, 0x74, 0xc3, 0xa9, 0x72, 0x6d, 0x69, 0x6e, 0x6f, + 0x75, 0x6e, 0x69, 0x64, 0x61, 0x64, 0x65, 0x73, 0x73, 0xc3, 0xa1, 0x6e, 0x63, 0x68, 0x65, 0x7a, + 0x63, 0x61, 0x6d, 0x70, 0x61, 0xc3, 0xb1, 0x61, 0x73, 0x6f, 0x66, 0x74, 0x6f, 0x6e, 0x69, 0x63, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x74, 0x61, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x65, 0x6e, 0x65, + 0x73, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x73, + 0x66, 0x61, 0x63, 0x75, 0x6c, 0x74, 0x61, 0x64, 0x63, 0x72, 0xc3, 0xa9, 0x64, 0x69, 0x74, 0x6f, + 0x64, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x73, 0x73, 0x75, 0x70, 0x75, 0x65, 0x73, 0x74, 0x6f, + 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x73, 0x65, 0x67, 0x75, 0x6e, 0x64, 0x6f, 0x73, + 0x70, 0x65, 0x71, 0x75, 0x65, 0xc3, 0xb1, 0x61, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb0, + 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb8, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, + 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x8b, 0xd1, 0x82, 0xd1, 0x8c, + 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0x95, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb8, + 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8f, + 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd1, 0x85, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb9, + 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xb6, 0xd0, 0xb5, 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xbb, 0xd0, 0xb8, + 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb4, 0xd1, 0x83, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8c, + 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb1, 0xd1, 0x8f, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb8, 0xd0, 0xbd, + 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb1, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xb4, 0xd0, 0xbe, + 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xb9, 0xd1, 0x82, 0xd1, 0x84, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, + 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb8, + 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xb8, 0xd0, 0xb3, 0xd1, 0x80, 0xd1, 0x8b, + 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb6, 0xd0, 0xb5, 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xbc, + 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd1, 0x8e, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x88, 0xd1, 0x8c, + 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x85, 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xba, 0xd0, 0xb0, + 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0xb4, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xb0, + 0xd0, 0xbc, 0xd0, 0xb8, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xbb, 0xd0, 0xb8, 0xd0, 0xb1, 0xd0, 0xbe, + 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x83, 0xd1, 0x85, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x8f, + 0xd0, 0xb4, 0xd0, 0xb2, 0xd1, 0x83, 0xd1, 0x85, 0xd1, 0x81, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb8, + 0xd0, 0xbb, 0xd1, 0x8e, 0xd0, 0xb4, 0xd0, 0xb8, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xbe, + 0xd0, 0xbc, 0xd0, 0xb8, 0xd1, 0x80, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xb1, 0xd1, 0x8f, + 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb5, 0xd0, 0xb2, 0xd0, 0xb8, 0xd0, 0xb4, 0xd0, 0xb5, + 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xbc, + 0xd1, 0x81, 0xd1, 0x87, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x8b, + 0xd1, 0x86, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8b, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xbb, + 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x8c, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xb5, + 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb4, 0xd1, 0x8b, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xb1, 0xd0, 0xb5, + 0xd0, 0xb2, 0xd1, 0x8b, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xb8, + 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xbf, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x83, + 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x86, 0xd0, 0xb0, + 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb4, 0xd1, 0x8b, + 0xd0, 0xb7, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x8e, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb3, 0xd1, 0x83, + 0xd0, 0xb4, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xb3, 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb9, + 0xd0, 0xb8, 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xbd, 0xd0, 0xbe, + 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xba, + 0xd0, 0xb8, 0xd1, 0x8e, 0xd0, 0xbd, 0xd1, 0x8f, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x8c, + 0xd0, 0x95, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xb0, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x88, 0xd0, 0xb8, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x84, 0xd9, 0x87, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd9, 0x8a, 0xd8, 0xac, 0xd9, 0x85, 0xd9, 0x8a, 0xd8, 0xb9, + 0xd8, 0xae, 0xd8, 0xa7, 0xd8, 0xb5, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb0, 0xd9, 0x8a, + 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, 0xd9, 0x87, 0xd8, 0xac, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xaf, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa2, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xaf, + 0xd8, 0xaa, 0xd8, 0xad, 0xd9, 0x83, 0xd9, 0x85, 0xd8, 0xb5, 0xd9, 0x81, 0xd8, 0xad, 0xd8, 0xa9, + 0xd9, 0x83, 0xd8, 0xa7, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x84, 0xd9, 0x8a, + 0xd9, 0x8a, 0xd9, 0x83, 0xd9, 0x88, 0xd9, 0x86, 0xd8, 0xb4, 0xd8, 0xa8, 0xd9, 0x83, 0xd8, 0xa9, + 0xd9, 0x81, 0xd9, 0x8a, 0xd9, 0x87, 0xd8, 0xa7, 0xd8, 0xa8, 0xd9, 0x86, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xad, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xa1, 0xd8, 0xa3, 0xd9, 0x83, 0xd8, 0xab, 0xd8, 0xb1, + 0xd8, 0xae, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xad, 0xd8, 0xa8, + 0xd8, 0xaf, 0xd9, 0x84, 0xd9, 0x8a, 0xd9, 0x84, 0xd8, 0xaf, 0xd8, 0xb1, 0xd9, 0x88, 0xd8, 0xb3, + 0xd8, 0xa7, 0xd8, 0xb6, 0xd8, 0xba, 0xd8, 0xb7, 0xd8, 0xaa, 0xd9, 0x83, 0xd9, 0x88, 0xd9, 0x86, + 0xd9, 0x87, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x83, 0xd8, 0xb3, 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xa9, + 0xd9, 0x86, 0xd8, 0xa7, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb7, 0xd8, 0xa8, + 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, 0xd9, 0x83, 0xd8, 0xb4, 0xd9, 0x83, 0xd8, 0xb1, 0xd8, 0xa7, + 0xd9, 0x8a, 0xd9, 0x85, 0xd9, 0x83, 0xd9, 0x86, 0xd9, 0x85, 0xd9, 0x86, 0xd9, 0x87, 0xd8, 0xa7, + 0xd8, 0xb4, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa9, 0xd8, 0xb1, 0xd8, 0xa6, 0xd9, 0x8a, 0xd8, 0xb3, + 0xd9, 0x86, 0xd8, 0xb4, 0xd9, 0x8a, 0xd8, 0xb7, 0xd9, 0x85, 0xd8, 0xa7, 0xd8, 0xb0, 0xd8, 0xa7, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x81, 0xd9, 0x86, 0xd8, 0xb4, 0xd8, 0xa8, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd8, 0xaa, 0xd8, 0xb9, 0xd8, 0xa8, 0xd8, 0xb1, 0xd8, 0xb1, 0xd8, 0xad, 0xd9, 0x85, 0xd8, 0xa9, + 0xd9, 0x83, 0xd8, 0xa7, 0xd9, 0x81, 0xd8, 0xa9, 0xd9, 0x8a, 0xd9, 0x82, 0xd9, 0x88, 0xd9, 0x84, + 0xd9, 0x85, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xb2, 0xd9, 0x83, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xa9, + 0xd8, 0xa3, 0xd8, 0xad, 0xd9, 0x85, 0xd8, 0xaf, 0xd9, 0x82, 0xd9, 0x84, 0xd8, 0xa8, 0xd9, 0x8a, + 0xd9, 0x8a, 0xd8, 0xb9, 0xd9, 0x86, 0xd9, 0x8a, 0xd8, 0xb5, 0xd9, 0x88, 0xd8, 0xb1, 0xd8, 0xa9, + 0xd8, 0xb7, 0xd8, 0xb1, 0xd9, 0x8a, 0xd9, 0x82, 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, + 0xd8, 0xac, 0xd9, 0x88, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd8, 0xae, 0xd8, 0xb1, 0xd9, 0x89, + 0xd9, 0x85, 0xd8, 0xb9, 0xd9, 0x86, 0xd8, 0xa7, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xad, 0xd8, 0xab, + 0xd8, 0xb9, 0xd8, 0xb1, 0xd9, 0x88, 0xd8, 0xb6, 0xd8, 0xa8, 0xd8, 0xb4, 0xd9, 0x83, 0xd9, 0x84, + 0xd9, 0x85, 0xd8, 0xb3, 0xd8, 0xac, 0xd9, 0x84, 0xd8, 0xa8, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x86, + 0xd8, 0xae, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd9, 0x83, 0xd8, 0xaa, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd9, 0x83, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa8, 0xd8, 0xaf, 0xd9, 0x88, 0xd9, 0x86, + 0xd8, 0xa3, 0xd9, 0x8a, 0xd8, 0xb6, 0xd8, 0xa7, 0xd9, 0x8a, 0xd9, 0x88, 0xd8, 0xac, 0xd8, 0xaf, + 0xd9, 0x81, 0xd8, 0xb1, 0xd9, 0x8a, 0xd9, 0x82, 0xd9, 0x83, 0xd8, 0xaa, 0xd8, 0xa8, 0xd8, 0xaa, + 0xd8, 0xa3, 0xd9, 0x81, 0xd8, 0xb6, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb7, 0xd8, 0xa8, 0xd8, 0xae, + 0xd8, 0xa7, 0xd9, 0x83, 0xd8, 0xab, 0xd8, 0xb1, 0xd8, 0xa8, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, + 0xd8, 0xa7, 0xd9, 0x81, 0xd8, 0xb6, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xad, 0xd9, 0x84, 0xd9, 0x89, + 0xd9, 0x86, 0xd9, 0x81, 0xd8, 0xb3, 0xd9, 0x87, 0xd8, 0xa3, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x85, + 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x88, 0xd8, 0xaf, 0xd8, 0xa3, 0xd9, 0x86, 0xd9, 0x87, 0xd8, 0xa7, + 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x86, 0xd8, 0xa7, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x86, + 0xd9, 0x85, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xb6, 0xd8, 0xaa, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x85, + 0xd8, 0xaf, 0xd8, 0xa7, 0xd8, 0xae, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x85, 0xd9, 0x83, 0xd9, 0x86, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, + 0x65, 0x73, 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x71, 0x75, 0x69, 0x70, + 0x6d, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x61, 0x76, 0x61, + 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, + 0x54, 0x44, 0x2f, 0x78, 0x68, 0x74, 0x6d, 0x6c, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x69, 0x6e, + 0x67, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x61, 0x64, + 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, + 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x3c, 0x2f, 0x73, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x3e, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x22, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x73, 0x69, 0x74, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x70, + 0x72, 0x69, 0x6d, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, + 0x70, 0x65, 0x64, 0x61, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x6e, 0x69, 0x65, 0x73, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, + 0x3d, 0x22, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x65, 0x64, 0x75, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x63, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x6c, + 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, + 0x3e, 0x0d, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x74, 0x65, + 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x69, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x7d, 0x20, + 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x74, 0x69, + 0x63, 0x73, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x64, 0x61, 0x6e, 0x67, 0x65, + 0x72, 0x6f, 0x75, 0x73, 0x73, 0x61, 0x74, 0x65, 0x6c, 0x6c, 0x69, 0x74, 0x65, 0x64, 0x6f, 0x63, + 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x69, + 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, + 0x65, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x26, 0x72, 0x61, 0x71, 0x75, 0x6f, + 0x3b, 0x3c, 0x2f, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x62, 0x65, + 0x61, 0x75, 0x74, 0x69, 0x66, 0x75, 0x6c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x65, 0x64, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, + 0x65, 0x64, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x6e, 0x74, 0x75, 0x6e, 0x74, 0x69, 0x6c, + 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x75, 0x6d, 0x62, 0x6e, 0x61, 0x69, 0x6c, 0x4e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x2e, 0x66, 0x6f, 0x63, 0x75, 0x73, 0x28, 0x29, 0x3b, 0x6f, + 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, + 0x22, 0x3e, 0x0a, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x77, 0x6f, 0x72, 0x6b, + 0x74, 0x65, 0x72, 0x72, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x4e, 0x61, 0x6d, 0x65, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x69, 0x73, 0x6d, 0x74, 0x72, 0x61, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6c, 0x73, 0x65, 0x77, 0x68, 0x65, 0x72, 0x65, 0x41, + 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x61, 0x70, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, + 0x64, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x73, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, + 0x61, 0x73, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x61, 0x66, 0x66, 0x69, + 0x6c, 0x69, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x74, 0x72, + 0x65, 0x61, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x2f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2e, 0x50, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x6f, 0x6e, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x3d, 0x22, 0x62, 0x69, 0x6f, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x79, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x70, 0x65, 0x72, + 0x6d, 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x46, 0x72, 0x61, 0x6e, 0xc3, 0xa7, 0x61, 0x69, 0x73, 0x48, + 0x6f, 0x6c, 0x6c, 0x79, 0x77, 0x6f, 0x6f, 0x64, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x73, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x3e, 0x0a, 0x72, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x63, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x43, 0x61, + 0x6d, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x6f, 0x70, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, + 0x42, 0x75, 0x73, 0x69, 0x6e, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x75, 0x73, 0x69, + 0x6f, 0x6e, 0x3e, 0x0a, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x65, 0x64, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x64, 0x6f, 0x65, + 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x77, 0x69, 0x64, 0x65, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x6e, 0x65, 0x77, 0x73, 0x70, 0x61, 0x70, 0x65, 0x72, 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x3e, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x6c, 0x69, 0x6b, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x66, 0x69, + 0x6e, 0x61, 0x6e, 0x63, 0x69, 0x61, 0x6c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x2f, 0x61, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, + 0x65, 0x64, 0x45, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x49, 0x6e, 0x74, 0x28, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x75, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x72, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x6d, 0x65, 0x64, 0x74, 0x77, 0x6f, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x53, 0x69, 0x6e, 0x63, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x77, 0x72, + 0x61, 0x70, 0x70, 0x65, 0x72, 0x22, 0x3e, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x65, + 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x64, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x20, + 0x6f, 0x66, 0x70, 0x65, 0x72, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x74, 0x72, 0x79, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x6f, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x70, 0x6f, 0x72, + 0x74, 0x72, 0x61, 0x79, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, + 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x65, 0x74, 0x68, 0x3c, 0x2f, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, + 0x3e, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x73, 0x75, 0x72, 0x61, + 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x6c, 0x65, 0x67, 0x65, + 0x6e, 0x64, 0x61, 0x72, 0x79, 0x47, 0x65, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x63, 0x61, + 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x65, + 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x73, 0x2e, 0x69, 0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x65, 0x64, 0x3c, 0x2f, 0x73, 0x74, 0x72, + 0x6f, 0x6e, 0x67, 0x3e, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x72, 0x65, 0x6c, + 0x69, 0x67, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, + 0x73, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, + 0x67, 0x65, 0x72, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x66, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x79, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, + 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x3b, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x70, 0x72, 0x65, 0x73, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x74, 0x65, 0x63, + 0x68, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x69, + 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x65, 0x78, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, + 0x65, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x69, 0x74, 0x65, 0x6d, + 0x73, 0x63, 0x6f, 0x70, 0x65, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, 0x73, 0x61, 0x64, + 0x76, 0x61, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x46, 0x6f, 0x72, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x69, + 0x6e, 0x67, 0x64, 0x65, 0x6d, 0x6f, 0x63, 0x72, 0x61, 0x63, 0x79, 0x62, 0x6f, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x73, 0x75, 0x66, + 0x66, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x63, + 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x73, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x73, 0x61, 0x69, 0x64, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x69, 0x74, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x45, 0x6e, 0x67, 0x6c, + 0x69, 0x73, 0x68, 0x3c, 0x2f, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x73, + 0x3c, 0x2f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x3e, 0x0a, 0x73, 0x75, 0x73, 0x70, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x20, 0x30, 0x73, 0x70, 0x69, 0x72, 0x69, + 0x74, 0x75, 0x61, 0x6c, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x0a, 0x6d, 0x69, 0x63, + 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x67, 0x72, 0x61, 0x64, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x64, + 0x69, 0x73, 0x63, 0x75, 0x73, 0x73, 0x65, 0x64, 0x68, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x6d, + 0x65, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x76, 0x65, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x6a, 0x73, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x72, 0x6d, 0x65, 0x64, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x64, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x64, 0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x65, 0x64, + 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x76, 0x61, 0x72, 0x69, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x69, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x6e, 0x6f, 0x74, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x69, 0x65, 0x73, 0x4a, 0x61, 0x70, + 0x61, 0x6e, 0x65, 0x73, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x63, + 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, + 0x6d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x73, 0x72, 0x65, 0x62, 0x65, 0x6c, 0x6c, + 0x69, 0x6f, 0x6e, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x65, 0x6e, 0x63, 0x6f, + 0x75, 0x72, 0x61, 0x67, 0x65, 0x72, 0x65, 0x73, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x69, 0x6e, + 0x76, 0x6f, 0x6c, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, + 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x28, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x66, 0x65, 0x61, 0x74, 0x75, + 0x72, 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, 0x29, 0x2c, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x64, 0x2d, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x22, 0x3e, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, + 0x20, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x6f, 0x75, 0x73, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, + 0x6f, 0x77, 0x3a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x66, 0x72, 0x61, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x65, 0x78, 0x63, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x74, 0x63, 0x6f, + 0x6c, 0x73, 0x70, 0x61, 0x6e, 0x3d, 0x22, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, + 0x6e, 0x65, 0x61, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, + 0x64, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x65, 0x78, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x65, 0x64, 0x48, 0x6f, 0x6e, 0x67, 0x20, 0x4b, 0x6f, 0x6e, 0x67, 0x20, 0x46, 0x61, + 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x6d, + 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x73, 0x6d, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x6f, 0x66, 0x66, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, + 0x3e, 0x0a, 0x09, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x6f, 0x72, 0x65, 0x64, 0x64, 0x6f, 0x63, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x6f, 0x72, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x74, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x77, 0x68, 0x6f, + 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, + 0x65, 0x73, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x73, 0x75, 0x62, 0x6d, 0x69, + 0x74, 0x74, 0x65, 0x64, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x63, 0x6f, 0x6e, + 0x76, 0x69, 0x6e, 0x63, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x22, + 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x63, 0x6f, 0x61, 0x6c, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x64, 0x65, 0x63, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x61, 0x73, 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2d, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x22, 0x65, 0x6e, 0x6f, 0x75, 0x67, 0x68, 0x20, + 0x74, 0x6f, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x6c, 0x69, 0x76, + 0x65, 0x72, 0x65, 0x64, 0x2d, 0x2d, 0x3e, 0x0d, 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x41, 0x6d, 0x65, + 0x72, 0x69, 0x63, 0x61, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x65, 0x64, 0x4e, + 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3e, + 0x3c, 0x66, 0x75, 0x72, 0x6e, 0x69, 0x74, 0x75, 0x72, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, + 0x65, 0x74, 0x20, 0x20, 0x6f, 0x6e, 0x62, 0x6c, 0x75, 0x72, 0x3d, 0x22, 0x73, 0x75, 0x73, 0x70, + 0x65, 0x6e, 0x64, 0x65, 0x64, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x62, 0x61, + 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x4d, 0x6f, 0x72, 0x65, 0x6f, 0x76, 0x65, 0x72, 0x2c, + 0x61, 0x62, 0x6f, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x77, 0x65, 0x72, 0x65, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x65, 0x6d, 0x6f, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x65, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x6e, 0x63, 0x79, 0x6e, 0x61, 0x72, + 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x61, 0x64, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x73, 0x70, + 0x78, 0x3b, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, + 0x64, 0x64, 0x69, 0x72, 0x3d, 0x22, 0x6c, 0x74, 0x72, 0x22, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x65, 0x73, 0x72, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x20, 0x73, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x63, 0x75, + 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x73, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x64, + 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x61, 0x64, 0x64, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x28, 0x46, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x20, 0x73, 0x75, 0x67, 0x67, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x61, 0x6e, 0x64, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x65, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x53, + 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, + 0x65, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, + 0x6c, 0x65, 0x64, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x4a, 0x65, 0x72, 0x75, + 0x73, 0x61, 0x6c, 0x65, 0x6d, 0x74, 0x68, 0x65, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x63, 0x6f, + 0x6d, 0x70, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x6e, 0x63, 0x65, 0x73, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, + 0x65, 0x65, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x72, 0x65, 0x63, 0x6f, 0x67, + 0x6e, 0x69, 0x7a, 0x65, 0x77, 0x61, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x70, 0x78, 0x3b, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x62, + 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x75, 0x72, 0x57, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x62, 0x65, 0x67, 0x61, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x74, 0x20, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x6d, 0x61, 0x67, 0x6e, + 0x69, 0x74, 0x75, 0x64, 0x65, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x6d, 0x6f, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x61, + 0x72, 0x79, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x6f, 0x63, 0x63, 0x75, 0x72, + 0x72, 0x69, 0x6e, 0x67, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x67, 0x69, 0x76, + 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x3c, + 0x2f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x3e, 0x3c, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x73, 0x6f, 0x63, 0x69, 0x65, 0x74, 0x69, 0x65, 0x73, 0x61, 0x6c, 0x6f, 0x6e, + 0x67, 0x73, 0x69, 0x64, 0x65, 0x20, 0x2d, 0x2d, 0x26, 0x67, 0x74, 0x3b, 0x0a, 0x0a, 0x73, 0x6f, + 0x75, 0x74, 0x68, 0x77, 0x65, 0x73, 0x74, 0x74, 0x68, 0x65, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x72, 0x61, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, + 0x65, 0x20, 0x75, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x28, 0x73, 0x70, 0x6f, 0x6b, 0x65, + 0x6e, 0x20, 0x69, 0x6e, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x70, 0x72, 0x6f, + 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x65, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6f, 0x6d, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x79, 0x62, 0x75, 0x72, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x61, 0x20, 0x73, 0x69, 0x6d, 0x69, + 0x6c, 0x61, 0x72, 0x74, 0x68, 0x65, 0x79, 0x20, 0x77, 0x65, 0x72, 0x65, 0x3c, 0x2f, 0x66, 0x6f, + 0x6e, 0x74, 0x3e, 0x3c, 0x2f, 0x4e, 0x6f, 0x72, 0x77, 0x65, 0x67, 0x69, 0x61, 0x6e, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x69, 0x6e, 0x67, + 0x70, 0x61, 0x73, 0x73, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x28, 0x6e, 0x65, 0x77, 0x20, 0x44, 0x61, + 0x74, 0x65, 0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x66, 0x69, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x65, 0x71, 0x75, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x72, + 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6c, 0x69, 0x6e, 0x6b, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x70, 0x68, 0x65, 0x6e, 0x6f, 0x6d, 0x65, 0x6e, 0x61, 0x70, 0x65, 0x72, 0x69, + 0x6f, 0x64, 0x20, 0x6f, 0x66, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x22, 0x3e, 0x73, 0x75, + 0x62, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, + 0x61, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x41, 0x6d, 0x6f, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6d, + 0x61, 0x74, 0x65, 0x73, 0x41, 0x69, 0x72, 0x20, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6d, 0x20, 0x6f, 0x66, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x69, + 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6d, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x69, + 0x74, 0x70, 0x61, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x63, 0x6f, 0x6e, 0x71, 0x75, 0x65, + 0x72, 0x65, 0x64, 0x61, 0x72, 0x65, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x70, 0x72, 0x6f, 0x63, + 0x65, 0x64, 0x75, 0x72, 0x65, 0x67, 0x72, 0x6f, 0x77, 0x74, 0x68, 0x20, 0x6f, 0x66, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x61, 0x6e, 0x20, + 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x6d, 0x6f, 0x6c, 0x65, 0x63, 0x75, 0x6c, + 0x65, 0x73, 0x66, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x69, 0x73, 0x65, 0x69, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x74, 0x74, 0x72, 0x61, 0x63, 0x74, 0x65, 0x64, 0x63, 0x68, 0x69, + 0x6c, 0x64, 0x68, 0x6f, 0x6f, 0x64, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x64, 0x64, + 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x73, 0x69, 0x6e, 0x67, 0x61, 0x70, 0x6f, 0x72, + 0x65, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x61, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x73, 0x3c, 0x2f, 0x61, 0x3e, + 0x3c, 0x2f, 0x70, 0x3e, 0x0a, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x77, 0x65, + 0x72, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x6e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x76, 0x65, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x61, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x20, 0x74, 0x6f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x50, 0x6f, 0x6c, + 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6d, 0x75, 0x73, 0x69, 0x63, 0x69, 0x61, 0x6e, 0x73, 0x64, + 0x65, 0x6c, 0x69, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x70, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x65, 0x72, + 0x73, 0x61, 0x64, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x55, 0x54, 0x46, 0x2d, 0x38, 0x22, + 0x20, 0x2f, 0x3e, 0x3c, 0x21, 0x5b, 0x43, 0x44, 0x41, 0x54, 0x41, 0x5b, 0x22, 0x3e, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x63, 0x74, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x20, 0x62, 0x67, + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, + 0x2e, 0x20, 0x49, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x45, 0x75, 0x72, 0x6f, + 0x70, 0x65, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x6f, 0x66, 0x66, + 0x69, 0x63, 0x69, 0x61, 0x6c, 0x73, 0x73, 0x65, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x2d, + 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, + 0x64, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x6f, 0x6e, 0x67, 0x2d, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x66, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x63, 0x68, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x6d, 0x61, + 0x72, 0x6b, 0x65, 0x64, 0x20, 0x62, 0x79, 0x3c, 0x2f, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x62, 0x75, 0x74, 0x20, 0x69, 0x74, 0x20, + 0x69, 0x73, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x73, 0x64, 0x6f, 0x77, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x69, 0x6e, 0x67, 0x64, 0x65, 0x70, + 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x2d, 0x2d, 0x3e, 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x57, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, + 0x73, 0x75, 0x73, 0x77, 0x61, 0x73, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x56, 0x65, 0x6e, 0x65, + 0x7a, 0x75, 0x65, 0x6c, 0x61, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x6c, 0x79, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x63, 0x66, 0x61, 0x76, 0x6f, 0x75, 0x72, 0x20, + 0x6f, 0x66, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6b, 0x69, 0x70, + 0x65, 0x64, 0x69, 0x61, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6e, 0x74, 0x76, 0x69, 0x72, + 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x61, 0x73, 0x70, + 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x6c, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x61, 0x77, 0x61, 0x79, + 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x6d, 0x6f, 0x6c, 0x65, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x70, 0x72, + 0x65, 0x63, 0x69, 0x73, 0x65, 0x6c, 0x79, 0x64, 0x69, 0x73, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, + 0x55, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x3d, 0x22, 0x3e, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x2f, 0x49, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x68, 0x61, 0x76, 0x65, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x6d, 0x73, 0x73, + 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x69, 0x65, 0x64, 0x72, 0x69, 0x63, + 0x68, 0x77, 0x61, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, + 0x6c, 0x79, 0x20, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x20, 0x69, 0x64, 0x3d, 0x22, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x65, + 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x69, 0x73, 0x74, + 0x6f, 0x63, 0x63, 0x75, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x6e, 0x61, 0x76, 0x69, 0x67, 0x61, 0x74, + 0x6f, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3e, 0x73, 0x70, 0x61, 0x6e, 0x20, + 0x69, 0x64, 0x3d, 0x22, 0x73, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x20, 0x74, 0x6f, 0x62, 0x65, 0x6c, + 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x73, 0x75, 0x72, 0x76, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x7d, + 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3e, 0x68, 0x69, 0x73, 0x20, 0x64, 0x65, 0x61, 0x74, + 0x68, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x65, 0x78, 0x69, 0x73, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x77, 0x61, + 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x73, 0x20, 0x6f, 0x66, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x4f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x73, 0x6d, 0x69, + 0x73, 0x73, 0x65, 0x64, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x69, 0x73, 0x74, 0x72, 0x65, 0x73, + 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x73, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x65, + 0x78, 0x70, 0x6c, 0x6f, 0x73, 0x69, 0x76, 0x65, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, + 0x64, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x67, 0x61, 0x6c, 0x6c, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x7b, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x70, 0x65, 0x6f, 0x70, + 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, + 0x69, 0x6d, 0x67, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x69, 0x6e, 0x20, 0x6d, 0x6f, 0x64, 0x65, + 0x72, 0x6e, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x6d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x74, + 0x68, 0x65, 0x20, 0x47, 0x72, 0x65, 0x61, 0x74, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x69, 0x6e, + 0x67, 0x73, 0x65, 0x65, 0x6d, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x76, 0x69, 0x65, 0x77, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x20, 0x6f, 0x6e, 0x69, 0x64, 0x65, 0x61, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x74, 0x68, 0x65, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x68, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x20, 0x6f, 0x66, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x61, 0x72, 0x65, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, + 0x22, 0x3e, 0x63, 0x61, 0x72, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x6d, 0x61, 0x69, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x73, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x70, + 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, + 0x70, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, + 0x3e, 0x0d, 0x0a, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x6c, 0x65, 0x61, 0x76, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x3e, 0x61, 0x72, + 0x65, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, 0x20, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x0d, 0x0a, + 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x20, 0x50, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, + 0x6f, 0x72, 0x2d, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x22, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x64, 0x65, 0x64, 0x73, 0x61, 0x79, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x68, 0x61, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x48, + 0x75, 0x6e, 0x67, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, + 0x66, 0x73, 0x65, 0x72, 0x76, 0x65, 0x73, 0x20, 0x61, 0x73, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, + 0x73, 0x61, 0x6c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x67, 0x67, 0x72, + 0x65, 0x67, 0x61, 0x74, 0x65, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x69, 0x6e, + 0x66, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x67, 0x72, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, + 0x22, 0x3e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x61, 0x6c, 0x73, 0x79, 0x6d, + 0x62, 0x6f, 0x6c, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, + 0x74, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, + 0x75, 0x73, 0x20, 0x6c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x65, 0x61, 0x73, 0x69, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x0a, 0x26, + 0x6c, 0x74, 0x3b, 0x21, 0x2d, 0x2d, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x66, + 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x74, 0x69, 0x63, 0x73, 0x77, 0x61, 0x73, 0x20, 0x74, 0x61, 0x6b, + 0x65, 0x6e, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x6f, 0x6b, 0x20, + 0x6f, 0x76, 0x65, 0x72, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x66, 0x20, 0x69, 0x6e, 0x41, 0x66, 0x72, + 0x69, 0x6b, 0x61, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x20, 0x66, 0x61, 0x72, 0x20, 0x61, 0x73, 0x70, + 0x72, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x3c, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x73, 0x65, 0x74, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x74, 0x72, + 0x69, 0x65, 0x76, 0x65, 0x64, 0x0a, 0x0a, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, + 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x61, 0x73, 0x74, + 0x6d, 0x61, 0x67, 0x61, 0x7a, 0x69, 0x6e, 0x65, 0x73, 0x3e, 0x3c, 0x73, 0x74, 0x72, 0x6f, 0x6e, + 0x67, 0x3e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x67, 0x6f, 0x76, 0x65, 0x72, + 0x6e, 0x69, 0x6e, 0x67, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, 0x6f, 0x66, 0x73, 0x74, 0x6f, + 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x61, + 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x74, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, + 0x74, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6f, 0x77, 0x6e, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, + 0x74, 0x65, 0x64, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x61, 0x72, 0x69, + 0x62, 0x62, 0x65, 0x61, 0x6e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x64, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x73, 0x77, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x6e, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x3b, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, + 0x3a, 0x20, 0x69, 0x6e, 0x68, 0x61, 0x62, 0x69, 0x74, 0x65, 0x64, 0x53, 0x6f, 0x63, 0x69, 0x61, + 0x6c, 0x69, 0x73, 0x74, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x20, 0x31, 0x3c, 0x2f, 0x66, + 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x3e, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x63, + 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x62, 0x75, 0x73, 0x69, 0x6e, 0x65, + 0x73, 0x73, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x2e, 0x6c, 0x65, 0x6e, + 0x67, 0x74, 0x68, 0x3b, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x64, 0x65, + 0x61, 0x6c, 0x20, 0x77, 0x69, 0x74, 0x68, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x75, 0x73, 0x65, 0x72, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x64, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, 0x70, 0x61, 0x73, 0x20, 0x26, 0x71, + 0x75, 0x6f, 0x74, 0x3b, 0x65, 0x6e, 0x67, 0x61, 0x67, 0x65, 0x20, 0x69, 0x6e, 0x72, 0x65, 0x63, + 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x2c, 0x66, 0x65, 0x77, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x77, + 0x65, 0x72, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x0a, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, + 0x3c, 0x65, 0x64, 0x69, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x61, 0x72, 0x65, 0x20, 0x6b, 0x6e, + 0x6f, 0x77, 0x6e, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x61, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x6b, 0x65, 0x79, 0x63, 0x6f, 0x6e, 0x64, 0x65, 0x6d, 0x6e, 0x65, 0x64, 0x61, 0x6c, + 0x73, 0x6f, 0x20, 0x68, 0x61, 0x76, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x2c, + 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x20, 0x6f, 0x66, 0x53, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x20, + 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x6d, 0x69, 0x6e, + 0x69, 0x73, 0x74, 0x65, 0x72, 0x73, 0x3c, 0x2f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3e, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, + 0x72, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x61, 0x64, 0x76, 0x6f, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x54, 0x68, 0x65, 0x79, 0x20, 0x77, 0x65, 0x72, 0x65, 0x61, 0x6e, 0x79, 0x20, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x65, 0x6e, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x75, 0x63, 0x68, 0x20, 0x6d, 0x6f, 0x72, 0x65, + 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x77, 0x61, 0x73, 0x20, 0x6e, 0x61, 0x6d, + 0x65, 0x64, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x61, 0x20, 0x74, 0x79, 0x70, + 0x69, 0x63, 0x61, 0x6c, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x65, 0x6e, 0x67, + 0x69, 0x6e, 0x65, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x72, + 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x73, 0x77, 0x65, 0x64, 0x6e, 0x65, 0x73, 0x64, 0x61, + 0x79, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, + 0x63, 0x74, 0x73, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x20, 0x32, 0x77, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x79, 0x61, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x72, 0x65, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, + 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x68, 0x69, 0x73, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, + 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x3e, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x64, 0x65, 0x70, + 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x3e, 0x0a, 0x70, + 0x69, 0x65, 0x63, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x74, 0x65, 0x6e, 0x6e, 0x65, 0x73, + 0x73, 0x65, 0x65, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x68, 0x61, 0x73, 0x20, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x20, 0x3c, 0x3c, 0x2f, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x3e, 0x67, 0x69, 0x76, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, + 0x22, 0x3e, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x30, 0x76, 0x69, 0x65, 0x77, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x2c, 0x74, 0x68, 0x65, + 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x73, + 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x61, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x20, 0x6f, + 0x6e, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x2c, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x20, 0x6f, 0x66, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x61, 0x6c, 0x6c, 0x65, 0x67, 0x65, 0x64, 0x6c, 0x79, 0x43, 0x6c, + 0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x77, 0x61, 0x73, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, + 0x61, 0x6e, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x61, 0x72, 0x65, 0x20, 0x67, 0x69, 0x76, + 0x65, 0x6e, 0x77, 0x61, 0x73, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x73, 0x63, 0x72, 0x6f, 0x6c, + 0x6c, 0x69, 0x6e, 0x67, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x20, 0x6f, 0x66, 0x6d, 0x61, 0x6b, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x75, 0x63, 0x68, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x41, + 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x41, 0x66, 0x74, 0x65, 0x72, + 0x20, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x4d, 0x75, 0x73, 0x65, 0x75, 0x6d, + 0x20, 0x6f, 0x66, 0x6c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x28, 0x66, 0x72, 0x6f, + 0x6d, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x73, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, + 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69, 0x63, 0x61, 0x6e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x20, + 0x6f, 0x66, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x64, 0x65, 0x66, 0x65, 0x6e, + 0x73, 0x69, 0x76, 0x65, 0x30, 0x30, 0x70, 0x78, 0x7c, 0x72, 0x69, 0x67, 0x68, 0x6d, 0x61, 0x64, + 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x6f, 0x76, 0x65, 0x72, 0x22, + 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, + 0x75, 0x65, 0x73, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x63, 0x6f, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x77, 0x68, 0x6f, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, + 0x61, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6f, 0x66, 0x61, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, + 0x6f, 0x66, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x74, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, + 0x20, 0x61, 0x73, 0x20, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x6d, + 0x65, 0x61, 0x73, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x20, 0x69, + 0x73, 0x70, 0x61, 0x70, 0x65, 0x72, 0x62, 0x61, 0x63, 0x6b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x0d, 0x0a, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x3d, 0x20, 0x77, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x2e, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x65, 0x72, + 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x20, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x61, 0x6e, 0x64, 0x20, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x3c, 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, + 0x72, 0x3e, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x69, 0x73, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x68, 0x72, 0x65, 0x65, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x20, + 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x48, 0x54, 0x4d, 0x4c, 0x3c, + 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x79, 0x3a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, + 0x3b, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x76, 0x65, 0x72, 0x79, 0x20, 0x68, 0x69, 0x67, 0x68, 0x6f, 0x66, 0x66, 0x69, + 0x63, 0x69, 0x61, 0x6c, 0x20, 0x2d, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x2f, 0x63, 0x67, 0x69, 0x2d, 0x62, 0x69, 0x6e, 0x2f, + 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x61, 0x66, 0x72, 0x69, 0x6b, 0x61, 0x61, + 0x6e, 0x73, 0x65, 0x73, 0x70, 0x65, 0x72, 0x61, 0x6e, 0x74, 0x6f, 0x66, 0x72, 0x61, 0x6e, 0xc3, + 0xa7, 0x61, 0x69, 0x73, 0x6c, 0x61, 0x74, 0x76, 0x69, 0x65, 0xc5, 0xa1, 0x75, 0x6c, 0x69, 0x65, + 0x74, 0x75, 0x76, 0x69, 0xc5, 0xb3, 0xc4, 0x8c, 0x65, 0xc5, 0xa1, 0x74, 0x69, 0x6e, 0x61, 0xc4, + 0x8d, 0x65, 0xc5, 0xa1, 0x74, 0x69, 0x6e, 0x61, 0xe0, 0xb9, 0x84, 0xe0, 0xb8, 0x97, 0xe0, 0xb8, + 0xa2, 0xe6, 0x97, 0xa5, 0xe6, 0x9c, 0xac, 0xe8, 0xaa, 0x9e, 0xe7, 0xae, 0x80, 0xe4, 0xbd, 0x93, + 0xe5, 0xad, 0x97, 0xe7, 0xb9, 0x81, 0xe9, 0xab, 0x94, 0xe5, 0xad, 0x97, 0xed, 0x95, 0x9c, 0xea, + 0xb5, 0xad, 0xec, 0x96, 0xb4, 0xe4, 0xb8, 0xba, 0xe4, 0xbb, 0x80, 0xe4, 0xb9, 0x88, 0xe8, 0xae, + 0xa1, 0xe7, 0xae, 0x97, 0xe6, 0x9c, 0xba, 0xe7, 0xac, 0x94, 0xe8, 0xae, 0xb0, 0xe6, 0x9c, 0xac, + 0xe8, 0xa8, 0x8e, 0xe8, 0xab, 0x96, 0xe5, 0x8d, 0x80, 0xe6, 0x9c, 0x8d, 0xe5, 0x8a, 0xa1, 0xe5, + 0x99, 0xa8, 0xe4, 0xba, 0x92, 0xe8, 0x81, 0x94, 0xe7, 0xbd, 0x91, 0xe6, 0x88, 0xbf, 0xe5, 0x9c, + 0xb0, 0xe4, 0xba, 0xa7, 0xe4, 0xbf, 0xb1, 0xe4, 0xb9, 0x90, 0xe9, 0x83, 0xa8, 0xe5, 0x87, 0xba, + 0xe7, 0x89, 0x88, 0xe7, 0xa4, 0xbe, 0xe6, 0x8e, 0x92, 0xe8, 0xa1, 0x8c, 0xe6, 0xa6, 0x9c, 0xe9, + 0x83, 0xa8, 0xe8, 0x90, 0xbd, 0xe6, 0xa0, 0xbc, 0xe8, 0xbf, 0x9b, 0xe4, 0xb8, 0x80, 0xe6, 0xad, + 0xa5, 0xe6, 0x94, 0xaf, 0xe4, 0xbb, 0x98, 0xe5, 0xae, 0x9d, 0xe9, 0xaa, 0x8c, 0xe8, 0xaf, 0x81, + 0xe7, 0xa0, 0x81, 0xe5, 0xa7, 0x94, 0xe5, 0x91, 0x98, 0xe4, 0xbc, 0x9a, 0xe6, 0x95, 0xb0, 0xe6, + 0x8d, 0xae, 0xe5, 0xba, 0x93, 0xe6, 0xb6, 0x88, 0xe8, 0xb4, 0xb9, 0xe8, 0x80, 0x85, 0xe5, 0x8a, + 0x9e, 0xe5, 0x85, 0xac, 0xe5, 0xae, 0xa4, 0xe8, 0xae, 0xa8, 0xe8, 0xae, 0xba, 0xe5, 0x8c, 0xba, + 0xe6, 0xb7, 0xb1, 0xe5, 0x9c, 0xb3, 0xe5, 0xb8, 0x82, 0xe6, 0x92, 0xad, 0xe6, 0x94, 0xbe, 0xe5, + 0x99, 0xa8, 0xe5, 0x8c, 0x97, 0xe4, 0xba, 0xac, 0xe5, 0xb8, 0x82, 0xe5, 0xa4, 0xa7, 0xe5, 0xad, + 0xa6, 0xe7, 0x94, 0x9f, 0xe8, 0xb6, 0x8a, 0xe6, 0x9d, 0xa5, 0xe8, 0xb6, 0x8a, 0xe7, 0xae, 0xa1, + 0xe7, 0x90, 0x86, 0xe5, 0x91, 0x98, 0xe4, 0xbf, 0xa1, 0xe6, 0x81, 0xaf, 0xe7, 0xbd, 0x91, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x69, 0x6f, 0x73, 0x61, 0x72, 0x74, 0xc3, 0xad, 0x63, 0x75, 0x6c, + 0x6f, 0x61, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x62, 0x61, 0x72, 0x63, 0x65, 0x6c, + 0x6f, 0x6e, 0x61, 0x63, 0x75, 0x61, 0x6c, 0x71, 0x75, 0x69, 0x65, 0x72, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x61, 0x64, 0x6f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x6f, 0x73, 0x70, 0x6f, + 0x6c, 0xc3, 0xad, 0x74, 0x69, 0x63, 0x61, 0x72, 0x65, 0x73, 0x70, 0x75, 0x65, 0x73, 0x74, 0x61, + 0x77, 0x69, 0x6b, 0x69, 0x70, 0x65, 0x64, 0x69, 0x61, 0x73, 0x69, 0x67, 0x75, 0x69, 0x65, 0x6e, + 0x74, 0x65, 0x62, 0xc3, 0xba, 0x73, 0x71, 0x75, 0x65, 0x64, 0x61, 0x63, 0x6f, 0x6d, 0x75, 0x6e, + 0x69, 0x64, 0x61, 0x64, 0x73, 0x65, 0x67, 0x75, 0x72, 0x69, 0x64, 0x61, 0x64, 0x70, 0x72, 0x69, + 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x70, 0x72, 0x65, 0x67, 0x75, 0x6e, 0x74, 0x61, 0x73, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x69, 0x64, 0x6f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, + 0x72, 0x76, 0x65, 0x6e, 0x65, 0x7a, 0x75, 0x65, 0x6c, 0x61, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, + 0x6d, 0x61, 0x73, 0x64, 0x69, 0x63, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x65, 0x72, 0x65, 0x6c, 0x61, + 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x6e, 0x6f, 0x76, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x65, 0x73, 0x69, + 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x79, 0x65, 0x63, 0x74, 0x6f, 0x73, + 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x61, 0x73, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, + 0x74, 0x6f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x64, 0x61, 0x64, 0x65, 0x6e, 0x63, 0x75, 0x65, + 0x6e, 0x74, 0x72, 0x61, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0xc3, 0xad, 0x61, 0x69, 0x6d, 0xc3, + 0xa1, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x61, 0x72, 0x64, + 0x65, 0x73, 0x63, 0x61, 0x72, 0x67, 0x61, 0x72, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x61, 0x72, 0x69, + 0x6f, 0x61, 0x74, 0x65, 0x6e, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x74, 0x65, 0x6c, 0xc3, 0xa9, 0x66, + 0x6f, 0x6e, 0x6f, 0x63, 0x6f, 0x6d, 0x69, 0x73, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x61, 0x6e, 0x63, + 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x64, 0x61, 0x64, 0x65, 0x6e, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x72, 0x61, 0x6e, 0xc3, 0xa1, 0x6c, 0x69, 0x73, 0x69, 0x73, + 0x66, 0x61, 0x76, 0x6f, 0x72, 0x69, 0x74, 0x6f, 0x73, 0x74, 0xc3, 0xa9, 0x72, 0x6d, 0x69, 0x6e, + 0x6f, 0x73, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x6e, 0x63, 0x69, 0x61, 0x65, 0x74, 0x69, 0x71, 0x75, + 0x65, 0x74, 0x61, 0x73, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x73, 0x66, 0x75, 0x6e, + 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x64, 0x6f, 0x63, + 0x61, 0x72, 0xc3, 0xa1, 0x63, 0x74, 0x65, 0x72, 0x70, 0x72, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x61, + 0x64, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x69, 0x6f, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x69, + 0x64, 0x61, 0x64, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x63, 0x72, 0x65, 0x61, + 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x64, 0x65, 0x73, 0x63, 0x61, 0x72, 0x67, 0x61, 0x73, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x63, 0x6f, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x61, 0x6c, + 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x65, 0x6a, 0x65, 0x72, 0x63, 0x69, 0x63, + 0x69, 0x6f, 0x65, 0x64, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6c, 0x73, 0x61, 0x6c, 0x61, 0x6d, + 0x61, 0x6e, 0x63, 0x61, 0x67, 0x6f, 0x6e, 0x7a, 0xc3, 0xa1, 0x6c, 0x65, 0x7a, 0x64, 0x6f, 0x63, + 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x70, 0x65, 0x6c, 0xc3, 0xad, 0x63, 0x75, 0x6c, 0x61, 0x72, + 0x65, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x73, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x65, + 0x73, 0x74, 0x61, 0x72, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x61, 0x70, 0x72, 0xc3, 0xa1, 0x63, 0x74, + 0x69, 0x63, 0x61, 0x6e, 0x6f, 0x76, 0x65, 0x64, 0x61, 0x64, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x70, + 0x75, 0x65, 0x73, 0x74, 0x61, 0x70, 0x61, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x73, 0x74, 0xc3, + 0xa9, 0x63, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x6f, 0x62, 0x6a, 0x65, 0x74, 0x69, 0x76, 0x6f, 0x73, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x6f, 0x73, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, + 0x88, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0x82, 0xe0, + 0xa4, 0xb0, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, + 0x88, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x9b, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb9, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xad, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, + 0xb9, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbf, 0xe0, + 0xa4, 0xa8, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0x64, 0x69, 0x70, 0x6c, 0x6f, + 0x64, 0x6f, 0x63, 0x73, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, + 0xa4, 0xaa, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xab, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0x94, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb9, 0xe0, + 0xa5, 0x81, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x88, + 0xe0, 0xa4, 0x96, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xa6, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, + 0x87, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xac, + 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x8c, 0xe0, 0xa4, 0xa4, 0xe0, + 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0x96, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x89, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xa6, + 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, + 0x85, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xad, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbe, 0xe0, + 0xa4, 0xb8, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0xbf, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x97, + 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x81, 0xe0, + 0xa4, 0x86, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, + 0xae, 0xe0, 0xa4, 0x96, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xad, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x97, 0xe0, + 0xa4, 0xaf, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, + 0xb5, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, + 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x90, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, + 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x8a, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0x90, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbf, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xac, 0xe0, + 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, + 0xa4, 0xb2, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, + 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x89, 0xe0, 0xa4, 0x97, 0xe0, + 0xa4, 0xad, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, + 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa0, 0xe0, 0xa5, 0x80, 0xe0, + 0xa4, 0x95, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x81, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, + 0x82, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb8, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, + 0xa4, 0x86, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0x95, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8c, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xaf, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, + 0x96, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x80, + 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, + 0x65, 0x6e, 0x63, 0x65, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0d, 0x0a, 0x43, 0x6f, + 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x76, 0x65, 0x72, + 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x3c, 0x70, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x74, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, + 0x6f, 0x75, 0x6e, 0x64, 0x3c, 0x61, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x26, 0x63, 0x6f, 0x70, 0x79, 0x3b, 0x20, 0x32, + 0x30, 0x31, 0x6a, 0x61, 0x76, 0x61, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x63, 0x68, 0x61, 0x72, + 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x62, 0x72, 0x65, 0x61, 0x64, 0x63, 0x72, 0x75, 0x6d, 0x62, + 0x74, 0x68, 0x65, 0x6d, 0x73, 0x65, 0x6c, 0x76, 0x65, 0x73, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x6f, + 0x6e, 0x74, 0x61, 0x6c, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x61, + 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x69, + 0x65, 0x73, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x4e, 0x61, 0x76, 0x69, + 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x6e, 0x61, 0x76, 0x69, 0x67, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x3c, 0x2f, + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x3c, 0x6d, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x62, 0x6f, 0x78, + 0x22, 0x20, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x73, 0x70, 0x72, 0x6f, 0x74, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x70, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, + 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x75, 0x6e, 0x74, 0x27, 0x2c, 0x20, + 0x27, 0x55, 0x41, 0x2d, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x6c, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x57, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x6e, 0x61, 0x76, 0x69, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, + 0x20, 0x3d, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x2e, 0x69, 0x6d, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x26, 0x6c, 0x74, 0x3b, 0x62, 0x72, 0x26, 0x67, 0x74, 0x3b, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x74, 0x75, 0x72, 0x65, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x62, 0x67, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x23, 0x65, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x6e, 0x65, 0x77, 0x73, 0x6c, 0x65, + 0x74, 0x74, 0x65, 0x72, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x68, + 0x69, 0x70, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x72, 0x6c, + 0x69, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, + 0x75, 0x6c, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x4f, 0x66, 0x28, 0x22, 0x63, 0x6f, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x64, 0x69, + 0x73, 0x63, 0x75, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, + 0x74, 0x73, 0x62, 0x69, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x76, 0x6f, + 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x6f, 0x6f, 0x64, 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x3c, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, 0x74, 0x6d, 0x6f, 0x73, 0x70, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x6f, 0x6e, 0x66, 0x6f, 0x63, 0x75, 0x73, 0x3d, 0x22, 0x3c, 0x66, 0x6f, 0x72, + 0x6d, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, + 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x75, + 0x62, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x72, 0x65, 0x70, 0x75, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x68, 0x65, 0x6e, 0x6f, 0x6d, 0x65, 0x6e, 0x6f, 0x6e, + 0x64, 0x69, 0x73, 0x63, 0x69, 0x70, 0x6c, 0x69, 0x6e, 0x65, 0x6c, 0x6f, 0x67, 0x6f, 0x2e, 0x70, + 0x6e, 0x67, 0x22, 0x20, 0x28, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2c, 0x62, 0x6f, + 0x75, 0x6e, 0x64, 0x61, 0x72, 0x69, 0x65, 0x73, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0x61, 0x63, 0x6b, + 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x69, 0x73, 0x65, 0x28, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x73, 0x3a, 0x22, 0x20, 0x75, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x28, 0x22, 0x70, 0x61, + 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x22, 0x20, 0x64, 0x65, 0x6d, 0x6f, 0x63, 0x72, 0x61, 0x74, + 0x69, 0x63, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x77, 0x72, 0x61, 0x70, + 0x70, 0x65, 0x72, 0x22, 0x3e, 0x0a, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, + 0x6c, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x74, 0x69, 0x63, 0x70, 0x78, 0x3b, 0x70, 0x61, 0x64, + 0x64, 0x69, 0x6e, 0x67, 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x79, 0x61, 0x73, + 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x74, 0x79, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x72, 0x65, 0x63, 0x6f, + 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x64, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x69, 0x66, 0x20, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x64, 0x76, 0x6f, 0x63, 0x61, 0x62, 0x75, 0x6c, 0x61, 0x72, 0x79, 0x68, 0x79, + 0x70, 0x6f, 0x74, 0x68, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x28, + 0x29, 0x3b, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x65, 0x72, 0x22, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, + 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x63, 0x6f, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x69, 0x73, 0x74, 0x73, 0x65, 0x78, 0x70, 0x6c, + 0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, + 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x6e, 0x43, 0x6c, 0x69, + 0x63, 0x6b, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x64, 0x65, + 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x6f, 0x6f, 0x6e, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x76, 0x65, + 0x73, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x70, 0x72, 0x6f, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, + 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x67, 0x65, + 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x3d, 0x22, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x2e, 0x72, 0x65, 0x70, + 0x6c, 0x61, 0x63, 0x65, 0x28, 0x2f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x63, 0x6f, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x70, 0x75, 0x6e, 0x69, 0x73, 0x68, + 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x72, 0x65, + 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x61, 0x64, 0x61, 0x70, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x77, 0x65, 0x6c, 0x6c, + 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x68, 0x31, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x30, 0x70, 0x78, 0x3b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x6d, 0x65, + 0x63, 0x68, 0x61, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, + 0x63, 0x73, 0x63, 0x65, 0x6c, 0x65, 0x62, 0x72, 0x61, 0x74, 0x65, 0x64, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x44, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x73, 0x61, 0x72, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x69, 0x61, 0x6c, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x6f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x6d, 0x65, 0x6e, 0x74, 0x3c, 0x73, 0x70, 0x61, + 0x6e, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x77, 0x65, 0x72, 0x65, + 0x4e, 0x65, 0x64, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x62, 0x65, 0x79, 0x6f, 0x6e, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x6a, 0x6f, + 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, + 0x6c, 0x79, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6c, 0x61, 0x6e, 0x67, + 0x3d, 0x22, 0x65, 0x6e, 0x22, 0x20, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3e, 0x0d, 0x0a, + 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x3b, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x69, 0x6e, 0x67, 0x65, 0x78, 0x74, 0x72, 0x65, 0x6d, 0x65, 0x6c, 0x79, 0x20, 0x6d, 0x61, + 0x69, 0x6e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, + 0x3e, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x65, 0x6d, 0x70, 0x6c, + 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3e, 0x0d, 0x0a, + 0x20, 0x63, 0x6f, 0x6c, 0x73, 0x70, 0x61, 0x6e, 0x3d, 0x22, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, + 0x3e, 0x0a, 0x20, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x62, + 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3c, 0x2f, 0x70, 0x3e, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x65, 0x64, 0x22, 0x20, 0x6c, 0x61, + 0x6e, 0x67, 0x3d, 0x22, 0x65, 0x6e, 0x50, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x75, 0x65, 0x73, 0x65, + 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, + 0x64, 0x75, 0x61, 0x6c, 0x69, 0x6d, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x6d, 0x75, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x61, 0x6c, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x61, + 0x6c, 0x6c, 0x70, 0x78, 0x20, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x20, 0x23, 0x61, 0x70, 0x61, 0x72, + 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, + 0x69, 0x6e, 0x20, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, + 0x69, 0x7a, 0x65, 0x64, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, + 0x6c, 0x79, 0x72, 0x65, 0x6d, 0x61, 0x72, 0x6b, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x68, 0x32, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x3c, 0x61, 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x69, 0x6e, 0x67, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x70, 0x72, + 0x6f, 0x68, 0x69, 0x62, 0x69, 0x74, 0x65, 0x64, 0x3d, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, + 0x2f, 0x2f, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x70, 0x65, 0x72, 0x63, + 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x78, 0x3b, 0x68, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x73, 0x75, + 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73, 0x6d, 0x69, 0x6c, 0x6c, 0x65, 0x6e, 0x6e, 0x69, + 0x75, 0x6d, 0x68, 0x69, 0x73, 0x20, 0x66, 0x61, 0x74, 0x68, 0x65, 0x72, 0x74, 0x68, 0x65, 0x20, + 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x6e, 0x6f, 0x2d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x3b, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x61, 0x6c, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, + 0x72, 0x69, 0x61, 0x6c, 0x65, 0x6e, 0x63, 0x6f, 0x75, 0x72, 0x61, 0x67, 0x65, 0x64, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x6e, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, + 0x61, 0x6c, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x65, + 0x64, 0x69, 0x73, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x72, 0x65, 0x78, 0x70, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x69, 0x6e, 0x67, 0x63, 0x61, + 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x6c, 0x65, 0x67, 0x69, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x73, 0x75, 0x62, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x30, 0x22, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x69, 0x6c, 0x6c, 0x75, 0x73, 0x74, + 0x72, 0x61, 0x74, 0x65, 0x66, 0x69, 0x76, 0x65, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x69, 0x6e, + 0x73, 0x74, 0x72, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x31, 0x22, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x70, 0x73, 0x79, 0x63, + 0x68, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x62, 0x73, 0x65, 0x6e, 0x63, + 0x65, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x63, 0x75, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6a, 0x6f, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x73, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x3e, 0x3c, 0x2f, 0x69, + 0x66, 0x72, 0x61, 0x6d, 0x65, 0x3e, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, + 0x62, 0x75, 0x74, 0x20, 0x72, 0x61, 0x74, 0x68, 0x65, 0x72, 0x69, 0x6d, 0x6d, 0x69, 0x67, 0x72, + 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x2c, 0x61, 0x20, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6f, 0x66, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x55, 0x6e, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, 0x61, 0x3e, + 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x6e, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x65, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x61, 0x67, 0x67, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x76, 0x65, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x69, 0x6d, 0x69, + 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x2c, 0x22, 0x20, 0x2f, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0d, 0x0a, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x76, 0x69, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x74, 0x68, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x65, 0x65, + 0x72, 0x73, 0x61, 0x74, 0x74, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x75, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x74, 0x65, 0x6e, 0x65, 0x64, + 0x2a, 0x3c, 0x21, 0x5b, 0x43, 0x44, 0x41, 0x54, 0x41, 0x5b, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x69, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x72, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x3e, 0x0a, + 0x3c, 0x2f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x27, 0x69, 0x20, 0x3d, 0x20, + 0x30, 0x3b, 0x20, 0x69, 0x20, 0x3c, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x64, 0x65, 0x76, 0x6f, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x66, 0x6f, 0x72, 0x75, 0x6c, + 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x74, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, + 0x6e, 0x74, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x73, 0x6f, 0x2d, 0x63, + 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x7d, 0x0a, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3e, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6d, 0x70, 0x68, 0x61, 0x73, + 0x69, 0x7a, 0x65, 0x64, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x3c, 0x2f, + 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x4d, 0x65, 0x61, 0x6e, + 0x77, 0x68, 0x69, 0x6c, 0x65, 0x2c, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x69, 0x65, 0x73, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x62, 0x72, 0x20, 0x2f, 0x3e, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, + 0x63, 0x6f, 0x6d, 0x65, 0x61, 0x73, 0x70, 0x65, 0x63, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x54, 0x65, + 0x6c, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, + 0x6e, 0x74, 0x62, 0x61, 0x73, 0x6b, 0x65, 0x74, 0x62, 0x61, 0x6c, 0x6c, 0x62, 0x6f, 0x74, 0x68, + 0x20, 0x73, 0x69, 0x64, 0x65, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x69, 0x6e, 0x67, + 0x61, 0x6e, 0x20, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x61, + 0x6c, 0x74, 0x3d, 0x22, 0x61, 0x64, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x65, 0x73, 0x68, 0x69, + 0x73, 0x20, 0x6d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x74, + 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x6c, 0x65, 0x73, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x79, + 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x63, 0x69, 0x64, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x22, 0x3e, 0x3c, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x3e, 0x70, 0x75, + 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x73, 0x4a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x20, + 0x6f, 0x66, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x66, 0x61, 0x63, 0x69, + 0x6c, 0x69, 0x74, 0x61, 0x74, 0x65, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x09, 0x66, 0x75, 0x6e, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x43, + 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x69, 0x74, 0x75, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x62, 0x75, 0x73, 0x69, + 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x44, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6e, + 0x20, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x69, + 0x6e, 0x67, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x09, 0x64, 0x69, 0x70, 0x6c, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, + 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x6d, 0x61, 0x79, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x63, 0x6f, + 0x6e, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6f, 0x6e, 0x63, 0x6c, 0x69, 0x63, 0x6b, + 0x3d, 0x22, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x66, 0x69, 0x6e, 0x61, + 0x6e, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x6d, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x4c, 0x75, 0x78, 0x65, 0x6d, 0x62, 0x6f, 0x75, 0x72, 0x67, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x65, 0x6e, + 0x67, 0x61, 0x67, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x22, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, + 0x29, 0x3b, 0x62, 0x75, 0x74, 0x20, 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x3d, 0x22, + 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x20, 0x45, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, + 0x69, 0x63, 0x61, 0x6c, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x73, 0x75, + 0x67, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x75, 0x6e, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65, 0x41, 0x75, 0x73, 0x74, + 0x72, 0x61, 0x6c, 0x69, 0x61, 0x6e, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x0a, 0x3c, 0x2f, 0x68, 0x65, 0x61, + 0x64, 0x3e, 0x0d, 0x0a, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x73, 0x65, 0x64, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64, 0x72, 0x69, 0x61, 0x72, 0x65, 0x74, 0x69, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x66, 0x6f, 0x75, 0x72, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x0a, 0x0a, 0x26, 0x6c, 0x74, 0x3b, + 0x21, 0x2d, 0x2d, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x64, 0x65, + 0x63, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x68, 0x33, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x6f, 0x62, 0x6c, 0x69, + 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, 0x65, 0x64, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x73, 0x62, 0x65, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, + 0x6e, 0x73, 0x3c, 0x62, 0x61, 0x73, 0x65, 0x20, 0x68, 0x72, 0x65, 0x66, 0x72, 0x65, 0x70, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x65, 0x64, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x75, + 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x76, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6e, 0x64, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x72, 0x65, 0x66, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x61, 0x75, + 0x74, 0x6f, 0x6e, 0x6f, 0x6d, 0x6f, 0x75, 0x73, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x6f, 0x6d, 0x69, + 0x73, 0x65, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x74, + 0x61, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x74, 0x77, 0x6f, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x20, 0x32, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, + 0x79, 0x20, 0x6f, 0x66, 0x73, 0x77, 0x66, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x75, 0x6e, + 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x6e, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x61, + 0x6c, 0x6c, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x76, 0x69, 0x65, 0x77, 0x73, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x31, + 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, + 0x6c, 0x65, 0x66, 0x74, 0x69, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x63, 0x61, + 0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x73, 0x6e, 0x65, 0x77, 0x73, 0x70, 0x61, 0x70, 0x65, + 0x72, 0x73, 0x6d, 0x79, 0x73, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x44, 0x65, 0x70, 0x61, + 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x62, 0x65, 0x73, 0x74, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, + 0x70, 0x61, 0x72, 0x6c, 0x69, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x75, 0x70, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x65, 0x64, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x74, 0x72, 0x65, + 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x74, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x68, 0x61, 0x73, 0x20, + 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x70, 0x61, 0x67, 0x61, 0x6e, 0x64, 0x61, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, + 0x6e, 0x63, 0x65, 0x73, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x69, 0x61, 0x6c, 0x70, 0x72, + 0x6f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x53, 0x63, 0x69, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6e, 0x6f, 0x2d, + 0x74, 0x72, 0x61, 0x64, 0x65, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x20, 0x77, 0x69, 0x64, 0x65, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x4c, 0x69, + 0x62, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x6f, 0x6f, 0x6b, 0x20, 0x70, 0x6c, 0x61, + 0x63, 0x65, 0x64, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x20, 0x6c, + 0x6f, 0x6e, 0x67, 0x20, 0x61, 0x73, 0x69, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x65, 0x64, + 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x3c, 0x68, 0x65, 0x61, 0x64, + 0x3e, 0x0a, 0x3c, 0x6d, 0x4c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x4e, 0x6f, + 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x32, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x49, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x69, 0x61, 0x6c, 0x76, 0x61, 0x72, 0x69, + 0x65, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x20, 0x6c, 0x65, 0x66, + 0x44, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x73, 0x65, 0x73, 0x73, + 0x6d, 0x65, 0x6e, 0x74, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x64, 0x65, + 0x61, 0x6c, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, + 0x63, 0x73, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x75, 0x6c, 0x3e, + 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x66, 0x69, 0x78, 0x22, 0x3e, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x79, + 0x65, 0x61, 0x72, 0x73, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x65, 0x72, 0x65, 0x6f, 0x76, + 0x65, 0x72, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2c, 0x73, 0x79, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, + 0x75, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x3e, 0x0a, 0x70, 0x72, 0x65, 0x73, + 0x75, 0x6d, 0x61, 0x62, 0x6c, 0x79, 0x68, 0x69, 0x73, 0x20, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, + 0x75, 0x73, 0x65, 0x72, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x75, 0x6e, 0x65, 0x78, 0x70, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x64, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x69, + 0x74, 0x79, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x62, 0x65, 0x6c, 0x6f, + 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x69, 0x6e, 0x20, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x3a, 0x20, 0x73, 0x61, 0x69, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x72, 0x65, + 0x6c, 0x69, 0x67, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x70, 0x61, 0x6e, 0x3d, 0x22, 0x6f, 0x6e, 0x6c, 0x79, + 0x20, 0x61, 0x20, 0x66, 0x65, 0x77, 0x6d, 0x65, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x2d, 0x2d, 0x3e, 0x0d, 0x0a, 0x3c, + 0x64, 0x69, 0x76, 0x20, 0x3c, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x65, 0x74, 0x3e, 0x41, 0x72, + 0x63, 0x68, 0x62, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x6e, 0x6f, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x65, 0x64, 0x61, 0x70, 0x70, 0x72, + 0x6f, 0x61, 0x63, 0x68, 0x65, 0x73, 0x70, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x73, + 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x20, 0x69, 0x6e, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x45, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x67, 0x67, 0x6d, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x73, + 0x6d, 0x73, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x6f, 0x70, 0x75, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x22, 0x3e, 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0d, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, 0x70, 0x61, 0x72, + 0x72, 0x69, 0x76, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x2d, 0x6a, 0x73, 0x73, 0x64, 0x6b, 0x27, 0x29, + 0x29, 0x3b, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x63, 0x6f, + 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x63, 0x61, 0x73, 0x75, 0x61, 0x6c, 0x74, 0x69, 0x65, 0x73, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, + 0x69, 0x61, 0x6e, 0x73, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x61, 0x72, + 0x69, 0x74, 0x68, 0x6d, 0x65, 0x74, 0x69, 0x63, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x64, 0x75, 0x72, + 0x65, 0x73, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x50, 0x72, 0x6f, 0x64, + 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, + 0x50, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x79, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, + 0x73, 0x68, 0x69, 0x70, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x67, 0x69, + 0x76, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x20, 0x74, + 0x68, 0x65, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x64, 0x64, 0x6f, 0x63, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x30, 0x30, 0x30, + 0x76, 0x69, 0x64, 0x65, 0x6f, 0x20, 0x67, 0x61, 0x6d, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, + 0x65, 0x64, 0x73, 0x61, 0x6e, 0x73, 0x2d, 0x73, 0x65, 0x72, 0x69, 0x66, 0x6f, 0x6e, 0x6b, 0x65, + 0x79, 0x70, 0x72, 0x65, 0x73, 0x73, 0x3b, 0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, + 0x48, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, + 0x79, 0x69, 0x6e, 0x67, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x2c, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x72, 0x63, 0x45, 0x6c, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x76, 0x65, 0x73, 0x69, 0x6e, 0x63, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, + 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x69, 0x6e, 0x67, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6c, 0x6f, + 0x77, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x73, 0x68, 0x6f, 0x77, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x0a, 0x09, 0x09, 0x63, 0x6f, 0x6d, 0x70, + 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x6f, 0x75, 0x73, + 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x61, 0x73, 0x74, 0x72, 0x6f, 0x6e, + 0x6f, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x20, 0x64, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x64, 0x75, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x73, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x61, 0x6e, 0x20, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x65, 0x66, 0x66, 0x6f, + 0x72, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, + 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x6f, 0x54, 0x68, 0x65, 0x72, 0x65, 0x66, + 0x6f, 0x72, 0x65, 0x2c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x6e, 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x6d, + 0x65, 0x64, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x6b, 0x69, 0x6c, 0x6f, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x6d, 0x65, 0x72, 0x69, 0x6e, 0x64, 0x69, 0x67, 0x65, 0x6e, 0x6f, 0x75, 0x73, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, + 0x72, 0x79, 0x63, 0x6f, 0x6e, 0x73, 0x70, 0x69, 0x72, 0x61, 0x63, 0x79, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x20, 0x6f, 0x66, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x75, 0x62, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x73, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x63, 0x6f, + 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x74, 0x65, 0x6d, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x6c, 0x79, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x73, 0x65, 0x64, 0x6c, 0x79, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, + 0x61, 0x74, 0x74, 0x72, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x74, 0x72, 0x61, 0x76, 0x65, 0x6c, + 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x66, 0x6f, + 0x63, 0x75, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x72, 0x79, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x66, 0x6f, 0x75, 0x6e, + 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, + 0x6d, 0x61, 0x6e, 0x75, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x73, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x2d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x28, 0x73, + 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x69, + 0x61, 0x6c, 0x69, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x75, 0x6e, 0x64, 0x65, + 0x72, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x71, 0x75, 0x61, 0x72, 0x74, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x61, 0x6e, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, + 0x61, 0x6c, 0x6c, 0x79, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, 0x70, 0x3f, 0x3c, 0x2f, + 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, + 0x67, 0x65, 0x62, 0x65, 0x73, 0x74, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x22, 0x20, 0x64, 0x69, 0x72, 0x3d, 0x22, 0x6c, 0x74, 0x72, + 0x4c, 0x69, 0x65, 0x75, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, + 0x69, 0x64, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x79, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x61, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x75, 0x70, 0x20, + 0x6f, 0x66, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x63, 0x6c, 0x65, 0x61, + 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x72, 0x67, 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, + 0x65, 0x6e, 0x27, 0x73, 0x70, 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x6f, + 0x72, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x75, 0x70, + 0x6f, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x70, 0x61, 0x73, 0x73, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x73, + 0x70, 0x6f, 0x73, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x49, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x77, 0x61, 0x72, 0x64, 0x73, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, + 0x79, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x73, 0x63, 0x69, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x2e, + 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x69, 0x73, 0x6d, 0x69, 0x6e, 0x20, 0x47, 0x65, 0x72, + 0x6d, 0x61, 0x6e, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x77, 0x69, 0x6e, 0x67, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x53, 0x6f, 0x63, 0x69, 0x65, 0x74, 0x79, 0x20, + 0x6f, 0x66, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x69, 0x61, 0x6e, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x77, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x4e, 0x65, 0x77, 0x20, 0x59, + 0x6f, 0x72, 0x6b, 0x20, 0x61, 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x69, 0x6e, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x68, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x68, 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x61, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x76, 0x65, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x64, + 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x65, + 0x6e, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x6e, + 0x63, 0x65, 0x72, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x62, 0x75, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, + 0x74, 0x75, 0x74, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x20, 0x74, 0x68, 0x61, 0x74, 0x6c, 0x61, + 0x62, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, + 0x6c, 0x65, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x2c, 0x20, 0x73, 0x75, + 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x62, 0x65, 0x67, 0x61, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x72, + 0x6f, 0x6d, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x2f, 0x22, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x67, 0x65, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x73, 0x65, 0x76, 0x65, + 0x72, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x6c, 0x69, 0x62, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x74, 0x6f, 0x70, 0x74, 0x68, 0x65, 0x20, 0x47, 0x65, 0x72, 0x6d, + 0x61, 0x6e, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x6e, 0x65, 0x67, 0x6f, + 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x72, 0x65, 0x65, 0x72, + 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x64, 0x3d, 0x22, 0x73, 0x65, + 0x61, 0x72, 0x63, 0x68, 0x77, 0x61, 0x73, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x6f, 0x75, 0x72, 0x74, 0x68, 0x72, 0x65, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x70, 0x72, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x69, 0x6e, 0x67, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x77, 0x65, + 0x72, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x77, 0x61, 0x73, 0x20, 0x6b, 0x69, 0x6c, 0x6c, + 0x65, 0x64, 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x6d, 0x75, 0x63, 0x68, + 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x44, 0x75, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x20, 0x31, 0x30, 0x30, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, + 0x74, 0x68, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x67, 0x64, 0x6f, 0x6d, 0x20, 0x6f, 0x66, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x66, 0x61, 0x6d, 0x6f, 0x75, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x73, 0x74, 0x68, 0x65, 0x20, 0x46, 0x72, 0x65, 0x6e, 0x63, 0x68, + 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x64, 0x22, 0x3e, 0x69, 0x73, 0x20, 0x73, 0x61, 0x69, 0x64, 0x20, 0x74, 0x6f, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x64, + 0x75, 0x6d, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x61, 0x20, 0x73, 0x65, + 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x2d, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, + 0x20, 0x4f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x77, + 0x69, 0x64, 0x65, 0x2e, 0x61, 0x72, 0x69, 0x61, 0x2d, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x74, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x20, 0x77, + 0x61, 0x73, 0x64, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x6c, 0x6f, 0x6f, 0x6b, + 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, 0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, + 0x61, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, + 0x72, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x74, 0x68, + 0x65, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, + 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x77, 0x68, 0x65, 0x72, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x74, + 0x72, 0x61, 0x63, 0x6b, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x74, 0x65, + 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x69, 0x64, + 0x3d, 0x22, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x73, 0x74, + 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x61, 0x64, 0x6f, 0x70, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x74, 0x68, 0x65, 0x6f, 0x6c, 0x6f, + 0x67, 0x69, 0x61, 0x6e, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x76, 0x61, + 0x72, 0x69, 0x61, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, + 0x6e, 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x61, 0x75, 0x74, 0x6f, + 0x6d, 0x6f, 0x74, 0x69, 0x76, 0x65, 0x62, 0x79, 0x20, 0x66, 0x61, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x70, 0x75, 0x72, 0x73, 0x75, 0x69, + 0x74, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x62, 0x72, + 0x6f, 0x75, 0x67, 0x68, 0x74, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x20, 0x45, 0x6e, 0x67, 0x6c, 0x61, + 0x6e, 0x64, 0x61, 0x67, 0x72, 0x65, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x63, 0x63, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x70, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x76, 0x20, 0x73, 0x74, + 0x79, 0x6c, 0x65, 0x3d, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x68, 0x65, 0x72, 0x74, 0x72, + 0x65, 0x6d, 0x65, 0x6e, 0x64, 0x6f, 0x75, 0x73, 0x66, 0x72, 0x65, 0x65, 0x64, 0x6f, 0x6d, 0x20, + 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x30, 0x20, 0x31, 0x65, + 0x6d, 0x20, 0x31, 0x65, 0x6d, 0x3b, 0x42, 0x61, 0x73, 0x6b, 0x65, 0x74, 0x62, 0x61, 0x6c, 0x6c, + 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x61, 0x6e, 0x20, 0x65, 0x61, 0x72, + 0x6c, 0x69, 0x65, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x2f, 0x22, + 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x70, 0x69, 0x74, 0x74, + 0x73, 0x62, 0x75, 0x72, 0x67, 0x68, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x3e, 0x0d, + 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x28, 0x66, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, + 0x20, 0x6f, 0x75, 0x74, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, + 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x0d, 0x0a, 0x20, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x69, 0x74, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, + 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x20, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x2c, 0x20, 0x62, + 0x67, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x74, 0x61, 0x62, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x3d, 0x22, 0x64, 0x69, 0x73, 0x61, 0x73, 0x74, 0x72, 0x6f, 0x75, 0x73, 0x41, 0x6e, 0x61, 0x6c, + 0x79, 0x74, 0x69, 0x63, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, + 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x3e, 0x0a, 0x3c, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x73, 0x69, + 0x6e, 0x67, 0x65, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x2e, 0x73, 0x72, 0x63, 0x20, 0x3d, 0x20, 0x22, + 0x2f, 0x2f, 0x76, 0x69, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x6c, 0x79, + 0x69, 0x73, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, + 0x69, 0x6e, 0x67, 0x73, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x65, + 0x64, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x75, 0xc3, + 0xaa, 0x73, 0xd7, 0xa2, 0xd7, 0x91, 0xd7, 0xa8, 0xd7, 0x99, 0xd7, 0xaa, 0xd9, 0x81, 0xd8, 0xa7, + 0xd8, 0xb1, 0xd8, 0xb3, 0xdb, 0x8c, 0x64, 0x65, 0x73, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x6f, + 0x63, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x69, 0x6f, 0x65, 0x64, 0x75, 0x63, 0x61, 0x63, + 0x69, 0xc3, 0xb3, 0x6e, 0x73, 0x65, 0x70, 0x74, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x65, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x64, 0x6f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x63, 0x69, 0xc3, + 0xb3, 0x6e, 0x75, 0x62, 0x69, 0x63, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x69, 0x64, 0x61, 0x64, 0x72, 0x65, 0x73, 0x70, 0x75, 0x65, 0x73, 0x74, 0x61, 0x73, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x64, 0x6f, 0x73, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x61, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x64, 0x6f, 0x73, 0x61, 0x72, + 0x74, 0xc3, 0xad, 0x63, 0x75, 0x6c, 0x6f, 0x73, 0x64, 0x69, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x65, 0x73, 0x73, 0x69, 0x67, 0x75, 0x69, 0x65, 0x6e, 0x74, 0x65, 0x73, 0x72, 0x65, 0x70, 0xc3, + 0xba, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x69, 0x74, 0x75, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x70, 0x72, 0x69, 0x76, 0x61, 0x63, + 0x69, 0x64, 0x61, 0x64, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x6f, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x70, 0x6f, 0x62, 0x6c, 0x61, 0x63, 0x69, 0xc3, + 0xb3, 0x6e, 0x70, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x65, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x69, 0x64, 0x6f, 0x73, 0x61, 0x63, 0x63, 0x65, 0x73, 0x6f, 0x72, 0x69, 0x6f, 0x73, + 0x74, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, + 0x61, 0x6c, 0x65, 0x73, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0xc3, 0xad, 0x61, 0x65, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x65, 0x73, 0x64, 0x69, 0x73, 0x70, 0x6f, 0x6e, 0x69, 0x62, + 0x6c, 0x65, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x64, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x76, 0x61, 0x6c, 0x6c, 0x61, 0x64, 0x6f, 0x6c, 0x69, 0x64, + 0x62, 0x69, 0x62, 0x6c, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x61, 0x72, 0x65, 0x6c, 0x61, 0x63, 0x69, + 0x6f, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x6e, 0x64, 0x61, 0x72, 0x69, 0x6f, 0x70, 0x6f, + 0x6c, 0xc3, 0xad, 0x74, 0x69, 0x63, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, + 0x65, 0x73, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x73, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x61, 0x6c, 0x65, 0x7a, 0x61, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x65, 0x73, + 0x64, 0x69, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x65, 0x63, 0x6f, 0x6e, 0xc3, 0xb3, + 0x6d, 0x69, 0x63, 0x61, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x6f, + 0x64, 0x72, 0xc3, 0xad, 0x67, 0x75, 0x65, 0x7a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x63, 0x75, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x63, + 0x75, 0x73, 0x69, 0xc3, 0xb3, 0x6e, 0x65, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x61, + 0x66, 0x75, 0x6e, 0x64, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x66, 0x72, 0x65, 0x63, 0x75, 0x65, + 0x6e, 0x74, 0x65, 0x73, 0x70, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x65, 0x74, 0x6f, + 0x74, 0x61, 0x6c, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb6, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x83, 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xbc, 0xd0, 0xbe, + 0xd0, 0xb6, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb2, 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x8f, + 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xb6, 0xd0, 0xb5, 0xd1, 0x87, 0xd1, 0x82, 0xd0, 0xbe, + 0xd0, 0xb1, 0xd1, 0x8b, 0xd0, 0xb1, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xb5, 0xd0, 0xbe, + 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8c, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb3, + 0xd0, 0xbe, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xbf, 0xd0, 0xbe, + 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, + 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xb9, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x87, 0xd0, 0xb5, 0xd1, 0x80, + 0xd0, 0xb5, 0xd0, 0xb7, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb3, 0xd1, 0x83, 0xd1, 0x82, 0xd1, 0x81, + 0xd0, 0xb0, 0xd0, 0xb9, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xb6, 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xbd, + 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xb6, 0xd0, 0xb4, 0xd1, 0x83, 0xd0, 0xb1, 0xd1, 0x83, + 0xd0, 0xb4, 0xd1, 0x83, 0xd1, 0x82, 0xd0, 0x9f, 0xd0, 0xbe, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xba, + 0xd0, 0xb7, 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x8c, 0xd0, 0xb2, 0xd0, 0xb8, 0xd0, 0xb4, + 0xd0, 0xb5, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xb2, 0xd1, 0x8f, 0xd0, 0xb7, 0xd0, 0xb8, 0xd0, 0xbd, + 0xd1, 0x83, 0xd0, 0xb6, 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb5, + 0xd0, 0xb9, 0xd0, 0xbb, 0xd1, 0x8e, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0xbf, 0xd0, 0xbe, + 0xd1, 0x80, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, + 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xb9, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, + 0xd0, 0xb8, 0xd1, 0x85, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xb0, 0xd1, 0x82, + 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, + 0xd0, 0xbe, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb6, 0xd0, 0xb8, + 0xd0, 0xb7, 0xd0, 0xbd, 0xd1, 0x8c, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb9, + 0xd0, 0xbb, 0xd1, 0x83, 0xd1, 0x87, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbf, 0xd0, 0xb5, 0xd1, 0x80, + 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x87, + 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xbe, + 0xd1, 0x82, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x8b, 0xd1, 0x85, 0xd0, 0xbf, 0xd1, 0x80, + 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0xbe, 0xd0, 0xb9, + 0xd0, 0xbf, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbd, + 0xd0, 0xb5, 0xd0, 0xb5, 0xd1, 0x87, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x8b, 0xd0, 0xb5, 0xd1, 0x83, 0xd1, 0x81, 0xd0, 0xbb, 0xd1, 0x83, + 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xb0, + 0xd0, 0xb7, 0xd0, 0xb0, 0xd0, 0xb4, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xb5, + 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xbf, 0xd0, 0xbe, 0xd1, 0x87, + 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0x9f, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb5, 0xd1, 0x82, + 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x8b, + 0xd0, 0xb9, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x82, 0xd0, 0xb0, + 0xd0, 0xba, 0xd0, 0xb8, 0xd1, 0x85, 0xd1, 0x81, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd1, 0x83, + 0xd0, 0xa1, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xba, 0xd1, 0x82, 0xd1, 0x84, 0xd0, 0xbe, 0xd1, 0x80, + 0xd1, 0x83, 0xd0, 0xbc, 0xd0, 0x9a, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xba, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb3, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb2, + 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0xbd, 0xd0, 0xb0, + 0xd0, 0xb9, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb8, 0xd0, 0xbc, + 0xd1, 0x81, 0xd0, 0xb2, 0xd1, 0x8f, 0xd0, 0xb7, 0xd1, 0x8c, 0xd0, 0xbb, 0xd1, 0x8e, 0xd0, 0xb1, + 0xd0, 0xbe, 0xd0, 0xb9, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x81, + 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xb4, 0xd0, 0xb8, 0xd0, 0x9a, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xbc, + 0xd0, 0xb5, 0xd0, 0xa4, 0xd0, 0xbe, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xbc, 0xd1, 0x80, 0xd1, 0x8b, + 0xd0, 0xbd, 0xd0, 0xba, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb0, 0xd0, 0xbb, 0xd0, 0xb8, + 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xba, 0xd1, 0x82, 0xd1, 0x8b, 0xd1, 0x81, + 0xd1, 0x8f, 0xd1, 0x87, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x8f, 0xd1, 0x86, 0xd1, 0x86, + 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x82, 0xd1, 0x80, 0xd1, 0x82, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xb4, + 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xbc, 0xd1, 0x8b, 0xd1, 0x85, 0xd1, 0x80, 0xd1, 0x8b, + 0xd0, 0xbd, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0x9d, 0xd0, 0xbe, 0xd0, 0xb2, 0xd1, 0x8b, 0xd0, 0xb9, + 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x81, + 0xd1, 0x82, 0xd0, 0xb0, 0xd1, 0x84, 0xd0, 0xb8, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xbc, 0xd0, 0xbc, + 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x82, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xb0, + 0xd0, 0xbd, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb5, + 0xd0, 0xba, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x88, 0xd0, 0xb8, 0xd1, 0x85, + 0xd0, 0xbc, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x83, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x8e, 0xd1, 0x82, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, + 0xd0, 0xb4, 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x8d, 0xd1, 0x82, + 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x83, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbd, 0xd1, 0x86, 0xd0, 0xb5, + 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xba, + 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0x90, 0xd1, 0x80, 0xd1, 0x85, 0xd0, 0xb8, 0xd0, 0xb2, 0xd9, 0x85, + 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xaf, 0xd9, 0x89, 0xd8, 0xa5, 0xd8, 0xb1, 0xd8, 0xb3, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x83, 0xd8, 0xaa, 0xd8, 0xa8, 0xd9, 0x87, 0xd8, 0xa7, + 0xd8, 0xa8, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x8a, + 0xd9, 0x88, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb5, 0xd9, 0x88, 0xd8, 0xb1, 0xd8, 0xac, + 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xaf, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xb6, + 0xd9, 0x88, 0xd8, 0xa5, 0xd8, 0xb6, 0xd8, 0xa7, 0xd9, 0x81, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x82, 0xd8, 0xb3, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd8, 0xaa, 0xd8, 0xad, 0xd9, 0x85, 0xd9, 0x8a, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x84, 0xd9, 0x81, + 0xd8, 0xa7, 0xd8, 0xaa, 0xd9, 0x85, 0xd9, 0x84, 0xd8, 0xaa, 0xd9, 0x82, 0xd9, 0x89, 0xd8, 0xaa, + 0xd8, 0xb9, 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb4, 0xd8, 0xb9, + 0xd8, 0xb1, 0xd8, 0xa3, 0xd8, 0xae, 0xd8, 0xa8, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xaa, 0xd8, 0xb7, + 0xd9, 0x88, 0xd9, 0x8a, 0xd8, 0xb1, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, 0xd9, 0x83, 0xd9, 0x85, + 0xd8, 0xa5, 0xd8, 0xb1, 0xd9, 0x81, 0xd8, 0xa7, 0xd9, 0x82, 0xd8, 0xb7, 0xd9, 0x84, 0xd8, 0xa8, + 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x84, 0xd8, 0xba, 0xd8, 0xa9, 0xd8, 0xaa, + 0xd8, 0xb1, 0xd8, 0xaa, 0xd9, 0x8a, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x86, 0xd8, 0xa7, + 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb4, 0xd9, 0x8a, 0xd8, 0xae, 0xd9, 0x85, 0xd9, 0x86, + 0xd8, 0xaa, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xa8, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x82, 0xd8, 0xb5, 0xd8, 0xb5, 0xd8, 0xa7, 0xd9, 0x81, 0xd9, 0x84, + 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, 0xd9, 0x87, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xad, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xab, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x84, 0xd9, 0x87, + 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd9, 0x85, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x83, + 0xd8, 0xaa, 0xd8, 0xa8, 0xd8, 0xa9, 0xd9, 0x8a, 0xd9, 0x85, 0xd9, 0x83, 0xd9, 0x86, 0xd9, 0x83, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb7, 0xd9, 0x81, 0xd9, 0x84, 0xd9, 0x81, 0xd9, 0x8a, 0xd8, 0xaf, + 0xd9, 0x8a, 0xd9, 0x88, 0xd8, 0xa5, 0xd8, 0xaf, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xa9, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xae, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb5, 0xd8, 0xad, + 0xd8, 0xa9, 0xd8, 0xaa, 0xd8, 0xb3, 0xd8, 0xac, 0xd9, 0x8a, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x88, 0xd9, 0x82, 0xd8, 0xaa, 0xd8, 0xb9, 0xd9, 0x86, 0xd8, 0xaf, 0xd9, 0x85, 0xd8, 0xa7, + 0xd9, 0x85, 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x86, 0xd8, 0xa9, 0xd8, 0xaa, 0xd8, 0xb5, 0xd9, 0x85, + 0xd9, 0x8a, 0xd9, 0x85, 0xd8, 0xa3, 0xd8, 0xb1, 0xd8, 0xb4, 0xd9, 0x8a, 0xd9, 0x81, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xb0, 0xd9, 0x8a, 0xd9, 0x86, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xa8, 0xd9, 0x8a, + 0xd8, 0xa9, 0xd8, 0xa8, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa9, 0xd8, 0xa3, 0xd9, 0x84, + 0xd8, 0xb9, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd9, 0x81, 0xd8, 0xb1, + 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd9, 0x83, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb9, 0xd8, 0xa7, + 0xd9, 0x84, 0xd9, 0x89, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x88, 0xd9, 0x84, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xb3, 0xd9, 0x86, 0xd8, 0xa9, 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xb9, + 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb5, 0xd8, 0xad, 0xd9, 0x81, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x86, 0xd9, 0x83, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xae, 0xd8, 0xa7, 0xd8, 0xb5, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, + 0xd9, 0x84, 0xd9, 0x81, 0xd8, 0xa3, 0xd8, 0xb9, 0xd8, 0xb6, 0xd8, 0xa7, 0xd8, 0xa1, 0xd9, 0x83, + 0xd8, 0xaa, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xae, 0xd9, 0x8a, + 0xd8, 0xb1, 0xd8, 0xb1, 0xd8, 0xb3, 0xd8, 0xa7, 0xd8, 0xa6, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x82, 0xd9, 0x84, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd8, 0xaf, 0xd8, 0xa8, + 0xd9, 0x85, 0xd9, 0x82, 0xd8, 0xa7, 0xd8, 0xb7, 0xd8, 0xb9, 0xd9, 0x85, 0xd8, 0xb1, 0xd8, 0xa7, + 0xd8, 0xb3, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xb7, 0xd9, 0x82, 0xd8, 0xa9, 0xd8, 0xa7, + 0xd9, 0x84, 0xd9, 0x83, 0xd8, 0xaa, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xac, + 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xb4, 0xd8, 0xaa, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x82, 0xd8, 0xaf, 0xd9, 0x85, 0xd9, 0x8a, 0xd8, 0xb9, 0xd8, 0xb7, 0xd9, 0x8a, 0xd9, 0x83, + 0x73, 0x42, 0x79, 0x54, 0x61, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x2e, 0x6a, 0x70, 0x67, 0x22, + 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x31, 0x70, 0x78, 0x20, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x20, + 0x23, 0x2e, 0x67, 0x69, 0x66, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, 0x6f, + 0x6e, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x3d, 0x22, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x65, 0x64, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x2e, 0x70, + 0x6e, 0x67, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, + 0x6d, 0x65, 0x6e, 0x74, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x61, + 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6d, + 0x64, 0x61, 0x73, 0x68, 0x3b, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79, + 0x3c, 0x2f, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x3e, 0x3c, 0x2f, 0x72, 0x61, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x74, 0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6d, 0x70, + 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, + 0x65, 0x72, 0x76, 0x69, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x3a, 0x63, 0x6f, 0x70, + 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3e, 0x30, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x3d, 0x22, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x72, 0x65, + 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3c, + 0x75, 0x6c, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x41, 0x73, 0x73, 0x6f, 0x63, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x73, + 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x73, 0x65, 0x74, 0x54, 0x69, + 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x28, 0x75, 0x72, 0x6c, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, + 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x65, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x73, 0x6d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x2d, 0x74, 0x6f, 0x70, 0x3a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x61, 0x6c, 0x6c, + 0x79, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x20, 0x6e, + 0x6f, 0x2d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x4a, 0x50, 0x47, 0x7c, 0x74, 0x68, 0x75, 0x6d, 0x62, 0x7c, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x65, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x3c, + 0x62, 0x6f, 0x64, 0x79, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x6c, 0x65, 0x66, 0x74, 0x3b, 0x3c, + 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x68, 0x75, 0x6e, 0x64, 0x72, 0x65, + 0x64, 0x73, 0x20, 0x6f, 0x66, 0x0a, 0x0a, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6c, 0x65, 0x61, 0x72, + 0x3a, 0x62, 0x6f, 0x74, 0x68, 0x3b, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x3d, 0x22, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2d, 0x74, 0x6f, + 0x70, 0x3a, 0x4e, 0x65, 0x77, 0x20, 0x5a, 0x65, 0x61, 0x6c, 0x61, 0x6e, 0x64, 0x72, 0x65, 0x63, + 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x67, 0x72, 0x61, + 0x70, 0x68, 0x79, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x26, 0x6c, + 0x74, 0x3b, 0x73, 0x75, 0x70, 0x26, 0x67, 0x74, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x76, + 0x65, 0x72, 0x73, 0x79, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x61, + 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6d, 0x61, 0x78, 0x6c, 0x65, 0x6e, + 0x67, 0x74, 0x68, 0x3d, 0x22, 0x73, 0x77, 0x69, 0x74, 0x7a, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, + 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x73, 0x73, 0x65, 0x6e, + 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x0a, 0x0a, 0x41, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, + 0x20, 0x3c, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x61, 0x72, 0x65, 0x61, 0x3e, 0x74, 0x68, 0x75, 0x6e, + 0x64, 0x65, 0x72, 0x62, 0x69, 0x72, 0x64, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, + 0x65, 0x64, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6e, 0x64, 0x61, 0x73, 0x68, 0x3b, 0x73, 0x70, 0x65, + 0x63, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, + 0x69, 0x65, 0x73, 0x6c, 0x65, 0x67, 0x69, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x73, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, + 0x69, 0x64, 0x3d, 0x22, 0x69, 0x6c, 0x6c, 0x75, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x64, 0x65, + 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x65, 0x72, 0x72, 0x69, 0x74, + 0x6f, 0x72, 0x69, 0x65, 0x73, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x69, 0x65, 0x73, + 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x36, 0x22, 0x20, 0x68, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x73, 0x61, 0x6e, 0x73, 0x2d, 0x73, 0x65, 0x72, 0x69, 0x66, + 0x3b, 0x63, 0x61, 0x70, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x69, 0x73, 0x61, + 0x70, 0x70, 0x65, 0x61, 0x72, 0x65, 0x64, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x69, 0x74, 0x20, + 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x41, 0x66, 0x67, 0x68, 0x61, 0x6e, 0x69, 0x73, + 0x74, 0x61, 0x6e, 0x77, 0x61, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x61, + 0x74, 0x68, 0x2e, 0x66, 0x6c, 0x6f, 0x6f, 0x72, 0x28, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x63, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x62, 0x65, 0x6f, + 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, + 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x65, 0x6e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64, + 0x3c, 0x68, 0x32, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x6f, 0x72, 0x65, 0x20, + 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, + 0x6e, 0x69, 0x6e, 0x76, 0x61, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x29, 0x2e, 0x67, 0x65, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x28, 0x29, 0x66, 0x75, 0x6e, 0x64, 0x61, 0x6d, 0x65, 0x6e, 0x74, + 0x61, 0x6c, 0x44, 0x65, 0x73, 0x70, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x22, 0x3e, 0x3c, + 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x69, 0x6e, 0x73, 0x70, 0x69, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x65, 0x78, 0x61, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x72, + 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x3c, + 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x20, 0x3d, 0x20, 0x27, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x2e, 0x73, 0x75, 0x62, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x69, 0x6e, 0x66, + 0x6c, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x64, 0x75, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x4d, + 0x69, 0x64, 0x64, 0x6c, 0x65, 0x20, 0x45, 0x61, 0x73, 0x74, 0x3c, 0x6e, 0x6f, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x63, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x20, + 0x70, 0x65, 0x72, 0x68, 0x61, 0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x69, + 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x20, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x66, 0x61, 0x6d, 0x6f, 0x75, 0x73, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x69, + 0x74, 0x79, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x6c, 0x79, 0x73, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x74, 0x79, 0x2d, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x3e, 0x0a, 0x3c, 0x74, 0x64, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x70, + 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x20, 0x74, 0x6f, 0x64, 0x6f, 0x63, 0x74, 0x72, 0x69, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x65, 0x6e, 0x61, 0x69, + 0x73, 0x73, 0x61, 0x6e, 0x63, 0x65, 0x61, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x70, 0x6c, + 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x70, 0x72, 0x65, 0x64, 0x65, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x3c, 0x69, 0x6d, + 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x3c, 0x68, 0x31, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x61, + 0x79, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x62, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x64, 0x3c, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x65, 0x74, 0x3e, 0x70, + 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x69, 0x76, 0x65, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x65, 0x6e, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x6f, 0x75, 0x6e, + 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, + 0x72, 0x2e, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x61, 0x67, 0x72, 0x69, + 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x72, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x72, 0x73, 0x74, 0x6f, 0x77, + 0x61, 0x72, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x4d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x28, 0x65, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x3c, 0x74, 0x64, 0x20, 0x77, 0x69, 0x64, + 0x74, 0x68, 0x3d, 0x22, 0x3b, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x31, 0x30, 0x30, 0x25, 0x69, + 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x3c, 0x68, 0x33, 0x20, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x3d, 0x22, 0x20, 0x6f, 0x6e, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x3d, 0x22, + 0x29, 0x2e, 0x61, 0x64, 0x64, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x61, 0x75, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x61, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x0d, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x74, 0x68, 0x65, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x49, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x69, + 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x22, 0x3e, 0x0a, 0x3c, 0x68, 0x65, + 0x61, 0x64, 0x3e, 0x0a, 0x3c, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x31, + 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x65, 0x6e, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x3b, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x3e, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x73, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x77, 0x61, 0x73, + 0x20, 0x61, 0x64, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x74, 0x68, 0x65, 0x20, 0x42, 0x72, 0x69, 0x74, 0x69, 0x73, 0x68, 0x77, 0x61, + 0x73, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x21, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x61, 0x6e, 0x74, 0x3b, 0x70, 0x78, 0x3b, 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x66, + 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20, 0x62, 0x79, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x6d, 0x69, 0x67, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, + 0x64, 0x3c, 0x68, 0x34, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x64, 0x69, 0x73, 0x74, + 0x69, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x4e, 0x6f, 0x76, 0x65, 0x6d, + 0x62, 0x65, 0x72, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, + 0x70, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x61, 0x63, 0x71, 0x75, 0x69, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x65, 0x72, 0x73, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x7b, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, + 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x69, 0x6e, 0x76, 0x65, 0x73, + 0x74, 0x69, 0x67, 0x61, 0x74, 0x65, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, 0x6e, 0x63, 0x65, + 0x64, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x77, 0x69, 0x64, 0x65, + 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x64, 0x64, 0x69, 0x73, 0x63, 0x75, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x28, 0x64, + 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x76, + 0x65, 0x6c, 0x79, 0x49, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x69, 0x74, + 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x72, + 0x79, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x68, 0x61, 0x62, 0x69, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x69, + 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x63, 0x68, 0x6f, 0x6c, 0x61, + 0x72, 0x73, 0x68, 0x69, 0x70, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x20, 0x65, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, + 0x65, 0x70, 0x78, 0x3b, 0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x61, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x72, 0x6f, 0x6c, + 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x6c, 0x79, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x65, 0x76, + 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, + 0x6e, 0x63, 0x65, 0x73, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, + 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x3d, 0x22, 0x68, 0x69, 0x67, 0x68, 0x20, + 0x73, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, + 0x6f, 0x63, 0x6f, 0x6d, 0x66, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x64, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x79, 0x65, 0x61, + 0x72, 0x73, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x20, + 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x77, 0x68, 0x6f, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x3c, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x69, + 0x6e, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x20, 0x6f, 0x66, 0x61, 0x70, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x53, 0x4f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, 0x31, 0x22, + 0x77, 0x61, 0x73, 0x20, 0x62, 0x6f, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x68, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x65, 0x64, 0x20, 0x61, + 0x73, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x69, 0x73, 0x20, 0x62, + 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x3a, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x69, 0x67, + 0x6e, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x63, 0x65, 0x6c, 0x65, 0x62, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x2f, 0x6a, + 0x73, 0x2f, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x69, 0x73, 0x20, 0x6b, 0x6e, 0x6f, 0x77, + 0x6e, 0x20, 0x61, 0x73, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x65, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, + 0x74, 0x61, 0x62, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x3d, 0x22, 0x69, 0x74, 0x20, 0x63, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x3c, 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x0d, 0x0a, 0x3c, 0x68, 0x65, + 0x61, 0x64, 0x3e, 0x0d, 0x0a, 0x3c, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x68, 0x65, 0x20, 0x68, + 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x65, 0x64, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x74, 0x6f, 0x20, 0x73, 0x61, 0x79, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x61, + 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, + 0x62, 0x65, 0x6c, 0x69, 0x65, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x70, 0x68, 0x6f, 0x74, 0x6f, + 0x67, 0x72, 0x61, 0x70, 0x68, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x69, 0x6e, + 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x52, 0x65, 0x70, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6f, 0x66, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x69, + 0x6c, 0x79, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x74, 0x65, 0x63, + 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x6c, 0x65, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x61, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x66, 0x72, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x69, + 0x63, 0x69, 0x74, 0x79, 0x68, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x73, 0x74, 0x61, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x73, 0x70, 0x61, 0x72, 0x74, 0x6e, 0x65, + 0x72, 0x73, 0x68, 0x69, 0x70, 0x65, 0x6d, 0x70, 0x68, 0x61, 0x73, 0x69, 0x73, 0x20, 0x6f, 0x6e, + 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x73, 0x68, 0x61, 0x72, 0x65, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x66, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x65, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x74, + 0x65, 0x6e, 0x22, 0x3e, 0x3c, 0x2f, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x3e, 0x61, 0x73, 0x20, + 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x3a, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x64, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, + 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x64, + 0x20, 0x6f, 0x75, 0x74, 0x6f, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x76, + 0x69, 0x65, 0x77, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x73, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, + 0x6c, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x69, 0x6e, 0x20, 0x4e, + 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x3c, + 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x69, 0x6e, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, + 0x61, 0x74, 0x65, 0x3b, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x61, 0x74, + 0x74, 0x61, 0x63, 0x68, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x22, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x63, + 0x61, 0x72, 0x72, 0x69, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x6e, 0x64, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3e, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x4d, 0x75, 0x63, 0x68, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x20, + 0x6f, 0x66, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x32, 0x73, 0x69, 0x7a, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x6d, 0x69, 0x78, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x65, + 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x65, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x63, + 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6f, 0x6e, 0x73, 0x75, 0x62, + 0x6d, 0x69, 0x74, 0x3d, 0x22, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, + 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2f, 0x44, 0x54, 0x44, 0x20, + 0x58, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x6f, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x6f, 0x75, + 0x6c, 0x64, 0x64, 0x65, 0x73, 0x70, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x73, 0x63, 0x69, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x20, 0x6c, 0x65, 0x67, 0x69, 0x73, 0x6c, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x2e, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x61, 0x6c, + 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x67, 0x72, 0x69, 0x63, 0x75, 0x6c, + 0x74, 0x75, 0x72, 0x65, 0x77, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x61, + 0x70, 0x70, 0x72, 0x6f, 0x61, 0x63, 0x68, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, + 0x69, 0x67, 0x65, 0x6e, 0x74, 0x79, 0x65, 0x61, 0x72, 0x73, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, + 0x2c, 0x73, 0x61, 0x6e, 0x73, 0x2d, 0x73, 0x65, 0x72, 0x69, 0x66, 0x64, 0x65, 0x74, 0x65, 0x72, + 0x6d, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, + 0x65, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2c, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x64, 0x68, 0x69, 0x67, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x20, 0x63, 0x6f, + 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x66, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, + 0x69, 0x7a, 0x65, 0x3a, 0x31, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x68, 0x69, 0x73, 0x20, 0x62, + 0x72, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, + 0x65, 0x61, 0x6e, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x72, 0x79, 0x67, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x75, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x6e, + 0x6f, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x74, + 0x69, 0x6c, 0x6c, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x6f, 0x47, 0x4d, 0x54, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x41, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x69, + 0x6d, 0x67, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x75, + 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x77, 0x61, 0x73, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, + 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x69, 0x67, 0x68, + 0x62, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, + 0x68, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x68, 0x65, 0x20, 0x77, 0x61, 0x73, 0x69, 0x6e, 0x74, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x69, 0x6e, 0x67, 0x74, 0x65, 0x72, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, + 0x61, 0x6c, 0x4d, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x72, 0x67, + 0x75, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, + 0x63, 0x61, 0x6e, 0x63, 0x6f, 0x6e, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x77, 0x69, + 0x64, 0x65, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, 0x6b, 0x69, + 0x6c, 0x6c, 0x65, 0x64, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x49, + 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x74, 0x73, + 0x61, 0x72, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x6c, 0x65, 0x67, 0x69, 0x73, + 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x79, 0x65, 0x61, 0x72, 0x73, 0x20, 0x61, 0x66, 0x74, + 0x65, 0x72, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x68, 0x65, + 0x20, 0x68, 0x69, 0x67, 0x68, 0x65, 0x73, 0x74, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x64, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x61, 0x72, + 0x67, 0x75, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x73, 0x68, 0x6f, 0x77, 0x65, 0x64, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x70, 0x72, 0x65, 0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6e, 0x74, 0x74, + 0x68, 0x65, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x2d, 0x6c, 0x69, 0x76, 0x65, 0x64, 0x3c, 0x2f, 0x73, 0x70, 0x61, + 0x6e, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, 0x64, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, + 0x64, 0x79, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x63, 0x6f, 0x6d, + 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x65, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2c, 0x3c, 0x2f, + 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x33, 0x49, + 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x2d, 0x73, 0x63, 0x61, 0x6c, 0x65, + 0x2e, 0x20, 0x41, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x74, 0x77, 0x6f, 0x20, 0x6f, 0x72, 0x20, 0x6d, 0x6f, + 0x72, 0x65, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x73, 0x75, 0x62, + 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x3c, 0x2f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x65, + 0x6e, 0x74, 0x61, 0x6c, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, + 0x63, 0x65, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x20, 0x6f, 0x66, + 0x73, 0x69, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x65, 0x6e, 0x73, 0x75, 0x72, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x70, 0x6f, 0x74, 0x65, + 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x77, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x77, 0x73, 0x69, 0x74, 0x75, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x69, 0x6e, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x54, 0x72, + 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6f, 0x66, 0x61, 0x74, 0x6d, 0x6f, 0x73, 0x70, + 0x68, 0x65, 0x72, 0x69, 0x63, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x69, 0x73, 0x65, 0x73, 0x63, 0x61, 0x6c, 0x63, 0x75, + 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x6d, 0x6e, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x70, 0x61, 0x67, 0x65, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, + 0x70, 0x3f, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x48, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, + 0x6c, 0x73, 0x6f, 0x77, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x73, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x20, 0x66, 0x61, 0x76, 0x6f, + 0x72, 0x20, 0x6f, 0x66, 0x4d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x6d, + 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x72, 0x6d, 0x75, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x2f, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x69, 0x6e, 0x76, 0x6f, + 0x6c, 0x76, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6d, 0x61, 0x64, + 0x65, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x65, 0x6d, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x62, 0x65, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x50, 0x61, + 0x6c, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x20, 0x61, + 0x66, 0x74, 0x65, 0x72, 0x69, 0x74, 0x20, 0x68, 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x6d, + 0x6f, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, + 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x75, 0x74, 0x69, 0x76, 0x65, 0x74, 0x65, 0x6d, 0x70, 0x6f, + 0x72, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x49, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, + 0x2c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6b, 0x65, + 0x73, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x75, 0x62, 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6c, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x70, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x65, 0x6e, + 0x74, 0x6c, 0x79, 0x77, 0x61, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x6c, 0x79, 0x6f, 0x75, + 0x74, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x61, 0x73, 0x74, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, + 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x6f, 0x67, 0x3d, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, + 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x63, 0x6c, 0x65, 0x61, + 0x72, 0x66, 0x69, 0x78, 0x22, 0x3e, 0x0a, 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x77, 0x61, 0x73, 0x20, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x61, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x69, 0x6e, + 0x73, 0x70, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x66, 0x75, 0x6c, 0x20, 0x61, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x6d, + 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x73, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, + 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x31, 0x30, 0x30, 0x25, 0x3b, 0x74, 0x65, 0x63, 0x68, 0x6e, + 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x2c, 0x77, 0x61, 0x73, 0x20, 0x61, 0x64, 0x6f, 0x70, 0x74, 0x65, + 0x64, 0x74, 0x6f, 0x20, 0x6b, 0x65, 0x65, 0x70, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x74, 0x74, + 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x62, 0x69, 0x72, 0x74, + 0x68, 0x73, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x63, 0x75, 0x74, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x3b, 0x61, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x61, + 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x42, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x71, 0x22, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x61, 0x20, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x22, 0x20, + 0x2f, 0x3e, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x45, 0x6e, 0x76, + 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x0d, 0x0a, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, + 0x3e, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x6c, 0x79, 0x2c, 0x3e, 0x0a, + 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, + 0x68, 0x3d, 0x22, 0x31, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, + 0x63, 0x69, 0x74, 0x69, 0x7a, 0x65, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x70, 0x6f, 0x6c, 0x69, 0x74, + 0x69, 0x63, 0x69, 0x61, 0x6e, 0x73, 0x72, 0x65, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x61, 0x73, 0x20, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x61, 0x73, 0x3a, 0x6e, 0x6f, 0x6e, + 0x65, 0x3b, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, 0x65, + 0x6c, 0x6c, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x6f, 0x6e, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x64, + 0x6f, 0x77, 0x6e, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x77, 0x68, + 0x65, 0x6e, 0x20, 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x61, + 0x63, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x64, 0x61, 0x74, 0x65, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, + 0x74, 0x68, 0x65, 0x20, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x64, 0x65, 0x6c, 0x69, 0x63, + 0x69, 0x6f, 0x75, 0x73, 0x22, 0x3e, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, + 0x74, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, + 0x6c, 0x79, 0x61, 0x20, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0d, 0x0a, 0x09, + 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x66, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x6d, 0x61, + 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x74, + 0x6f, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x61, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x65, 0x72, 0x22, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x66, 0x72, 0x61, 0x6d, 0x65, + 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x61, 0x6e, 0x61, 0x6c, + 0x79, 0x73, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x66, 0x69, 0x72, + 0x73, 0x74, 0x44, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x69, 0x6e, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x20, 0x6f, 0x66, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, 0x66, 0x6f, + 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x6f, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, 0x62, + 0x65, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x3a, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x65, 0x6e, 0x74, + 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x65, 0x71, 0x75, 0x69, 0x6c, + 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x6e, 0x65, 0x65, 0x64, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x61, 0x72, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x73, + 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x65, 0x73, 0x61, + 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x67, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x6f, 0x66, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x2d, 0x64, 0x61, 0x79, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x6c, + 0x79, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x62, 0x75, 0x74, 0x20, + 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x69, 0x73, 0x20, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x6c, 0x79, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x77, 0x61, 0x73, 0x20, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x74, 0x6f, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x62, + 0x75, 0x74, 0x20, 0x64, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x6f, 0x6e, 0x4d, 0x6f, 0x75, 0x73, + 0x65, 0x4f, 0x76, 0x65, 0x72, 0x61, 0x73, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x63, 0x6f, 0x6d, 0x69, 0x6e, + 0x67, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, + 0x79, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x72, 0x20, + 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, + 0x65, 0x64, 0x61, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x20, 0x6f, 0x66, 0x61, 0x72, 0x65, + 0x20, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, + 0x20, 0x69, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x6d, 0x75, + 0x63, 0x68, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x0a, 0x09, 0x3c, 0x2f, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x3e, 0x61, 0x64, 0x6f, 0x70, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x70, + 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, + 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x63, 0x68, 0x69, 0x6c, 0x64, + 0x72, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x69, 0x6e, + 0x67, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x6d, 0x61, 0x6e, 0x75, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x73, 0x77, 0x61, 0x72, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, + 0x73, 0x74, 0x62, 0x79, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x61, 0x6e, 0x64, + 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, + 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x65, 0x74, 0x61, 0x72, 0x79, 0x6f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x70, 0x72, 0x65, 0x73, 0x74, 0x69, 0x67, + 0x69, 0x6f, 0x75, 0x73, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x65, + 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x6b, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x49, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, + 0x69, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x65, + 0x74, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x2e, 0x53, + 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, 0x62, 0x72, 0x6f, 0x75, + 0x67, 0x68, 0x74, 0x20, 0x74, 0x68, 0x65, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x66, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, + 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x61, + 0x6c, 0x6c, 0x79, 0x69, 0x6e, 0x20, 0x68, 0x6f, 0x6e, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x72, 0x65, + 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x61, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x6b, + 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x31, 0x73, 0x74, 0x20, 0x45, 0x61, 0x72, 0x6c, 0x20, 0x6f, 0x66, + 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x70, 0x72, 0x69, 0x6e, 0x63, + 0x69, 0x70, 0x61, 0x6c, 0x6c, 0x79, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x20, + 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x62, 0x61, 0x63, 0x6b, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x68, + 0x69, 0x73, 0x65, 0x78, 0x70, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x61, 0x72, 0x65, + 0x20, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x61, 0x64, 0x64, 0x46, 0x61, 0x76, 0x6f, 0x72, 0x69, 0x74, 0x65, 0x63, 0x69, + 0x74, 0x69, 0x7a, 0x65, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x70, 0x61, 0x72, 0x74, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, + 0x6e, 0x20, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x69, 0x6e, 0x75, 0x65, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6d, 0x69, 0x6e, 0x75, 0x73, 0x3b, + 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x68, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x69, 0x6e, 0x20, 0x68, 0x69, 0x73, 0x20, 0x62, + 0x6f, 0x6f, 0x6b, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x66, 0x6f, + 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x26, + 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x69, 0x73, 0x74, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x61, 0x20, 0x6f, 0x66, + 0x61, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x77, 0x65, 0x72, 0x65, 0x20, + 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x62, 0x74, + 0x6e, 0x64, 0x61, 0x79, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x66, 0x65, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x73, 0x68, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x69, 0x6e, 0x20, + 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x4c, 0x6f, + 0x72, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, + 0x61, 0x6c, 0x6c, 0x79, 0x68, 0x61, 0x73, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x77, 0x6e, 0x45, + 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, + 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x65, 0x61, 0x63, 0x68, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2c, 0x62, 0x65, 0x68, 0x61, 0x76, + 0x69, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x61, 0x6e, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, + 0x65, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, 0x70, 0x70, 0x65, + 0x61, 0x72, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x6d, 0x61, 0x79, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, + 0x64, 0x27, 0x73, 0x63, 0x61, 0x6e, 0x20, 0x6c, 0x65, 0x61, 0x64, 0x20, 0x74, 0x6f, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, + 0x22, 0x30, 0x22, 0x20, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x77, + 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x2c, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x63, 0x69, 0x74, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x09, 0x09, 0x72, 0x65, 0x66, 0x6c, + 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x65, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x72, 0x61, 0x64, + 0x69, 0x6f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x61, 0x74, 0x68, 0x65, 0x72, 0x2c, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, + 0x6f, 0x75, 0x6c, 0x64, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, + 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x61, 0x20, 0x70, 0x6f, 0x6c, 0x69, + 0x74, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, + 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x73, 0x77, 0x6f, 0x72, 0x6b, 0x65, + 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x65, 0x72, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, + 0x3e, 0x6f, 0x66, 0x20, 0x68, 0x69, 0x73, 0x20, 0x6c, 0x69, 0x66, 0x65, 0x61, 0x63, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x6e, 0x69, 0x65, 0x64, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x57, 0x69, 0x64, + 0x74, 0x68, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x4c, 0x65, 0x67, + 0x69, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x74, 0x6c, 0x79, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x68, 0x61, + 0x73, 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x6f, + 0x74, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x66, + 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x75, 0x73, 0x75, 0x61, 0x6c, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x77, 0x68, 0x65, 0x72, + 0x65, 0x77, 0x68, 0x65, 0x72, 0x65, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x3e, 0x20, 0x3c, 0x61, + 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, + 0x3d, 0x22, 0x74, 0x68, 0x65, 0x6d, 0x73, 0x65, 0x6c, 0x76, 0x65, 0x73, 0x2c, 0x61, 0x6c, 0x74, + 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x68, 0x65, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x62, 0x65, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x72, 0x6f, + 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x64, + 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x73, 0x69, 0x64, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x65, 0x77, 0x73, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, + 0x73, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x64, 0x6f, 0x77, 0x6e, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x61, 0x74, 0x74, + 0x65, 0x6d, 0x70, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x48, 0x6f, + 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x6e, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, + 0x6d, 0x65, 0x72, 0x73, 0x61, 0x74, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x61, + 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, + 0x67, 0x68, 0x20, 0x69, 0x74, 0x77, 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, + 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x47, 0x6f, 0x76, 0x65, 0x72, + 0x6e, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x3e, 0x3c, 0x61, 0x20, + 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x74, 0x68, 0x65, 0x20, 0x65, 0x63, 0x6f, 0x6e, 0x6f, + 0x6d, 0x79, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x6d, 0x6f, 0x73, + 0x74, 0x20, 0x77, 0x69, 0x64, 0x65, 0x6c, 0x79, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6c, 0x61, + 0x74, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x70, 0x65, 0x72, 0x68, 0x61, 0x70, 0x73, 0x72, 0x69, + 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x73, 0x20, + 0x77, 0x68, 0x65, 0x6e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x74, 0x68, 0x65, 0x20, 0x77, 0x65, + 0x73, 0x74, 0x65, 0x72, 0x6e, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x68, + 0x65, 0x73, 0x65, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x20, + 0x6f, 0x66, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x68, 0x69, 0x73, 0x61, 0x72, 0x65, + 0x61, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, + 0x6e, 0x6c, 0x79, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x61, + 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x57, 0x65, 0x73, + 0x74, 0x65, 0x72, 0x6e, 0x54, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x61, 0x6c, 0x63, 0x6f, 0x6c, 0x73, 0x70, 0x61, 0x6e, 0x3d, 0x32, 0x20, 0x7c, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x70, 0x6f, 0x73, 0x73, 0x69, + 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, + 0x6c, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x61, 0x20, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, + 0x61, 0x6e, 0x64, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x69, 0x73, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x73, + 0x20, 0x6f, 0x66, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x6d, 0x65, + 0x72, 0x63, 0x68, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x65, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x73, + 0x74, 0x20, 0x6f, 0x66, 0x6e, 0x6f, 0x20, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x65, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x20, 0x69, 0x6e, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x2e, 0x20, 0x54, 0x68, 0x65, + 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x2f, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x6c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x6e, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x73, + 0x20, 0x69, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, + 0x66, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x20, 0x66, 0x65, 0x77, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x6d, + 0x75, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, + 0x72, 0x6b, 0x20, 0x6f, 0x66, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x2c, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x67, 0x6f, 0x76, 0x65, 0x72, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x73, 0x20, 0x6f, + 0x66, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x09, 0x09, 0x3c, 0x64, + 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x69, 0x74, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3d, 0x22, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x61, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, + 0x20, 0x69, 0x6e, 0x69, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x65, 0x78, + 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x0a, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x6c, + 0x65, 0x61, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x09, 0x3c, 0x61, 0x20, 0x68, 0x72, + 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x77, 0x61, 0x73, 0x20, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x64, + 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x69, + 0x6e, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x77, 0x61, 0x73, 0x20, 0x73, 0x65, 0x65, 0x6e, 0x20, 0x61, + 0x73, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x73, 0x74, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, + 0x69, 0x6e, 0x65, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x64, 0x69, + 0x61, 0x6c, 0x65, 0x63, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x61, 0x73, 0x20, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x61, + 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x77, 0x65, 0x73, 0x74, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x62, 0x65, 0x74, 0x77, + 0x65, 0x65, 0x6e, 0x20, 0x74, 0x77, 0x6f, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, 0x61, 0x6e, 0x64, 0x63, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x20, + 0x77, 0x61, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x74, 0x68, + 0x65, 0x6d, 0x73, 0x65, 0x6c, 0x76, 0x65, 0x73, 0x2e, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x20, 0x6f, 0x66, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x74, 0x6f, 0x20, 0x6a, 0x6f, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x61, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x6c, 0x61, 0x73, 0x74, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x68, + 0x69, 0x73, 0x69, 0x73, 0x20, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x65, 0x72, 0x6d, 0x20, 0x69, 0x73, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x67, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x54, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x74, 0x68, 0x65, 0x20, 0x73, 0x69, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x73, + 0x75, 0x62, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, + 0x65, 0x6e, 0x63, 0x65, 0x2c, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x57, 0x65, 0x73, 0x74, + 0x74, 0x68, 0x65, 0x79, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x73, 0x6c, 0x6f, 0x76, 0x65, + 0x6e, 0xc4, 0x8d, 0x69, 0x6e, 0x61, 0x63, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x69, 0x6f, + 0x73, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x64, 0x61, 0x64, 0x63, 0x6f, 0x6e, 0x64, + 0x69, 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x64, 0x61, 0x64, + 0x65, 0x73, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x74, 0x65, 0x63, + 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0xc3, 0xad, 0x61, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x63, 0x69, + 0xc3, 0xb3, 0x6e, 0x70, 0x75, 0x6e, 0x74, 0x75, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x61, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, + 0x65, 0xc3, 0xb1, 0x61, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0xc3, 0xad, 0x61, 0x73, 0x72, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x72, 0x73, 0x65, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x74, 0x72, 0x61, 0x74, 0x61, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x6f, + 0x72, 0x65, 0x67, 0xc3, 0xad, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x61, 0x72, 0xc3, 0xad, 0x61, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x65, + 0x73, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x69, 0x6d, 0x70, 0x6f, + 0x72, 0x74, 0x61, 0x6e, 0x74, 0x65, 0x73, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x63, + 0x69, 0x61, 0x70, 0x6f, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x64, 0x61, 0x64, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x65, 0x73, 0x61, 0x6e, 0x74, 0x65, 0x63, 0x72, 0x65, 0x63, 0x69, 0x6d, 0x69, 0x65, + 0x6e, 0x74, 0x6f, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x69, 0x64, 0x61, 0x64, 0x65, 0x73, 0x73, 0x75, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x72, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x63, + 0x69, 0xc3, 0xb3, 0x6e, 0x64, 0x69, 0x73, 0x70, 0x6f, 0x6e, 0x69, 0x62, 0x6c, 0x65, 0x73, 0x65, + 0x76, 0x61, 0x6c, 0x75, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x65, 0x73, 0x74, 0x75, 0x64, 0x69, + 0x61, 0x6e, 0x74, 0x65, 0x73, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x61, 0x62, 0x6c, 0x65, + 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x67, 0x75, 0x61, 0x64, 0x61, + 0x6c, 0x61, 0x6a, 0x61, 0x72, 0x61, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x64, 0x6f, + 0x73, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x69, 0x64, 0x61, 0x64, 0x63, 0x6f, 0x6d, 0x65, + 0x72, 0x63, 0x69, 0x61, 0x6c, 0x65, 0x73, 0x66, 0x6f, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x66, 0xc3, + 0xad, 0x61, 0x61, 0x75, 0x74, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x64, 0x65, 0x73, 0x69, 0x6e, 0x67, + 0x65, 0x6e, 0x69, 0x65, 0x72, 0xc3, 0xad, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x76, 0x69, 0x73, 0x69, + 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x63, 0x69, 0x64, 0x6f, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x61, + 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x76, 0x65, 0x67, 0x61, + 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x69, 0x64, 0x61, 0x64, + 0x6c, 0x69, 0x6e, 0x65, 0x2d, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x66, 0x6f, 0x6e, 0x74, + 0x2d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x22, 0x20, 0x3a, 0x20, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x2f, 0x2f, 0x3c, 0x21, 0x5b, 0x43, 0x44, 0x41, + 0x54, 0x41, 0x5b, 0x0a, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x30, 0x70, 0x78, 0x3b, + 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x68, 0x69, 0x70, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x2d, 0x77, 0x69, 0x64, 0x74, 0x68, + 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x3d, 0x22, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x2f, 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x77, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x20, 0x21, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x61, 0x6e, 0x74, 0x3b, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, + 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x63, 0x6f, 0x6e, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x76, 0x65, 0x3c, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x75, 0x61, 0x6c, + 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x31, 0x38, 0x74, 0x68, + 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, + 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3c, 0x69, 0x6d, 0x67, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x69, 0x76, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x31, 0x39, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x61, 0x72, 0x63, 0x68, + 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x69, 0x6e, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x32, 0x30, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, + 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3e, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x6e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x2f, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, + 0x64, 0x69, 0x76, 0x3e, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x27, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x27, 0x29, 0x46, 0x75, 0x72, 0x74, + 0x68, 0x65, 0x72, 0x6d, 0x6f, 0x72, 0x65, 0x2c, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x3d, 0x20, + 0x70, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x64, 0x72, 0x61, 0x6d, + 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x6f, 0x6e, 0x65, 0x67, 0x6f, 0x74, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x68, 0x65, 0x61, 0x64, 0x71, 0x75, 0x61, 0x72, 0x74, 0x65, 0x72, 0x73, 0x53, 0x6f, 0x75, 0x74, + 0x68, 0x20, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x75, 0x6e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x66, 0x75, 0x6c, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, + 0x41, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2c, 0x3c, 0x68, 0x74, 0x6d, + 0x6c, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x3d, 0x22, 0x26, 0x6c, 0x74, 0x3b, 0x2f, 0x73, 0x75, 0x70, + 0x26, 0x67, 0x74, 0x3b, 0x64, 0x65, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x70, 0x68, 0x69, 0x6c, 0x61, 0x64, 0x65, 0x6c, 0x70, 0x68, 0x69, 0x61, 0x68, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x29, 0x3b, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0a, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x2d, 0x74, 0x6f, 0x70, 0x3a, + 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x67, 0x65, 0x74, 0x41, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, + 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3d, 0x66, 0x75, 0x6e, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x2e, 0x64, 0x74, 0x64, 0x22, 0x3e, 0x0d, 0x0a, 0x3c, 0x68, 0x74, + 0x67, 0x65, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, + 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x61, 0x67, 0x72, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x20, 0x31, + 0x61, 0x20, 0x76, 0x61, 0x72, 0x69, 0x65, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x45, 0x6e, 0x63, 0x79, 0x63, 0x6c, 0x6f, 0x70, + 0x65, 0x64, 0x69, 0x61, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, + 0x64, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x64, 0x61, 0x63, 0x63, 0x6f, + 0x6d, 0x70, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x44, 0x65, 0x6d, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, + 0x29, 0x3b, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x64, 0x65, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, + 0x65, 0x20, 0x6f, 0x66, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, + 0x28, 0x55, 0x53, 0x29, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x28, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x48, + 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x69, 0x67, + 0x65, 0x6e, 0x63, 0x65, 0x22, 0x20, 0x74, 0x61, 0x62, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x3d, 0x22, + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3b, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x77, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x72, 0x61, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x20, + 0x66, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x74, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x6e, 0x65, 0x72, 0x65, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6e, 0x63, 0x79, 0x63, 0x6c, 0x6f, 0x70, + 0x65, 0x64, 0x69, 0x61, 0x3b, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x31, + 0x6a, 0x75, 0x72, 0x69, 0x73, 0x64, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x49, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2c, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x63, 0x6f, 0x6e, 0x76, + 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x69, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, + 0x72, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x72, 0x65, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x26, 0x6c, 0x74, 0x3b, 0x6d, 0x61, 0x74, 0x68, + 0x26, 0x67, 0x74, 0x3b, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x3c, 0x69, 0x6d, 0x67, + 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x6e, 0x61, 0x76, 0x69, 0x67, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0x3e, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x6e, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x63, 0x68, 0x61, 0x6d, 0x70, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x6d, 0x65, 0x64, 0x69, + 0x61, 0x3d, 0x22, 0x61, 0x6c, 0x6c, 0x22, 0x20, 0x76, 0x69, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x53, 0x74, 0x72, 0x69, + 0x63, 0x74, 0x2f, 0x2f, 0x45, 0x4e, 0x22, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, + 0x74, 0x69, 0x65, 0x73, 0x43, 0x68, 0x61, 0x6d, 0x70, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, + 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x3c, 0x21, 0x5b, 0x65, + 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x7d, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0a, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x69, 0x74, 0x79, + 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x50, 0x72, 0x6f, 0x66, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x77, 0x61, 0x73, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x28, 0x73, 0x75, 0x63, + 0x68, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x28, 0x75, 0x6e, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x74, 0x68, 0x65, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, + 0x74, 0x6d, 0x6c, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x22, 0x3e, 0x3c, 0x61, + 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x63, 0x6f, 0x6e, 0x73, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x3d, 0x22, 0x47, 0x75, 0x69, 0x64, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x6f, 0x76, 0x65, 0x72, 0x77, 0x68, 0x65, 0x6c, 0x6d, 0x69, 0x6e, 0x67, 0x61, 0x67, 0x61, 0x69, + 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x2c, 0x0a, 0x2e, 0x6e, 0x6f, 0x6e, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x20, + 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 0x2f, 0x61, 0x3e, + 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x66, 0x20, 0x28, 0x64, 0x6f, 0x63, 0x75, 0x6d, + 0x65, 0x6e, 0x74, 0x2e, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x20, 0x31, 0x70, 0x78, 0x20, + 0x7b, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x31, 0x74, 0x72, 0x65, 0x61, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x30, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x3d, 0x22, 0x31, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x69, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x61, 0x63, 0x68, 0x69, 0x65, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x4a, 0x61, 0x76, 0x61, + 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x20, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x74, 0x68, 0x65, + 0x6c, 0x65, 0x73, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x63, 0x65, + 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x3e, 0x26, 0x6e, 0x62, + 0x73, 0x70, 0x3b, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x22, 0x3e, 0x0a, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x61, 0x20, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x73, 0x72, 0x63, 0x3d, 0x27, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x61, 0x76, 0x69, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, + 0x68, 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x73, + 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x2f, + 0x64, 0x69, 0x76, 0x3e, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, + 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x66, 0x75, 0x6e, 0x64, + 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x6f, 0x70, 0x6f, 0x6c, + 0x69, 0x74, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, + 0x22, 0x20, 0x78, 0x6d, 0x6c, 0x3a, 0x6c, 0x61, 0x6e, 0x67, 0x3d, 0x22, 0x64, 0x65, 0x6c, 0x69, + 0x62, 0x65, 0x72, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x63, 0x65, + 0x6e, 0x74, 0x65, 0x72, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6d, 0x70, 0x72, + 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, + 0x67, 0x20, 0x69, 0x6e, 0x4a, 0x65, 0x73, 0x75, 0x73, 0x20, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x64, 0x69, 0x73, 0x61, + 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, + 0x67, 0x6e, 0x3a, 0x72, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, + 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x69, 0x65, 0x73, 0x62, 0x6f, 0x64, 0x79, + 0x3e, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x69, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x6c, 0x79, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x61, 0x6c, + 0x69, 0x73, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x3b, + 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x65, 0x78, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, + 0x65, 0x20, 0x6f, 0x66, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x74, 0x68, 0x65, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x09, 0x3c, 0x75, 0x6c, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x6e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x72, 0x68, 0x6f, 0x6f, 0x64, + 0x61, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x73, 0x72, 0x65, 0x64, 0x75, + 0x63, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, + 0x73, 0x20, 0x74, 0x6f, 0x4e, 0x6f, 0x6e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, + 0x74, 0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x0a, 0x09, 0x09, 0x3c, + 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x28, 0x73, 0x65, 0x65, + 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x29, 0x2e, 0x22, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x73, 0x65, + 0x61, 0x72, 0x63, 0x68, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x69, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x09, 0x09, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0a, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, + 0x61, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x68, 0x72, 0x6f, + 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x48, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, + 0x46, 0x61, 0x6d, 0x65, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x27, 0x74, + 0x65, 0x78, 0x74, 0x2f, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x76, 0x65, 0x72, 0x79, + 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x7b, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, + 0x75, 0x6e, 0x64, 0x3a, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x69, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, + 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x20, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, + 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3e, 0x3c, 0x6e, 0x6f, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x66, + 0x6f, 0x75, 0x6e, 0x64, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x68, 0x61, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x6e, 0x65, 0x69, 0x67, + 0x68, 0x62, 0x6f, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x64, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x09, 0x3c, 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x6e, 0x73, 0x74, + 0x72, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x53, 0x6f, 0x76, 0x69, 0x65, 0x74, 0x20, 0x55, + 0x6e, 0x69, 0x6f, 0x6e, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x64, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x6f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x20, 0x66, + 0x61, 0x63, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x61, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x73, 0x75, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x75, 0x63, 0x68, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, + 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x75, 0x62, 0x62, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, + 0x72, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x72, 0x65, + 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x20, 0x53, 0x65, 0x70, 0x74, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x49, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x69, 0x67, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x70, 0x78, 0x3b, 0x20, + 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x74, 0x6f, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, + 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x6c, 0x69, 0x6e, 0x6b, + 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, + 0x6c, 0x69, 0x74, 0x79, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x74, 0x72, + 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x62, 0x65, + 0x69, 0x6e, 0x67, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x61, 0x72, 0x65, 0x20, + 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x61, 0x20, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x77, 0x68, 0x6f, + 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x61, 0x72, 0x67, 0x75, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x6e, 0x6f, 0x77, 0x20, 0x6b, 0x6e, 0x6f, 0x77, + 0x6e, 0x20, 0x61, 0x73, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x61, 0x72, 0x6c, 0x79, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x64, 0x65, 0x72, 0x69, + 0x76, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x53, 0x63, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x61, + 0x76, 0x69, 0x61, 0x6e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, + 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x20, 0x65, + 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x74, 0x68, 0x65, 0x20, 0x4e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x70, 0x61, 0x67, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x61, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x6f, 0x75, + 0x73, 0x20, 0x74, 0x6f, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x2f, 0x75, 0x6c, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x77, 0x61, 0x73, 0x20, + 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x61, 0x6e, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, + 0x6d, 0x65, 0x20, 0x61, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, + 0x74, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x22, 0x20, 0x77, 0x61, 0x73, 0x20, + 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x64, 0x6e, 0x6f, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, + 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x3e, 0x0d, 0x0a, 0x3c, + 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0d, 0x0a, 0x3c, 0x77, 0x65, 0x72, 0x65, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x6d, 0x70, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x63, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, + 0x6e, 0x64, 0x3a, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x20, + 0x69, 0x74, 0x73, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x6e, 0x74, 0x6f, + 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, + 0x63, 0x65, 0x73, 0x73, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, + 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x79, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x69, 0x73, 0x6d, 0x20, 0x6f, 0x66, + 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x70, 0x72, 0x6f, 0x62, + 0x61, 0x62, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x72, 0x74, + 0x69, 0x63, 0x6c, 0x65, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, + 0x49, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x61, 0x6e, 0x20, 0x61, + 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x63, 0x63, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x61, 0x6c, 0x6c, 0x79, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x41, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x62, 0x65, 0x74, 0x74, + 0x65, 0x72, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x6e, + 0x61, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x73, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x70, 0x61, 0x73, 0x73, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, + 0x78, 0x6d, 0x6c, 0x22, 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, + 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x69, 0x6d, 0x67, + 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x69, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, + 0x77, 0x77, 0x77, 0x2e, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x57, 0x61, 0x72, 0x20, 0x49, 0x49, + 0x74, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x6f, 0x6e, 0x69, 0x61, 0x6c, 0x73, 0x66, 0x6f, 0x75, 0x6e, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, + 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x79, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x68, 0x65, 0x20, + 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x76, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x66, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x62, 0x61, 0x63, 0x6b, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x73, 0x73, 0x22, 0x20, 0x6d, 0x65, 0x64, + 0x69, 0x61, 0x3d, 0x22, 0x50, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, + 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6f, 0x6e, 0x70, 0x72, 0x6f, 0x76, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x22, 0x77, 0x61, 0x73, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, + 0x76, 0x61, 0x72, 0x69, 0x65, 0x74, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x6c, 0x69, 0x6b, 0x65, + 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x65, + 0x64, 0x20, 0x6f, 0x66, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x68, 0x61, 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x75, 0x70, + 0x6c, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, + 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x62, 0x65, 0x66, 0x6f, + 0x72, 0x65, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x20, 0x62, 0x65, + 0x63, 0x61, 0x6d, 0x65, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x72, 0x65, 0x73, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x6d, 0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x3e, 0x3c, 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x70, 0x6c, + 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x49, 0x6e, 0x74, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x61, 0x20, 0x77, 0x69, 0x64, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x6f, 0x6e, 0x20, 0x62, 0x65, 0x68, 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x76, 0x61, 0x6c, 0x69, + 0x67, 0x6e, 0x3d, 0x22, 0x74, 0x6f, 0x70, 0x22, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x6c, + 0x65, 0x20, 0x6f, 0x66, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2c, + 0x3c, 0x2f, 0x6e, 0x6f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x73, 0x61, 0x69, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x76, 0x65, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, + 0x68, 0x79, 0x70, 0x6f, 0x74, 0x68, 0x65, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x70, 0x68, 0x69, 0x6c, + 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x73, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x62, 0x79, 0x69, 0x6e, 0x61, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x74, 0x6f, 0x77, 0x65, 0x72, 0x65, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x74, 0x65, 0x6e, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x20, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, + 0x20, 0x66, 0x6f, 0x72, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x69, 0x6e, 0x76, 0x65, + 0x6e, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6e, + 0x64, 0x61, 0x72, 0x64, 0x77, 0x61, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, + 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x66, + 0x65, 0x73, 0x73, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x4f, 0x63, 0x65, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x6c, 0x61, 0x73, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, + 0x79, 0x65, 0x61, 0x72, 0x73, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x61, 0x6e, 0x20, 0x65, + 0x78, 0x74, 0x72, 0x65, 0x6d, 0x65, 0x6c, 0x79, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x0a, 0x61, 0x6e, 0x20, 0x65, + 0x66, 0x66, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x75, 0x74, 0x68, + 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, 0x3e, 0x73, 0x75, 0x66, 0x66, + 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x74, 0x68, 0x65, 0x20, 0x45, 0x75, 0x72, 0x6f, + 0x70, 0x65, 0x61, 0x6e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x63, 0x6c, 0x65, 0x61, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x64, 0x69, 0x64, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6e, 0x74, 0x6c, 0x79, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x65, 0x63, 0x6f, 0x6e, + 0x6f, 0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, + 0x61, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x73, 0x75, + 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x65, 0x78, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x74, 0x75, 0x72, 0x65, 0x73, 0x3c, 0x2f, 0x73, 0x70, + 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x0a, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x73, 0x69, 0x73, + 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, + 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x61, 0x73, 0x73, 0x61, + 0x73, 0x73, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x73, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x3d, 0x22, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, + 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x77, 0x65, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x22, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x0d, 0x0a, 0x20, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x62, 0x65, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, + 0x20, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x68, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x74, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x6f, 0x66, 0x73, 0x75, 0x70, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, + 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x69, 0x73, 0x20, 0x6d, + 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x77, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x65, 0x64, + 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x69, 0x6e, 0x67, 0x68, 0x69, 0x73, 0x20, + 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x61, 0x74, 0x73, 0x74, 0x75, 0x64, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x48, 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x72, 0x65, 0x73, 0x65, + 0x61, 0x72, 0x63, 0x68, 0x20, 0x61, 0x6e, 0x64, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x64, 0x65, 0x66, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x6e, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x62, 0x75, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x6f, 0x66, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x79, 0x65, 0x61, 0x72, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x67, 0x65, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x75, 0x64, 0x79, 0x20, 0x6f, 0x66, 0x3c, 0x75, 0x6c, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x73, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x68, 0x65, 0x20, 0x77, 0x61, 0x73, 0x3c, 0x6c, 0x69, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x66, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x6e, 0x6f, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, + 0x68, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x65, 0x78, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, + 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x74, 0x65, 0x72, 0x72, + 0x69, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x22, 0x3e, 0x52, 0x6f, 0x6d, 0x61, 0x6e, 0x20, 0x45, 0x6d, 0x70, 0x69, 0x72, 0x65, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x49, 0x6e, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, 0x74, 0x2c, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, + 0x20, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, + 0x61, 0x6e, 0x64, 0x20, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x66, 0x65, 0x28, 0x61, 0x6c, 0x73, + 0x6f, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x3e, 0x3c, 0x75, 0x6c, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, + 0x65, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x73, 0x65, 0x65, 0x6d, + 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x76, 0x65, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x6e, 0x6f, + 0x61, 0x6e, 0x20, 0x65, 0x78, 0x63, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x49, 0x6e, 0x20, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, 0x2c, + 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x63, 0x68, 0x61, 0x72, + 0x67, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x6d, 0x69, 0x6c, 0x69, 0x74, 0x61, 0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, + 0x61, 0x6c, 0x6c, 0x79, 0x73, 0x65, 0x74, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x69, 0x6e, 0x67, + 0x61, 0x72, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x76, 0x69, 0x63, 0x74, + 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x28, 0x29, 0x3b, 0x3c, 0x2f, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x3e, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x6f, 0x75, 0x73, 0x6c, 0x79, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x76, 0x6f, 0x6c, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x61, 0x6e, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x61, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6e, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x77, 0x69, 0x73, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6f, 0x66, + 0x68, 0x61, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x2c, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x74, 0x6f, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x61, 0x72, 0x65, 0x20, + 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, + 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x6f, 0x66, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x64, 0x75, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x61, 0x72, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x70, 0x6f, 0x70, + 0x75, 0x6c, 0x61, 0x72, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x20, 0x6f, 0x66, 0x61, 0x6e, 0x64, 0x20, + 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, + 0x69, 0x7a, 0x65, 0x64, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x54, 0x65, 0x78, 0x74, + 0x77, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x72, 0x65, 0x63, 0x65, + 0x69, 0x76, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x61, 0x72, 0x65, 0x61, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x74, 0x68, 0x65, 0x20, + 0x62, 0x61, 0x73, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x6e, 0x73, 0x65, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x64, 0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x65, 0x64, 0x20, 0x62, 0x79, 0x61, 0x74, 0x20, 0x6c, + 0x65, 0x61, 0x73, 0x74, 0x20, 0x74, 0x77, 0x6f, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x63, 0x6c, + 0x61, 0x72, 0x65, 0x64, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x61, 0x70, 0x70, 0x65, + 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x74, + 0x6f, 0x70, 0x3a, 0x31, 0x2f, 0x5e, 0x5c, 0x73, 0x2b, 0x7c, 0x5c, 0x73, 0x2b, 0x24, 0x2f, 0x67, + 0x65, 0x29, 0x7b, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x65, 0x7d, 0x3b, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x74, 0x77, 0x6f, 0x20, 0x73, 0x65, 0x70, 0x61, + 0x72, 0x61, 0x74, 0x65, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, 0x61, 0x6e, 0x64, + 0x77, 0x68, 0x6f, 0x20, 0x68, 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x61, 0x74, 0x68, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x61, 0x6c, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, + 0x09, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x65, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, 0x28, 0x55, 0x4b, 0x29, 0x65, 0x6e, 0x67, 0x6c, + 0x69, 0x73, 0x68, 0x20, 0x28, 0x55, 0x53, 0x29, 0xd0, 0x9c, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xb3, + 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xa1, 0xd1, 0x80, 0xd0, 0xbf, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, + 0xd1, 0x81, 0xd1, 0x80, 0xd0, 0xbf, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x80, + 0xd0, 0xbf, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xbe, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xa8, + 0xd9, 0x8a, 0xd8, 0xa9, 0xe6, 0xad, 0xa3, 0xe9, 0xab, 0x94, 0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87, + 0xe7, 0xae, 0x80, 0xe4, 0xbd, 0x93, 0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87, 0xe7, 0xb9, 0x81, 0xe4, + 0xbd, 0x93, 0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87, 0xe6, 0x9c, 0x89, 0xe9, 0x99, 0x90, 0xe5, 0x85, + 0xac, 0xe5, 0x8f, 0xb8, 0xe4, 0xba, 0xba, 0xe6, 0xb0, 0x91, 0xe6, 0x94, 0xbf, 0xe5, 0xba, 0x9c, + 0xe9, 0x98, 0xbf, 0xe9, 0x87, 0x8c, 0xe5, 0xb7, 0xb4, 0xe5, 0xb7, 0xb4, 0xe7, 0xa4, 0xbe, 0xe4, + 0xbc, 0x9a, 0xe4, 0xb8, 0xbb, 0xe4, 0xb9, 0x89, 0xe6, 0x93, 0x8d, 0xe4, 0xbd, 0x9c, 0xe7, 0xb3, + 0xbb, 0xe7, 0xbb, 0x9f, 0xe6, 0x94, 0xbf, 0xe7, 0xad, 0x96, 0xe6, 0xb3, 0x95, 0xe8, 0xa7, 0x84, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x68, 0x65, 0x72, 0x72, + 0x61, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0xc3, 0xb3, + 0x6e, 0x69, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x63, 0x6c, 0x61, 0x73, 0x69, 0x66, 0x69, 0x63, 0x61, 0x64, 0x6f, 0x73, 0x63, 0x6f, 0x6e, 0x6f, + 0x63, 0x69, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x63, + 0x69, 0xc3, 0xb3, 0x6e, 0x72, 0x65, 0x6c, 0x61, 0x63, 0x69, 0x6f, 0x6e, 0x61, 0x64, 0x61, 0x73, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0xc3, 0xa1, 0x74, 0x69, 0x63, 0x61, 0x72, 0x65, 0x6c, 0x61, + 0x63, 0x69, 0x6f, 0x6e, 0x61, 0x64, 0x6f, 0x73, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x61, 0x6d, + 0x65, 0x6e, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x61, 0x64, 0x6f, 0x72, 0x65, 0x73, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x61, 0x79, 0x75, 0x6e, + 0x74, 0x61, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x63, 0x61, 0x64, 0x6f, 0x4c, + 0x69, 0x62, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0xc3, 0xa1, 0x63, 0x74, 0x65, 0x6e, 0x6f, 0x73, + 0x68, 0x61, 0x62, 0x69, 0x74, 0x61, 0x63, 0x69, 0x6f, 0x6e, 0x65, 0x73, 0x63, 0x75, 0x6d, 0x70, + 0x6c, 0x69, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x61, 0x75, 0x72, 0x61, + 0x6e, 0x74, 0x65, 0x73, 0x64, 0x69, 0x73, 0x70, 0x6f, 0x73, 0x69, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x75, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x72, 0xc3, 0xb3, 0x6e, 0x69, 0x63, 0x61, 0x61, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x63, 0x69, + 0x6f, 0x6e, 0x65, 0x73, 0x64, 0x65, 0x73, 0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x61, 0x64, 0x6f, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x72, 0x65, 0x61, 0x6c, + 0x69, 0x7a, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x63, + 0x69, 0xc3, 0xb3, 0x6e, 0x65, 0x6e, 0x63, 0x69, 0x63, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x69, 0x61, + 0x65, 0x6e, 0x66, 0x65, 0x72, 0x6d, 0x65, 0x64, 0x61, 0x64, 0x65, 0x73, 0x69, 0x6e, 0x73, 0x74, + 0x72, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0x73, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, 0x6e, + 0x63, 0x69, 0x61, 0x73, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x65, 0x73, 0x73, 0x75, 0x62, 0x63, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x61, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbb, 0xd1, 0x8c, + 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xa0, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x81, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x8b, 0xd0, 0xb1, 0xd0, 0xbe, + 0xd0, 0xbb, 0xd1, 0x8c, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd1, 0x81, + 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb6, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb5, + 0xd0, 0xb4, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xb3, 0xd0, 0xb8, 0xd1, 0x85, 0xd1, 0x81, 0xd0, 0xbb, + 0xd1, 0x83, 0xd1, 0x87, 0xd0, 0xb0, 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb9, 0xd1, 0x87, + 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xb4, 0xd0, 0xb0, + 0xd0, 0xa0, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x8f, 0xd0, 0x9c, 0xd0, 0xbe, + 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xb3, + 0xd0, 0xb8, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb0, + 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xb4, 0xd0, 0xb0, + 0xd0, 0xbd, 0xd0, 0xbd, 0xd1, 0x8b, 0xd1, 0x85, 0xd0, 0xb4, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb6, + 0xd0, 0xbd, 0xd1, 0x8b, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xbd, 0xd0, 0xbe, + 0xd0, 0x9c, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb2, 0xd1, 0x8b, 0xd1, 0x80, 0xd1, 0x83, + 0xd0, 0xb1, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xb9, 0xd0, 0x9c, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xba, + 0xd0, 0xb2, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xbd, 0xd1, 0x8b, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xb0, + 0xd0, 0xb1, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xb4, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb6, + 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x83, 0xd1, 0x81, 0xd0, 0xbb, 0xd1, 0x83, 0xd0, 0xb3, 0xd0, 0xb8, + 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbf, 0xd0, 0xb5, 0xd1, 0x80, 0xd1, 0x8c, 0xd0, 0x9e, 0xd0, 0xb4, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbf, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, + 0xd0, 0xbc, 0xd1, 0x83, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xbe, 0xd1, 0x82, 0xd1, 0x83, + 0xd0, 0xb0, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xbb, 0xd1, 0x8f, 0xd0, 0xb2, 0xd0, 0xbe, + 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x89, 0xd0, 0xb5, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xbe, + 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, + 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xb8, 0xd0, 0xb4, 0xd1, 0x80, + 0xd1, 0x83, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb9, 0xd1, 0x84, 0xd0, 0xbe, 0xd1, 0x80, 0xd1, 0x83, + 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x85, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd1, 0x88, 0xd0, 0xbe, + 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xb2, 0xd1, 0x81, 0xd1, 0x81, + 0xd1, 0x8b, 0xd0, 0xbb, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xb6, 0xd0, 0xb4, + 0xd1, 0x8b, 0xd0, 0xb9, 0xd0, 0xb2, 0xd0, 0xbb, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, + 0xd0, 0xb3, 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xbf, 0xd0, 0xbf, 0xd1, 0x8b, 0xd0, 0xb2, 0xd0, 0xbc, + 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xbe, + 0xd1, 0x82, 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xb0, 0xd0, 0xbb, + 0xd0, 0xbf, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb2, 0xd1, 0x8b, 0xd0, 0xb9, 0xd0, 0xb4, 0xd0, 0xb5, + 0xd0, 0xbb, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8c, + 0xd0, 0xb3, 0xd0, 0xb8, 0xd0, 0xbf, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xbe, 0xd0, 0xb4, + 0xd0, 0xb1, 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xbe, 0xd1, 0x81, + 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xb5, + 0xd0, 0xbd, 0xd1, 0x82, 0xd0, 0xba, 0xd1, 0x83, 0xd0, 0xbf, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, + 0xd0, 0xb4, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb6, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x80, 0xd0, 0xb0, + 0xd0, 0xbc, 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x85, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb0, + 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xa0, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xb0, + 0xd0, 0xa2, 0xd0, 0xbe, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xbe, + 0xd0, 0xb2, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xb2, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, + 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb0, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd1, 0x81, 0xd0, 0xbf, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xba, 0xd1, 0x81, 0xd0, 0xbb, + 0xd1, 0x83, 0xd0, 0xb6, 0xd0, 0xb1, 0xd1, 0x8b, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x82, + 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xbf, 0xd0, 0xb5, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xb8, + 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xbf, 0xd0, 0xbe, + 0xd0, 0xbc, 0xd0, 0xbe, 0xd1, 0x89, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xb0, 0xd0, 0xb9, 0xd1, 0x82, + 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xbf, 0xd0, 0xbe, 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x83, + 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbe, 0xd1, 0x89, 0xd1, 0x8c, 0xd0, 0xb4, 0xd0, 0xbe, + 0xd0, 0xbb, 0xd0, 0xb6, 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x81, 0xd1, 0x8b, 0xd0, 0xbb, + 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xb1, 0xd1, 0x8b, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xbe, + 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xbd, 0xd1, 0x8b, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xb8, 0xd0, 0xb5, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb5, + 0xd0, 0xba, 0xd1, 0x82, 0xd0, 0xa1, 0xd0, 0xb5, 0xd0, 0xb9, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x81, + 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x82, 0xd0, 0xb0, + 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd0, 0xb9, 0xd0, 0xbd, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb5, + 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x80, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x8f, 0xd1, 0x81, 0xd1, 0x82, + 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x84, 0xd0, 0xb8, 0xd0, 0xbb, 0xd1, 0x8c, + 0xd0, 0xbc, 0xd1, 0x8b, 0xd1, 0x83, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xbd, 0xd1, 0x8f, + 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xbd, 0xd1, 0x8b, 0xd1, 0x85, 0xd0, 0xb8, 0xd1, 0x81, + 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xb4, 0xd0, 0xb5, + 0xd0, 0xbb, 0xd1, 0x8e, 0xd1, 0x8f, 0xd0, 0xbd, 0xd0, 0xb2, 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x8f, + 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbd, 0xd1, 0x8c, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xb8, 0xd1, 0x85, 0xd0, 0xb4, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xb7, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb8, 0xd1, 0x82, + 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xb7, 0xd1, 0x8f, 0xd1, 0x84, 0xd0, 0xbe, + 0xd1, 0x80, 0xd1, 0x83, 0xd0, 0xbc, 0xd0, 0xb0, 0xd0, 0xa2, 0xd0, 0xb5, 0xd0, 0xbf, 0xd0, 0xb5, + 0xd1, 0x80, 0xd1, 0x8c, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x8f, 0xd1, 0x86, 0xd0, 0xb0, + 0xd0, 0xb7, 0xd0, 0xb0, 0xd1, 0x89, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8b, 0xd0, 0x9b, 0xd1, 0x83, + 0xd1, 0x87, 0xd1, 0x88, 0xd0, 0xb8, 0xd0, 0xb5, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, + 0x80, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, + 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, + 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x97, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0x82, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb5, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb9, 0xe0, + 0xa5, 0x8b, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0xa4, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xb9, 0xe0, + 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x9f, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xb0, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, + 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x81, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xad, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, + 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x87, 0xe0, + 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0x9f, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa7, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, + 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, + 0x9d, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa3, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xa1, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xb2, + 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb2, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, + 0xb5, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x86, 0xe0, + 0xa4, 0xaa, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, + 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0xa0, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x86, 0xe0, + 0xa4, 0xaa, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb5, + 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9c, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x89, 0xe0, + 0xa4, 0xa8, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb9, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9c, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x9a, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9c, 0xe0, + 0xa5, 0x88, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xaa, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xaf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9a, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x9c, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb2, + 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xac, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa5, 0x81, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xac, 0xe0, + 0xa4, 0xa1, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb6, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xb6, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, + 0xbc, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xb6, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0xa4, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, + 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xbc, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xae, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, + 0x95, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb2, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x96, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, + 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xaf, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xab, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, + 0x95, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb5, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, + 0x9c, 0xe0, 0xa4, 0xbc, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, + 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xac, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xac, 0xe0, + 0xa4, 0xa1, 0xe0, 0xa4, 0xbc, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8c, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0xb8, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x8f, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0x95, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0x95, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, + 0x82, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, + 0xd8, 0xaa, 0xd8, 0xb3, 0xd8, 0xaa, 0xd8, 0xb7, 0xd9, 0x8a, 0xd8, 0xb9, 0xd9, 0x85, 0xd8, 0xb4, + 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa9, 0xd8, 0xa8, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb3, + 0xd8, 0xb7, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb5, 0xd9, 0x81, 0xd8, 0xad, 0xd8, 0xa9, + 0xd9, 0x85, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb6, 0xd9, 0x8a, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xae, 0xd8, 0xa7, 0xd8, 0xb5, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb2, + 0xd9, 0x8a, 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x88, 0xd8, 0xaf, 0xd8, 0xa8, 0xd8, 0xb1, 0xd9, 0x86, 0xd8, 0xa7, + 0xd9, 0x85, 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd9, 0x88, 0xd9, 0x84, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x85, 0xd9, 0x88, 0xd9, 0x82, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xb1, + 0xd8, 0xa8, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xb9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xac, 0xd9, 0x88, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb0, 0xd9, 0x87, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xad, 0xd9, 0x8a, + 0xd8, 0xa7, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xad, 0xd9, 0x82, 0xd9, 0x88, 0xd9, 0x82, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, 0xd8, 0xb1, 0xd9, 0x8a, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb9, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x82, 0xd9, 0x85, 0xd8, 0xad, 0xd9, 0x81, 0xd9, 0x88, + 0xd8, 0xb8, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xab, 0xd8, 0xa7, 0xd9, 0x86, 0xd9, 0x8a, + 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd9, 0x87, 0xd8, 0xaf, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x85, 0xd8, 0xb1, 0xd8, 0xa3, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x82, 0xd8, 0xb1, + 0xd8, 0xa2, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb4, 0xd8, 0xa8, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xad, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xac, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd8, 0xb3, + 0xd8, 0xb1, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x88, 0xd9, 0x85, + 0xd9, 0x85, 0xd8, 0xac, 0xd9, 0x85, 0xd9, 0x88, 0xd8, 0xb9, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb1, 0xd8, 0xad, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x86, 0xd9, 0x82, + 0xd8, 0xa7, 0xd8, 0xb7, 0xd9, 0x81, 0xd9, 0x84, 0xd8, 0xb3, 0xd8, 0xb7, 0xd9, 0x8a, 0xd9, 0x86, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x88, 0xd9, 0x8a, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xaf, 0xd9, 0x86, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa7, + 0xd8, 0xaa, 0xd9, 0x87, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xb6, + 0xd8, 0xaa, 0xd8, 0xad, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, 0xd9, 0x8a, 0xd8, 0xa8, 0xd8, 0xaa, + 0xd9, 0x88, 0xd9, 0x82, 0xd9, 0x8a, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x88, + 0xd9, 0x84, 0xd9, 0x89, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa8, 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xaf, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb1, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xb7, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb4, 0xd8, 0xae, + 0xd8, 0xb5, 0xd9, 0x8a, 0xd8, 0xb3, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xab, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xab, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb5, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xad, 0xd8, 0xaf, + 0xd9, 0x8a, 0xd8, 0xab, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb2, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb1, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xae, 0xd9, 0x84, 0xd9, 0x8a, 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xac, 0xd9, 0x85, 0xd9, 0x8a, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, + 0xd9, 0x85, 0xd9, 0x87, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xac, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd8, 0xa7, 0xd8, 0xb9, 0xd8, 0xa9, 0xd9, 0x85, 0xd8, 0xb4, + 0xd8, 0xa7, 0xd9, 0x87, 0xd8, 0xaf, 0xd9, 0x87, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xa6, + 0xd9, 0x8a, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd8, 0xae, 0xd9, 0x88, 0xd9, 0x84, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x81, 0xd9, 0x86, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x83, 0xd8, 0xaa, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd9, 0x88, + 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd8, 0xb1, 0xd9, 0x88, 0xd8, 0xb3, + 0xd8, 0xa7, 0xd8, 0xb3, 0xd8, 0xaa, 0xd8, 0xba, 0xd8, 0xb1, 0xd9, 0x82, 0xd8, 0xaa, 0xd8, 0xb5, + 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x8a, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa8, 0xd9, 0x86, + 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xb8, 0xd9, 0x8a, 0xd9, 0x85, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x2e, 0x6a, 0x70, 0x67, 0x22, 0x20, 0x77, 0x69, 0x64, + 0x74, 0x68, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x3c, 0x62, + 0x6f, 0x64, 0x79, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x4d, 0x61, 0x74, 0x68, 0x2e, + 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x28, 0x29, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6d, 0x70, 0x6f, + 0x72, 0x61, 0x72, 0x79, 0x20, 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x20, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6d, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2e, + 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x28, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x22, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, + 0x3d, 0x22, 0x2f, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x65, 0x64, + 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61, 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6d, + 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x22, + 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x69, 0x6e, 0x76, 0x65, 0x73, 0x74, 0x69, 0x67, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6f, 0x6e, 0x2e, 0x69, 0x63, 0x6f, 0x22, + 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x61, + 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4d, 0x61, 0x73, 0x73, 0x61, + 0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x3d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x70, + 0x72, 0x6f, 0x6e, 0x75, 0x6e, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x61, 0x63, 0x6b, + 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x23, 0x66, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, + 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2c, 0x20, 0x6d, 0x69, 0x73, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73, + 0x26, 0x6c, 0x74, 0x3b, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x26, 0x67, 0x74, 0x3b, 0x70, 0x73, 0x79, + 0x63, 0x68, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x3d, 0x22, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x3d, + 0x22, 0x61, 0x73, 0x20, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x53, 0x75, + 0x70, 0x72, 0x65, 0x6d, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x72, 0x74, 0x6f, 0x63, 0x63, 0x61, 0x73, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, + 0x63, 0x61, 0x70, 0x78, 0x3b, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x6f, + 0x70, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x69, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x65, + 0x72, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x74, 0x6f, 0x4c, 0x6f, 0x77, 0x65, + 0x72, 0x43, 0x61, 0x73, 0x65, 0x28, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, + 0x69, 0x6e, 0x67, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x46, 0x6f, 0x72, + 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x22, 0x20, 0x6d, 0x61, 0x78, 0x6c, 0x65, 0x6e, 0x67, + 0x74, 0x68, 0x3d, 0x22, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, + 0x3b, 0x63, 0x6f, 0x6e, 0x73, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x6e, 0x65, 0x73, 0x73, 0x4d, 0x65, + 0x64, 0x69, 0x74, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x65, 0x61, 0x6e, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x61, 0x73, 0x73, 0x61, 0x73, 0x73, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, + 0x79, 0x20, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, + 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, + 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x72, 0x65, 0x66, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x3c, 0x2f, 0x75, 0x6c, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, + 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x68, 0x72, 0x65, 0x66, 0x77, 0x61, 0x73, 0x20, 0x70, 0x75, + 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x53, 0x61, 0x6e, 0x20, 0x46, 0x72, 0x61, 0x6e, 0x63, + 0x69, 0x73, 0x63, 0x6f, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, + 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x6f, + 0x70, 0x68, 0x69, 0x73, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x6d, 0x61, 0x74, 0x68, 0x65, + 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0d, 0x0a, + 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x63, + 0x6f, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x73, 0x6d, 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, + 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x28, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x2c, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x20, + 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x70, 0x61, 0x72, + 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x47, 0x72, 0x65, 0x61, 0x74, 0x20, 0x42, 0x72, 0x69, + 0x74, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, + 0x3d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x3b, 0x20, 0x66, 0x6f, 0x6e, + 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x20, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x73, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x20, + 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, + 0x29, 0x20, 0x7b, 0x61, 0x72, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x0a, 0x09, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x20, 0x73, 0x72, + 0x63, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x20, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x22, 0x20, 0x2f, 0x3e, 0x3c, + 0x2f, 0x61, 0x72, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x68, 0x61, + 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x6d, 0x6f, 0x73, 0x74, 0x20, + 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x3c, + 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x2e, 0x67, 0x69, 0x66, + 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x3c, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65, + 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x2d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, + 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x6f, 0x67, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, + 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x70, 0x61, 0x72, 0x6c, 0x69, 0x61, 0x6d, 0x65, 0x6e, + 0x74, 0x61, 0x72, 0x79, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x6f, 0x72, + 0x65, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x74, 0x72, + 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x70, 0x72, 0x65, 0x64, 0x6f, + 0x6d, 0x69, 0x6e, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x7c, 0x26, + 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x2f, 0x73, 0x70, 0x61, + 0x6e, 0x3e, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x3c, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x6f, 0x72, 0x22, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x61, 0x6c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x22, + 0x6f, 0x67, 0x3a, 0x2f, 0x78, 0x2d, 0x73, 0x68, 0x6f, 0x63, 0x6b, 0x77, 0x61, 0x76, 0x65, 0x2d, + 0x64, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x75, 0x72, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x4e, 0x65, 0x76, 0x65, 0x72, 0x74, + 0x68, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x77, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x41, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6c, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, + 0x3d, 0x22, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x20, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x3c, 0x62, 0x6f, + 0x64, 0x79, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x64, 0x69, 0x73, 0x63, 0x75, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, + 0x6c, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x69, 0x65, 0x77, 0x68, 0x6f, 0x6d, 0x6f, 0x73, + 0x65, 0x78, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x6e, + 0x63, 0x65, 0x20, 0x6f, 0x66, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, 0x73, 0x6f, + 0x72, 0x69, 0x67, 0x69, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x64, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x23, + 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x22, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, + 0x22, 0x30, 0x22, 0x3e, 0x72, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, + 0x79, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x73, + 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x77, 0x61, 0x73, 0x20, 0x64, + 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x64, 0x6f, 0x2d, 0x45, 0x75, 0x72, + 0x6f, 0x70, 0x65, 0x61, 0x6e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x20, + 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x61, + 0x72, 0x65, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x63, 0x6c, 0x6f, 0x73, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, + 0x6b, 0x20, 0x43, 0x69, 0x74, 0x79, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x73, 0x65, 0x61, + 0x72, 0x63, 0x68, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x63, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x61, 0x74, + 0x68, 0x65, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x69, 0x61, 0x6e, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, + 0x64, 0x20, 0x6f, 0x66, 0x22, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, + 0x20, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2e, 0x72, + 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x28, 0x62, 0x72, 0x61, 0x6e, 0x63, + 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x21, 0x5b, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, + 0x0d, 0x0a, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, + 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x72, 0x65, 0x73, 0x70, + 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x2e, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x69, 0x73, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x54, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, + 0x75, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x61, 0x6e, 0x63, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6e, 0x64, 0x61, 0x73, 0x68, 0x3b, + 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, + 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x65, 0x71, 0x75, 0x69, 0x70, 0x70, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x3c, + 0x2f, 0x61, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x66, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x68, + 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x67, 0x65, + 0x20, 0x6f, 0x66, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x72, 0x65, 0x67, + 0x61, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x26, 0x71, + 0x75, 0x6f, 0x74, 0x3b, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x62, 0x6f, + 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x74, 0x68, 0x6f, 0x75, 0x67, + 0x68, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, + 0x65, 0x73, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x20, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x6f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x6a, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x74, 0x77, 0x6f, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x65, 0x73, 0x74, + 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x6d, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x41, 0x63, + 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x64, 0x65, 0x20, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x6c, 0x79, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x66, + 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x77, 0x61, 0x73, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6d, + 0x64, 0x61, 0x73, 0x68, 0x3b, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, + 0x61, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x70, 0x70, + 0x65, 0x61, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x20, 0x6f, 0x66, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x6c, + 0x79, 0x6f, 0x6e, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x6f, 0x76, 0x65, 0x72, 0x3d, 0x22, 0x62, 0x65, + 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x73, 0x79, 0x6e, 0x63, + 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x70, 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x73, 0x65, 0x65, 0x6d, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x66, 0x61, 0x6d, 0x69, + 0x6c, 0x69, 0x61, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x70, 0x6f, 0x73, 0x73, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, + 0x29, 0x20, 0x7b, 0x74, 0x6f, 0x6f, 0x6b, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x69, 0x6e, + 0x61, 0x6e, 0x64, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x73, 0x75, 0x62, + 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x3e, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, + 0x74, 0x67, 0x72, 0x65, 0x61, 0x74, 0x20, 0x64, 0x65, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x45, 0x6e, + 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x73, 0x75, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x6c, + 0x79, 0x20, 0x61, 0x6c, 0x6c, 0x32, 0x30, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, + 0x79, 0x2c, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x73, 0x6e, + 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x74, 0x65, + 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x69, 0x74, + 0x20, 0x69, 0x73, 0x44, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, + 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x54, 0x68, 0x65, + 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x79, 0x20, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x3a, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x74, 0x6c, 0x79, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x77, 0x6f, 0x72, 0x6c, 0x64, + 0x27, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x28, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x61, + 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x6c, 0x65, 0x66, 0x74, 0x22, 0x20, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x6c, 0x79, 0x62, 0x61, 0x73, 0x69, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x63, 0x65, 0x6e, + 0x74, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x64, + 0x75, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6a, 0x75, 0x72, 0x69, 0x73, 0x64, 0x69, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x6f, 0x6e, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x6f, 0x75, 0x74, 0x3d, 0x22, 0x4e, 0x65, + 0x77, 0x20, 0x54, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, + 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x74, + 0x65, 0x64, 0x66, 0x69, 0x6c, 0x6d, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2d, + 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x2e, 0x64, 0x74, 0x64, 0x22, 0x3e, 0x68, 0x61, 0x73, 0x20, + 0x62, 0x65, 0x65, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x62, 0x75, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x75, 0x6e, 0x70, 0x72, 0x65, 0x63, + 0x65, 0x64, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x69, 0x73, 0x20, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, + 0x72, 0x20, 0x74, 0x6f, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x69, + 0x6e, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x69, 0x73, + 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x75, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x09, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x61, + 0x72, 0x65, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x63, 0x6f, 0x6e, 0x66, + 0x6c, 0x69, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, + 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x72, 0x61, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x65, + 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, + 0x20, 0x66, 0x6f, 0x72, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x6f, + 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x26, 0x6e, 0x62, 0x73, 0x70, + 0x3b, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x20, 0x74, 0x6f, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x79, 0x65, + 0x61, 0x72, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x67, + 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, + 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x20, 0x74, 0x6f, 0x09, 0x09, 0x3c, 0x75, 0x6c, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x31, 0x39, 0x74, + 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x2c, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x73, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, 0x65, 0x20, 0x77, + 0x6f, 0x75, 0x6c, 0x64, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, + 0x64, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x69, 0x73, + 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x63, 0x65, 0x6e, 0x74, 0x72, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, + 0x3d, 0x22, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x62, 0x72, 0x6f, 0x75, + 0x67, 0x68, 0x74, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, + 0x6c, 0x6c, 0x79, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x73, + 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x0a, 0x3c, 0x64, + 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x65, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x69, 0x6e, + 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x72, 0x65, 0x70, 0x75, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x0a, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, + 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x64, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x6c, + 0x61, 0x72, 0x67, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x49, 0x6e, 0x73, 0x74, + 0x69, 0x74, 0x75, 0x74, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x2d, + 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x73, 0x65, 0x2c, + 0x77, 0x61, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x63, 0x6c, 0x61, + 0x69, 0x6d, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, + 0x72, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x44, 0x65, 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, + 0x74, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x61, 0x6c, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x73, 0x74, + 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x61, 0x6c, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x77, 0x61, + 0x79, 0x73, 0x61, 0x72, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x65, + 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x70, 0x68, 0x69, 0x6c, + 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x79, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, + 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x63, 0x69, 0x76, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x73, 0x6c, 0x61, 0x6e, 0x64, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x63, 0x61, 0x6e, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3d, 0x22, 0x22, 0x20, 0x2f, 0x3e, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x2f, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, + 0x3e, 0x4d, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x74, 0x72, 0x61, 0x63, + 0x65, 0x64, 0x69, 0x73, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x62, + 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x69, 0x73, 0x20, 0x66, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x6c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x65, 0x74, 0x69, 0x63, 0x61, + 0x6c, 0x6c, 0x79, 0x46, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x67, 0x6f, 0x76, + 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x69, 0x73, 0x20, 0x64, 0x65, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x74, + 0x69, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3e, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x20, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x61, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x69, 0x74, 0x73, 0x77, + 0x61, 0x73, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x64, 0x69, 0x73, 0x70, + 0x6c, 0x61, 0x79, 0x3a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, + 0x70, 0x61, 0x6c, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x61, 0x73, 0x2f, 0x62, 0x6f, + 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, + 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x65, 0x64, 0x68, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x72, 0x65, 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x75, 0x6e, + 0x64, 0x65, 0x72, 0x67, 0x72, 0x61, 0x64, 0x75, 0x61, 0x74, 0x65, 0x54, 0x68, 0x65, 0x72, 0x65, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x77, 0x6f, 0x67, 0x72, 0x61, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x72, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x64, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x66, 0x75, 0x6e, 0x64, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x6c, 0x6c, 0x79, 0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, 0x6c, 0x6c, + 0x69, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x63, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, + 0x65, 0x6c, 0x79, 0x2c, 0x61, 0x6e, 0x64, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, + 0x6c, 0x69, 0x6e, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x70, 0x65, + 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x32, 0x30, 0x74, 0x68, 0x20, + 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x2e, 0x61, 0x6e, 0x64, 0x20, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x73, 0x68, 0x65, 0x64, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x68, 0x61, 0x72, 0x74, 0x62, 0x65, + 0x61, 0x74, 0x74, 0x6f, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x6d, + 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x68, + 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, + 0x61, 0x6e, 0x64, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x61, 0x6c, + 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x63, 0x68, 0x61, + 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, + 0x66, 0x77, 0x61, 0x73, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x61, 0x6e, + 0x64, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x61, 0x20, 0x63, 0x6f, 0x6e, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x74, 0x68, 0x65, 0x20, 0x50, 0x72, 0x65, 0x73, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x64, 0x66, 0x72, 0x65, 0x65, 0x20, 0x73, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x73, + 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x73, + 0x74, 0x72, 0x6f, 0x79, 0x65, 0x64, 0x61, 0x77, 0x61, 0x79, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, + 0x74, 0x68, 0x65, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, + 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x79, 0x66, 0x6f, 0x6c, + 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x70, + 0x6f, 0x77, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x61, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, 0x20, 0x6f, + 0x66, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x77, 0x65, 0x76, + 0x65, 0x72, 0x2c, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x69, 0x73, 0x20, 0x74, 0x68, 0x6f, 0x75, 0x67, + 0x68, 0x74, 0x20, 0x74, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6e, 0x64, 0x77, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, 0x61, + 0x72, 0x65, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x61, 0x6c, 0x73, 0x6f, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x3e, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x65, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x44, 0x4f, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x41, 0x4c, 0x54, 0x45, 0x52, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x74, 0x68, 0x65, + 0x6d, 0x65, 0x73, 0x2f, 0x3f, 0x73, 0x6f, 0x72, 0x74, 0x3d, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, + 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x73, 0x69, 0x73, + 0x20, 0x66, 0x6f, 0x72, 0x68, 0x61, 0x73, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x64, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, + 0x74, 0x68, 0x6f, 0x73, 0x65, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x69, + 0x6e, 0x67, 0x69, 0x73, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x76, + 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x53, 0x6f, 0x75, 0x74, + 0x68, 0x20, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6e, + 0x65, 0x73, 0x73, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x73, 0x65, + 0x3b, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x3b, 0x20, 0x62, 0x61, 0x63, 0x6b, + 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x73, 0x74, + 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x62, 0x61, 0x68, 0x61, 0x73, 0x61, 0x20, 0x4d, + 0x65, 0x6c, 0x61, 0x79, 0x75, 0x6e, 0x6f, 0x72, 0x73, 0x6b, 0x20, 0x62, 0x6f, 0x6b, 0x6d, 0xc3, + 0xa5, 0x6c, 0x6e, 0x6f, 0x72, 0x73, 0x6b, 0x20, 0x6e, 0x79, 0x6e, 0x6f, 0x72, 0x73, 0x6b, 0x73, + 0x6c, 0x6f, 0x76, 0x65, 0x6e, 0xc5, 0xa1, 0xc4, 0x8d, 0x69, 0x6e, 0x61, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x63, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x63, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x63, 0x69, + 0xc3, 0xb3, 0x6e, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x63, 0x69, 0xc3, 0xb3, 0x6e, + 0x22, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x64, 0x69, + 0x73, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x27, 0x2c, 0x20, 0x27, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x74, 0x61, 0x6e, + 0x65, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x3a, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x3c, 0x21, + 0x5b, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x0a, 0x3c, 0x2f, 0x3e, 0x3c, 0x6d, + 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x66, 0x72, 0x61, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2d, 0x62, 0x6f, 0x74, 0x74, 0x6f, + 0x6d, 0x3a, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x3e, + 0x3d, 0x68, 0x74, 0x74, 0x70, 0x25, 0x33, 0x41, 0x25, 0x32, 0x46, 0x25, 0x32, 0x46, 0x3c, 0x66, + 0x6f, 0x72, 0x6d, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x6d, 0x65, 0x74, 0x68, + 0x6f, 0x64, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74, 0x22, 0x20, 0x2f, 0x66, 0x61, 0x76, 0x69, 0x63, + 0x6f, 0x6e, 0x2e, 0x69, 0x63, 0x6f, 0x22, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x2e, 0x73, 0x65, 0x74, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x28, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x29, 0x3b, + 0x3c, 0x21, 0x5b, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x0d, 0x0a, 0x64, 0x69, + 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, 0x55, 0x6e, 0x66, 0x6f, + 0x72, 0x74, 0x75, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x2c, 0x22, 0x3e, 0x26, 0x6e, 0x62, 0x73, + 0x70, 0x3b, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x2f, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6f, 0x6e, + 0x2e, 0x69, 0x63, 0x6f, 0x22, 0x3e, 0x3d, 0x27, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, + 0x65, 0x74, 0x27, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, + 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x61, 0x6e, + 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x61, 0x73, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x70, 0x74, 0x22, 0x3e, 0x3c, 0x2f, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x73, 0x75, + 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x0a, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x28, 0x29, 0x20, 0x7b, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x2f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, + 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x73, 0x74, 0x79, + 0x6c, 0x65, 0x2e, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x63, 0x63, 0x6f, 0x72, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x62, 0x6f, 0x64, + 0x79, 0x2e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x20, + 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x70, 0x6f, + 0x73, 0x74, 0x22, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x6d, 0x65, 0x61, 0x6e, + 0x69, 0x6e, 0x67, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x2d, 0x2d, 0x3c, 0x21, 0x5b, 0x65, + 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x50, 0x72, 0x69, 0x6d, 0x65, 0x20, 0x4d, 0x69, + 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x3c, 0x2f, 0x61, 0x3e, 0x20, 0x3c, 0x61, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x74, 0x68, 0x65, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, + 0x20, 0x6f, 0x6e, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x6f, 0x76, 0x65, 0x72, 0x3d, 0x22, 0x74, 0x68, + 0x65, 0x20, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x68, 0x72, 0x65, 0x66, + 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x61, 0x73, 0x20, 0x6f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x77, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, + 0x3c, 0x21, 0x5b, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x0a, 0x0a, 0x64, 0x65, + 0x70, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x55, 0x6e, 0x69, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x61, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, + 0x6c, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, + 0x65, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2d, 0x3a, 0x20, + 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x42, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x2d, 0x73, 0x74, 0x72, 0x69, 0x63, + 0x74, 0x2e, 0x64, 0x74, 0x64, 0x22, 0x3e, 0x0a, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x69, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x61, + 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x73, 0x29, 0x3b, 0x20, 0x6a, 0x73, + 0x2e, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x69, 0x64, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, + 0x22, 0x31, 0x30, 0x30, 0x25, 0x22, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x52, 0x6f, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x61, 0x74, 0x68, 0x6f, 0x6c, + 0x69, 0x63, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, + 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x67, + 0x69, 0x66, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x31, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x73, 0x63, 0x72, 0x69, + 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x63, 0x68, 0x61, 0x65, 0x6f, 0x6c, + 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x70, 0x72, 0x69, 0x6d, 0x65, 0x20, 0x6d, 0x69, 0x6e, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x3e, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x28, 0x77, 0x2e, 0x61, 0x74, + 0x74, 0x61, 0x63, 0x68, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x28, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, + 0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x61, 0x49, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, + 0x6c, 0x61, 0x72, 0x2c, 0x20, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x6c, 0x65, 0x66, 0x74, + 0x22, 0x20, 0x43, 0x7a, 0x65, 0x63, 0x68, 0x20, 0x52, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x20, 0x4b, 0x69, 0x6e, 0x67, 0x64, 0x6f, 0x6d, 0x63, 0x6f, + 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x63, 0x6f, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, + 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x28, 0x29, 0x20, 0x7b, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x73, + 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x28, 0x27, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x3c, 0x2f, 0x61, 0x3e, + 0x0a, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x0a, 0x3c, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3d, 0x22, 0x28, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, + 0x61, 0x73, 0x09, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x3e, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x73, 0x65, + 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x67, + 0x6e, 0x3d, 0x22, 0x74, 0x6f, 0x70, 0x22, 0x3e, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x6f, 0x20, 0x63, 0x61, 0x72, 0x62, 0x6f, 0x6e, 0x20, 0x64, 0x69, 0x6f, 0x78, 0x69, + 0x64, 0x65, 0x0a, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2d, 0x2f, 0x62, + 0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x6f, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x74, 0x6f, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0d, + 0x0a, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x69, + 0x64, 0x74, 0x68, 0x3a, 0x54, 0x69, 0xe1, 0xba, 0xbf, 0x6e, 0x67, 0x20, 0x56, 0x69, 0xe1, 0xbb, + 0x87, 0x74, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2d, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x30, 0x22, + 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x3c, 0x2f, 0x73, 0x70, + 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x77, 0x61, 0x73, 0x20, 0x64, 0x69, + 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, + 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x29, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x3e, 0x0a, 0x0a, 0x44, 0x65, 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x65, 0x63, 0x63, 0x6c, 0x65, 0x73, 0x69, 0x61, 0x73, 0x74, 0x69, 0x63, 0x61, 0x6c, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x3c, 0x2f, 0x62, 0x6f, + 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x68, 0x61, 0x73, 0x20, 0x6e, 0x65, + 0x76, 0x65, 0x72, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, + 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x74, 0x6f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, + 0x79, 0x20, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, + 0x77, 0x61, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x70, 0x65, + 0x72, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x22, 0x20, 0x2f, 0x3e, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x65, + 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, + 0x65, 0x74, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x75, 0x73, 0x65, 0x64, + 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, + 0x64, 0x64, 0x69, 0x6e, 0x67, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, + 0x72, 0x65, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x27, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6f, 0x72, + 0x20, 0x6e, 0x6f, 0x74, 0x54, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x6c, + 0x73, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6d, 0x61, 0x6e, 0x79, + 0x61, 0x20, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6f, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x6d, 0x70, 0x6f, + 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x2e, 0x20, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x61, 0x6c, + 0x6c, 0x79, 0x41, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x20, + 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x73, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x66, 0x6f, 0x72, + 0x6d, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74, 0x22, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x70, 0x6f, + 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x6c, + 0x79, 0x20, 0x74, 0x6f, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x20, + 0x69, 0x6e, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x62, 0x65, 0x65, 0x6e, + 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x61, 0x6e, + 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x6c, 0x69, 0x67, + 0x6e, 0x3d, 0x22, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3e, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x79, + 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x69, 0x74, 0x20, 0x77, + 0x61, 0x73, 0x70, 0x74, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, + 0x20, 0x76, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x74, 0x6f, 0x70, 0x22, 0x20, 0x69, 0x6e, + 0x68, 0x61, 0x62, 0x69, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x66, 0x6f, 0x6c, 0x6c, + 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x79, 0x65, 0x61, 0x72, 0x0d, 0x0a, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x20, + 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x61, 0x72, 0x67, 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x61, 0x20, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x62, 0x65, 0x73, 0x74, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, + 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x6f, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x72, 0x65, 0x63, 0x6f, + 0x67, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x63, 0x69, + 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x3d, 0x22, 0x45, 0x6e, 0x74, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x20, 0x61, 0x77, 0x61, 0x79, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x3b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x76, 0x65, + 0x73, 0x74, 0x69, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x6e, 0x79, + 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x69, + 0x74, 0x20, 0x69, 0x73, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x3c, 0x73, + 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x20, 0x61, 0x6c, 0x69, + 0x67, 0x6e, 0x3d, 0x22, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, + 0x3e, 0x0a, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x61, 0x73, 0x70, 0x65, 0x63, 0x74, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x73, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, + 0x62, 0x65, 0x65, 0x6e, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x61, 0x6e, 0x20, 0x55, 0x6e, 0x69, + 0x6f, 0x6e, 0x72, 0x65, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, + 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x56, 0x69, + 0x63, 0x65, 0x20, 0x50, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x63, 0x6f, 0x6d, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6d, 0x70, + 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, + 0x31, 0x31, 0x70, 0x78, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x20, 0x6f, 0x66, + 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x09, 0x3c, + 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x73, 0x20, 0x6f, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x6d, 0x62, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x73, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6d, 0x65, + 0x61, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x75, 0x74, 0x73, + 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x74, 0x28, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, + 0x28, 0x29, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x6e, 0x74, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x43, 0x6f, + 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x77, 0x65, 0x72, 0x65, + 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x73, 0x65, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x31, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, + 0x22, 0x31, 0x22, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, + 0x6e, 0x74, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x68, 0x61, 0x64, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x64, 0x65, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x3d, 0x22, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x3a, 0x62, 0x0d, 0x0a, 0x3c, 0x2f, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, + 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x5f, 0x69, 0x64, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x3d, 0x22, 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x0d, 0x0a, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x72, 0x65, + 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x78, 0x4d, 0x4c, 0x48, 0x74, 0x74, + 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x6c, 0x61, 0x72, + 0x67, 0x65, 0x73, 0x74, 0x76, 0x65, 0x72, 0x79, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, + 0x6e, 0x74, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x73, 0x75, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x70, + 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x66, 0x6f, 0x72, 0x65, + 0x69, 0x67, 0x6e, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x73, 0x65, 0x74, 0x44, 0x6f, + 0x6d, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x69, 0x73, 0x20, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x49, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x6d, 0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x69, 0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x74, 0x6f, + 0x20, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x69, 0x73, 0x20, 0x72, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x65, 0x66, 0x66, + 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x20, + 0x6f, 0x66, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x70, 0x65, + 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x28, 0x66, 0x75, 0x6e, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0d, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x20, 0x4e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x6f, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x70, 0x65, 0x22, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x41, 0x73, 0x73, 0x6f, 0x63, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x0a, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, + 0x0a, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x69, 0x73, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x61, 0x6d, 0x6f, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, + 0x6e, 0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2f, 0x3e, 0x0a, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, + 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, + 0x6c, 0x73, 0x65, 0x3b, 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x20, + 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x74, 0x6f, + 0x3b, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x66, 0x66, 0x66, 0x7d, 0x0a, 0x2e, 0x0a, 0x3c, + 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x3e, 0x0d, 0x0a, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, + 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x76, 0x65, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, + 0x65, 0x64, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, + 0x63, 0x65, 0x6c, 0x65, 0x62, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x46, 0x6f, + 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x64, + 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x62, 0x74, 0x61, 0x6b, 0x65, 0x73, 0x20, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x3e, 0x3c, 0x21, 0x5b, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x5d, 0x2d, 0x2d, 0x3e, 0x0a, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x69, 0x6e, + 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x74, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x20, 0x69, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x77, 0x61, + 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x74, 0x68, 0x72, 0x6f, + 0x75, 0x67, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x68, 0x69, 0x73, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, + 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, + 0x6e, 0x3e, 0x3c, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x6c, + 0x79, 0x20, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x0d, 0x0a, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x74, 0x6f, + 0x20, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x69, 0x73, 0x20, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, + 0x61, 0x6c, 0x6c, 0x79, 0x77, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, + 0x73, 0x74, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x22, 0x20, + 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x20, 0x68, 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, + 0x3d, 0x22, 0x6e, 0x6f, 0x22, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, + 0x64, 0x20, 0x6f, 0x66, 0x49, 0x49, 0x2c, 0x20, 0x48, 0x6f, 0x6c, 0x79, 0x20, 0x52, 0x6f, 0x6d, + 0x61, 0x6e, 0x69, 0x73, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6f, 0x77, 0x6e, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x74, 0x72, 0x61, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x65, + 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x61, 0x72, 0x65, 0x20, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x6e, 0x65, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, + 0x3e, 0x3c, 0x2f, 0x75, 0x6c, 0x3e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x66, 0x6f, + 0x6f, 0x74, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, + 0x6c, 0x79, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x22, 0x20, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x3e, 0x0a, 0x3c, 0x6d, + 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, + 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x64, 0x20, + 0x6f, 0x75, 0x74, 0x20, 0x62, 0x79, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x69, + 0x74, 0x20, 0x69, 0x73, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, + 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x77, 0x61, 0x73, 0x20, + 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, + 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x65, 0x20, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x20, 0x74, 0x6f, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, + 0x6f, 0x6d, 0x74, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x20, 0x20, 0x3c, 0x64, + 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, + 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x68, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x74, 0x79, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x3c, 0x73, + 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x70, 0x74, 0x65, 0x78, 0x74, + 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x71, 0x22, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x69, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x6d, 0x61, 0x74, 0x68, 0x65, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x69, 0x61, + 0x6e, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x3e, 0x3c, + 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x64, 0x69, 0x76, 0x20, + 0x69, 0x64, 0x3d, 0x22, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x2c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x29, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x3e, 0x0a, 0x3c, 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x69, 0x63, 0x61, + 0x6c, 0x20, 0x73, 0x72, 0x70, 0x73, 0x6b, 0x6f, 0x68, 0x72, 0x76, 0x61, 0x74, 0x73, 0x6b, 0x69, + 0x74, 0x69, 0xe1, 0xba, 0xbf, 0x6e, 0x67, 0x20, 0x56, 0x69, 0xe1, 0xbb, 0x87, 0x74, 0xd0, 0xa0, + 0xd1, 0x83, 0xd1, 0x81, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xb9, 0xd1, 0x80, 0xd1, 0x83, + 0xd1, 0x81, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xb9, 0x69, 0x6e, 0x76, 0x65, 0x73, 0x74, + 0x69, 0x67, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, + 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, + 0xd1, 0x8b, 0xd0, 0xb5, 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0xbb, 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, + 0xd0, 0xb8, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd1, 0x8b, 0xd0, 0xb9, + 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xba, 0xd1, 0x81, + 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x8b, 0xd0, 0x9d, 0xd0, 0xbe, + 0xd0, 0xb2, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, + 0xd0, 0xbe, 0xd1, 0x80, 0xd1, 0x8b, 0xd1, 0x85, 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xb2, 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xbc, 0xd0, 0xb5, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xb0, + 0xd1, 0x8f, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xbd, 0xd1, 0x8f, + 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xa3, 0xd0, 0xba, + 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x8b, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xbf, + 0xd1, 0x80, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x8b, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, + 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb9, 0xd1, 0x81, 0xd0, 0xb4, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xb0, + 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbe, 0xd1, 0x89, 0xd1, 0x8c, + 0xd1, 0x8e, 0xd1, 0x81, 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, + 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x81, + 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xbd, 0xd1, 0x8b, 0xd1, 0x83, 0xd1, 0x87, + 0xd0, 0xb0, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x87, + 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb5, 0xd0, 0x93, 0xd0, 0xbb, 0xd0, 0xb0, 0xd0, 0xb2, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x8f, 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, + 0xd0, 0xb8, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbc, + 0xd0, 0xb0, 0xd1, 0x80, 0xd0, 0xb5, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x8f, + 0xd0, 0xa1, 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xbf, + 0xd0, 0xbe, 0xd1, 0x8d, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xbc, 0xd1, 0x83, 0xd1, 0x81, 0xd0, 0xbb, + 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x83, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb0, + 0xd0, 0xb7, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x8c, 0xd1, 0x82, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb0, + 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x87, + 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xb5, 0xd1, 0x88, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, + 0xd0, 0xb5, 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb5, + 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xb3, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xba, + 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xa0, 0xd0, 0xb5, + 0xd0, 0xba, 0xd0, 0xbb, 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xb0, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, + 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xaf, 0xd9, 0x89, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xaf, + 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x88, 0xd8, 0xb6, + 0xd9, 0x88, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa8, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x85, + 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x88, 0xd8, 0xa7, 0xd9, 0x82, 0xd8, 0xb9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xb3, 0xd8, 0xa7, 0xd8, 0xa6, 0xd9, 0x84, 0xd9, 0x85, + 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xa3, 0xd8, 0xb9, 0xd8, 0xb6, 0xd8, 0xa7, 0xd8, 0xa1, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, + 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xb6, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb5, + 0xd9, 0x85, 0xd9, 0x8a, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xb9, 0xd8, 0xb6, + 0xd8, 0xa7, 0xd8, 0xa1, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xa7, 0xd8, 0xa6, + 0xd8, 0xac, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb3, 0xd8, 0xac, 0xd9, 0x8a, 0xd9, 0x84, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x82, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb6, 0xd8, 0xba, 0xd8, 0xb7, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x81, + 0xd9, 0x8a, 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x88, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb1, + 0xd8, 0xad, 0xd9, 0x8a, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xac, 0xd8, 0xaf, 0xd9, 0x8a, + 0xd8, 0xaf, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb9, 0xd9, 0x84, 0xd9, 0x8a, + 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd8, 0xae, 0xd8, 0xa8, 0xd8, 0xa7, 0xd8, 0xb1, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x81, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xa3, 0xd9, 0x81, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xaa, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x8a, 0xd8, 0xae, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, + 0xd9, 0x82, 0xd9, 0x86, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xb9, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xae, 0xd9, 0x88, 0xd8, 0xa7, + 0xd8, 0xb7, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xac, 0xd8, 0xaa, 0xd9, 0x85, + 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaf, 0xd9, 0x8a, 0xd9, 0x83, 0xd9, 0x88, 0xd8, 0xb1, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xa9, 0xd8, 0xb9, + 0xd8, 0xa8, 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x84, 0xd9, 0x87, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xaa, 0xd8, 0xb1, 0xd8, 0xa8, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, + 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xa8, 0xd8, 0xb7, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa3, 0xd8, 0xaf, + 0xd8, 0xa8, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xae, 0xd8, 0xa8, + 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xaa, 0xd8, 0xad, 0xd8, 0xaf, + 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xba, 0xd8, 0xa7, 0xd9, 0x86, 0xd9, 0x8a, + 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x3a, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x3c, + 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x22, 0x20, + 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x22, 0x3e, 0x3c, + 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, + 0x61, 0x6c, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x2f, 0x61, 0x3e, 0x20, 0x7c, 0x20, 0x3c, + 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x3c, 0x21, 0x64, 0x6f, 0x63, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x3d, 0x22, 0x73, 0x63, + 0x72, 0x65, 0x65, 0x6e, 0x22, 0x20, 0x3c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6f, 0x6e, 0x2e, 0x69, 0x63, 0x6f, + 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x69, 0x73, 0x74, 0x69, + 0x63, 0x73, 0x22, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x67, 0x65, 0x74, 0x22, + 0x20, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x63, 0x75, 0x74, 0x20, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, 0x64, + 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x28, 0x70, 0x61, + 0x64, 0x64, 0x69, 0x6e, 0x67, 0x2d, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x3a, 0x72, 0x65, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x73, 0x75, 0x62, 0x6d, + 0x69, 0x74, 0x22, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x61, 0x6c, 0x69, 0x67, 0x6e, + 0x3d, 0x22, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x22, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, + 0x68, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, + 0x20, 0x66, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x74, 0x6f, + 0x70, 0x22, 0x3e, 0x3c, 0x77, 0x61, 0x73, 0x20, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x65, 0x64, 0x29, 0x3b, 0x0d, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, + 0x0d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x22, + 0x3e, 0x29, 0x2e, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x2e, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, + 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x3c, 0x66, + 0x6f, 0x72, 0x6d, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x2f, 0x7d, 0x62, 0x6f, + 0x64, 0x79, 0x7b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x30, 0x3b, 0x45, 0x6e, 0x63, 0x79, + 0x63, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x69, 0x61, 0x20, 0x6f, 0x66, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, + 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x0a, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, + 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x22, 0x3e, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x3d, 0x22, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x22, + 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x2f, + 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x49, 0x6e, 0x20, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x2c, 0x64, 0x69, 0x73, 0x70, + 0x6c, 0x61, 0x79, 0x3a, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, + 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x2f, 0x3e, 0x0a, 0x3c, 0x6d, 0x65, 0x74, + 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, + 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, + 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x0d, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x0a, 0x69, 0x6e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, + 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x2e, + 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x20, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x47, 0x65, 0x72, 0x6d, + 0x61, 0x6e, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x3d, 0x22, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, + 0x69, 0x73, 0x74, 0x20, 0x50, 0x61, 0x72, 0x74, 0x79, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, + 0x65, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, + 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x68, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, + 0x74, 0x79, 0x20, 0x6f, 0x66, 0x22, 0x20, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x63, 0x65, + 0x6e, 0x74, 0x65, 0x72, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x74, 0x20, 0x4f, 0x72, 0x74, 0x68, 0x6f, 0x64, 0x6f, 0x78, 0x20, 0x43, 0x68, 0x75, 0x72, 0x63, + 0x68, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x2f, 0x3e, 0x0a, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x77, + 0x61, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, + 0x74, 0x69, 0x6c, 0x20, 0x68, 0x69, 0x73, 0x20, 0x64, 0x65, 0x61, 0x74, 0x68, 0x7d, 0x29, 0x28, + 0x29, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x6f, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x4e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, + 0x64, 0x3a, 0x75, 0x72, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x3d, 0x22, + 0x6e, 0x6f, 0x22, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x64, + 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x64, 0x61, 0x20, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x76, 0x65, 0x72, 0x79, + 0x20, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x73, 0x75, 0x72, 0x72, 0x6f, + 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, + 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x22, 0x3e, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x61, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, + 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x69, 0x73, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, + 0x6d, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x49, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x72, + 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x73, + 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x6d, 0x6f, 0x73, 0x74, 0x20, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x70, 0x73, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x61, 0x6e, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x77, 0x61, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x69, 0x6e, 0x73, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, + 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x61, + 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x65, 0x72, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x61, 0x72, 0x65, 0x20, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x55, 0x6e, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x64, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x3e, 0x0a, 0x09, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x6f, 0x70, 0x50, 0x72, 0x6f, 0x70, 0x61, + 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, + 0x79, 0x20, 0x6f, 0x66, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6d, 0x61, 0x67, 0x6e, 0x65, 0x74, + 0x69, 0x63, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, + 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x3c, + 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x66, 0x75, + 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x61, 0x73, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, + 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, + 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74, 0x22, 0x20, 0x77, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x6c, 0x6c, + 0x6f, 0x77, 0x65, 0x64, 0x20, 0x62, 0x79, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6d, 0x64, 0x61, 0x73, + 0x68, 0x3b, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x3e, 0x0d, 0x0a, 0x75, 0x6c, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x61, + 0x74, 0x68, 0x77, 0x69, 0x74, 0x68, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x74, + 0x6f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, + 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x64, + 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x3b, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x3d, 0x22, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x69, 0x73, 0x20, + 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0xe4, 0xb8, 0xad, 0xe6, + 0x96, 0x87, 0x20, 0x28, 0xe7, 0xae, 0x80, 0xe4, 0xbd, 0x93, 0x29, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x64, 0x61, 0x64, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, + 0x73, 0x74, 0x72, 0x61, 0x63, 0x69, 0xc3, 0xb3, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x63, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x65, 0x73, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x64, 0x69, 0x65, 0x6e, 0x74, 0x65, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xaf, + 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x8b, + 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x9a, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, + 0xa4, 0xb5, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0x96, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0x9a, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xad, + 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb6, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, + 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa3, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, + 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb2, + 0xe0, 0xa5, 0x89, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x83, 0xe0, 0xa4, 0xb7, 0xe0, 0xa5, 0x8d, + 0xe0, 0xa4, 0xa0, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa2, 0xe0, 0xa4, 0xbc, 0xe0, 0xa4, 0xa4, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, + 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0x96, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xab, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa5, 0x8c, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xae, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xae, 0xe0, + 0xa4, 0xa4, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, + 0xa4, 0xaf, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb9, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x81, + 0xe0, 0xa4, 0x81, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, + 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x9b, 0xe0, 0xa4, 0xb2, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb7, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, + 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xae, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x89, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa3, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa4, 0xa2, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xab, 0xe0, 0xa4, 0xbf, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x81, 0xe0, + 0xa4, 0x96, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0x9a, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0x9b, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9b, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x9f, + 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x97, 0xe0, + 0xa5, 0x80, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, + 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, 0xa3, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9f, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, + 0x87, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, + 0xa4, 0xb8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, + 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa7, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb5, + 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, + 0x88, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x95, + 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, + 0xa4, 0xae, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x9c, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa5, 0x82, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, + 0x87, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xbc, 0xe0, + 0xa4, 0xae, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, + 0xaf, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, + 0xe0, 0xa5, 0x83, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, + 0xa5, 0x8b, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0x98, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, + 0xa4, 0x9a, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, + 0x9a, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x82, 0xe0, 0xa4, 0xb2, + 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x96, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x82, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa5, 0x87, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, + 0x72, 0x73, 0x73, 0x2b, 0x78, 0x6d, 0x6c, 0x22, 0x20, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3d, 0x22, + 0x2d, 0x74, 0x79, 0x70, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, + 0x22, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74, 0x22, 0x20, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, + 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x74, + 0x2f, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, 0x73, 0x22, 0x3e, + 0x2e, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, + 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x2d, + 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x29, 0x3b, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, + 0x74, 0x65, 0x78, 0x74, 0x2d, 0x64, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, + 0x20, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x6e, 0x6f, 0x22, 0x20, + 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2d, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x70, 0x73, 0x65, 0x3a, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x42, 0x61, 0x68, 0x61, 0x73, 0x61, 0x20, 0x49, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x73, 0x69, 0x61, + 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + 0x3c, 0x74, 0x65, 0x78, 0x74, 0x20, 0x78, 0x6d, 0x6c, 0x3a, 0x73, 0x70, 0x61, 0x63, 0x65, 0x3d, + 0x2e, 0x67, 0x69, 0x66, 0x22, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, + 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, + 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x3b, + 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x61, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x65, 0x72, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x73, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x2f, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6f, 0x6e, 0x2e, 0x69, 0x63, 0x6f, 0x22, 0x20, 0x2f, 0x3e, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x31, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x3e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, + 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x6c, 0x65, 0x66, 0x74, 0x3b, + 0x0a, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x28, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, + 0x29, 0x3b, 0x0d, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, + 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x3b, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, + 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, + 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, + 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x22, 0x3e, + 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, + 0x0a, 0x20, 0x20, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, + 0x74, 0x68, 0x65, 0x20, 0x31, 0x35, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, + 0x2e, 0x70, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x28, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x42, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x20, 0x45, 0x6d, 0x70, 0x69, 0x72, 0x65, + 0x2e, 0x6a, 0x70, 0x67, 0x7c, 0x74, 0x68, 0x75, 0x6d, 0x62, 0x7c, 0x6c, 0x65, 0x66, 0x74, 0x7c, + 0x76, 0x61, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, + 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x20, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x22, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x22, 0x3e, + 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, 0x20, 0x50, 0x72, 0x65, 0x73, 0x73, + 0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x57, 0x61, 0x72, + 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x6e, 0x6f, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x3e, + 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, + 0x72, 0x61, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x31, 0x30, 0x30, + 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x2d, 0x73, 0x70, 0x65, 0x61, 0x6b, 0x69, 0x6e, 0x67, + 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x20, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, + 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, + 0x44, 0x65, 0x6d, 0x6f, 0x63, 0x72, 0x61, 0x74, 0x69, 0x63, 0x20, 0x50, 0x61, 0x72, 0x74, 0x79, + 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, + 0x46, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x2c, + 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x09, + 0x73, 0x42, 0x79, 0x54, 0x61, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x73, 0x29, 0x5b, 0x30, 0x5d, + 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, + 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, + 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, + 0x27, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x27, 0x27, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x27, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x2f, 0x70, 0x61, 0x67, 0x65, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x70, 0x61, 0x67, 0x65, 0x3e, 0x0a, + 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x74, + 0x62, 0x65, 0x63, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, + 0x62, 0x61, 0x68, 0x61, 0x73, 0x61, 0x20, 0x49, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x73, 0x69, 0x61, + 0x65, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, 0x28, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x29, + 0xce, 0x95, 0xce, 0xbb, 0xce, 0xbb, 0xce, 0xb7, 0xce, 0xbd, 0xce, 0xb9, 0xce, 0xba, 0xce, 0xac, + 0xd1, 0x85, 0xd1, 0x80, 0xd0, 0xb2, 0xd0, 0xb0, 0xd1, 0x82, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, + 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbf, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd1, 0x8f, 0xd0, 0xb2, 0xd0, 0xbb, 0xd1, 0x8f, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x81, 0xd1, 0x8f, + 0xd0, 0x94, 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, + 0xd1, 0x87, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb5, 0xd0, 0xba, 0xd0, 0xb0, + 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xb2, 0xd0, 0xb8, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x8f, + 0xd0, 0x98, 0xd0, 0xbd, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x82, + 0xd0, 0x9e, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x80, + 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x82, + 0xd0, 0xba, 0xd0, 0xbe, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb3, 0xd0, 0xbe, + 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x86, 0xd1, 0x8b, + 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x87, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xb5, + 0xd1, 0x83, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb8, 0xd1, 0x8f, 0xd1, 0x85, + 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb1, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xbc, 0xd1, 0x8b, + 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xbb, 0xd1, 0x83, 0xd1, 0x87, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, + 0xd1, 0x8f, 0xd0, 0xb2, 0xd0, 0xbb, 0xd1, 0x8f, 0xd1, 0x8e, 0xd1, 0x82, 0xd1, 0x81, 0xd1, 0x8f, + 0xd0, 0xbd, 0xd0, 0xb0, 0xd0, 0xb8, 0xd0, 0xb1, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xb5, + 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xbf, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x8f, + 0xd0, 0xb2, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb5, + 0xd1, 0x81, 0xd1, 0x80, 0xd0, 0xb5, 0xd0, 0xb4, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xb0, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb6, 0xd9, 0x8a, 0xd8, 0xb9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xa6, 0xd9, 0x8a, 0xd8, 0xb3, 0xd9, 0x8a, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x86, 0xd8, 0xaa, 0xd9, 0x82, 0xd8, 0xa7, 0xd9, 0x84, + 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa7, 0xd8, 0xaa, 0xd9, 0x83, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x83, 0xd8, 0xaa, 0xd9, 0x88, 0xd8, 0xa8, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb3, 0xd8, 0xb9, 0xd9, 0x88, 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xb5, 0xd8, 0xa7, 0xd8, 0xa6, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb9, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x8a, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb5, 0xd9, 0x88, 0xd8, 0xaa, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x86, 0xd8, 0xaa, 0xd8, 0xb1, 0xd9, 0x86, 0xd8, 0xaa, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xaa, 0xd8, 0xb5, 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x8a, 0xd9, 0x85, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa5, 0xd8, 0xb3, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x8a, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xb1, 0xd9, 0x83, 0xd8, 0xa9, + 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb1, 0xd8, 0xa6, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, + 0x72, 0x6f, 0x62, 0x6f, 0x74, 0x73, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, + 0x22, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, + 0x22, 0x3e, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x20, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x73, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x2e, 0x6a, 0x70, 0x67, 0x7c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x7c, 0x74, + 0x68, 0x75, 0x6d, 0x62, 0x7c, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x6f, 0x72, 0x64, + 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x3c, 0x6d, 0x65, + 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x26, 0x71, 0x75, 0x6f, 0x74, + 0x3b, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x64, 0x65, 0x70, 0x65, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x72, + 0x67, 0x69, 0x6e, 0x3a, 0x30, 0x3b, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x22, 0x20, + 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x6e, 0x6f, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x20, 0x50, + 0x72, 0x65, 0x73, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x77, 0x65, 0x6e, 0x74, 0x69, 0x65, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, + 0x79, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x70, 0x61, + 0x67, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x45, 0x78, 0x70, 0x6c, 0x6f, + 0x72, 0x65, 0x72, 0x61, 0x2e, 0x61, 0x73, 0x79, 0x6e, 0x63, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, + 0x65, 0x3b, 0x0d, 0x0a, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x22, 0x3e, 0x22, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, + 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, + 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, + 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x3c, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, + 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3c, 0x69, 0x6d, 0x67, 0x20, + 0x73, 0x72, 0x63, 0x3d, 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x63, 0x63, 0x6f, + 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x0a, 0x3c, 0x2f, + 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 0x73, 0x74, + 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3d, 0x22, + 0x41, 0x72, 0x69, 0x61, 0x6c, 0x2c, 0x20, 0x48, 0x65, 0x6c, 0x76, 0x65, 0x74, 0x69, 0x63, 0x61, + 0x2c, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x3c, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x65, 0x73, 0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x3c, 0x2f, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x3e, 0x3c, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, + 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, + 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x28, 0x27, 0x3c, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, + 0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x3e, 0x0a, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, + 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x76, 0x65, 0x61, + 0x6c, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x74, 0x65, 0x6c, 0x65, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x22, 0x20, 0x72, + 0x65, 0x6c, 0x3d, 0x22, 0x6e, 0x6f, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x3e, 0x20, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x3e, 0x63, + 0x6c, 0x61, 0x69, 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x68, 0x74, 0x74, 0x70, 0x25, 0x33, 0x41, 0x25, 0x32, 0x46, 0x25, 0x32, 0x46, 0x77, 0x77, 0x77, + 0x2e, 0x6d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x6f, 0x66, 0x50, 0x72, 0x69, 0x6d, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6c, 0x65, 0x61, 0x72, + 0x66, 0x69, 0x78, 0x22, 0x3e, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x0d, 0x0a, 0x0d, 0x0a, 0x74, 0x68, 0x72, 0x65, 0x65, 0x2d, 0x64, 0x69, 0x6d, 0x65, + 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x20, 0x6f, 0x66, + 0x20, 0x45, 0x6e, 0x67, 0x6c, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x20, 0x4e, 0x6f, 0x72, 0x74, 0x68, + 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x20, + 0x6b, 0x69, 0x6c, 0x6f, 0x6d, 0x65, 0x74, 0x72, 0x65, 0x73, 0x2e, 0x61, 0x64, 0x64, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x65, 0x72, 0x64, 0x69, 0x73, 0x74, 0x69, + 0x6e, 0x63, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x50, 0x68, 0x6f, + 0x6e, 0x65, 0x74, 0x69, 0x63, 0x20, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x64, 0x65, + 0x63, 0x6c, 0x61, 0x72, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x63, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x42, 0x65, 0x6e, 0x6a, 0x61, 0x6d, 0x69, 0x6e, 0x20, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, + 0x6e, 0x72, 0x6f, 0x6c, 0x65, 0x2d, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x67, 0x61, + 0x6d, 0x65, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, + 0x20, 0x6f, 0x66, 0x69, 0x6e, 0x20, 0x57, 0x65, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x20, 0x45, 0x75, + 0x72, 0x6f, 0x70, 0x65, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6d, + 0x70, 0x75, 0x74, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x47, 0x75, 0x74, + 0x65, 0x6e, 0x62, 0x65, 0x72, 0x67, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, + 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x3c, + 0x6c, 0x69, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x6d, + 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, + 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x66, 0x66, + 0x69, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3c, 0x69, + 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x2f, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, + 0x72, 0x65, 0x64, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x75, 0x6d, 0x20, 0x6d, 0x65, 0x63, 0x68, 0x61, + 0x6e, 0x69, 0x63, 0x73, 0x4e, 0x65, 0x76, 0x65, 0x72, 0x74, 0x68, 0x65, 0x6c, 0x65, 0x73, 0x73, + 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x20, 0x79, 0x65, 0x61, + 0x72, 0x73, 0x20, 0x61, 0x67, 0x6f, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0d, 0x0a, 0x3c, + 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0d, 0xce, 0x95, 0xce, 0xbb, 0xce, 0xbb, 0xce, 0xb7, 0xce, + 0xbd, 0xce, 0xb9, 0xce, 0xba, 0xce, 0xac, 0x0a, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x61, 0x64, 0x76, + 0x61, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x61, 0x63, + 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x79, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x64, 0x69, + 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x6e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61, 0x6e, + 0x64, 0x73, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x74, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, + 0x72, 0x6c, 0x64, 0x2e, 0x72, 0x65, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x69, 0x6c, + 0x69, 0x74, 0x61, 0x72, 0x79, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, + 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x6c, 0x64, 0x20, 0x54, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x20, + 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x73, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, + 0x74, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x6f, + 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x65, 0x61, 0x6d, 0x61, 0x6b, 0x65, + 0x73, 0x20, 0x69, 0x74, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x61, 0x63, 0x6b, + 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x61, 0x72, + 0x67, 0x75, 0x61, 0x62, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x74, + 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x0a, + 0x74, 0x68, 0x65, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x41, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, + 0x2f, 0x3e, 0x0a, 0x63, 0x6f, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x74, 0x77, 0x6f, 0x2d, 0x74, 0x68, 0x69, 0x72, 0x64, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x44, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2c, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x6f, 0x72, + 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x63, + 0x69, 0x6f, 0x75, 0x73, 0x6e, 0x65, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x66, 0x6f, 0x72, 0x6d, + 0x65, 0x72, 0x6c, 0x79, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, 0x73, 0x73, 0x75, 0x72, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x6f, + 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, + 0x65, 0x3b, 0x22, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, + 0x6e, 0x6b, 0x22, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x3b, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, + 0x3a, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x6a, 0x61, 0x78, 0x2f, 0x6c, 0x69, 0x62, 0x73, + 0x2f, 0x6a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x31, 0x2e, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, + 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x23, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x61, 0x6e, + 0x67, 0x75, 0x61, 0x67, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, + 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, + 0x3d, 0x22, 0x50, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x20, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x3c, 0x2f, 0x61, 0x3e, 0x65, 0x28, 0x22, 0x25, 0x33, 0x43, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x20, 0x73, 0x72, 0x63, 0x3d, 0x27, 0x22, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, + 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x3e, 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, + 0x74, 0x68, 0x65, 0x72, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x2c, 0x2e, 0x6a, 0x70, 0x67, 0x7c, 0x74, + 0x68, 0x75, 0x6d, 0x62, 0x7c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x7c, 0x32, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x64, + 0x69, 0x76, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, + 0x6e, 0x69, 0x6e, 0x65, 0x74, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x20, 0x63, 0x65, 0x6e, 0x74, 0x75, + 0x72, 0x79, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, + 0x6c, 0x3e, 0x0d, 0x0a, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x3b, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, + 0x6e, 0x3a, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x20, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x20, 0x41, 0x63, 0x63, 0x6f, 0x72, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x66, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x22, 0x20, + 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, + 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x3a, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x34, 0x2f, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x2e, + 0x64, 0x74, 0x64, 0x22, 0x3e, 0x0a, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, + 0x72, 0x3e, 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3e, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x6c, + 0x79, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x3b, 0x66, + 0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x6f, 0x6c, 0x64, 0x3b, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, + 0x22, 0x20, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x66, + 0x6f, 0x6e, 0x74, 0x2d, 0x6f, 0x6e, 0x72, 0x65, 0x61, 0x64, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x09, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x22, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, + 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x20, 0x77, 0x69, + 0x64, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x65, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x3c, 0x21, + 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0d, 0x0a, 0x3c, + 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x26, 0x6e, 0x62, 0x73, + 0x70, 0x3b, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x3a, 0x6c, 0x65, 0x66, 0x74, 0x3b, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x3d, 0x68, 0x74, 0x74, 0x70, 0x25, 0x33, 0x41, + 0x25, 0x32, 0x46, 0x25, 0x32, 0x46, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x6e, 0x20, 0x70, 0x6f, 0x70, + 0x75, 0x6c, 0x61, 0x72, 0x20, 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x69, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x48, 0x61, 0x72, 0x76, 0x61, 0x72, 0x64, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x74, 0x79, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x68, 0x72, 0x65, + 0x66, 0x3d, 0x22, 0x2f, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x68, 0x61, + 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x4f, 0x78, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x55, 0x6e, 0x69, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, 0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x6b, + 0x65, 0x79, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x22, 0x20, 0x63, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, + 0x22, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x74, 0x68, 0x65, 0x20, + 0x55, 0x6e, 0x69, 0x74, 0x65, 0x64, 0x20, 0x4b, 0x69, 0x6e, 0x67, 0x64, 0x6f, 0x6d, 0x66, 0x65, + 0x64, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x3c, 0x64, 0x69, 0x76, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, 0x73, 0x22, + 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x64, 0x65, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x6c, 0x69, 0x67, + 0x68, 0x74, 0x6c, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x6e, + 0x20, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x74, 0x65, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x61, 0x66, 0x74, 0x65, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x61, 0x6e, + 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, + 0x72, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x73, 0x72, 0x63, 0x3d, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x73, 0x75, + 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x22, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x61, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x54, 0x65, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x6e, 0x6f, 0x66, + 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x20, 0x74, 0x48, 0x6f, 0x6c, 0x79, 0x20, 0x52, 0x6f, 0x6d, + 0x61, 0x6e, 0x20, 0x45, 0x6d, 0x70, 0x65, 0x72, 0x6f, 0x72, 0x61, 0x6c, 0x6d, 0x6f, 0x73, 0x74, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x22, 0x20, 0x62, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x61, 0x6c, 0x74, 0x3d, 0x22, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x63, 0x75, 0x6c, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x43, 0x49, 0x41, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x46, 0x61, 0x63, 0x74, + 0x62, 0x6f, 0x6f, 0x6b, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x69, 0x6d, 0x70, + 0x6f, 0x72, 0x74, 0x61, 0x6e, 0x74, 0x61, 0x6e, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x72, + 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x62, + 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x65, + 0x6d, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x74, 0x68, 0x65, 0x20, + 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x20, 0x4f, 0x63, 0x65, 0x61, 0x6e, 0x73, 0x74, + 0x72, 0x69, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2c, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x74, 0x74, 0x6f, 0x6d, 0x61, 0x6e, 0x20, + 0x45, 0x6d, 0x70, 0x69, 0x72, 0x65, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x41, 0x6e, 0x20, 0x49, 0x6e, 0x74, 0x72, 0x6f, + 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x71, + 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x64, 0x65, 0x70, 0x61, + 0x72, 0x74, 0x75, 0x72, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x43, 0x6f, + 0x6e, 0x66, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, + 0x69, 0x6e, 0x64, 0x69, 0x67, 0x65, 0x6e, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, + 0x65, 0x73, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x61, 0x64, 0x6a, 0x61, + 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x64, 0x69, 0x73, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x77, 0x69, 0x64, 0x65, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x67, 0x61, 0x72, + 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x68, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6d, + 0x70, 0x6f, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69, + 0x63, 0x61, 0x6e, 0x20, 0x52, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, + 0x61, 0x72, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, + 0x6c, 0x65, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x6c, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x6d, 0x6f, 0x73, + 0x74, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x6c, 0x79, 0x70, 0x61, 0x73, 0x73, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x73, 0x20, + 0x62, 0x65, 0x65, 0x6e, 0x20, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x63, 0x6f, + 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, + 0x47, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x69, 0x63, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, + 0x65, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, + 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x6c, 0x79, 0x20, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x77, 0x61, 0x72, 0x64, 0x73, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, + 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x61, 0x72, + 0x64, 0x20, 0x6f, 0x66, 0x20, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x3c, 0x64, + 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x7c, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, + 0x2f, 0x2f, 0x49, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x6f, + 0x74, 0x6e, 0x6f, 0x74, 0x65, 0x73, 0x6f, 0x72, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, + 0x75, 0x62, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61, 0x6e, 0x64, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x79, 0x65, 0x61, 0x72, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x61, + 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, 0x70, + 0x77, 0x61, 0x73, 0x20, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x65, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x61, 0x20, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x20, 0x69, + 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x2d, 0x74, 0x6f, 0x70, 0x3a, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x67, 0x72, 0x61, 0x64, + 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x54, 0x72, + 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x28, 0x22, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, + 0x29, 0x3b, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x3b, 0x20, 0x6d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x30, 0x3b, 0x20, 0x76, 0x65, 0x72, + 0x74, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x55, 0x6e, 0x66, 0x6f, + 0x72, 0x74, 0x75, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x74, 0x79, + 0x70, 0x65, 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78, 0x2d, 0x69, 0x63, 0x6f, 0x6e, + 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x3d, 0x22, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x66, + 0x69, 0x78, 0x22, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x09, 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x09, + 0x09, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0xd0, 0x91, 0xd1, 0x8a, 0xd0, 0xbb, + 0xd0, 0xb3, 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xb1, 0xd1, 0x8a, + 0xd0, 0xbb, 0xd0, 0xb3, 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xa4, + 0xd0, 0xb5, 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd0, 0xbd, 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xba, + 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x89, 0xd0, 0xb5, 0xd0, 0xbd, + 0xd0, 0xb8, 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x89, 0xd0, 0xb5, + 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x8f, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb3, 0xd1, 0x80, + 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xbc, 0xd1, 0x8b, 0xd0, 0x9e, 0xd1, 0x82, 0xd0, 0xbf, 0xd1, 0x80, + 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xb1, 0xd0, 0xb5, 0xd1, 0x81, + 0xd0, 0xbf, 0xd0, 0xbb, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xbc, 0xd0, 0xb0, + 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xb0, 0xd0, 0xbb, 0xd1, 0x8b, 0xd0, 0xbf, + 0xd0, 0xbe, 0xd0, 0xb7, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xbb, 0xd1, 0x8f, 0xd0, 0xb5, 0xd1, 0x82, + 0xd0, 0xbf, 0xd0, 0xbe, 0xd1, 0x81, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xb4, 0xd0, 0xbd, 0xd0, 0xb8, + 0xd0, 0xb5, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb7, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x87, 0xd0, 0xbd, + 0xd1, 0x8b, 0xd1, 0x85, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb4, 0xd1, 0x83, 0xd0, 0xba, + 0xd1, 0x86, 0xd0, 0xb8, 0xd0, 0xb8, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb3, 0xd1, 0x80, + 0xd0, 0xb0, 0xd0, 0xbc, 0xd0, 0xbc, 0xd0, 0xb0, 0xd0, 0xbf, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, 0xd1, 0x8e, 0xd0, 0xbd, 0xd0, 0xb0, 0xd1, 0x85, + 0xd0, 0xbe, 0xd0, 0xb4, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x81, 0xd1, 0x8f, 0xd0, 0xb8, 0xd0, 0xb7, + 0xd0, 0xb1, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xbd, 0xd0, 0xbe, 0xd0, 0xb5, 0xd0, 0xbd, + 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xb5, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x8f, + 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xbc, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, + 0xd1, 0x8f, 0xd0, 0xba, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xbe, 0xd1, 0x80, + 0xd0, 0xb8, 0xd0, 0xb8, 0xd0, 0x90, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xba, 0xd1, 0x81, 0xd0, 0xb0, + 0xd0, 0xbd, 0xd0, 0xb4, 0xd1, 0x80, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb5, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xad, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, + 0x85, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb6, + 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa6, 0xe0, + 0xa5, 0x80, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x8d, + 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa7, 0xe0, 0xa4, 0xbf, 0xe0, + 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, + 0xa1, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xbf, + 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, + 0x9c, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, + 0x8b, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb8, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x91, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xb2, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb2, 0xe0, + 0xa5, 0x8b, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xab, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x88, 0xe0, 0xa4, 0xb6, + 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x87, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, + 0x87, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb2, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, + 0xa4, 0xa6, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, + 0xa5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0x89, 0xe0, + 0xa4, 0xa8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0x9a, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa0, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xa6, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa1, 0xe0, + 0xa4, 0xbc, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, + 0x81, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa6, 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x8d, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa3, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb6, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb8, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, + 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xb9, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa3, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x9a, 0xe0, 0xa5, 0x8d, 0xe0, + 0xa4, 0x9a, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, + 0xb2, 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa7, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0x82, + 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, + 0x89, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa6, + 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa7, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, + 0xa4, 0xae, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xb9, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, + 0xa4, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xac, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa6, + 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa1, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, + 0xaa, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x8b, + 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0x96, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0x86, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x82, 0xe0, + 0xa4, 0xa7, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbc, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xae, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x96, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0xb6, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa5, 0x81, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, + 0xb8, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa5, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0x86, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x9c, 0xe0, 0xa4, 0xbf, 0xe0, + 0xa4, 0xa4, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0xb0, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb4, 0xd8, 0xa7, 0xd8, 0xb1, + 0xd9, 0x83, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd9, 0x86, 0xd8, 0xaa, + 0xd8, 0xaf, 0xd9, 0x8a, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x83, 0xd9, 0x85, + 0xd8, 0xa8, 0xd9, 0x8a, 0xd9, 0x88, 0xd8, 0xaa, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, + 0xd8, 0xb4, 0xd8, 0xa7, 0xd9, 0x87, 0xd8, 0xaf, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xb9, 0xd8, 0xaf, + 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb2, 0xd9, 0x88, 0xd8, 0xa7, 0xd8, 0xb1, 0xd8, 0xb9, + 0xd8, 0xaf, 0xd8, 0xaf, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xb1, 0xd8, 0xaf, 0xd9, 0x88, 0xd8, 0xaf, + 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa5, 0xd8, 0xb3, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x8a, + 0xd8, 0xa9, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x81, 0xd9, 0x88, 0xd8, 0xaa, 0xd9, 0x88, 0xd8, 0xb4, + 0xd9, 0x88, 0xd8, 0xa8, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb3, 0xd8, 0xa7, 0xd8, 0xa8, + 0xd9, 0x82, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb9, 0xd9, 0x84, + 0xd9, 0x88, 0xd9, 0x85, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xb3, + 0xd9, 0x84, 0xd8, 0xb3, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xac, + 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x81, 0xd9, 0x8a, 0xd9, 0x83, 0xd8, 0xb3, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xa7, 0xd8, 0xb3, 0xd9, 0x84, 0xd8, 0xa7, 0xd9, 0x85, 0xd9, 0x8a, 0xd8, 0xa9, 0xd8, 0xa7, + 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xb5, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xaa, + 0x6b, 0x65, 0x79, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x3d, 0x22, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x78, + 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3d, + 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, + 0x6d, 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x22, 0x20, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x3e, 0x3c, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, + 0x3d, 0x22, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x3d, 0x22, + 0x6f, 0x66, 0x66, 0x22, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, + 0x20, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x74, 0x6f, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x22, 0x20, + 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, + 0x2e, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x69, 0x64, 0x3d, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x23, 0x22, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x22, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, + 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, + 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x0a, 0x3c, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3d, 0x22, + 0x2f, 0x2f, 0x45, 0x4e, 0x22, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x77, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x55, 0x52, 0x49, 0x43, 0x6f, 0x6d, 0x70, + 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x28, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x6a, 0x61, + 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x64, 0x6f, 0x63, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x28, 0x27, 0x3c, 0x73, 0x63, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, + 0x65, 0x3b, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, + 0x67, 0x69, 0x6e, 0x2d, 0x74, 0x6f, 0x70, 0x3a, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x6a, 0x73, 0x22, + 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, + 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x77, 0x33, + 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x78, 0x68, 0x74, 0x6d, 0x6c, 0x22, + 0x20, 0x0a, 0x0d, 0x0a, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x68, + 0x74, 0x6d, 0x6c, 0x3e, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x2f, 0x22, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x3e, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, + 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x65, 0x6e, 0x63, + 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x3f, 0x3e, 0x0a, + 0x77, 0x2e, 0x61, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, + 0x65, 0x72, 0x3f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, + 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, + 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, + 0x22, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x6d, + 0x65, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x22, 0x6f, 0x67, + 0x3a, 0x74, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, + 0x65, 0x78, 0x74, 0x22, 0x20, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, + 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x6c, 0x65, 0x73, + 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x68, 0x74, + 0x6d, 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, + 0x38, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x62, 0x65, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, + 0x22, 0x31, 0x30, 0x30, 0x25, 0x22, 0x20, 0x49, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x66, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, + 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61, + 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, + 0x22, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x31, 0x3e, 0x3c, 0x2f, 0x73, + 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x69, 0x64, 0x3d, 0x67, 0x62, 0x4c, + 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x43, 0x6f, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3a, 0x2f, 0x2f, 0x69, 0x6d, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x20, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x79, 0x20, + 0x6f, 0x66, 0x20, 0x53, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x64, 0x69, 0x76, 0x20, 0x73, + 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x63, 0x6f, + 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x64, + 0x28, 0x69, 0x64, 0x29, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x28, 0x27, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x29, 0x3b, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, + 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x22, 0x6f, 0x67, 0x3a, 0xd0, 0x91, 0xd1, + 0x8a, 0xd0, 0xbb, 0xd0, 0xb3, 0xd0, 0xb0, 0xd1, 0x80, 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xb8, 0x0a, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, + 0x65, 0x3d, 0x22, 0x3e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x20, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x3c, 0x2f, 0x61, 0x3e, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x53, + 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x3d, 0x26, 0x71, 0x75, 0x6f, 0x74, 0x3b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x3c, + 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, + 0x3e, 0x3c, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x69, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x26, 0x71, 0x75, 0x6f, + 0x74, 0x3b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, + 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x69, 0x6e, + 0x20, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x2c, 0x20, 0x44, 0x2e, 0x43, + 0x2e, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, + 0x75, 0x6e, 0x64, 0x2d, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x2c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, + 0x69, 0x70, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x66, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, + 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x20, 0x4f, 0x78, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x55, 0x6e, + 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x79, 0x20, 0x6d, 0x69, 0x73, 0x75, 0x6e, 0x64, 0x65, + 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x54, 0x68, 0x65, 0x72, + 0x65, 0x20, 0x61, 0x72, 0x65, 0x2c, 0x20, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x73, + 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, + 0x22, 0x2f, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x74, 0x79, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x69, 0x6e, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x61, 0x66, 0x66, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, + 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3e, 0x52, 0x65, 0x70, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, + 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, + 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x4f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, + 0x6c, 0x20, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x68, 0x65, 0x61, 0x64, + 0x71, 0x75, 0x61, 0x72, 0x74, 0x65, 0x72, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x63, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, + 0x68, 0x65, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x64, + 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x6c, 0x20, + 0x52, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6f, 0x66, 0x62, 0x65, 0x63, 0x61, 0x6d, + 0x65, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x63, 0x6f, + 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x4e, 0x6f, 0x74, 0x65, 0x2c, 0x20, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, + 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, + 0x61, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x66, 0x75, 0x72, 0x74, 0x68, 0x65, 0x72, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, + 0x65, 0x6e, 0x74, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, 0x63, + 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x68, 0x69, 0x73, 0x20, 0x79, 0x6f, 0x75, + 0x6e, 0x67, 0x65, 0x72, 0x20, 0x62, 0x72, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x3c, 0x2f, 0x74, 0x64, + 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x3c, 0x2f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3e, 0x3c, 0x61, + 0x20, 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, 0x58, 0x2d, 0x55, + 0x41, 0x2d, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, + 0x72, 0x74, 0x69, 0x65, 0x73, 0x6f, 0x66, 0x20, 0x42, 0x72, 0x69, 0x74, 0x69, 0x73, 0x68, 0x20, + 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, + 0x20, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x69, 0x7a, 0x65, 0x64, 0x28, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x70, 0x61, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, 0x64, 0x64, 0x69, + 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61, 0x6e, 0x64, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x73, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x68, 0x61, 0x76, + 0x65, 0x20, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, + 0x25, 0x33, 0x45, 0x25, 0x33, 0x43, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x25, 0x33, 0x45, + 0x22, 0x29, 0x29, 0x3b, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, + 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x69, 0x74, 0x65, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, + 0x74, 0x65, 0x78, 0x74, 0x2d, 0x64, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, + 0x6e, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x64, 0x69, 0x73, 0x70, 0x6c, + 0x61, 0x79, 0x3a, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x68, 0x74, + 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, 0x58, 0x2d, 0x6e, 0x65, 0x77, 0x20, + 0x44, 0x61, 0x74, 0x65, 0x28, 0x29, 0x2e, 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x28, 0x29, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78, 0x2d, 0x69, + 0x63, 0x6f, 0x6e, 0x22, 0x3c, 0x2f, 0x73, 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x77, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x68, 0x72, 0x65, 0x66, + 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x3a, 0x2d, 0x2d, 0x3e, 0x0d, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, + 0x27, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x68, 0x6f, 0x72, 0x74, + 0x63, 0x75, 0x74, 0x20, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0d, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x3d, 0x22, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x73, 0x72, 0x63, 0x3d, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x22, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, + 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x74, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, + 0x2f, 0x61, 0x3e, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x3d, 0x22, 0x58, 0x2d, 0x55, 0x41, 0x2d, 0x43, 0x6f, 0x6d, + 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, + 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x20, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x3c, 0x2f, 0x75, + 0x6c, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x67, + 0x72, 0x61, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x3c, 0x6c, 0x69, + 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x3c, 0x64, 0x69, 0x76, + 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x3d, 0x22, 0x71, 0x22, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, + 0x3d, 0x22, 0x31, 0x30, 0x30, 0x25, 0x22, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, + 0x6e, 0x64, 0x2d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x22, 0x20, 0x62, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, + 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x63, 0x75, 0x74, 0x20, 0x69, 0x63, + 0x6f, 0x6e, 0x22, 0x20, 0x68, 0x36, 0x3e, 0x3c, 0x75, 0x6c, 0x3e, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, + 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x20, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, 0x63, 0x73, 0x73, 0x22, + 0x20, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x3d, 0x22, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x22, 0x20, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, + 0x22, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x68, 0x74, 0x6d, 0x6c, + 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, + 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x0d, 0x0a, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, 0x3e, 0x3c, 0x2f, 0x73, + 0x70, 0x61, 0x6e, 0x3e, 0x3c, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, + 0x22, 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, + 0x22, 0x30, 0x22, 0x3e, 0x3b, 0x0a, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, + 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x64, 0x6f, 0x65, 0x73, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c, 0x79, + 0x46, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, + 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, + 0x45, 0x20, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3a, 0x76, + 0x6f, 0x69, 0x64, 0x28, 0x30, 0x29, 0x3b, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, + 0x65, 0x6e, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, + 0x6f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x3d, 0x22, 0x6f, 0x66, 0x66, 0x22, 0x20, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, + 0x65, 0x72, 0x65, 0x64, 0x3e, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x3e, 0x0d, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x74, 0x68, 0x72, 0x6f, + 0x75, 0x67, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6d, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, + 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x64, 0x75, 0x72, 0x69, + 0x6e, 0x67, 0x20, 0x68, 0x69, 0x73, 0x20, 0x6c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x2c, + 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, + 0x78, 0x2d, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, + 0x61, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x64, 0x69, 0x70, 0x6c, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x61, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, + 0x65, 0x72, 0x65, 0x64, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, + 0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x20, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x65, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x22, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3a, 0x2f, 0x2f, 0x69, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x74, 0x68, 0x65, 0x20, 0x65, 0x73, 0x74, 0x61, + 0x62, 0x6c, 0x69, 0x73, 0x68, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x0a, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, + 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x26, 0x61, 0x6d, 0x70, 0x3b, 0x6e, + 0x62, 0x73, 0x70, 0x3b, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, + 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x71, 0x75, 0x69, 0x74, 0x65, 0x20, 0x64, 0x69, + 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x6d, 0x61, 0x72, 0x6b, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, + 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, + 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x77, 0x69, 0x64, 0x65, + 0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x77, 0x61, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x77, 0x69, 0x74, 0x68, 0x20, 0x76, 0x61, 0x72, 0x79, 0x69, 0x6e, 0x67, + 0x20, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x73, 0x68, 0x61, 0x76, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x28, 0x64, 0x6f, 0x63, + 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x64, + 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0x65, 0x74, 0x61, 0x20, 0x63, 0x68, 0x61, 0x72, + 0x73, 0x65, 0x74, 0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x3e, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x2f, 0x3e, 0x0a, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x61, 0x62, 0x6c, 0x79, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x6c, 0x79, + 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, + 0x70, 0x65, 0x72, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, + 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x73, 0x75, + 0x62, 0x6d, 0x69, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x66, 0x61, 0x6d, 0x69, + 0x6c, 0x69, 0x65, 0x73, 0x20, 0x72, 0x65, 0x73, 0x69, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, + 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x72, 0x69, 0x65, 0x73, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x20, 0x70, 0x72, 0x6f, + 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, + 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x64, 0x65, 0x74, 0x65, + 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x6f, + 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x75, 0xc3, + 0xaa, 0x73, 0x20, 0x28, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x75, 0x29, 0xd0, 0xa3, 0xd0, 0xba, + 0xd1, 0x80, 0xd0, 0xb0, 0xd1, 0x97, 0xd0, 0xbd, 0xd1, 0x81, 0xd1, 0x8c, 0xd0, 0xba, 0xd0, 0xb0, + 0xd1, 0x83, 0xd0, 0xba, 0xd1, 0x80, 0xd0, 0xb0, 0xd1, 0x97, 0xd0, 0xbd, 0xd1, 0x81, 0xd1, 0x8c, + 0xd0, 0xba, 0xd0, 0xb0, 0xd0, 0xa0, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x81, 0xd0, 0xb8, 0xd0, 0xb9, + 0xd1, 0x81, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xb9, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xb5, + 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xb0, 0xd0, 0xbb, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb8, 0xd0, 0xbd, + 0xd1, 0x84, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd1, 0x83, 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xbb, 0xd0, 0xb5, 0xd0, 0xbd, + 0xd0, 0xb8, 0xd1, 0x8f, 0xd0, 0xbd, 0xd0, 0xb5, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x85, 0xd0, 0xbe, + 0xd0, 0xb4, 0xd0, 0xb8, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x84, 0xd0, 0xbe, + 0xd1, 0x80, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, 0xd1, 0x8f, 0xd0, 0x98, 0xd0, 0xbd, + 0xd1, 0x84, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, 0xd1, 0x8f, + 0xd0, 0xa0, 0xd0, 0xb5, 0xd1, 0x81, 0xd0, 0xbf, 0xd1, 0x83, 0xd0, 0xb1, 0xd0, 0xbb, 0xd0, 0xb8, + 0xd0, 0xba, 0xd0, 0xb8, 0xd0, 0xba, 0xd0, 0xbe, 0xd0, 0xbb, 0xd0, 0xb8, 0xd1, 0x87, 0xd0, 0xb5, + 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x84, 0xd0, 0xbe, + 0xd1, 0x80, 0xd0, 0xbc, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, 0xd1, 0x8e, 0xd1, 0x82, 0xd0, 0xb5, + 0xd1, 0x80, 0xd1, 0x80, 0xd0, 0xb8, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x80, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd0, 0xb4, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xbe, 0xd1, 0x87, + 0xd0, 0xbd, 0xd0, 0xbe, 0xd8, 0xa7, 0xd9, 0x84, 0xd9, 0x85, 0xd8, 0xaa, 0xd9, 0x88, 0xd8, 0xa7, + 0xd8, 0xac, 0xd8, 0xaf, 0xd9, 0x88, 0xd9, 0x86, 0xd8, 0xa7, 0xd9, 0x84, 0xd8, 0xa7, 0xd8, 0xb4, + 0xd8, 0xaa, 0xd8, 0xb1, 0xd8, 0xa7, 0xd9, 0x83, 0xd8, 0xa7, 0xd8, 0xaa, 0xd8, 0xa7, 0xd9, 0x84, + 0xd8, 0xa7, 0xd9, 0x82, 0xd8, 0xaa, 0xd8, 0xb1, 0xd8, 0xa7, 0xd8, 0xad, 0xd8, 0xa7, 0xd8, 0xaa, + 0x68, 0x74, 0x6d, 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x55, 0x54, + 0x46, 0x2d, 0x38, 0x22, 0x20, 0x73, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x28, + 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, + 0x79, 0x3a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x2d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, 0x3c, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x73, 0x75, 0x62, 0x6d, + 0x69, 0x74, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x27, 0x74, 0x65, 0x78, 0x74, + 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, + 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x22, 0x20, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, + 0x72, 0x67, 0x2f, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x63, 0x75, 0x74, 0x20, 0x69, 0x63, 0x6f, 0x6e, + 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x22, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6f, + 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x3d, 0x22, 0x6f, 0x66, 0x66, 0x22, 0x20, 0x3c, 0x2f, 0x61, + 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x3d, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x0a, 0x3c, 0x6c, 0x69, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x63, 0x73, 0x73, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x3c, 0x66, 0x6f, 0x72, + 0x6d, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, + 0x2f, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, + 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x65, 0x22, 0x20, 0x0d, 0x0a, 0x3c, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, + 0x20, 0x6f, 0x6e, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x3a, 0x28, 0x6e, 0x65, 0x77, 0x20, 0x44, 0x61, 0x74, 0x65, 0x29, 0x2e, + 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x28, 0x29, 0x7d, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x3d, 0x22, 0x31, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x31, 0x22, 0x20, 0x50, + 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x27, 0x73, 0x20, 0x52, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x20, 0x6f, 0x66, 0x20, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x64, 0x65, + 0x63, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, + 0x0a, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3c, 0x2f, 0x64, + 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, + 0x2f, 0x64, 0x23, 0x76, 0x69, 0x65, 0x77, 0x70, 0x6f, 0x72, 0x74, 0x7b, 0x6d, 0x69, 0x6e, 0x2d, + 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, + 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x3e, 0x3c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3d, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x61, 0x73, 0x20, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x3c, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x3c, 0x21, 0x44, 0x4f, 0x43, + 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 0x3c, 0x21, 0x2d, 0x2d, 0x5b, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x41, 0x69, + 0x72, 0x70, 0x6f, 0x72, 0x74, 0x3e, 0x0a, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, + 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x61, + 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0xe0, + 0xb8, 0xa0, 0xe0, 0xb8, 0xb2, 0xe0, 0xb8, 0xa9, 0xe0, 0xb8, 0xb2, 0xe0, 0xb9, 0x84, 0xe0, 0xb8, + 0x97, 0xe0, 0xb8, 0xa2, 0xe1, 0x83, 0xa5, 0xe1, 0x83, 0x90, 0xe1, 0x83, 0xa0, 0xe1, 0x83, 0x97, + 0xe1, 0x83, 0xa3, 0xe1, 0x83, 0x9a, 0xe1, 0x83, 0x98, 0xe6, 0xad, 0xa3, 0xe9, 0xab, 0x94, 0xe4, + 0xb8, 0xad, 0xe6, 0x96, 0x87, 0x20, 0x28, 0xe7, 0xb9, 0x81, 0xe9, 0xab, 0x94, 0x29, 0xe0, 0xa4, + 0xa8, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa6, 0xe0, 0xa5, 0x87, + 0xe0, 0xa4, 0xb6, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0xb2, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, + 0xb7, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa4, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0x9c, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa5, 0x80, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xac, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, + 0xa7, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa5, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xb5, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x95, + 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa3, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xae, 0xe0, + 0xa4, 0x97, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, + 0xbf, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa0, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, 0x82, + 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x9c, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9e, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x85, 0xe0, 0xa4, 0xae, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, + 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa8, 0xe0, + 0xa4, 0x97, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa1, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, + 0xbe, 0xe0, 0xa4, 0x81, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaf, 0xe0, 0xa5, 0x8b, + 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x81, 0xe0, + 0xa4, 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xaa, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0x81, 0xe0, 0xa4, 0x9a, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xac, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0xa7, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa3, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0x95, + 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x87, 0xe0, + 0xa4, 0x9f, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xae, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8b, 0xe0, 0xa4, + 0x82, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xab, 0xe0, 0xa4, 0xbc, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa5, 0x8d, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa3, 0xe0, 0xa4, 0xb2, 0xe0, 0xa4, + 0xbf, 0xe0, 0xa4, 0xae, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x9f, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xa1, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x2e, 0x67, 0x65, 0x74, + 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x54, 0x61, 0x67, 0x4e, 0x61, 0x6d, + 0x65, 0x28, 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74, 0x6d, 0x6c, + 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x63, 0x68, + 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x3e, 0x3a, 0x75, + 0x72, 0x6c, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, + 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x3e, + 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, + 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, + 0x39, 0x2f, 0x78, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x20, 0x78, 0x6d, 0x6c, 0x74, 0x79, 0x70, 0x65, + 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x22, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x67, 0x65, 0x74, 0x22, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, + 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x20, 0x3d, + 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, + 0x78, 0x2d, 0x69, 0x63, 0x6f, 0x6e, 0x22, 0x20, 0x2f, 0x3e, 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, + 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x70, + 0x2e, 0x63, 0x73, 0x73, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, + 0x2f, 0x63, 0x73, 0x73, 0x22, 0x20, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x3c, + 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x22, 0x20, 0x77, 0x69, + 0x64, 0x74, 0x68, 0x3d, 0x22, 0x31, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x22, + 0x31, 0x22, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x64, + 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x22, 0x3e, 0x61, 0x6c, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x65, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x2d, 0x2f, 0x2f, 0x57, 0x33, 0x43, 0x2f, 0x2f, 0x44, 0x54, 0x44, 0x20, + 0x58, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x31, 0x2e, 0x30, 0x20, 0x65, 0x6c, 0x6c, 0x73, 0x70, 0x61, + 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x70, 0x61, 0x64, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x22, 0x2f, 0x61, 0x3e, 0x26, 0x6e, 0x62, 0x73, 0x70, 0x3b, 0x3c, + 0x73, 0x70, 0x61, 0x6e, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x3d, 0x22, 0x73, 0x0a, 0x3c, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, + 0x22, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3d, 0x22, 0x4a, 0x61, 0x76, 0x61, + 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x20, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, + 0x74, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x67, 0x3d, + 0x22, 0x30, 0x22, 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, + 0x22, 0x30, 0x22, 0x20, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, + 0x73, 0x22, 0x20, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x27, + 0x74, 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, + 0x63, 0x73, 0x73, 0x22, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x74, 0x20, 0x68, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x3d, 0x22, 0x31, 0x22, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x31, + 0x22, 0x20, 0x3d, 0x27, 0x2b, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x55, 0x52, 0x49, 0x43, 0x6f, + 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x28, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, + 0x6c, 0x3d, 0x22, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x65, 0x22, 0x20, 0x0a, 0x62, + 0x6f, 0x64, 0x79, 0x2c, 0x20, 0x74, 0x72, 0x2c, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2c, 0x20, + 0x74, 0x65, 0x78, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x72, + 0x6f, 0x62, 0x6f, 0x74, 0x73, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, + 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74, 0x22, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, + 0x3e, 0x0a, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, + 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x3c, 0x2f, 0x64, 0x69, + 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x3e, 0x61, 0x72, 0x69, 0x61, 0x2d, 0x68, 0x69, 0x64, + 0x64, 0x65, 0x6e, 0x3d, 0x22, 0x74, 0x72, 0x75, 0x65, 0x22, 0x3e, 0xc2, 0xb7, 0x3c, 0x72, 0x69, + 0x70, 0x74, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x6a, + 0x61, 0x76, 0x61, 0x73, 0x6c, 0x3d, 0x30, 0x3b, 0x7d, 0x29, 0x28, 0x29, 0x3b, 0x0a, 0x28, 0x66, + 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, + 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x3a, 0x20, 0x75, 0x72, 0x6c, 0x28, + 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x6c, 0x69, 0x3e, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, + 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x09, 0x09, 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, + 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x74, 0x6f, 0x72, + 0x22, 0x20, 0x61, 0x72, 0x69, 0x61, 0x2d, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x3d, 0x22, 0x74, + 0x72, 0x75, 0x3e, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + 0x3d, 0x22, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x20, 0x2f, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x3c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x3c, + 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x22, + 0x20, 0x61, 0x72, 0x69, 0x61, 0x2d, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x3d, 0x22, 0x74, 0x72, + 0x65, 0x3d, 0x28, 0x6e, 0x65, 0x77, 0x20, 0x44, 0x61, 0x74, 0x65, 0x29, 0x2e, 0x67, 0x65, 0x74, + 0x54, 0x69, 0x6d, 0x65, 0x28, 0x29, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x75, 0xc3, 0xaa, 0x73, + 0x20, 0x28, 0x64, 0x6f, 0x20, 0x42, 0x72, 0x61, 0x73, 0x69, 0x6c, 0x29, 0xd0, 0xbe, 0xd1, 0x80, + 0xd0, 0xb3, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xb0, 0xd1, 0x86, 0xd0, 0xb8, + 0xd0, 0xb8, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb7, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb6, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x8c, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x80, 0xd0, 0xb0, + 0xd0, 0xb7, 0xd0, 0xbe, 0xd0, 0xb2, 0xd0, 0xb0, 0xd0, 0xbd, 0xd0, 0xb8, 0xd1, 0x8f, 0xd1, 0x80, + 0xd0, 0xb5, 0xd0, 0xb3, 0xd0, 0xb8, 0xd1, 0x81, 0xd1, 0x82, 0xd1, 0x80, 0xd0, 0xb0, 0xd1, 0x86, + 0xd0, 0xb8, 0xd0, 0xb8, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb7, 0xd0, 0xbc, 0xd0, 0xbe, 0xd0, 0xb6, + 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd0, 0xbe, 0xd0, 0xb1, 0xd1, 0x8f, + 0xd0, 0xb7, 0xd0, 0xb0, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xbd, 0xd0, 0xb0, + 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x50, + 0x55, 0x42, 0x4c, 0x49, 0x43, 0x20, 0x22, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x22, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x3c, 0x6d, + 0x65, 0x74, 0x61, 0x20, 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x2f, 0x2f, 0x45, 0x4e, 0x22, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x3c, 0x68, 0x74, 0x6d, + 0x6c, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x77, 0x77, 0x77, 0x2d, 0x2f, 0x2f, 0x57, 0x33, 0x43, 0x2f, 0x2f, 0x44, 0x54, 0x44, 0x20, 0x58, + 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x31, 0x2e, 0x30, 0x20, 0x54, 0x44, 0x54, 0x44, 0x2f, 0x78, 0x68, + 0x74, 0x6d, 0x6c, 0x31, 0x2d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x54, 0x52, + 0x2f, 0x78, 0x68, 0x74, 0x6d, 0x6c, 0x31, 0x2f, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x27, 0x74, 0x65, + 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x3b, 0x3c, + 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, + 0x2e, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x3c, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, + 0x22, 0x20, 0x6e, 0x61, 0x6a, 0x73, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, + 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x28, 0x64, 0x6f, 0x63, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x29, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x79, 0x28, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, + 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x22, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x55, 0x41, 0x2d, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x22, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x74, 0x6d, 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, + 0x73, 0x65, 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x6c, 0x69, + 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x63, 0x75, 0x74, + 0x20, 0x69, 0x63, 0x6f, 0x6e, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 0x65, 0x6c, 0x3d, 0x22, + 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x3c, 0x2f, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x3d, 0x3d, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x3c, 0x61, 0x20, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x3d, 0x22, 0x5f, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x22, 0x20, 0x68, 0x72, 0x65, + 0x66, 0x3d, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x45, + 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x61, + 0x2e, 0x74, 0x79, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x27, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, + 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, + 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x68, 0x74, 0x6d, + 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, + 0x22, 0x20, 0x2f, 0x3e, 0x64, 0x74, 0x64, 0x22, 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x20, + 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x2d, 0x2f, 0x2f, 0x57, 0x33, + 0x43, 0x2f, 0x2f, 0x44, 0x54, 0x44, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x34, 0x2e, 0x30, 0x31, + 0x20, 0x54, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x54, 0x61, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x28, + 0x27, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x29, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x3d, 0x22, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x20, 0x6e, 0x61, 0x6d, + 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, + 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, + 0x22, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x22, 0x3e, + 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x64, 0x28, 0x3d, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, + 0x74, 0x2e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x28, + 0x27, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x27, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, + 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, + 0x64, 0x2e, 0x67, 0x65, 0x74, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x54, + 0x61, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x73, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x22, 0x20, 0x68, + 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, + 0x43, 0x2f, 0x2f, 0x44, 0x54, 0x44, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x34, 0x2e, 0x30, 0x31, + 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x3c, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x0a, + 0x0a, 0x3c, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x74, 0x65, + 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x64, 0x74, + 0x64, 0x22, 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3d, + 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75, 0x69, 0x76, 0x3d, 0x22, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, + 0x20, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x70, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x30, 0x22, + 0x68, 0x74, 0x6d, 0x6c, 0x3b, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x75, 0x74, + 0x66, 0x2d, 0x38, 0x22, 0x20, 0x2f, 0x3e, 0x0a, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, + 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3a, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0x22, 0x3e, 0x3c, + 0x3c, 0x6c, 0x69, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x27, 0x74, + 0x65, 0x78, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x27, 0x3e, + 0xd0, 0xb4, 0xd0, 0xb5, 0xd1, 0x8f, 0xd1, 0x82, 0xd0, 0xb5, 0xd0, 0xbb, 0xd1, 0x8c, 0xd0, 0xbd, + 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, 0xd1, 0x81, 0xd0, 0xbe, 0xd0, 0xbe, 0xd1, 0x82, + 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xb8, 0xd0, 0xb8, + 0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xbe, 0xd0, 0xb8, 0xd0, 0xb7, 0xd0, 0xb2, 0xd0, 0xbe, 0xd0, 0xb4, + 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb2, 0xd0, 0xb0, 0xd0, 0xb1, 0xd0, 0xb5, 0xd0, 0xb7, 0xd0, 0xbe, + 0xd0, 0xbf, 0xd0, 0xb0, 0xd1, 0x81, 0xd0, 0xbd, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xb8, + 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xa4, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, + 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb8, + 0xe0, 0xa4, 0x89, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb9, 0xe0, 0xa5, 0x8b, 0xe0, + 0xa4, 0x82, 0xe0, 0xa4, 0xa8, 0xe0, 0xa5, 0x87, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0xa7, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xa8, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0xad, 0xe0, 0xa4, 0xbe, + 0xe0, 0xa4, 0xab, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb8, 0xe0, + 0xa4, 0xbf, 0xe0, 0xa4, 0x82, 0xe0, 0xa4, 0x97, 0xe0, 0xa4, 0xb8, 0xe0, 0xa5, 0x81, 0xe0, 0xa4, + 0xb0, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb7, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xa4, + 0xe0, 0xa4, 0x95, 0xe0, 0xa5, 0x89, 0xe0, 0xa4, 0xaa, 0xe0, 0xa5, 0x80, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xbe, 0xe0, 0xa4, 0x87, 0xe0, 0xa4, 0x9f, 0xe0, 0xa4, 0xb5, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, + 0x9c, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0x9e, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xaa, 0xe0, 0xa4, 0xa8, + 0xe0, 0xa4, 0x95, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0xb0, 0xe0, 0xa5, 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, + 0xa4, 0xb5, 0xe0, 0xa4, 0xbe, 0xe0, 0xa4, 0x88, 0xe0, 0xa4, 0xb8, 0xe0, 0xa4, 0x95, 0xe0, 0xa5, + 0x8d, 0xe0, 0xa4, 0xb0, 0xe0, 0xa4, 0xbf, 0xe0, 0xa4, 0xaf, 0xe0, 0xa4, 0xa4, 0xe0, 0xa4, 0xbe]; diff --git a/rust/vendor/brotli-decompressor/src/ffi/alloc_util.rs b/rust/vendor/brotli-decompressor/src/ffi/alloc_util.rs new file mode 100644 index 0000000..ee6759a --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/ffi/alloc_util.rs @@ -0,0 +1,228 @@ +use core; +#[cfg(feature="std")] +use std; +use ::alloc; +use super::interface::{c_void, CAllocator}; +#[cfg(feature="std")] +use std::vec::Vec; +#[cfg(feature="std")] +pub use std::boxed::Box; + +#[cfg(feature="std")] +pub struct MemoryBlock<Ty:Sized+Default>(Box<[Ty]>); +#[cfg(feature="std")] +impl<Ty:Sized+Default> Default for MemoryBlock<Ty> { + fn default() -> Self { + MemoryBlock(Vec::<Ty>::new().into_boxed_slice()) + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default> alloc::SliceWrapper<Ty> for MemoryBlock<Ty> { + fn slice(&self) -> &[Ty] { + &self.0[..] + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default> alloc::SliceWrapperMut<Ty> for MemoryBlock<Ty> { + fn slice_mut(&mut self) -> &mut [Ty] { + &mut self.0[..] + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default> core::ops::Index<usize> for MemoryBlock<Ty> { + type Output = Ty; + fn index(&self, index:usize) -> &Ty { + &self.0[index] + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default> core::ops::IndexMut<usize> for MemoryBlock<Ty> { + + fn index_mut(&mut self, index:usize) -> &mut Ty { + &mut self.0[index] + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default> Drop for MemoryBlock<Ty> { + fn drop (&mut self) { + if self.0.len() != 0 { + print!("leaking memory block of length {} element size: {}\n", self.0.len(), core::mem::size_of::<Ty>()); + + let to_forget = core::mem::replace(self, MemoryBlock::default()); + core::mem::forget(to_forget);// leak it -- it's the only safe way with custom allocators + } + } +} +pub struct SubclassableAllocator { + alloc: CAllocator + // have alternative ty here +} + +impl SubclassableAllocator { + pub unsafe fn new(sub_alloc:CAllocator) -> Self { + SubclassableAllocator{ + alloc:sub_alloc, + } + } +} +#[cfg(feature="std")] +impl<Ty:Sized+Default+Clone> alloc::Allocator<Ty> for SubclassableAllocator { + type AllocatedMemory = MemoryBlock<Ty>; + fn alloc_cell(&mut self, size:usize) ->MemoryBlock<Ty>{ + if size == 0 { + return MemoryBlock::<Ty>::default(); + } + if let Some(alloc_fn) = self.alloc.alloc_func { + let ptr = alloc_fn(self.alloc.opaque, size * core::mem::size_of::<Ty>()); + let typed_ptr = unsafe {core::mem::transmute::<*mut c_void, *mut Ty>(ptr)}; + let slice_ref = unsafe {super::slice_from_raw_parts_or_nil_mut(typed_ptr, size)}; + for item in slice_ref.iter_mut() { + unsafe{core::ptr::write(item, Ty::default())}; + } + return MemoryBlock(unsafe{Box::from_raw(slice_ref)}) + } + MemoryBlock(vec![Ty::default();size].into_boxed_slice()) + } + fn free_cell(&mut self, mut bv:MemoryBlock<Ty>) { + if (*bv.0).len() != 0 { + if let Some(_) = self.alloc.alloc_func { + let slice_ptr = (*bv.0).as_mut_ptr(); + let _box_ptr = Box::into_raw(core::mem::replace(&mut bv.0, Vec::<Ty>::new().into_boxed_slice())); + if let Some(free_fn) = self.alloc.free_func { + unsafe {free_fn(self.alloc.opaque, core::mem::transmute::<*mut Ty, *mut c_void>(slice_ptr))}; + } + } else { + let _to_free = core::mem::replace(&mut bv.0, Vec::<Ty>::new().into_boxed_slice()); + } + } + } +} + + + + + + + + + + + +#[cfg(not(feature="std"))] +static mut G_SLICE:&'static mut[u8] = &mut[]; +#[cfg(not(feature="std"))] +pub struct MemoryBlock<Ty:Sized+Default>(*mut[Ty]); +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default> Default for MemoryBlock<Ty> { + fn default() -> Self { + MemoryBlock(unsafe{core::mem::transmute::<*mut [u8], *mut[Ty]>(G_SLICE.as_mut())}) + } +} +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default> alloc::SliceWrapper<Ty> for MemoryBlock<Ty> { + fn slice(&self) -> &[Ty] { + if unsafe{(*self.0).len()} == 0 { + &[] + } else { + unsafe{super::slice_from_raw_parts_or_nil(&(*self.0)[0], (*self.0).len())} + } + } +} +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default> alloc::SliceWrapperMut<Ty> for MemoryBlock<Ty> { + fn slice_mut(&mut self) -> &mut [Ty] { + if unsafe{(*self.0).len()} == 0 { + &mut [] + } else { + unsafe{super::slice_from_raw_parts_or_nil_mut(&mut (*self.0)[0], (*self.0).len())} + } + } +} + +#[cfg(not(feature="std"))] +#[cfg(feature="no-stdlib-ffi-binding")] +#[panic_handler] +extern fn panic_impl(_: &::core::panic::PanicInfo) -> ! { + loop {} +} +#[cfg(not(feature="std"))] +#[cfg(feature="no-stdlib-ffi-binding")] +#[lang = "eh_personality"] +extern "C" fn eh_personality() { +} + +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default> core::ops::Index<usize> for MemoryBlock<Ty> { + type Output = Ty; + fn index(&self, index:usize) -> &Ty { + unsafe{&(*self.0)[index]} + } +} +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default> core::ops::IndexMut<usize> for MemoryBlock<Ty> { + + fn index_mut(&mut self, index:usize) -> &mut Ty { + unsafe{&mut (*self.0)[index]} + } +} + +#[cfg(not(feature="std"))] +impl<Ty:Sized+Default+Clone> alloc::Allocator<Ty> for SubclassableAllocator { + type AllocatedMemory = MemoryBlock<Ty>; + fn alloc_cell(&mut self, size:usize) ->MemoryBlock<Ty>{ + if size == 0 { + return MemoryBlock::<Ty>::default(); + } + if let Some(alloc_fn) = self.alloc.alloc_func { + let ptr = alloc_fn(self.alloc.opaque, size * core::mem::size_of::<Ty>()); + let typed_ptr = unsafe {core::mem::transmute::<*mut c_void, *mut Ty>(ptr)}; + let slice_ref = unsafe {super::slice_from_raw_parts_or_nil_mut(typed_ptr, size)}; + for item in slice_ref.iter_mut() { + unsafe{core::ptr::write(item, Ty::default())}; + } + return MemoryBlock(slice_ref.as_mut()) + } else { + panic!("Must provide allocators in no-stdlib code"); + } + } + fn free_cell(&mut self, mut bv:MemoryBlock<Ty>) { + use alloc::SliceWrapper; + use alloc::SliceWrapperMut; + if bv.slice().len() != 0 { + if let Some(_) = self.alloc.alloc_func { + if let Some(free_fn) = self.alloc.free_func { + unsafe {free_fn(self.alloc.opaque, core::mem::transmute::<*mut Ty, *mut c_void>(&mut bv.slice_mut()[0]))}; + } + let _ = core::mem::replace(&mut bv, + MemoryBlock::<Ty>::default()); + } else { + panic!("Must provide allocators in no-stdlib code"); + } + } + } +} + + +#[cfg(not(feature="std"))] +pub fn free_stdlib<T>(_data: *mut T, _size: usize) { + panic!("Must supply allocators if calling divans when compiled with features=no-stdlib"); +} +#[cfg(not(feature="std"))] +pub fn alloc_stdlib<T:Sized+Default+Copy+Clone>(_size: usize) -> *mut T { + panic!("Must supply allocators if calling divans when compiled with features=no-stdlib"); +} + +#[cfg(feature="std")] +pub unsafe fn free_stdlib<T>(ptr: *mut T, size: usize) { + let slice_ref = super::slice_from_raw_parts_or_nil_mut(ptr, size); + let _ = Box::from_raw(slice_ref); // free on drop +} +#[cfg(feature="std")] +pub fn alloc_stdlib<T:Sized+Default+Copy+Clone>(size: usize) -> *mut T { + std::panic::catch_unwind(|| { + let mut newly_allocated = vec![T::default();size].into_boxed_slice(); + let slice_ptr = newly_allocated.as_mut_ptr(); + let _box_ptr = Box::into_raw(newly_allocated); + slice_ptr + }).unwrap_or(core::ptr::null_mut()) +} diff --git a/rust/vendor/brotli-decompressor/src/ffi/interface.rs b/rust/vendor/brotli-decompressor/src/ffi/interface.rs new file mode 100644 index 0000000..eefccac --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/ffi/interface.rs @@ -0,0 +1,49 @@ +use ::BrotliResult; +#[allow(non_camel_case_types)] +#[repr(u8)] +pub enum c_void{ + _Nothing = 0, +} + +#[repr(C)] +#[allow(dead_code)] +pub enum BrotliDecoderParameter { + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0, + BROTLI_DECODER_PARAM_LARGE_WINDOW = 1, +} + + +#[repr(C)] +pub enum BrotliDecoderResult { + BROTLI_DECODER_RESULT_ERROR = 0, + BROTLI_DECODER_RESULT_SUCCESS = 1, + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2, + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3, +} + + +impl From<BrotliResult> for BrotliDecoderResult { + fn from(r: BrotliResult) -> Self { + match r { + BrotliResult::ResultSuccess => BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS, + BrotliResult::ResultFailure => BrotliDecoderResult::BROTLI_DECODER_RESULT_ERROR, + BrotliResult::NeedsMoreInput => BrotliDecoderResult::BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT , + BrotliResult::NeedsMoreOutput => BrotliDecoderResult::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT , + } + } +} +pub type brotli_alloc_func = Option<extern "C" fn(data: *mut c_void, size: usize) -> *mut c_void>; + +pub type brotli_free_func = Option<extern "C" fn(data: *mut c_void, ptr: *mut c_void) -> ()>; + + +#[repr(C)] +#[derive(Clone)] +pub struct CAllocator { + pub alloc_func: brotli_alloc_func, + pub free_func: brotli_free_func, + pub opaque: *mut c_void, +} + +unsafe impl Send for CAllocator { +} diff --git a/rust/vendor/brotli-decompressor/src/ffi/mod.rs b/rust/vendor/brotli-decompressor/src/ffi/mod.rs new file mode 100644 index 0000000..e8f4ae3 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/ffi/mod.rs @@ -0,0 +1,379 @@ +#![cfg(not(feature="safe"))] + +#[cfg(feature="std")] +use std::{thread,panic, io, boxed, any, string}; +#[cfg(feature="std")] +use std::io::Write; +use core; +use core::slice; +use core::ops; +pub mod interface; +pub mod alloc_util; +use self::alloc_util::SubclassableAllocator; +use alloc::{Allocator, SliceWrapper, SliceWrapperMut, StackAllocator, AllocatedStackMemory, bzero}; +use self::interface::{CAllocator, c_void, BrotliDecoderParameter, BrotliDecoderResult, brotli_alloc_func, brotli_free_func}; +use ::BrotliResult; +use ::BrotliDecoderReturnInfo; +use ::brotli_decode; +pub use ::HuffmanCode; +pub use super::state::{BrotliDecoderErrorCode, BrotliState}; + +pub unsafe fn slice_from_raw_parts_or_nil<'a, T>(data: *const T, len: usize) -> &'a [T] { + if len == 0 { + return &[]; + } + slice::from_raw_parts(data, len) +} + +pub unsafe fn slice_from_raw_parts_or_nil_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] { + if len == 0 { + return &mut []; + } + slice::from_raw_parts_mut(data, len) +} + +#[cfg(feature="std")] +type BrotliAdditionalErrorData = boxed::Box<dyn any::Any + Send + 'static>; +#[cfg(not(feature="std"))] +type BrotliAdditionalErrorData = (); + +#[repr(C)] +pub struct BrotliDecoderState { + pub custom_allocator: CAllocator, + pub decompressor: ::BrotliState<SubclassableAllocator, + SubclassableAllocator, + SubclassableAllocator>, +} + +#[cfg(not(feature="std"))] +fn brotli_new_decompressor_without_custom_alloc(_to_box: BrotliDecoderState) -> *mut BrotliDecoderState{ + panic!("Must supply allocators if calling divans when compiled without features=std"); +} + +#[cfg(feature="std")] +fn brotli_new_decompressor_without_custom_alloc(to_box: BrotliDecoderState) -> *mut BrotliDecoderState{ + alloc_util::Box::<BrotliDecoderState>::into_raw( + alloc_util::Box::<BrotliDecoderState>::new(to_box)) +} + + +#[no_mangle] +pub unsafe extern fn BrotliDecoderCreateInstance( + alloc_func: brotli_alloc_func, + free_func: brotli_free_func, + opaque: *mut c_void, +) -> *mut BrotliDecoderState { + match catch_panic_state(|| { + let allocators = CAllocator { + alloc_func:alloc_func, + free_func:free_func, + opaque:opaque, + }; + let custom_dictionary = <SubclassableAllocator as Allocator<u8>>::AllocatedMemory::default(); + let to_box = BrotliDecoderState { + custom_allocator: allocators.clone(), + decompressor: ::BrotliState::new_with_custom_dictionary( + SubclassableAllocator::new(allocators.clone()), + SubclassableAllocator::new(allocators.clone()), + SubclassableAllocator::new(allocators.clone()), + custom_dictionary, + ), + }; + if let Some(alloc) = alloc_func { + if free_func.is_none() { + panic!("either both alloc and free must exist or neither"); + } + let ptr = alloc(allocators.opaque, core::mem::size_of::<BrotliDecoderState>()); + let brotli_decoder_state_ptr = core::mem::transmute::<*mut c_void, *mut BrotliDecoderState>(ptr); + core::ptr::write(brotli_decoder_state_ptr, to_box); + brotli_decoder_state_ptr + } else { + brotli_new_decompressor_without_custom_alloc(to_box) + } + }) { + Ok(ret) => ret, + Err(mut e) => { + error_print(core::ptr::null_mut(), &mut e); + core::ptr::null_mut() + }, + } +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderSetParameter(_state_ptr: *mut BrotliDecoderState, + _selector: BrotliDecoderParameter, + _value: u32) { + // not implemented +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderDecompressPrealloc( + encoded_size: usize, + encoded_buffer: *const u8, + decoded_size: usize, + decoded_buffer: *mut u8, + scratch_u8_size: usize, + scratch_u8_buffer: *mut u8, + scratch_u32_size: usize, + scratch_u32_buffer: *mut u32, + scratch_hc_size: usize, + scratch_hc_buffer: *mut HuffmanCode, +) -> BrotliDecoderReturnInfo { + let input = slice_from_raw_parts_or_nil(encoded_buffer, encoded_size); + let output = slice_from_raw_parts_or_nil_mut(decoded_buffer, decoded_size); + let scratch_u8 = slice_from_raw_parts_or_nil_mut(scratch_u8_buffer, scratch_u8_size); + let scratch_u32 = slice_from_raw_parts_or_nil_mut(scratch_u32_buffer, scratch_u32_size); + let scratch_hc = slice_from_raw_parts_or_nil_mut(scratch_hc_buffer, scratch_hc_size); + ::brotli_decode_prealloc(input, output, scratch_u8, scratch_u32, scratch_hc) +} + + +#[no_mangle] +pub unsafe extern fn BrotliDecoderDecompressWithReturnInfo( + encoded_size: usize, + encoded_buffer: *const u8, + decoded_size: usize, + decoded_buffer: *mut u8, +) -> BrotliDecoderReturnInfo { + let input = slice_from_raw_parts_or_nil(encoded_buffer, encoded_size); + let output_scratch = slice_from_raw_parts_or_nil_mut(decoded_buffer, decoded_size); + ::brotli_decode(input, output_scratch) +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderDecompress( + encoded_size: usize, + encoded_buffer: *const u8, + decoded_size: *mut usize, + decoded_buffer: *mut u8, +) -> BrotliDecoderResult { + let res = BrotliDecoderDecompressWithReturnInfo(encoded_size, encoded_buffer, *decoded_size, decoded_buffer); + *decoded_size = res.decoded_size; + match res.result { + BrotliResult::ResultSuccess => BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS, + _ => BrotliDecoderResult::BROTLI_DECODER_RESULT_ERROR + } +} + +#[cfg(all(feature="std", not(feature="pass-through-ffi-panics")))] +fn catch_panic<F:FnOnce()->BrotliDecoderResult+panic::UnwindSafe>(f: F) -> thread::Result<BrotliDecoderResult> { + panic::catch_unwind(f) +} + +#[cfg(all(feature="std", not(feature="pass-through-ffi-panics")))] +fn catch_panic_state<F:FnOnce()->*mut BrotliDecoderState+panic::UnwindSafe>(f: F) -> thread::Result<*mut BrotliDecoderState> { + panic::catch_unwind(f) +} + +#[cfg(all(feature="std", not(feature="pass-through-ffi-panics")))] +unsafe fn error_print(state_ptr: *mut BrotliDecoderState, err: &mut BrotliAdditionalErrorData) { + if let Some(st) = err.downcast_ref::<&str>() { + if !state_ptr.is_null() { + let mut str_cpy = [0u8;256]; + let src:&[u8] = st.as_ref(); + let xlen = core::cmp::min(src.len(), str_cpy.len() - 1); + str_cpy.split_at_mut(xlen).0.clone_from_slice( + src.split_at(xlen).0); + str_cpy[xlen] = 0; // null terminate + (*state_ptr).decompressor.mtf_or_error_string = Err(str_cpy); + } + let _ign = writeln!(&mut io::stderr(), "panic: {}", st); + } else { + if let Some(st) = err.downcast_ref::<string::String>() { + + if !state_ptr.is_null() { + let mut str_cpy = [0u8;256]; + let src: &[u8] = st.as_ref(); + let xlen = core::cmp::min(src.len(), str_cpy.len() - 1); + str_cpy.split_at_mut(xlen).0.clone_from_slice( + src.split_at(xlen).0); + str_cpy[xlen] = 0; // null terminate + (*state_ptr).decompressor.mtf_or_error_string = Err(str_cpy); + } + let _ign = writeln!(&mut io::stderr(), "Internal Error {:?}", st); + } else { + let _ign = writeln!(&mut io::stderr(), "Internal Error {:?}", err); + } + } +} + +// can't catch panics in a reliable way without std:: configure with panic=abort. These shouldn't happen +#[cfg(any(not(feature="std"), feature="pass-through-ffi-panics"))] +fn catch_panic<F:FnOnce()->BrotliDecoderResult>(f: F) -> Result<BrotliDecoderResult, BrotliAdditionalErrorData> { + Ok(f()) +} + +#[cfg(any(not(feature="std"), feature="pass-through-ffi-panics"))] +fn catch_panic_state<F:FnOnce()->*mut BrotliDecoderState>(f: F) -> Result<*mut BrotliDecoderState, BrotliAdditionalErrorData> { + Ok(f()) +} + +#[cfg(any(not(feature="std"), feature="pass-through-ffi-panics"))] +fn error_print(_state_ptr: *mut BrotliDecoderState, _err: &mut BrotliAdditionalErrorData) { +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderDecompressStream( + state_ptr: *mut BrotliDecoderState, + available_in: *mut usize, + input_buf_ptr: *mut*const u8, + available_out: *mut usize, + output_buf_ptr: *mut*mut u8, + mut total_out: *mut usize) -> BrotliDecoderResult { + match catch_panic(move || { + let mut input_offset = 0usize; + let mut output_offset = 0usize; + let mut fallback_total_out = 0usize; + if total_out.is_null() { + total_out = &mut fallback_total_out; + } + let result: BrotliDecoderResult; + { + let input_buf = slice_from_raw_parts_or_nil(*input_buf_ptr, *available_in); + let output_buf = slice_from_raw_parts_or_nil_mut(*output_buf_ptr, *available_out); + result = super::decode::BrotliDecompressStream( + &mut *available_in, + &mut input_offset, + input_buf, + &mut *available_out, + &mut output_offset, + output_buf, + &mut *total_out, + &mut (*state_ptr).decompressor, + ).into(); + } + *input_buf_ptr = (*input_buf_ptr).offset(input_offset as isize); + *output_buf_ptr = (*output_buf_ptr).offset(output_offset as isize); + result + }) { + Ok(ret) => ret, + Err(mut readable_err) => { // if we panic (completely unexpected) then we should report it back to C and print + error_print(state_ptr, &mut readable_err); + (*state_ptr).decompressor.error_code = BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE; + BrotliDecoderResult::BROTLI_DECODER_RESULT_ERROR + } + } +} + +/// Equivalent to BrotliDecoderDecompressStream but with no optional arg and no double indirect ptrs +#[no_mangle] +pub unsafe extern fn BrotliDecoderDecompressStreaming( + state_ptr: *mut BrotliDecoderState, + available_in: *mut usize, + mut input_buf_ptr: *const u8, + available_out: *mut usize, + mut output_buf_ptr: *mut u8) -> BrotliDecoderResult { + BrotliDecoderDecompressStream(state_ptr, + available_in, + &mut input_buf_ptr, + available_out, + &mut output_buf_ptr, + core::ptr::null_mut()) +} + +#[cfg(feature="std")] +unsafe fn free_decompressor_no_custom_alloc(state_ptr: *mut BrotliDecoderState) { + let _state = alloc_util::Box::from_raw(state_ptr); +} + +#[cfg(not(feature="std"))] +unsafe fn free_decompressor_no_custom_alloc(_state_ptr: *mut BrotliDecoderState) { + unreachable!(); +} + + +#[no_mangle] +pub unsafe extern fn BrotliDecoderMallocU8(state_ptr: *mut BrotliDecoderState, size: usize) -> *mut u8 { + if let Some(alloc_fn) = (*state_ptr).custom_allocator.alloc_func { + return core::mem::transmute::<*mut c_void, *mut u8>(alloc_fn((*state_ptr).custom_allocator.opaque, size)); + } else { + return alloc_util::alloc_stdlib(size); + } +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderFreeU8(state_ptr: *mut BrotliDecoderState, data: *mut u8, size: usize) { + if let Some(free_fn) = (*state_ptr).custom_allocator.free_func { + free_fn((*state_ptr).custom_allocator.opaque, core::mem::transmute::<*mut u8, *mut c_void>(data)); + } else { + alloc_util::free_stdlib(data, size); + } +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderMallocUsize(state_ptr: *mut BrotliDecoderState, size: usize) -> *mut usize { + if let Some(alloc_fn) = (*state_ptr).custom_allocator.alloc_func { + return core::mem::transmute::<*mut c_void, *mut usize>(alloc_fn((*state_ptr).custom_allocator.opaque, + size * core::mem::size_of::<usize>())); + } else { + return alloc_util::alloc_stdlib(size); + } +} +#[no_mangle] +pub unsafe extern fn BrotliDecoderFreeUsize(state_ptr: *mut BrotliDecoderState, data: *mut usize, size: usize) { + if let Some(free_fn) = (*state_ptr).custom_allocator.free_func { + free_fn((*state_ptr).custom_allocator.opaque, core::mem::transmute::<*mut usize, *mut c_void>(data)); + } else { + alloc_util::free_stdlib(data, size); + } +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderDestroyInstance(state_ptr: *mut BrotliDecoderState) { + if let Some(_) = (*state_ptr).custom_allocator.alloc_func { + if let Some(free_fn) = (*state_ptr).custom_allocator.free_func { + let _to_free = core::ptr::read(state_ptr); + let ptr = core::mem::transmute::<*mut BrotliDecoderState, *mut c_void>(state_ptr); + free_fn((*state_ptr).custom_allocator.opaque, ptr); + } + } else { + free_decompressor_no_custom_alloc(state_ptr); + } +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderHasMoreOutput(state_ptr: *const BrotliDecoderState) -> i32 { + if super::decode::BrotliDecoderHasMoreOutput(&(*state_ptr).decompressor) {1} else {0} +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderTakeOutput(state_ptr: *mut BrotliDecoderState, size: *mut usize) -> *const u8 { + super::decode::BrotliDecoderTakeOutput(&mut (*state_ptr).decompressor, &mut *size).as_ptr() +} + + + +#[no_mangle] +pub unsafe extern fn BrotliDecoderIsUsed(state_ptr: *const BrotliDecoderState) -> i32 { + if super::decode::BrotliDecoderIsUsed(&(*state_ptr).decompressor) {1} else {0} +} +#[no_mangle] +pub unsafe extern fn BrotliDecoderIsFinished(state_ptr: *const BrotliDecoderState) -> i32 { + if super::decode::BrotliDecoderIsFinished(&(*state_ptr).decompressor) {1} else {0} +} +#[no_mangle] +pub unsafe extern fn BrotliDecoderGetErrorCode(state_ptr: *const BrotliDecoderState) -> BrotliDecoderErrorCode { + super::decode::BrotliDecoderGetErrorCode(&(*state_ptr).decompressor) +} + +#[no_mangle] +pub unsafe extern fn BrotliDecoderGetErrorString(state_ptr: *const BrotliDecoderState) -> *const u8 { + if !state_ptr.is_null() { + if let &Err(ref msg) = &(*state_ptr).decompressor.mtf_or_error_string { + // important: this must be a ref + // so stack memory is not returned + return msg.as_ptr(); + } + } + BrotliDecoderErrorString(super::decode::BrotliDecoderGetErrorCode(&(*state_ptr).decompressor)) +} +#[no_mangle] +pub extern fn BrotliDecoderErrorString(c: BrotliDecoderErrorCode) -> *const u8 { + ::state::BrotliDecoderErrorStr(c).as_ptr() +} + + +#[no_mangle] +pub extern fn BrotliDecoderVersion() -> u32 { + 0x1000f00 +} diff --git a/rust/vendor/brotli-decompressor/src/huffman/mod.rs b/rust/vendor/brotli-decompressor/src/huffman/mod.rs new file mode 100644 index 0000000..1f8386f --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/huffman/mod.rs @@ -0,0 +1,471 @@ +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +mod tests; +use ::core; +use alloc; +use alloc::Allocator; +use alloc::SliceWrapper; +use alloc::SliceWrapperMut; +use core::default::Default; +pub const BROTLI_HUFFMAN_MAX_CODE_LENGTH: usize = 15; + +// For current format this constant equals to kNumInsertAndCopyCodes +pub const BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE: usize = 704; + +// Maximum possible Huffman table size for an alphabet size of (index * 32), +// max code length 15 and root table bits 8. +// pub const kMaxHuffmanTableSize : [u16;23] = [ +// 256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822, +// 854, 886, 920, 952, 984, 1016, 1048, 1080, 1112, 1144,1176,1208,1240,272, +// 1304, 1336, 1368, 1400, 1432, 1464, 1496, 1528]; +// pub const BROTLI_HUFFMAN_MAX_SIZE_26 : u32 = 396; +// pub const BROTLI_HUFFMAN_MAX_SIZE_258 : u32 = 632; +// pub const BROTLI_HUFFMAN_MAX_SIZE_272 : u32 = 646; +// +pub const BROTLI_HUFFMAN_MAX_TABLE_SIZE: u32 = 1080; +pub const BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH: u32 = 5; + +#[repr(C)] +#[derive(PartialEq, Copy, Clone, Debug)] +pub struct HuffmanCode { + pub value: u16, // symbol value or table offset + pub bits: u8, // number of bits used for this symbol +} + +impl HuffmanCode { + pub fn eq(&self, other: &Self) -> bool { + self.value == other.value && self.bits == other.bits + } +} + +impl Default for HuffmanCode { + fn default() -> Self { + HuffmanCode { + value: 0, + bits: 0, + } + } +} + +// Contains a collection of Huffman trees with the same alphabet size. +pub struct HuffmanTreeGroup<Alloc32: Allocator<u32>, AllocHC: Allocator<HuffmanCode>> { + pub htrees: Alloc32::AllocatedMemory, + pub codes: AllocHC::AllocatedMemory, + pub alphabet_size: u16, + pub max_symbol: u16, + pub num_htrees: u16, +} + +impl<AllocU32 : alloc::Allocator<u32>, + AllocHC : alloc::Allocator<HuffmanCode> > HuffmanTreeGroup<AllocU32, AllocHC> { + pub fn init(self : &mut Self, mut alloc_u32 : &mut AllocU32, mut alloc_hc : &mut AllocHC, + alphabet_size : u16, max_symbol: u16, ntrees : u16) { + self.reset(&mut alloc_u32, &mut alloc_hc); + self.alphabet_size = alphabet_size; + self.max_symbol = max_symbol; + self.num_htrees = ntrees; + let nt = ntrees as usize; + let _ = core::mem::replace(&mut self.htrees, + alloc_u32.alloc_cell(nt)); + let _ = core::mem::replace(&mut self.codes, + alloc_hc.alloc_cell(nt * BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize)); + } + +// pub fn get_tree_mut<'a>(self :&'a mut Self, index : u32, mut tree_out : &'a mut [HuffmanCode]) { +// let start : usize = fast!((self.htrees)[index as usize]) as usize; +// let _ = core::mem::replace(&mut tree_out, fast_mut!((self.codes.slice_mut())[start;])); +// } +// pub fn get_tree<'a>(self :&'a Self, index : u32, mut tree_out : &'a [HuffmanCode]) { +// let start : usize = fast!((self.htrees)[index as usize]) as usize; +// let _ = core::mem::replace(&mut tree_out, fast_slice!((self.codes)[start;])); +// } + #[allow(dead_code)] + pub fn get_tree_mut(&mut self, index : u32) -> &mut [HuffmanCode] { + let start : usize = fast_slice!((self.htrees)[index as usize]) as usize; + fast_mut!((self.codes.slice_mut())[start;]) + } + #[allow(dead_code)] + pub fn get_tree(&self, index : u32) -> &[HuffmanCode] { + let start : usize = fast_slice!((self.htrees)[index as usize]) as usize; + fast_slice!((self.codes)[start;]) + } + pub fn reset(self : &mut Self, alloc_u32 : &mut AllocU32, alloc_hc : &mut AllocHC) { + alloc_u32.free_cell(core::mem::replace(&mut self.htrees, + AllocU32::AllocatedMemory::default())); + alloc_hc.free_cell(core::mem::replace(&mut self.codes, + AllocHC::AllocatedMemory::default())); + +// for mut iter in self.htrees[0..self.num_htrees as usize].iter_mut() { +// if iter.slice().len() > 0 { +// alloc_hc.free_cell(core::mem::replace(&mut iter, +// AllocHC::AllocatedMemory::default())); +// } +// } + + } + pub fn build_hgroup_cache(&self) -> [&[HuffmanCode]; 256] { + let mut ret : [&[HuffmanCode]; 256] = [&[]; 256]; + let mut index : usize = 0; + for htree in self.htrees.slice() { + ret[index] = fast_slice!((&self.codes)[*htree as usize ; ]); + index += 1; + } + ret + } +} + +impl<AllocU32 : alloc::Allocator<u32>, + AllocHC : alloc::Allocator<HuffmanCode> > Default for HuffmanTreeGroup<AllocU32, AllocHC> { + fn default() -> Self { + HuffmanTreeGroup::<AllocU32, AllocHC> { + htrees : AllocU32::AllocatedMemory::default(), + codes : AllocHC::AllocatedMemory::default(), + max_symbol: 0, + alphabet_size : 0, + num_htrees : 0, + } + } +} + + + +const BROTLI_REVERSE_BITS_MAX: usize = 8; + +const BROTLI_REVERSE_BITS_BASE: u8 = 0; +const kReverseBits: [u8; (1 << BROTLI_REVERSE_BITS_MAX)] = + [0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, + 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, + 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, + 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, + 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, + 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, + 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, + 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, + 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, + 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, + 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, + 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, + 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, + 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, + 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, + 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF]; + +const BROTLI_REVERSE_BITS_LOWEST: u32 = + (1u32 << (BROTLI_REVERSE_BITS_MAX as u32 - 1 + BROTLI_REVERSE_BITS_BASE as u32)); + +// Returns reverse(num >> BROTLI_REVERSE_BITS_BASE, BROTLI_REVERSE_BITS_MAX), +// where reverse(value, len) is the bit-wise reversal of the len least +// significant bits of value. +fn BrotliReverseBits(num: u32) -> u32 { + fast!((kReverseBits)[num as usize]) as u32 +} + +// Stores code in table[0], table[step], table[2*step], ..., table[end] +// Assumes that end is an integer multiple of step +fn ReplicateValue(table: &mut [HuffmanCode], + offset: u32, + step: i32, + mut end: i32, + code: HuffmanCode) { + loop { + end -= step; + fast_mut!((table)[offset as usize + end as usize]) = code; + if end <= 0 { + break; + } + } +} + +// Returns the table width of the next 2nd level table. count is the histogram +// of bit lengths for the remaining symbols, len is the code length of the next +// processed symbol +fn NextTableBitSize(count: &[u16], mut len: i32, root_bits: i32) -> i32 { + let mut left: i32 = 1 << (len - root_bits); + while len < BROTLI_HUFFMAN_MAX_CODE_LENGTH as i32 { + left -= fast!((count)[len as usize]) as i32; + if left <= 0 { + break; + } + len += 1; + left <<= 1; + } + len - root_bits +} + + +pub fn BrotliBuildCodeLengthsHuffmanTable(mut table: &mut [HuffmanCode], + code_lengths: &[u8], + count: &[u16]) { + let mut sorted: [i32; 18] = fast_uninitialized![18]; /* symbols sorted by code length */ + // offsets in sorted table for each length + let mut offset: [i32; (BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1) as usize] = + fast_uninitialized![(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1) as usize]; + assert!(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH as usize <= BROTLI_REVERSE_BITS_MAX as usize); + + // generate offsets into sorted symbol table by code length + let mut symbol: i32 = -1; /* symbol index in original or sorted table */ + let mut bits: i32 = 1; + for _ in 0..BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH { + symbol += fast!((count)[bits as usize]) as i32; + fast_mut!((offset)[bits as usize]) = symbol; + bits += 1; + } + // Symbols with code length 0 are placed after all other symbols. + fast_mut!((offset)[0]) = 17; + + // sort symbols by length, by symbol order within each length + symbol = 18; + loop { + for _ in 0..6 { + symbol -= 1; + let index = fast!((offset)[fast_inner!((code_lengths)[symbol as usize]) as usize]); + fast_mut!((offset)[fast_inner!((code_lengths)[symbol as usize]) as usize]) -= 1; + fast_mut!((sorted)[index as usize]) = symbol; + } + if symbol == 0 { + break; + } + } + + const table_size: i32 = 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH; + + // Special case: all symbols but one have 0 code length. + if fast!((offset)[0]) == 0 { + let code: HuffmanCode = HuffmanCode { + bits: 0, + value: fast!((sorted)[0]) as u16, + }; + for val in fast_mut!((table)[0 ; table_size as usize]).iter_mut() { + *val = code; + } + return; + } + + // fill in table + let mut key: u32 = 0; /* prefix code */ + let mut key_step: u32 = BROTLI_REVERSE_BITS_LOWEST; /* prefix code addend */ + symbol = 0; + bits = 1; + let mut step: i32 = 2; + loop { + let mut code: HuffmanCode = HuffmanCode { + bits: (bits as u8), + value: 0, + }; + let mut bits_count: i32 = fast!((count)[bits as usize]) as i32; + + while bits_count != 0 { + code.value = fast!((sorted)[symbol as usize]) as u16; + symbol += 1; + ReplicateValue(&mut table, BrotliReverseBits(key), step, table_size, code); + key += key_step; + bits_count -= 1; + } + step <<= 1; + key_step >>= 1; + bits += 1; + if !(bits <= BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH as i32) { + break; + } + } +} + +pub fn BrotliBuildHuffmanTable(mut root_table: &mut [HuffmanCode], + root_bits: i32, + symbol_lists: &[u16], + symbol_lists_offset: usize, /* need negative-index to symbol_lists */ + count: &mut [u16]) + -> u32 { + let mut code: HuffmanCode = HuffmanCode { + bits: 0, + value: 0, + }; /* current table entry */ + let mut max_length: i32 = -1; + + assert!(root_bits as isize <= BROTLI_REVERSE_BITS_MAX as isize); + assert!(BROTLI_HUFFMAN_MAX_CODE_LENGTH as isize - root_bits as isize <= + BROTLI_REVERSE_BITS_MAX as isize); + + while fast!((symbol_lists)[((symbol_lists_offset as isize) + max_length as isize) as usize]) == + 0xFFFF { + max_length -= 1; + } + max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH as i32 + 1; + + let mut table_free_offset: u32 = 0; + let mut table_bits: i32 = root_bits; /* key length of current table */ + let mut table_size: i32 = 1 << table_bits;/* size of current table */ + let mut total_size: i32 = table_size; /* sum of root table size and 2nd level table sizes */ + + // fill in root table + // let's reduce the table size to a smaller size if possible, and + // create the repetitions by memcpy if possible in the coming loop + if table_bits > max_length { + table_bits = max_length; + table_size = 1 << table_bits; + } + let mut key: u32 = 0; /* prefix code */ + let mut key_step: u32 = BROTLI_REVERSE_BITS_LOWEST; /* prefix code addend */ + let mut bits: i32 = 1; + let mut step: i32 = 2; /* step size to replicate values in current table */ + loop { + code.bits = bits as u8; + let mut symbol: i32 = bits - (BROTLI_HUFFMAN_MAX_CODE_LENGTH as i32 + 1); + let mut bits_count: i32 = fast!((count)[bits as usize]) as i32; + while bits_count != 0 { + symbol = + fast!((symbol_lists)[(symbol_lists_offset as isize + symbol as isize) as usize]) as i32; + code.value = symbol as u16; + ReplicateValue(&mut root_table, + table_free_offset + BrotliReverseBits(key), + step, + table_size, + code); + key += key_step; + bits_count -= 1; + } + step <<= 1; + key_step >>= 1; + bits += 1; + if !(bits <= table_bits) { + break; + } + } + + // if root_bits != table_bits we only created one fraction of the + // table, and we need to replicate it now. + while total_size != table_size { + for index in 0..table_size { + // FIXME: did I get this right? + fast_mut!((root_table)[table_free_offset as usize + table_size as usize + index as usize]) = + fast!((root_table)[table_free_offset as usize + index as usize]); + } + table_size <<= 1; + } + + // fill in 2nd level tables and add pointers to root table + key_step = BROTLI_REVERSE_BITS_LOWEST >> (root_bits - 1); + let mut sub_key: u32 = BROTLI_REVERSE_BITS_LOWEST << 1; /* 2nd level table prefix code */ + let mut sub_key_step: u32 = BROTLI_REVERSE_BITS_LOWEST; /* 2nd level table prefix code addend */ + + step = 2; + + let mut len: i32 = root_bits + 1; /* current code length */ + while len <= max_length { + let mut symbol: i32 = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH as i32 + 1); + while fast!((count)[len as usize]) != 0 { + if sub_key == (BROTLI_REVERSE_BITS_LOWEST << 1u32) { + table_free_offset += table_size as u32; + table_bits = NextTableBitSize(count, len, root_bits); + table_size = 1 << table_bits; + total_size += table_size; + sub_key = BrotliReverseBits(key); + key += key_step; + fast_mut!((root_table)[sub_key as usize]).bits = (table_bits + root_bits) as u8; + fast_mut!((root_table)[sub_key as usize]).value = + ((table_free_offset as usize) - sub_key as usize) as u16; + sub_key = 0; + } + code.bits = (len - root_bits) as u8; + symbol = + fast!((symbol_lists)[(symbol_lists_offset as isize + symbol as isize) as usize]) as i32; + code.value = symbol as u16; + ReplicateValue(&mut root_table, + table_free_offset + BrotliReverseBits(sub_key), + step, + table_size, + code); + sub_key += sub_key_step; + fast_mut!((count)[len as usize]) -= 1; + } + step <<= 1; + sub_key_step >>= 1; + len += 1 + } + total_size as u32 +} + + + +pub fn BrotliBuildSimpleHuffmanTable(table: &mut [HuffmanCode], + root_bits: i32, + val: &[u16], + num_symbols: u32) + -> u32 { + let mut table_size: u32 = 1; + let goal_size: u32 = 1u32 << root_bits; + assert!(num_symbols <= 4); + if num_symbols == 0 { + fast_mut!((table)[0]).bits = 0; + fast_mut!((table)[0]).value = fast!((val)[0]); + } else if num_symbols == 1 { + fast_mut!((table)[0]).bits = 1; + fast_mut!((table)[1]).bits = 1; + if fast!((val)[1]) > fast!((val)[0]) { + fast_mut!((table)[0]).value = fast!((val)[0]); + fast_mut!((table)[1]).value = fast!((val)[1]); + } else { + fast_mut!((table)[0]).value = fast!((val)[1]); + fast_mut!((table)[1]).value = fast!((val)[0]); + } + table_size = 2; + } else if num_symbols == 2 { + fast_mut!((table)[0]).bits = 1; + fast_mut!((table)[0]).value = fast!((val)[0]); + fast_mut!((table)[2]).bits = 1; + fast_mut!((table)[2]).value = fast!((val)[0]); + if fast!((val)[2]) > fast!((val)[1]) { + fast_mut!((table)[1]).value = fast!((val)[1]); + fast_mut!((table)[3]).value = fast!((val)[2]); + } else { + fast_mut!((table)[1]).value = fast!((val)[2]); + fast_mut!((table)[3]).value = fast!((val)[1]); + } + fast_mut!((table)[1]).bits = 2; + fast_mut!((table)[3]).bits = 2; + table_size = 4; + } else if num_symbols == 3 { + let last: u16 = if val.len() > 3 { fast!((val)[3]) } else { 65535 }; + let mut mval: [u16; 4] = [fast!((val)[0]), fast!((val)[1]), fast!((val)[2]), last]; + for i in 0..3 { + for k in i + 1..4 { + if mval[k] < mval[i] { + mval.swap(k, i); + } + } + } + for i in 0..4 { + fast_mut!((table)[i]).bits = 2; + } + fast_mut!((table)[0]).value = mval[0]; + fast_mut!((table)[2]).value = mval[1]; + fast_mut!((table)[1]).value = mval[2]; + fast_mut!((table)[3]).value = mval[3]; + table_size = 4; + } else if num_symbols == 4 { + let mut mval: [u16; 4] = [fast!((val)[0]), fast!((val)[1]), fast!((val)[2]), fast!((val)[3])]; + if mval[3] < mval[2] { + mval.swap(3, 2) + } + for i in 0..7 { + fast_mut!((table)[i]).value = mval[0]; + fast_mut!((table)[i]).bits = (1 + (i & 1)) as u8; + } + fast_mut!((table)[1]).value = mval[1]; + fast_mut!((table)[3]).value = mval[2]; + fast_mut!((table)[5]).value = mval[1]; + fast_mut!((table)[7]).value = mval[3]; + fast_mut!((table)[3]).bits = 3; + fast_mut!((table)[7]).bits = 3; + table_size = 8; + } else { + assert!(false); + } + while table_size != goal_size { + for index in 0..table_size { + fast_mut!((table)[(table_size + index) as usize]) = fast!((table)[index as usize]); + } + table_size <<= 1; + } + goal_size +} diff --git a/rust/vendor/brotli-decompressor/src/huffman/tests.rs b/rust/vendor/brotli-decompressor/src/huffman/tests.rs new file mode 100644 index 0000000..45969f1 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/huffman/tests.rs @@ -0,0 +1,8761 @@ +#[cfg(test)] + +use super::*; +#[test] +fn code_length_ht() { + let code_lengths: [u8; 19] = [0, 2, 3, 0, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let count: [u16; 6] = [0, 0, 3, 2, 0, 0]; + let mut table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = + [HuffmanCode { + value: 0, + bits: 0, + }; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH]; + BrotliBuildCodeLengthsHuffmanTable(&mut table, &code_lengths, &count); + let end_table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = [HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 5, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 5, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 5, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 2, + value: 1, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 3, + value: 5, + }]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn code_length_stringy_ht() { + let code_lengths: [u8; 19] = [1, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let count: [u16; 6] = [0, 1, 1, 2, 0, 0]; + let mut table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = + [HuffmanCode { + value: 0, + bits: 0, + }; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH]; + BrotliBuildCodeLengthsHuffmanTable(&mut table, &code_lengths, &count); + let end_table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = [HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 3, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 3, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 3, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 2, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 2, + value: 4, + }, + HuffmanCode { + bits: 1, + value: 0, + }, + HuffmanCode { + bits: 3, + value: 3, + }]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn code_length_single_value_ht() { + let code_lengths: [u8; 19] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let count: [u16; 6] = [0, 1, 0, 0, 0, 0]; + let mut table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = + [HuffmanCode { + value: 0, + bits: 0, + }; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH]; + BrotliBuildCodeLengthsHuffmanTable(&mut table, &code_lengths, &count); + let end_table: [HuffmanCode; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] = + [HuffmanCode { + bits: 0, + value: 9, + }; 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} + +#[test] +fn complex() { + let symbol_array: [u16; BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE] = + [65535, 65535, 65535, 72, 15, 0, 65, 5, 6, 66, 19, 65535, 65535, 65535, 65535, 65535, 1, 2, 3, + 4, 57, 16, 7, 8, 9, 10, 11, 12, 13, 14, 17, 73, 69, 18, 64, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 37, 31, 47, 34, 36, 103, 37, 36, 44, 38, 39, 40, 41, 49, 43, 46, 48, 50, 51, 50, 49, 138, + 55, 58, 68, 61, 56, 57, 62, 77, 88, 66, 76, 71, 63, 64, 67, 68, 127, 71, 117, 114, 73, 74, + 77, 76, 102, 86, 116, 255, 79, 80, 84, 82, 83, 87, 92, 93, 94, 95, 89, 90, 91, 96, 109, 117, + 102, 110, 97, 98, 99, 100, 122, 149, 115, 104, 105, 106, 107, 108, 167, 116, 111, 112, 113, + 114, 128, 118, 232, 254, 119, 120, 121, 127, 123, 142, 132, 133, 129, 129, 136, 130, 131, + 132, 133, 134, 135, 137, 224, 233, 139, 140, 141, 142, 143, 144, 162, 146, 147, 148, 169, + 157, 151, 152, 153, 154, 155, 156, 158, 181, 159, 160, 161, 162, 184, 164, 174, 180, 167, + 182, 212, 170, 171, 172, 190, 201, 175, 176, 177, 178, 179, 180, 188, 194, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 236, 207, 221, 216, 208, 209, 210, 211, 214, 213, 220, 215, 218, 217, 219, 222, 223, 234, + 227, 229, 224, 235, 226, 231, 228, 244, 230, 233, 232, 255, 253, 237, 251, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 252, 252, 253, 254, 255, 0, 23040, + 3500, 1, 0, 0, 0, 0, 0, 8192, 3500, 1, 0, 0, 0, 0, 0, 16, 0, 0, 0, 38400, 3500, 1, 0, 61712, + 21033, 32767, 0, 60189, 35058, 32767, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, + 51712, 3501, 1, 0, 15360, 0, 0, 0, 1536, 3502, 1, 0, 8192, 3500, 1, 0, 61792, 21033, 32767, + 0, 61458, 35058, 32767, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4102, 0, 0, 0, 38400, 3500, 1, 0, 0, 0, 0, + 0, 256, 0, 0, 0, 0, 0, 0, 0, 8192, 3500, 1, 0, 61792, 21033, 32767, 0, 18208, 35059, 32767, + 0, 4102, 0, 0, 65408, 65535, 0, 0, 0, 0, 0, 0, 0, 4102, 0, 0, 0, 16, 0, 0, 0, 9, 0, 0, 0, + 32768, 54143, 32705, 0, 0, 54016, 32705, 0, 0, 54016, 32705, 0, 3584, 0, 0, 0, 6, 0, 0, + 65408, 7, 3502, 32767, 0, 8192, 3500, 1, 0, 0, 54016, 32705, 0, 1, 0, 0, 0, 8192, 3500, 1, 0, + 12288, 54016, 32705, 0, 8192, 54016, 32705, 0, 61888, 21033, 32767, 0, 14237, 35059, 32767, + 0, 88, 53952, 32705, 0, 4607, 0, 0, 0, 8, 0, 0, 0, 4608, 54016, 32705, 0, 8192, 3500, 1, 0, + 8192, 3500, 1, 0, 62016, 21033, 32767, 0, 16544, 35059, 32767, 0, 4096, 0, 0, 0, 8192, 3500, + 1, 0, 61936, 21033, 32767, 0, 12502, 35059, 32767, 0, 0, 0, 0, 0, 43957, 36820, 32767, 0, 0, + 0, 0, 0, 44144, 37434, 32767, 0, 19984, 53952, 32705, 0, 0, 0, 0, 0, 62076, 21033, 32767, 0, + 62080, 21033, 32767, 0, 62084, 21033, 32767, 0, 64, 53952, 32705, 0, 65535, 65535, 65535, + 65535, 64, 0, 8296, 1, 62032, 21033, 32767, 0, 16900, 27601, 32767, 0, 18096, 27604, 32767, + 0, 0, 0, 0, 0, 62080, 21033, 32767, 0, 17447, 27601, 32767, 0, 62080, 21033, 32767, 0, 17246, + 27601, 32767, 0, 0, 0, 0, 0, 62784, 36821, 32767, 0, 62144, 21033, 32767, 0, 4085, 27601, + 32767, 0, 44624, 27603, 32767, 0, 62784, 36821, 32767, 0, 10112, 30246, 32767, 0, 46488, + 27603, 32767, 0, 18096, 27604, 32767, 0, 0, 0, 0, 0, 62256, 21033, 32767, 0, 23819, 27601, + 32767, 0, 62288, 21033, 32767, 0, 20326, 27600, 32767, 0, 15584, 36820, 32767, 0, 15096, + 36820, 32767, 0, 12288, 36820, 32767, 0, 15120, 36820, 32767, 0, 42681, 21547, 0, 0, 18096, + 27604, 32767, 0, 62400, 21033, 32767, 0, 1299, 0, 0, 0, 51315, 34237, 23510, 56320, 18096, + 27604, 32767, 0, 62400, 21033, 32767, 0, 11120, 27601, 32767, 0, 13272, 27604, 32767, 0, 28, + 0, 0, 0, 62384, 21033, 32767, 0, 10134, 27601, 32767, 0, 11072, 30235, 32767, 0, 0, 0, 50, 0]; + let mut counts: [u16; 11] = [0, 0, 0, 1, 6, 7, 4, 9, 17, 12, 60]; + let end_counts: [u16; 11] = [0, 0, 0, 1, 6, 7, 4, 9, 17, 0, 0]; + let mut table: [HuffmanCode; 328] = [HuffmanCode { + bits: 0, + value: 0, + }; 328]; + let size = BrotliBuildHuffmanTable(&mut table, 8, &symbol_array, 16, &mut counts); + assert_eq!(size, 328); + assert_eq!(counts, end_counts); + let end_table: [HuffmanCode; 328] = [HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 117, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 12, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 128, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 9, + value: 251, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 5, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 74, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 251, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 265, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 18, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 224, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 233, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 69, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 9, + value: 203, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 8, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 68, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 249, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 117, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 14, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 136, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 193, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 16, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 115, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 6, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 209, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 67, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 177, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 114, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 9, + value: 143, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 10, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 68, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 193, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 117, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 13, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 128, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 125, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 5, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 102, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 251, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 141, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 64, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 224, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 109, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 69, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 9, + value: 77, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 9, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 68, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 125, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 117, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 17, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 136, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 69, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 16, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 9, + value: 41, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 7, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 85, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 0, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 6, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 4, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 8, + value: 71, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 7, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 53, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 4, + value: 76, + }, + HuffmanCode { + bits: 7, + value: 114, + }, + HuffmanCode { + bits: 4, + value: 15, + }, + HuffmanCode { + bits: 5, + value: 57, + }, + HuffmanCode { + bits: 4, + value: 232, + }, + HuffmanCode { + bits: 9, + value: 17, + }, + HuffmanCode { + bits: 3, + value: 72, + }, + HuffmanCode { + bits: 5, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 116, + }, + HuffmanCode { + bits: 8, + value: 11, + }, + HuffmanCode { + bits: 4, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 68, + }, + HuffmanCode { + bits: 4, + value: 255, + }, + HuffmanCode { + bits: 10, + value: 69, + }, + HuffmanCode { + bits: 1, + value: 66, + }, + HuffmanCode { + bits: 1, + value: 127, + }, + HuffmanCode { + bits: 1, + value: 129, + }, + HuffmanCode { + bits: 1, + value: 130, + }, + HuffmanCode { + bits: 1, + value: 131, + }, + HuffmanCode { + bits: 1, + value: 132, + }, + HuffmanCode { + bits: 1, + value: 133, + }, + HuffmanCode { + bits: 1, + value: 134, + }, + HuffmanCode { + bits: 1, + value: 135, + }, + HuffmanCode { + bits: 1, + value: 137, + }, + HuffmanCode { + bits: 1, + value: 233, + }, + HuffmanCode { + bits: 1, + value: 253, + }, + HuffmanCode { + bits: 2, + value: 19, + }, + HuffmanCode { + bits: 2, + value: 21, + }, + HuffmanCode { + bits: 2, + value: 20, + }, + HuffmanCode { + bits: 2, + value: 22, + }, + HuffmanCode { + bits: 2, + value: 23, + }, + HuffmanCode { + bits: 2, + value: 25, + }, + HuffmanCode { + bits: 2, + value: 24, + }, + HuffmanCode { + bits: 2, + value: 26, + }, + HuffmanCode { + bits: 2, + value: 27, + }, + HuffmanCode { + bits: 2, + value: 37, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 2, + value: 38, + }, + HuffmanCode { + bits: 2, + value: 39, + }, + HuffmanCode { + bits: 2, + value: 41, + }, + HuffmanCode { + bits: 2, + value: 40, + }, + HuffmanCode { + bits: 2, + value: 49, + }, + HuffmanCode { + bits: 2, + value: 138, + }, + HuffmanCode { + bits: 2, + value: 140, + }, + HuffmanCode { + bits: 2, + value: 139, + }, + HuffmanCode { + bits: 2, + value: 141, + }, + HuffmanCode { + bits: 2, + value: 142, + }, + HuffmanCode { + bits: 2, + value: 144, + }, + HuffmanCode { + bits: 2, + value: 143, + }, + HuffmanCode { + bits: 2, + value: 162, + }, + HuffmanCode { + bits: 2, + value: 184, + }, + HuffmanCode { + bits: 2, + value: 186, + }, + HuffmanCode { + bits: 2, + value: 185, + }, + HuffmanCode { + bits: 2, + value: 187, + }, + HuffmanCode { + bits: 2, + value: 188, + }, + HuffmanCode { + bits: 2, + value: 190, + }, + HuffmanCode { + bits: 2, + value: 189, + }, + HuffmanCode { + bits: 2, + value: 191, + }, + HuffmanCode { + bits: 2, + value: 192, + }, + HuffmanCode { + bits: 2, + value: 194, + }, + HuffmanCode { + bits: 2, + value: 193, + }, + HuffmanCode { + bits: 2, + value: 195, + }, + HuffmanCode { + bits: 2, + value: 196, + }, + HuffmanCode { + bits: 2, + value: 198, + }, + HuffmanCode { + bits: 2, + value: 197, + }, + HuffmanCode { + bits: 2, + value: 199, + }, + HuffmanCode { + bits: 2, + value: 200, + }, + HuffmanCode { + bits: 2, + value: 202, + }, + HuffmanCode { + bits: 2, + value: 201, + }, + HuffmanCode { + bits: 2, + value: 203, + }, + HuffmanCode { + bits: 2, + value: 236, + }, + HuffmanCode { + bits: 2, + value: 238, + }, + HuffmanCode { + bits: 2, + value: 237, + }, + HuffmanCode { + bits: 2, + value: 239, + }, + HuffmanCode { + bits: 2, + value: 240, + }, + HuffmanCode { + bits: 2, + value: 242, + }, + HuffmanCode { + bits: 2, + value: 241, + }, + HuffmanCode { + bits: 2, + value: 243, + }, + HuffmanCode { + bits: 2, + value: 244, + }, + HuffmanCode { + bits: 2, + value: 246, + }, + HuffmanCode { + bits: 2, + value: 245, + }, + HuffmanCode { + bits: 2, + value: 247, + }, + HuffmanCode { + bits: 2, + value: 248, + }, + HuffmanCode { + bits: 2, + value: 250, + }, + HuffmanCode { + bits: 2, + value: 249, + }, + HuffmanCode { + bits: 2, + value: 252, + }]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn multilevel() { + let symbol_array: [u16; BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE] = + [65535, 65535, 65535, 65535, 0, 1, 3, 2, 6, 14, 17, 21, 65535, 65535, 65535, 65535, 72, 48, 4, + 8, 5, 73, 7, 9, 16, 10, 11, 12, 13, 20, 15, 47, 24, 22, 19, 21, 77, 41, 25, 24, 32, 26, 27, + 28, 29, 30, 31, 33, 40, 34, 35, 36, 37, 38, 39, 49, 56, 42, 43, 44, 45, 46, 57, 65, 64, 50, + 51, 52, 53, 54, 55, 71, 76, 58, 59, 60, 61, 62, 63, 97, 80, 66, 67, 68, 69, 78, 82, 75, 73, + 137, 75, 81, 96, 102, 138, 80, 88, 82, 83, 84, 85, 86, 87, 89, 112, 90, 91, 92, 93, 94, 95, + 117, 104, 98, 99, 100, 101, 105, 116, 109, 120, 106, 107, 108, 109, 110, 111, 118, 114, 122, + 115, 116, 170, 129, 121, 120, 128, 122, 123, 124, 125, 126, 127, 145, 136, 130, 131, 132, + 133, 134, 135, 140, 144, 139, 191, 216, 141, 142, 143, 169, 152, 146, 147, 148, 149, 150, + 151, 153, 160, 154, 155, 156, 157, 158, 159, 161, 168, 162, 163, 164, 165, 166, 167, 171, + 176, 193, 225, 177, 0, 0, 0, 0, 184, 178, 179, 180, 181, 182, 183, 185, 192, 186, 187, 188, + 189, 190, 209, 251, 200, 194, 195, 196, 197, 198, 199, 201, 208, 202, 203, 204, 205, 206, + 207, 217, 232, 210, 211, 212, 213, 214, 215, 226, 224, 218, 219, 220, 221, 222, 223, 241, + 248, 233, 227, 228, 229, 230, 231, 234, 240, 247, 235, 236, 237, 238, 239, 0, 255, 242, 243, + 244, 245, 246, 250, 0, 252, 0, 0, 0, 253, 254, 0, 0, 27136, 22, 1, 0, 0, 0, 0, 0, 12288, 22, + 1, 0, 0, 0, 0, 0, 16, 0, 0, 0, 42496, 22, 1, 0, 57680, 24511, 32767, 0, 60189, 35058, 32767, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 55808, 23, 1, 0, 15360, 0, 0, 0, 5632, + 24, 1, 0, 12288, 22, 1, 0, 57760, 24511, 32767, 0, 61458, 35058, 32767, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4102, 0, 0, 0, 42496, 22, 1, 0, 0, 0, 0, 0, 256, 0, 0, 0, 0, 0, 0, 0, 12288, 22, 1, 0, + 57760, 24511, 32767, 0, 18208, 35059, 32767, 0, 4102, 0, 0, 65408, 65535, 0, 0, 0, 0, 0, 0, + 0, 4102, 0, 0, 0, 16, 0, 0, 0, 9, 0, 0, 0, 32768, 255, 1, 0, 0, 128, 1, 0, 0, 128, 1, 0, + 3584, 0, 0, 0, 6, 0, 0, 65408, 7, 24, 32767, 0, 12288, 22, 1, 0, 0, 128, 1, 0, 1, 0, 0, 0, + 12288, 22, 1, 0, 12288, 128, 1, 0, 8192, 128, 1, 0, 57856, 24511, 32767, 0, 14237, 35059, + 32767, 0, 88, 32, 1, 0, 4607, 0, 0, 0, 8, 0, 0, 0, 4608, 128, 1, 0, 12288, 22, 1, 0, 12288, + 22, 1, 0, 57984, 24511, 32767, 0, 16544, 35059, 32767, 0, 4096, 0, 0, 0, 12288, 22, 1, 0, + 57904, 24511, 32767, 0, 12502, 35059, 32767, 0, 0, 0, 0, 0, 43957, 36820, 32767, 0, 0, 0, 0, + 0, 44144, 37434, 32767, 0, 19984, 32, 1, 0, 0, 0, 0, 0, 58044, 24511, 32767, 0, 58048, 24511, + 32767, 0, 58052, 24511, 32767, 0, 64, 32, 1, 0, 65535, 65535, 65535, 65535, 64, 0, 8296, 1, + 58000, 24511, 32767, 0, 4612, 24513, 32767, 0, 5784, 24516, 32767, 0, 0, 0, 0, 0, 58048, + 24511, 32767, 0, 5159, 24513, 32767, 0, 58048, 24511, 32767, 0, 4958, 24513, 32767, 0, 0, 0, + 0, 0, 62784, 36821, 32767, 0, 58112, 24511, 32767, 0, 57333, 24512, 32767, 0, 32336, 24515, + 32767, 0, 62784, 36821, 32767, 0, 10112, 30246, 32767, 0, 34200, 24515, 32767, 0, 5784, + 24516, 32767, 0, 0, 0, 0, 0, 58224, 24511, 32767, 0, 11531, 24513, 32767, 0, 58256, 24511, + 32767, 0, 8038, 24512, 32767, 0, 15584, 36820, 32767, 0, 15096, 36820, 32767, 0, 12288, + 36820, 32767, 0, 15120, 36820, 32767, 0, 42681, 21547, 0, 0, 5784, 24516, 32767, 0, 58368, + 24511, 32767, 0, 779, 0, 0, 0, 48416, 65151, 25138, 5632, 5784, 24516, 32767, 0, 58368, + 24511, 32767, 0, 64368, 24512, 32767, 0, 960, 24516, 32767, 0, 28, 0, 0, 0, 58352, 24511, + 32767, 0, 63382, 24512, 32767, 0, 11072, 30235, 32767, 0, 0, 0, 50, 0]; + let mut counts: [u16; 12] = [0, 0, 0, 0, 2, 6, 25, 12, 15, 12, 80, 88]; + let end_counts: [u16; 12] = [0, 0, 0, 0, 2, 6, 25, 12, 15, 0, 0, 0]; + let mut table: [HuffmanCode; 436] = [HuffmanCode { + bits: 0, + value: 0, + }; 436]; + let size = BrotliBuildHuffmanTable(&mut table, 8, &symbol_array, 16, &mut counts); + assert_eq!(size, 436); + assert_eq!(counts, end_counts); + let end_table: [HuffmanCode; 436] = [HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 136, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 216, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 200, + }, + HuffmanCode { + bits: 6, + value: 32, + }, + HuffmanCode { + bits: 9, + value: 259, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 168, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 8, + value: 11, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 6, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 96, + }, + HuffmanCode { + bits: 10, + value: 313, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 152, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 7, + value: 253, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 232, + }, + HuffmanCode { + bits: 6, + value: 56, + }, + HuffmanCode { + bits: 10, + value: 273, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 184, + }, + HuffmanCode { + bits: 6, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 225, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 5, + }, + HuffmanCode { + bits: 6, + value: 120, + }, + HuffmanCode { + bits: 11, + value: 341, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 144, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 248, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 6, + value: 40, + }, + HuffmanCode { + bits: 10, + value: 241, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 176, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 8, + value: 77, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 7, + value: 2, + }, + HuffmanCode { + bits: 6, + value: 104, + }, + HuffmanCode { + bits: 10, + value: 297, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 160, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 8, + value: 6, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 240, + }, + HuffmanCode { + bits: 6, + value: 76, + }, + HuffmanCode { + bits: 10, + value: 257, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 192, + }, + HuffmanCode { + bits: 6, + value: 24, + }, + HuffmanCode { + bits: 9, + value: 199, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 137, + }, + HuffmanCode { + bits: 6, + value: 128, + }, + HuffmanCode { + bits: 11, + value: 341, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 136, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 224, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 200, + }, + HuffmanCode { + bits: 6, + value: 32, + }, + HuffmanCode { + bits: 10, + value: 201, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 168, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 8, + value: 13, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 6, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 96, + }, + HuffmanCode { + bits: 10, + value: 257, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 152, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 7, + value: 254, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 232, + }, + HuffmanCode { + bits: 6, + value: 56, + }, + HuffmanCode { + bits: 10, + value: 217, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 184, + }, + HuffmanCode { + bits: 6, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 247, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 120, + }, + HuffmanCode { + bits: 11, + value: 293, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 144, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 252, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 6, + value: 40, + }, + HuffmanCode { + bits: 10, + value: 185, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 176, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 8, + value: 116, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 7, + value: 4, + }, + HuffmanCode { + bits: 6, + value: 104, + }, + HuffmanCode { + bits: 11, + value: 245, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 160, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 8, + value: 9, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 240, + }, + HuffmanCode { + bits: 6, + value: 76, + }, + HuffmanCode { + bits: 10, + value: 201, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 192, + }, + HuffmanCode { + bits: 6, + value: 24, + }, + HuffmanCode { + bits: 9, + value: 139, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 139, + }, + HuffmanCode { + bits: 6, + value: 128, + }, + HuffmanCode { + bits: 11, + value: 293, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 136, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 216, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 200, + }, + HuffmanCode { + bits: 6, + value: 32, + }, + HuffmanCode { + bits: 10, + value: 133, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 168, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 8, + value: 12, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 6, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 96, + }, + HuffmanCode { + bits: 10, + value: 189, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 152, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 7, + value: 253, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 232, + }, + HuffmanCode { + bits: 6, + value: 56, + }, + HuffmanCode { + bits: 10, + value: 149, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 184, + }, + HuffmanCode { + bits: 6, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 233, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 5, + }, + HuffmanCode { + bits: 6, + value: 120, + }, + HuffmanCode { + bits: 11, + value: 221, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 144, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 248, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 6, + value: 40, + }, + HuffmanCode { + bits: 10, + value: 117, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 176, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 8, + value: 102, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 7, + value: 2, + }, + HuffmanCode { + bits: 6, + value: 104, + }, + HuffmanCode { + bits: 11, + value: 173, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 160, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 8, + value: 7, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 240, + }, + HuffmanCode { + bits: 6, + value: 76, + }, + HuffmanCode { + bits: 10, + value: 133, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 192, + }, + HuffmanCode { + bits: 6, + value: 24, + }, + HuffmanCode { + bits: 9, + value: 73, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 137, + }, + HuffmanCode { + bits: 6, + value: 128, + }, + HuffmanCode { + bits: 11, + value: 221, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 136, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 224, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 200, + }, + HuffmanCode { + bits: 6, + value: 32, + }, + HuffmanCode { + bits: 10, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 168, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 8, + value: 20, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 6, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 96, + }, + HuffmanCode { + bits: 10, + value: 133, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 152, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 7, + value: 254, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 232, + }, + HuffmanCode { + bits: 6, + value: 56, + }, + HuffmanCode { + bits: 10, + value: 93, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 184, + }, + HuffmanCode { + bits: 6, + value: 16, + }, + HuffmanCode { + bits: 9, + value: 37, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 73, + }, + HuffmanCode { + bits: 6, + value: 120, + }, + HuffmanCode { + bits: 11, + value: 173, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 144, + }, + HuffmanCode { + bits: 5, + value: 88, + }, + HuffmanCode { + bits: 7, + value: 252, + }, + HuffmanCode { + bits: 5, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 6, + value: 40, + }, + HuffmanCode { + bits: 10, + value: 61, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 176, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 8, + value: 170, + }, + HuffmanCode { + bits: 5, + value: 64, + }, + HuffmanCode { + bits: 7, + value: 4, + }, + HuffmanCode { + bits: 6, + value: 104, + }, + HuffmanCode { + bits: 11, + value: 125, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 160, + }, + HuffmanCode { + bits: 5, + value: 112, + }, + HuffmanCode { + bits: 8, + value: 10, + }, + HuffmanCode { + bits: 5, + value: 48, + }, + HuffmanCode { + bits: 6, + value: 240, + }, + HuffmanCode { + bits: 6, + value: 76, + }, + HuffmanCode { + bits: 10, + value: 77, + }, + HuffmanCode { + bits: 4, + value: 72, + }, + HuffmanCode { + bits: 6, + value: 192, + }, + HuffmanCode { + bits: 6, + value: 24, + }, + HuffmanCode { + bits: 9, + value: 13, + }, + HuffmanCode { + bits: 5, + value: 80, + }, + HuffmanCode { + bits: 7, + value: 139, + }, + HuffmanCode { + bits: 6, + value: 128, + }, + HuffmanCode { + bits: 11, + value: 173, + }, + HuffmanCode { + bits: 1, + value: 14, + }, + HuffmanCode { + bits: 1, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 47, + }, + HuffmanCode { + bits: 1, + value: 65, + }, + HuffmanCode { + bits: 1, + value: 66, + }, + HuffmanCode { + bits: 1, + value: 67, + }, + HuffmanCode { + bits: 1, + value: 68, + }, + HuffmanCode { + bits: 1, + value: 69, + }, + HuffmanCode { + bits: 1, + value: 78, + }, + HuffmanCode { + bits: 1, + value: 138, + }, + HuffmanCode { + bits: 1, + value: 191, + }, + HuffmanCode { + bits: 1, + value: 251, + }, + HuffmanCode { + bits: 2, + value: 17, + }, + HuffmanCode { + bits: 2, + value: 25, + }, + HuffmanCode { + bits: 2, + value: 22, + }, + HuffmanCode { + bits: 2, + value: 26, + }, + HuffmanCode { + bits: 2, + value: 27, + }, + HuffmanCode { + bits: 2, + value: 29, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 2, + value: 30, + }, + HuffmanCode { + bits: 2, + value: 31, + }, + HuffmanCode { + bits: 2, + value: 34, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 2, + value: 35, + }, + HuffmanCode { + bits: 2, + value: 36, + }, + HuffmanCode { + bits: 2, + value: 38, + }, + HuffmanCode { + bits: 2, + value: 37, + }, + HuffmanCode { + bits: 2, + value: 39, + }, + HuffmanCode { + bits: 2, + value: 49, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 50, + }, + HuffmanCode { + bits: 2, + value: 52, + }, + HuffmanCode { + bits: 2, + value: 53, + }, + HuffmanCode { + bits: 2, + value: 55, + }, + HuffmanCode { + bits: 2, + value: 54, + }, + HuffmanCode { + bits: 2, + value: 71, + }, + HuffmanCode { + bits: 2, + value: 75, + }, + HuffmanCode { + bits: 2, + value: 82, + }, + HuffmanCode { + bits: 2, + value: 81, + }, + HuffmanCode { + bits: 2, + value: 83, + }, + HuffmanCode { + bits: 2, + value: 84, + }, + HuffmanCode { + bits: 2, + value: 86, + }, + HuffmanCode { + bits: 2, + value: 85, + }, + HuffmanCode { + bits: 2, + value: 87, + }, + HuffmanCode { + bits: 2, + value: 89, + }, + HuffmanCode { + bits: 2, + value: 91, + }, + HuffmanCode { + bits: 2, + value: 90, + }, + HuffmanCode { + bits: 2, + value: 92, + }, + HuffmanCode { + bits: 2, + value: 93, + }, + HuffmanCode { + bits: 2, + value: 95, + }, + HuffmanCode { + bits: 2, + value: 94, + }, + HuffmanCode { + bits: 2, + value: 117, + }, + HuffmanCode { + bits: 2, + value: 129, + }, + HuffmanCode { + bits: 2, + value: 131, + }, + HuffmanCode { + bits: 2, + value: 130, + }, + HuffmanCode { + bits: 2, + value: 132, + }, + HuffmanCode { + bits: 2, + value: 133, + }, + HuffmanCode { + bits: 2, + value: 135, + }, + HuffmanCode { + bits: 2, + value: 134, + }, + HuffmanCode { + bits: 2, + value: 140, + }, + HuffmanCode { + bits: 2, + value: 141, + }, + HuffmanCode { + bits: 2, + value: 143, + }, + HuffmanCode { + bits: 2, + value: 142, + }, + HuffmanCode { + bits: 2, + value: 169, + }, + HuffmanCode { + bits: 2, + value: 193, + }, + HuffmanCode { + bits: 2, + value: 195, + }, + HuffmanCode { + bits: 2, + value: 194, + }, + HuffmanCode { + bits: 2, + value: 196, + }, + HuffmanCode { + bits: 2, + value: 197, + }, + HuffmanCode { + bits: 2, + value: 199, + }, + HuffmanCode { + bits: 2, + value: 198, + }, + HuffmanCode { + bits: 2, + value: 201, + }, + HuffmanCode { + bits: 2, + value: 202, + }, + HuffmanCode { + bits: 2, + value: 204, + }, + HuffmanCode { + bits: 2, + value: 203, + }, + HuffmanCode { + bits: 2, + value: 205, + }, + HuffmanCode { + bits: 2, + value: 206, + }, + HuffmanCode { + bits: 2, + value: 217, + }, + HuffmanCode { + bits: 2, + value: 207, + }, + HuffmanCode { + bits: 2, + value: 218, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 221, + }, + HuffmanCode { + bits: 2, + value: 220, + }, + HuffmanCode { + bits: 2, + value: 222, + }, + HuffmanCode { + bits: 2, + value: 223, + }, + HuffmanCode { + bits: 2, + value: 242, + }, + HuffmanCode { + bits: 2, + value: 241, + }, + HuffmanCode { + bits: 2, + value: 243, + }, + HuffmanCode { + bits: 2, + value: 244, + }, + HuffmanCode { + bits: 2, + value: 246, + }, + HuffmanCode { + bits: 2, + value: 245, + }, + HuffmanCode { + bits: 2, + value: 250, + }, + HuffmanCode { + bits: 3, + value: 21, + }, + HuffmanCode { + bits: 3, + value: 44, + }, + HuffmanCode { + bits: 3, + value: 42, + }, + HuffmanCode { + bits: 3, + value: 46, + }, + HuffmanCode { + bits: 3, + value: 41, + }, + HuffmanCode { + bits: 3, + value: 45, + }, + HuffmanCode { + bits: 3, + value: 43, + }, + HuffmanCode { + bits: 3, + value: 57, + }, + HuffmanCode { + bits: 3, + value: 58, + }, + HuffmanCode { + bits: 3, + value: 62, + }, + HuffmanCode { + bits: 3, + value: 60, + }, + HuffmanCode { + bits: 3, + value: 97, + }, + HuffmanCode { + bits: 3, + value: 59, + }, + HuffmanCode { + bits: 3, + value: 63, + }, + HuffmanCode { + bits: 3, + value: 61, + }, + HuffmanCode { + bits: 3, + value: 98, + }, + HuffmanCode { + bits: 3, + value: 99, + }, + HuffmanCode { + bits: 3, + value: 106, + }, + HuffmanCode { + bits: 3, + value: 101, + }, + HuffmanCode { + bits: 3, + value: 108, + }, + HuffmanCode { + bits: 3, + value: 100, + }, + HuffmanCode { + bits: 3, + value: 107, + }, + HuffmanCode { + bits: 3, + value: 105, + }, + HuffmanCode { + bits: 3, + value: 109, + }, + HuffmanCode { + bits: 3, + value: 110, + }, + HuffmanCode { + bits: 3, + value: 122, + }, + HuffmanCode { + bits: 3, + value: 118, + }, + HuffmanCode { + bits: 3, + value: 124, + }, + HuffmanCode { + bits: 3, + value: 111, + }, + HuffmanCode { + bits: 3, + value: 123, + }, + HuffmanCode { + bits: 3, + value: 121, + }, + HuffmanCode { + bits: 3, + value: 125, + }, + HuffmanCode { + bits: 3, + value: 126, + }, + HuffmanCode { + bits: 3, + value: 147, + }, + HuffmanCode { + bits: 3, + value: 145, + }, + HuffmanCode { + bits: 3, + value: 149, + }, + HuffmanCode { + bits: 3, + value: 127, + }, + HuffmanCode { + bits: 3, + value: 148, + }, + HuffmanCode { + bits: 3, + value: 146, + }, + HuffmanCode { + bits: 3, + value: 150, + }, + HuffmanCode { + bits: 3, + value: 151, + }, + HuffmanCode { + bits: 3, + value: 156, + }, + HuffmanCode { + bits: 3, + value: 154, + }, + HuffmanCode { + bits: 3, + value: 158, + }, + HuffmanCode { + bits: 3, + value: 153, + }, + HuffmanCode { + bits: 3, + value: 157, + }, + HuffmanCode { + bits: 3, + value: 155, + }, + HuffmanCode { + bits: 3, + value: 159, + }, + HuffmanCode { + bits: 3, + value: 161, + }, + HuffmanCode { + bits: 3, + value: 165, + }, + HuffmanCode { + bits: 3, + value: 163, + }, + HuffmanCode { + bits: 3, + value: 167, + }, + HuffmanCode { + bits: 3, + value: 162, + }, + HuffmanCode { + bits: 3, + value: 166, + }, + HuffmanCode { + bits: 3, + value: 164, + }, + HuffmanCode { + bits: 3, + value: 171, + }, + HuffmanCode { + bits: 3, + value: 177, + }, + HuffmanCode { + bits: 3, + value: 181, + }, + HuffmanCode { + bits: 3, + value: 179, + }, + HuffmanCode { + bits: 3, + value: 183, + }, + HuffmanCode { + bits: 3, + value: 178, + }, + HuffmanCode { + bits: 3, + value: 182, + }, + HuffmanCode { + bits: 3, + value: 180, + }, + HuffmanCode { + bits: 3, + value: 185, + }, + HuffmanCode { + bits: 3, + value: 186, + }, + HuffmanCode { + bits: 3, + value: 190, + }, + HuffmanCode { + bits: 3, + value: 188, + }, + HuffmanCode { + bits: 3, + value: 210, + }, + HuffmanCode { + bits: 3, + value: 187, + }, + HuffmanCode { + bits: 3, + value: 209, + }, + HuffmanCode { + bits: 3, + value: 189, + }, + HuffmanCode { + bits: 3, + value: 211, + }, + HuffmanCode { + bits: 3, + value: 212, + }, + HuffmanCode { + bits: 3, + value: 226, + }, + HuffmanCode { + bits: 3, + value: 214, + }, + HuffmanCode { + bits: 3, + value: 228, + }, + HuffmanCode { + bits: 3, + value: 213, + }, + HuffmanCode { + bits: 3, + value: 227, + }, + HuffmanCode { + bits: 3, + value: 215, + }, + HuffmanCode { + bits: 3, + value: 229, + }, + HuffmanCode { + bits: 3, + value: 230, + }, + HuffmanCode { + bits: 3, + value: 236, + }, + HuffmanCode { + bits: 3, + value: 234, + }, + HuffmanCode { + bits: 3, + value: 238, + }, + HuffmanCode { + bits: 3, + value: 231, + }, + HuffmanCode { + bits: 3, + value: 237, + }, + HuffmanCode { + bits: 3, + value: 235, + }, + HuffmanCode { + bits: 3, + value: 239, + }]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } + +} +#[test] +fn singlelevel() { + let symbol_array: [u16; BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE] = + [65535, 65535, 65535, 137, 0, 16, 2, 17, 33, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1, 253, 3, 4, 5, 6, 7, 8, 9, 10, 65, 12, 13, 14, 24, 72, 32, 31, 19, 20, 21, 22, 23, 57, 26, + 26, 32, 28, 29, 30, 31, 249, 184, 34, 35, 36, 37, 38, 39, 40, 48, 42, 43, 44, 45, 46, 47, 58, + 49, 50, 51, 52, 53, 54, 55, 56, 72, 58, 59, 60, 61, 62, 63, 64, 65, 130, 67, 68, 69, 70, 71, + 77, 129, 76, 193, 192, 200, 78, 79, 80, 81, 82, 83, 84, 90, 86, 87, 88, 89, 90, 102, 92, 118, + 94, 95, 96, 97, 98, 99, 100, 101, 103, 103, 104, 105, 106, 107, 108, 115, 110, 111, 112, 113, + 114, 115, 127, 117, 253, 119, 120, 121, 122, 123, 124, 140, 204, 127, 128, 129, 131, 156, + 138, 133, 134, 135, 136, 137, 255, 139, 140, 141, 150, 143, 144, 145, 146, 147, 148, 149, + 150, 152, 152, 159, 154, 155, 156, 208, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 192, + 194, 187, 188, 213, 190, 197, 196, 200, 195, 195, 196, 197, 198, 199, 200, 235, 202, 203, + 204, 205, 206, 207, 208, 209, 224, 212, 222, 218, 236, 215, 216, 217, 240, 219, 220, 221, + 225, 223, 224, 225, 226, 227, 228, 236, 230, 231, 232, 233, 234, 241, 254, 237, 238, 239, + 240, 248, 244, 243, 246, 250, 246, 247, 251, 249, 250, 251, 252, 253, 254, 255, 0, 23040, + 3500, 1, 0, 0, 0, 0, 0, 8192, 3500, 1, 0, 0, 0, 0, 0, 16, 0, 0, 0, 38400, 3500, 1, 0, 61712, + 21033, 32767, 0, 60189, 35058, 32767, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, + 51712, 3501, 1, 0, 15360, 0, 0, 0, 1536, 3502, 1, 0, 8192, 3500, 1, 0, 61792, 21033, 32767, + 0, 61458, 35058, 32767, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4102, 0, 0, 0, 38400, 3500, 1, 0, 0, 0, 0, + 0, 256, 0, 0, 0, 0, 0, 0, 0, 8192, 3500, 1, 0, 61792, 21033, 32767, 0, 18208, 35059, 32767, + 0, 4102, 0, 0, 65408, 65535, 0, 0, 0, 0, 0, 0, 0, 4102, 0, 0, 0, 16, 0, 0, 0, 9, 0, 0, 0, + 32768, 54143, 32705, 0, 0, 54016, 32705, 0, 0, 54016, 32705, 0, 3584, 0, 0, 0, 6, 0, 0, + 65408, 7, 3502, 32767, 0, 8192, 3500, 1, 0, 0, 54016, 32705, 0, 1, 0, 0, 0, 8192, 3500, 1, 0, + 12288, 54016, 32705, 0, 8192, 54016, 32705, 0, 61888, 21033, 32767, 0, 14237, 35059, 32767, + 0, 88, 53952, 32705, 0, 4607, 0, 0, 0, 8, 0, 0, 0, 4608, 54016, 32705, 0, 8192, 3500, 1, 0, + 8192, 3500, 1, 0, 62016, 21033, 32767, 0, 16544, 35059, 32767, 0, 4096, 0, 0, 0, 8192, 3500, + 1, 0, 61936, 21033, 32767, 0, 12502, 35059, 32767, 0, 0, 0, 0, 0, 43957, 36820, 32767, 0, 0, + 0, 0, 0, 44144, 37434, 32767, 0, 19984, 53952, 32705, 0, 0, 0, 0, 0, 62076, 21033, 32767, 0, + 62080, 21033, 32767, 0, 62084, 21033, 32767, 0, 64, 53952, 32705, 0, 65535, 65535, 65535, + 65535, 64, 0, 8296, 1, 62032, 21033, 32767, 0, 16900, 27601, 32767, 0, 18096, 27604, 32767, + 0, 0, 0, 0, 0, 62080, 21033, 32767, 0, 17447, 27601, 32767, 0, 62080, 21033, 32767, 0, 17246, + 27601, 32767, 0, 0, 0, 0, 0, 62784, 36821, 32767, 0, 62144, 21033, 32767, 0, 4085, 27601, + 32767, 0, 44624, 27603, 32767, 0, 62784, 36821, 32767, 0, 10112, 30246, 32767, 0, 46488, + 27603, 32767, 0, 18096, 27604, 32767, 0, 0, 0, 0, 0, 62256, 21033, 32767, 0, 23819, 27601, + 32767, 0, 62288, 21033, 32767, 0, 20326, 27600, 32767, 0, 15584, 36820, 32767, 0, 15096, + 36820, 32767, 0, 12288, 36820, 32767, 0, 15120, 36820, 32767, 0, 42681, 21547, 0, 0, 18096, + 27604, 32767, 0, 62400, 21033, 32767, 0, 1299, 0, 0, 0, 51315, 34237, 23510, 56320, 18096, + 27604, 32767, 0, 62400, 21033, 32767, 0, 11120, 27601, 32767, 0, 13272, 27604, 32767, 0, 28, + 0, 0, 0, 62384, 21033, 32767, 0, 10134, 27601, 32767, 0, 11072, 30235, 32767, 0, 0, 0, 50, 0]; + let mut counts: [u16; 9] = [0, 0, 0, 2, 3, 7, 13, 6, 24]; + let end_counts: [u16; 9] = [0, 0, 0, 2, 3, 7, 13, 6, 24]; + let mut table: [HuffmanCode; 260] = [HuffmanCode { + bits: 0, + value: 0, + }; 260]; + let size = BrotliBuildHuffmanTable(&mut table, 8, &symbol_array, 16, &mut counts); + assert_eq!(size, 256); + assert_eq!(counts, end_counts); + let end_table: [HuffmanCode; 260] = [HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 249, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 130, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 4, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 48, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 10, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 33, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 6, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 56, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 9, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 251, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 156, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 5, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 52, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 37, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 7, + value: 17, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 7, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 138, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 250, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 130, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 4, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 50, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 10, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 35, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 6, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 129, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 9, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 252, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 156, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 5, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 54, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 39, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 7, + value: 31, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 7, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 140, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 249, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 130, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 4, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 49, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 10, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 34, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 6, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 72, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 9, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 251, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 156, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 5, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 53, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 38, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 7, + value: 17, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 7, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 139, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 8, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 250, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 130, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 4, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 51, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 10, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 2, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 36, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 208, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 6, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 131, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 184, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 9, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 5, + value: 254, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 7, + value: 252, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 200, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 6, + value: 156, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 5, + }, + HuffmanCode { + bits: 5, + value: 16, + }, + HuffmanCode { + bits: 8, + value: 55, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 192, + }, + HuffmanCode { + bits: 4, + value: 0, + }, + HuffmanCode { + bits: 6, + value: 65, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 3, + }, + HuffmanCode { + bits: 4, + value: 253, + }, + HuffmanCode { + bits: 8, + value: 40, + }, + HuffmanCode { + bits: 3, + value: 137, + }, + HuffmanCode { + bits: 5, + value: 235, + }, + HuffmanCode { + bits: 4, + value: 1, + }, + HuffmanCode { + bits: 7, + value: 31, + }, + HuffmanCode { + bits: 3, + value: 255, + }, + HuffmanCode { + bits: 6, + value: 7, + }, + HuffmanCode { + bits: 5, + value: 32, + }, + HuffmanCode { + bits: 8, + value: 141, + }, + HuffmanCode { + bits: 0, + value: 0, + }, + HuffmanCode { + bits: 0, + value: 0, + }, + HuffmanCode { + bits: 0, + value: 0, + }, + HuffmanCode { + bits: 0, + value: 0, + }]; + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn simple_0() { + let mut table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 0, + }; 256]; + let end_table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 32, + }; 256]; + let mut val: [u16; 1] = [32]; + let goal_size = BrotliBuildSimpleHuffmanTable(&mut table, 8, &mut val, 0); + assert_eq!(goal_size, 256); + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn simple_1() { + let mut table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 0, + }; 256]; + let end_table: [HuffmanCode; 256] = [HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }, + HuffmanCode { + bits: 1, + value: 146, + }, + HuffmanCode { + bits: 1, + value: 192, + }]; + let mut val: [u16; 2] = [146, 192]; + let goal_size = BrotliBuildSimpleHuffmanTable(&mut table, 8, &mut val, 1); + assert_eq!(goal_size, 256); + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} + + + + +#[test] +fn simple_2() { + let mut table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 0, + }; 256]; + let end_table: [HuffmanCode; 256] = [HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 28, + }, + HuffmanCode { + bits: 1, + value: 32, + }, + HuffmanCode { + bits: 2, + value: 33, + }]; + let mut val: [u16; 3] = [32, 28, 33]; + let goal_size = BrotliBuildSimpleHuffmanTable(&mut table, 8, &mut val, 2); + assert_eq!(goal_size, 256); + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} +#[test] +fn simple_3() { + let mut table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 0, + }; 256]; + let end_table: [HuffmanCode; 256] = [HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }, + HuffmanCode { + bits: 2, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 59, + }, + HuffmanCode { + bits: 2, + value: 51, + }, + HuffmanCode { + bits: 2, + value: 219, + }]; + let mut val: [u16; 4] = [51, 6, 59, 219]; + let goal_size = BrotliBuildSimpleHuffmanTable(&mut table, 8, &mut val, 3); + assert_eq!(goal_size, 256); + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} + + +#[test] +fn simple_4() { + let mut table: [HuffmanCode; 256] = [HuffmanCode { + bits: 0, + value: 0, + }; 256]; + let end_table: [HuffmanCode; 256] = [HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 10, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 2, + value: 118, + }, + HuffmanCode { + bits: 1, + value: 6, + }, + HuffmanCode { + bits: 3, + value: 15, + }]; + let mut val: [u16; 5] = [6, 118, 15, 10, 65535]; + let goal_size = BrotliBuildSimpleHuffmanTable(&mut table, 8, &mut val, 4); + assert_eq!(goal_size, 256); + for index in 0..end_table.len() { + assert_eq!([index, table[index].bits as usize, table[index].value as usize], + [index, end_table[index].bits as usize, end_table[index].value as usize]); + assert!(table[index] == end_table[index]); + } +} diff --git a/rust/vendor/brotli-decompressor/src/io_wrappers.rs b/rust/vendor/brotli-decompressor/src/io_wrappers.rs new file mode 100644 index 0000000..60bbe76 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/io_wrappers.rs @@ -0,0 +1,139 @@ +#[cfg(feature="std")] +use std::io::{self, ErrorKind, Read, Write}; + +/// this trait does not allow for transient errors: they must be retried in the underlying layer +pub trait CustomWrite<ErrType> { + fn write(self: &mut Self, data: &[u8]) -> Result<usize, ErrType>; + fn flush(self: &mut Self) -> Result<(), ErrType>; +} +/// this trait does not allow for transient errors: they must be retried in the underlying layer +pub trait CustomRead<ErrType> { + fn read(self: &mut Self, data: &mut [u8]) -> Result<usize, ErrType>; +} + +#[allow(dead_code)] // prefer to replace 2 inlines in BrotliDecompressCustomIo once traits work +pub fn write_all<ErrType, OutputType>(w: &mut OutputType, buf: &[u8]) -> Result<(), ErrType> + where OutputType: CustomWrite<ErrType> +{ + let mut total_written: usize = 0; + while total_written < buf.len() { + match w.write(&buf[total_written..]) { + Err(e) => return Result::Err(e), + // CustomResult::Transient(e) => continue, + Ok(cur_written) => { + assert_eq!(cur_written == 0, false); // not allowed by the contract + total_written += cur_written; + } + } + } + Ok(()) +} + +#[cfg(feature="std")] +pub struct IntoIoReader<InputType: Read>(pub InputType); + +#[cfg(feature="std")] +pub struct IntoIoWriter<InputType: Write>(pub InputType); + + +#[cfg(feature="std")] +pub struct IoWriterWrapper<'a, OutputType: Write + 'a>(pub &'a mut OutputType); + + +#[cfg(feature="std")] +pub struct IoReaderWrapper<'a, OutputType: Read + 'a>(pub &'a mut OutputType); + +#[cfg(feature="std")] +impl<'a, OutputType: Write> CustomWrite<io::Error> for IoWriterWrapper<'a, OutputType> { + fn write(self: &mut Self, buf: &[u8]) -> Result<usize, io::Error> { + loop { + match self.0.write(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_written) => return Ok(cur_written), + } + } + } + fn flush(self: &mut Self) -> Result<(), io::Error> { + loop { + match self.0.flush() { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(_) => return Ok(()), + } + } + } +} + + +#[cfg(feature="std")] +impl<'a, InputType: Read> CustomRead<io::Error> for IoReaderWrapper<'a, InputType> { + fn read(self: &mut Self, buf: &mut [u8]) -> Result<usize, io::Error> { + loop { + match self.0.read(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_read) => return Ok(cur_read), + } + } + } +} + +#[cfg(feature="std")] +impl<InputType: Read> CustomRead<io::Error> for IntoIoReader<InputType> { + fn read(self: &mut Self, buf: &mut [u8]) -> Result<usize, io::Error> { + loop { + match self.0.read(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_read) => return Ok(cur_read), + } + } + } +} + +#[cfg(feature="std")] +impl<InputType: Write> CustomWrite<io::Error> for IntoIoWriter<InputType> { + fn flush(self: &mut Self) -> Result<(), io::Error> { + loop { + match self.0.flush() { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(_) => return Ok(()), + } + } + } + fn write(self: &mut Self, buf: &[u8]) -> Result<usize, io::Error> { + loop { + match self.0.write(buf) { + Err(e) => { + match e.kind() { + ErrorKind::Interrupted => continue, + _ => return Err(e), + } + } + Ok(cur_written) => return Ok(cur_written), + } + } + } +} diff --git a/rust/vendor/brotli-decompressor/src/lib.rs b/rust/vendor/brotli-decompressor/src/lib.rs new file mode 100755 index 0000000..1dfea60 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/lib.rs @@ -0,0 +1,460 @@ +#![no_std] +#![allow(non_snake_case)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![cfg_attr(feature="no-stdlib-ffi-binding",cfg_attr(not(feature="std"), feature(lang_items)))] +#![cfg_attr(feature="no-stdlib-ffi-binding",cfg_attr(not(feature="std"), feature(panic_handler)))] + + +#[macro_use] +// <-- for debugging, remove xprintln from bit_reader and replace with println +#[cfg(feature="std")] +extern crate std; +#[cfg(feature="std")] +use std::io::{self, Error, ErrorKind, Read, Write}; +#[cfg(feature="std")] +extern crate alloc_stdlib; +#[macro_use] +extern crate alloc_no_stdlib as alloc; +pub use alloc::{AllocatedStackMemory, Allocator, SliceWrapper, SliceWrapperMut, StackAllocator, bzero}; +use core::ops; + +#[cfg(feature="std")] +pub use alloc_stdlib::StandardAlloc; +#[cfg(all(feature="unsafe",feature="std"))] +pub use alloc_stdlib::HeapAlloc; +#[macro_use] +mod memory; +pub mod dictionary; +mod brotli_alloc; +#[macro_use] +mod bit_reader; +mod huffman; +mod state; +mod prefix; +mod context; +pub mod transform; +mod test; +mod decode; +pub mod io_wrappers; +pub mod reader; +pub mod writer; +pub use huffman::{HuffmanCode, HuffmanTreeGroup}; +pub use state::BrotliState; +pub mod ffi; +pub use reader::{DecompressorCustomIo}; + +#[cfg(feature="std")] +pub use reader::{Decompressor}; + +pub use writer::{DecompressorWriterCustomIo}; +#[cfg(feature="std")] +pub use writer::{DecompressorWriter}; + +// use io_wrappers::write_all; +pub use io_wrappers::{CustomRead, CustomWrite}; +#[cfg(feature="std")] +pub use io_wrappers::{IntoIoReader, IoReaderWrapper, IntoIoWriter, IoWriterWrapper}; + +// interface +// pub fn BrotliDecompressStream(mut available_in: &mut usize, +// input_offset: &mut usize, +// input: &[u8], +// mut available_out: &mut usize, +// mut output_offset: &mut usize, +// mut output: &mut [u8], +// mut total_out: &mut usize, +// mut s: &mut BrotliState<AllocU8, AllocU32, AllocHC>); + +pub use decode::{BrotliDecompressStream, BrotliResult, BrotliDecoderHasMoreOutput, BrotliDecoderIsFinished, BrotliDecoderTakeOutput}; + + + + +#[cfg(not(any(feature="unsafe", not(feature="std"))))] +pub fn BrotliDecompress<InputType, OutputType>(r: &mut InputType, + w: &mut OutputType) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + let mut input_buffer: [u8; 4096] = [0; 4096]; + let mut output_buffer: [u8; 4096] = [0; 4096]; + BrotliDecompressCustomAlloc(r, + w, + &mut input_buffer[..], + &mut output_buffer[..], + StandardAlloc::default(), + StandardAlloc::default(), + StandardAlloc::default(), + ) +} + +#[cfg(feature="std")] +pub fn BrotliDecompressCustomDict<InputType, OutputType>(r: &mut InputType, + w: &mut OutputType, + input_buffer:&mut [u8], + output_buffer:&mut [u8], + custom_dictionary:std::vec::Vec<u8>) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + let mut alloc_u8 = brotli_alloc::BrotliAlloc::<u8>::new(); + let mut input_buffer_backing; + let mut output_buffer_backing; + { + let mut borrowed_input_buffer = input_buffer; + let mut borrowed_output_buffer = output_buffer; + if borrowed_input_buffer.len() == 0 { + input_buffer_backing = alloc_u8.alloc_cell(4096); + borrowed_input_buffer = input_buffer_backing.slice_mut(); + } + if borrowed_output_buffer.len() == 0 { + output_buffer_backing = alloc_u8.alloc_cell(4096); + borrowed_output_buffer = output_buffer_backing.slice_mut(); + } + let dict = alloc_u8.take_ownership(custom_dictionary); + BrotliDecompressCustomIoCustomDict(&mut IoReaderWrapper::<InputType>(r), + &mut IoWriterWrapper::<OutputType>(w), + borrowed_input_buffer, + borrowed_output_buffer, + alloc_u8, + brotli_alloc::BrotliAlloc::<u32>::new(), + brotli_alloc::BrotliAlloc::<HuffmanCode>::new(), + dict, + Error::new(ErrorKind::UnexpectedEof, "Unexpected EOF")) + } +} + +#[cfg(all(feature="unsafe",feature="std"))] +pub fn BrotliDecompress<InputType, OutputType>(r: &mut InputType, + w: &mut OutputType) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + let mut input_buffer: [u8; 4096] = [0; 4096]; + let mut output_buffer: [u8; 4096] = [0; 4096]; + BrotliDecompressCustomAlloc(r, + w, + &mut input_buffer[..], + &mut output_buffer[..], + HeapAlloc::<u8>::new(0), + HeapAlloc::<u32>::new(0), + HeapAlloc::<HuffmanCode>::new(HuffmanCode{ bits:2, value: 1})) +} + + +#[cfg(feature="std")] +pub fn BrotliDecompressCustomAlloc<InputType, + OutputType, + AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>> + (r: &mut InputType, + w: &mut OutputType, + input_buffer: &mut [u8], + output_buffer: &mut [u8], + alloc_u8: AllocU8, + alloc_u32: AllocU32, + alloc_hc: AllocHC) + -> Result<(), io::Error> + where InputType: Read, + OutputType: Write +{ + BrotliDecompressCustomIo(&mut IoReaderWrapper::<InputType>(r), + &mut IoWriterWrapper::<OutputType>(w), + input_buffer, + output_buffer, + alloc_u8, + alloc_u32, + alloc_hc, + Error::new(ErrorKind::UnexpectedEof, "Unexpected EOF")) +} +pub fn BrotliDecompressCustomIo<ErrType, + InputType, + OutputType, + AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>> + (r: &mut InputType, + w: &mut OutputType, + input_buffer: &mut [u8], + output_buffer: &mut [u8], + alloc_u8: AllocU8, + alloc_u32: AllocU32, + alloc_hc: AllocHC, + unexpected_eof_error_constant: ErrType) + -> Result<(), ErrType> + where InputType: CustomRead<ErrType>, + OutputType: CustomWrite<ErrType> +{ + BrotliDecompressCustomIoCustomDict(r, w, input_buffer, output_buffer, alloc_u8, alloc_u32, alloc_hc, AllocU8::AllocatedMemory::default(), unexpected_eof_error_constant) +} +pub fn BrotliDecompressCustomIoCustomDict<ErrType, + InputType, + OutputType, + AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>> + (r: &mut InputType, + w: &mut OutputType, + input_buffer: &mut [u8], + output_buffer: &mut [u8], + alloc_u8: AllocU8, + alloc_u32: AllocU32, + alloc_hc: AllocHC, + custom_dictionary: AllocU8::AllocatedMemory, + unexpected_eof_error_constant: ErrType) + -> Result<(), ErrType> + where InputType: CustomRead<ErrType>, + OutputType: CustomWrite<ErrType> +{ + let mut brotli_state = BrotliState::new_with_custom_dictionary(alloc_u8, alloc_u32, alloc_hc, custom_dictionary); + assert!(input_buffer.len() != 0); + assert!(output_buffer.len() != 0); + let mut available_out: usize = output_buffer.len(); + + let mut available_in: usize = 0; + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut result: BrotliResult = BrotliResult::NeedsMoreInput; + loop { + match result { + BrotliResult::NeedsMoreInput => { + input_offset = 0; + match r.read(input_buffer) { + Err(e) => { + return Err(e); + }, + Ok(size) => { + if size == 0 { + return Err(unexpected_eof_error_constant); + } + available_in = size; + } + } + } + BrotliResult::NeedsMoreOutput => { + let mut total_written: usize = 0; + while total_written < output_offset { + // this would be a call to write_all + match w.write(&output_buffer[total_written..output_offset]) { + Err(e) => { + return Result::Err(e); + }, + Ok(cur_written) => { + assert_eq!(cur_written == 0, false); // not allowed by the contract + total_written += cur_written; + } + } + } + + output_offset = 0; + } + BrotliResult::ResultSuccess => break, + BrotliResult::ResultFailure => { + return Err(unexpected_eof_error_constant); + } + } + let mut written: usize = 0; + result = BrotliDecompressStream(&mut available_in, + &mut input_offset, + input_buffer, + &mut available_out, + &mut output_offset, + output_buffer, + &mut written, + &mut brotli_state); + + if output_offset != 0 { + let mut total_written: usize = 0; + while total_written < output_offset { + match w.write(&output_buffer[total_written..output_offset]) { + Err(e) => { + return Result::Err(e); + }, + // CustomResult::Transient(e) => continue, + Ok(cur_written) => { + assert_eq!(cur_written == 0, false); // not allowed by the contract + total_written += cur_written; + } + } + } + output_offset = 0; + available_out = output_buffer.len() + } + } + Ok(()) +} + + +#[cfg(feature="std")] +pub fn copy_from_to<R: io::Read, W: io::Write>(mut r: R, mut w: W) -> io::Result<usize> { + let mut buffer: [u8; 65536] = [0; 65536]; + let mut out_size: usize = 0; + loop { + match r.read(&mut buffer[..]) { + Err(e) => { + if let io::ErrorKind::Interrupted = e.kind() { + continue + } + return Err(e); + } + Ok(size) => { + if size == 0 { + break; + } else { + match w.write_all(&buffer[..size]) { + Err(e) => { + if let io::ErrorKind::Interrupted = e.kind() { + continue + } + return Err(e); + } + Ok(_) => out_size += size, + } + } + } + } + } + Ok(out_size) +} + +#[repr(C)] +pub struct BrotliDecoderReturnInfo { + pub decoded_size: usize, + pub error_string: [u8;256], + pub error_code: state::BrotliDecoderErrorCode, + pub result: BrotliResult, +} +impl BrotliDecoderReturnInfo { + fn new<AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>>( + state: &BrotliState<AllocU8, AllocU32, AllocHC>, + result: BrotliResult, + output_size: usize, + ) -> Self { + let mut ret = BrotliDecoderReturnInfo{ + result: result, + decoded_size: output_size, + error_code: decode::BrotliDecoderGetErrorCode(&state), + error_string: if let &Err(msg) = &state.mtf_or_error_string { + msg + } else { + [0u8;256] + }, + }; + if ret.error_string[0] == 0 { + let error_string = state::BrotliDecoderErrorStr(ret.error_code); + let to_copy = core::cmp::min(error_string.len(), ret.error_string.len() - 1); + for (dst, src) in ret.error_string[..to_copy].iter_mut().zip(error_string[..to_copy].bytes()) { + *dst = src; + } + } + ret + } +} + +declare_stack_allocator_struct!(MemPool, 512, stack); + +pub fn brotli_decode_prealloc( + input: &[u8], + mut output: &mut[u8], + scratch_u8: &mut [u8], + scratch_u32: &mut [u32], + scratch_hc: &mut [HuffmanCode], +) -> BrotliDecoderReturnInfo { + let stack_u8_allocator = MemPool::<u8>::new_allocator(scratch_u8, bzero); + let stack_u32_allocator = MemPool::<u32>::new_allocator(scratch_u32, bzero); + let stack_hc_allocator = MemPool::<HuffmanCode>::new_allocator(scratch_hc, bzero); + let mut available_out = output.len(); + let mut available_in: usize = input.len(); + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut written: usize = 0; + let mut brotli_state = + BrotliState::new(stack_u8_allocator, stack_u32_allocator, stack_hc_allocator); + let result = ::BrotliDecompressStream(&mut available_in, + &mut input_offset, + &input[..], + &mut available_out, + &mut output_offset, + &mut output, + &mut written, + &mut brotli_state); + let return_info = BrotliDecoderReturnInfo::new(&brotli_state, result.into(), output_offset); + return_info +} + +#[cfg(not(feature="std"))] +pub fn brotli_decode( + input: &[u8], + output_and_scratch: &mut[u8], +) -> BrotliDecoderReturnInfo { + let mut stack_u32_buffer = [0u32; 12 * 1024 * 6]; + let mut stack_hc_buffer = [HuffmanCode::default(); 128 * (decode::kNumInsertAndCopyCodes as usize + decode::kNumLiteralCodes as usize) + 6 * decode::kNumBlockLengthCodes as usize * huffman::BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize]; + let mut guessed_output_size = core::cmp::min( + core::cmp::max(input.len(), // shouldn't shrink too much + output_and_scratch.len() / 3), + output_and_scratch.len()); + if input.len() > 2 { + let scratch_len = output_and_scratch.len() - guessed_output_size; + if let Ok(lgwin) = decode::lg_window_size(input[0], input[1]) { + let extra_window_size = 65536 + (decode::kNumLiteralCodes + decode::kNumInsertAndCopyCodes) as usize * 256 + (1usize << lgwin.0) * 5 / 4; + if extra_window_size < scratch_len { + guessed_output_size += (scratch_len - extra_window_size) * 3/4; + } + } + } + let (mut output, mut scratch_space) = output_and_scratch.split_at_mut(guessed_output_size); + let stack_u8_allocator = MemPool::<u8>::new_allocator(&mut scratch_space, bzero); + let stack_u32_allocator = MemPool::<u32>::new_allocator(&mut stack_u32_buffer, bzero); + let stack_hc_allocator = MemPool::<HuffmanCode>::new_allocator(&mut stack_hc_buffer, bzero); + let mut available_out = output.len(); + let mut available_in: usize = input.len(); + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut written: usize = 0; + let mut brotli_state = + BrotliState::new(stack_u8_allocator, stack_u32_allocator, stack_hc_allocator); + let result = ::BrotliDecompressStream(&mut available_in, + &mut input_offset, + &input[..], + &mut available_out, + &mut output_offset, + &mut output, + &mut written, + &mut brotli_state); + let return_info = BrotliDecoderReturnInfo::new(&brotli_state, result.into(), output_offset); + return_info +} + +#[cfg(feature="std")] +pub fn brotli_decode( + input: &[u8], + mut output: &mut[u8], +) -> BrotliDecoderReturnInfo { + let mut available_out = output.len(); + let mut available_in: usize = input.len(); + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut written: usize = 0; + let mut brotli_state = + BrotliState::new(StandardAlloc::default(), StandardAlloc::default(), StandardAlloc::default()); + let result = ::BrotliDecompressStream(&mut available_in, + &mut input_offset, + &input[..], + &mut available_out, + &mut output_offset, + &mut output, + &mut written, + &mut brotli_state); + let return_info = BrotliDecoderReturnInfo::new(&brotli_state, result.into(), output_offset); + return_info +} diff --git a/rust/vendor/brotli-decompressor/src/memory.rs b/rust/vendor/brotli-decompressor/src/memory.rs new file mode 100755 index 0000000..18164bb --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/memory.rs @@ -0,0 +1,175 @@ +#![allow(unused_macros)] +// use core::slice; + +#[cfg(not(feature="unsafe"))] +macro_rules! fast_ref { + (($slice : expr)[$index: expr]) => { + &($slice)[$index] + }; +} + +#[cfg(not(feature="unsafe"))] +macro_rules! fast_inner { + (($slice : expr)[$index: expr]) => { + ($slice)[$index] + }; +} + +#[cfg(not(feature="unsafe"))] +macro_rules! fast_inner { + (($slice : expr)[$index: expr]) => { + ($slice)[$index] + }; +} + +#[cfg(not(feature="unsafe"))] +macro_rules! fast { + (($slice : expr)[$index: expr]) => { + ($slice)[$index] + }; + (($slice : expr)[$start: expr ; $end : expr]) => { + &($slice)[$start .. $end] + }; + (($slice : expr)[$start: expr ;]) => { + &($slice)[$start .. ] + }; + (($slice : expr)[; $end : expr]) => { + &($slice)[.. $end ] + }; +} + +macro_rules! fast_uninitialized { + [$size : expr] => {[0; $size]}; + [$def_value : expr ; $size : expr] => {[$def_value; $size]}; +} + +#[cfg(not(feature="unsafe"))] +macro_rules! fast_mut { + (($slice : expr)[$index: expr]) => { + ($slice)[$index] + }; + (($slice : expr)[$start: expr ; $end : expr]) => { + &mut $slice[$start..$end] + }; + (($slice : expr)[$start: expr ;]) => { + &mut $slice[$start..] + }; + (($slice : expr)[; $end : expr]) => { + &mut $slice[..$end] + }; +} + + +#[cfg(feature="unsafe")] +#[allow(unused_unsafe)] +macro_rules! fast_ref { + (($slice : expr)[$index: expr]) => { + unsafe{$slice.get_unchecked($index)} + }; +} + +#[cfg(feature="unsafe")] +macro_rules! fast_inner { + (($slice : expr)[$index: expr]) => { + *$slice.get_unchecked($index) + }; +} +// #[cfg(feature="unsafe")] +// macro_rules! fast_slice { +// (($slice : expr)[$index: expr]) => { +// unsafe{*$slice.slice().get_unchecked($index)} +// }; +// } +// +#[cfg(feature="unsafe")] +macro_rules! fast { + (($slice : expr)[$index: expr]) => { + unsafe{*$slice.get_unchecked($index)} + }; + (($slice : expr)[$start: expr ; $end : expr]) => { + unsafe{::core::slice::from_raw_parts(($slice).as_ptr().offset($start as isize), + $end - $start)} + }; + (($slice : expr)[$start: expr ;]) => { + unsafe{::core::slice::from_raw_parts(($slice).as_ptr().offset($start as isize), + $slice.len() - $start)} + }; + (($slice : expr)[; $end : expr]) => { + unsafe{::core::slice::from_raw_parts(($slice).as_ptr(), $slice.len())} + }; +} + +macro_rules! fast_slice { + (($slice : expr)[$index: expr]) => { + fast!(($slice.slice())[$index]) + }; + (($slice : expr)[$index: expr;]) => { + fast!(($slice.slice())[$index;]) + }; + (($slice : expr)[$start :expr; $end: expr]) => { + fast!(($slice.slice())[$start;$end]) + }; +} +// macro_rules! fast_slice_ref { +// (($slice : expr)[$index: expr]) => { +// fast_ref!(($slice.slice())[$index]) +// }; +// (($slice : expr)[$index: expr]) => { +// fast_ref!(($slice.slice())[$index]) +// }; +// } +// +macro_rules! fast_slice_mut { + (($slice : expr)[$index: expr]) => { + fast_mut!(($slice.slice_mut())[$index]) + }; + (($slice : expr)[$index: expr;]) => { + fast_mut!(($slice.slice_mut())[$index;]) + }; + (($slice : expr)[$start :expr;$end: expr]) => { + fast_mut!(($slice.slice_mut())[$start;$end]) + }; +} + +#[cfg(feature="unsafe")] +macro_rules! fast_mut { + (($slice : expr)[$index: expr]) => { + *unsafe{$slice.get_unchecked_mut($index)} + }; + (($slice : expr)[$start: expr ; $end : expr]) => { + unsafe{::core::slice::from_raw_parts_mut(($slice).as_mut_ptr().offset($start as isize), + $end - $start)} + }; + (($slice : expr)[$start: expr ;]) => { + unsafe{::core::slice::from_raw_parts_mut(($slice).as_mut_ptr().offset($start as isize), + $slice.len() - $start)} + }; + (($slice : expr)[; $end : expr]) => { + unsafe{::core::slice::from_raw_parts_mut(($slice).as_mut_ptr(), $slice.len())} + }; +} + +// pub fn indexk<T>(item : &[T], index : usize) -> &T { +// return &item[index]; +// return unsafe{item.get_unchecked(index)}; +// } +// +// pub fn indexm<T>(item : &mut [T], index : usize) -> &mut T { +// return &mut item[index] +// return unsafe{item.get_unchecked_mut(index)}; +// } +// +// +// pub fn slicek<T>(item : &[T], start : usize, end :usize) -> &[T] { +// return unsafe{slice::from_raw_parts(item.as_ptr().offset(start as isize), end - start)}; +// } +// +// pub fn slicem<T>(item : &mut [T], start : usize, end :usize) -> &mut [T] { +// return unsafe{slice::from_raw_parts_mut(item.as_mut_ptr().offset(start as isize), end - start)}; +// } +// +// pub fn slicemend<T>(item : &mut [T], start : usize) -> &mut [T] { +// return unsafe{slice::from_raw_parts_mut(item.as_mut_ptr().offset(start as isize), +// item.len() - start)}; +// } +// diff --git a/rust/vendor/brotli-decompressor/src/prefix.rs b/rust/vendor/brotli-decompressor/src/prefix.rs new file mode 100644 index 0000000..3d53ced --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/prefix.rs @@ -0,0 +1,5755 @@ +#![allow(non_upper_case_globals)] +// Represents the range of values belonging to a prefix code: +// [offset, offset + 2^nbits) +pub struct PrefixCodeRange { + pub offset: u16, + pub nbits: u8, +} + +pub const kBlockLengthPrefixCode: [PrefixCodeRange; 26] = [PrefixCodeRange { + offset: 1, + nbits: 2, + }, + PrefixCodeRange { + offset: 5, + nbits: 2, + }, + PrefixCodeRange { + offset: 9, + nbits: 2, + }, + PrefixCodeRange { + offset: 13, + nbits: 2, + }, + PrefixCodeRange { + offset: 17, + nbits: 3, + }, + PrefixCodeRange { + offset: 25, + nbits: 3, + }, + PrefixCodeRange { + offset: 33, + nbits: 3, + }, + PrefixCodeRange { + offset: 41, + nbits: 3, + }, + PrefixCodeRange { + offset: 49, + nbits: 4, + }, + PrefixCodeRange { + offset: 65, + nbits: 4, + }, + PrefixCodeRange { + offset: 81, + nbits: 4, + }, + PrefixCodeRange { + offset: 97, + nbits: 4, + }, + PrefixCodeRange { + offset: 113, + nbits: 5, + }, + PrefixCodeRange { + offset: 145, + nbits: 5, + }, + PrefixCodeRange { + offset: 177, + nbits: 5, + }, + PrefixCodeRange { + offset: 209, + nbits: 5, + }, + PrefixCodeRange { + offset: 241, + nbits: 6, + }, + PrefixCodeRange { + offset: 305, + nbits: 6, + }, + PrefixCodeRange { + offset: 369, + nbits: 7, + }, + PrefixCodeRange { + offset: 497, + nbits: 8, + }, + PrefixCodeRange { + offset: 753, + nbits: 9, + }, + PrefixCodeRange { + offset: 1265, + nbits: 10, + }, + PrefixCodeRange { + offset: 2289, + nbits: 11, + }, + PrefixCodeRange { + offset: 4337, + nbits: 12, + }, + PrefixCodeRange { + offset: 8433, + nbits: 13, + }, + PrefixCodeRange { + offset: 16625, + nbits: 24, + }]; + + +#[derive(Debug, Copy, Clone)] +pub struct CmdLutElement { + pub insert_len_extra_bits: u8, + pub copy_len_extra_bits: u8, + pub distance_code: i8, + pub context: u8, + pub insert_len_offset: u16, + pub copy_len_offset: u16, +} +pub const kCmdLut: [CmdLutElement; 704] = [CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0000, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0000, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0000, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0001, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0001, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0001, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0002, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0002, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0002, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0003, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0003, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0003, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0004, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0004, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0004, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0005, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0005, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0005, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0006, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0006, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0006, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x00, + insert_len_offset: 0x0008, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x01, + insert_len_offset: 0x0008, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x02, + insert_len_offset: 0x0008, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: 0, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0000, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0000, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0000, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0001, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0001, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0001, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0002, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0002, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0002, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0003, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0003, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0003, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0004, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0004, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0004, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0005, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0005, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0005, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0006, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0006, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0006, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0008, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0008, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0008, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x000a, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x000a, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x000a, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x000e, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x000e, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x000e, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0012, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0012, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0012, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x001a, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x001a, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x001a, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0022, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0022, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0022, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0032, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0032, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0032, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0042, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0042, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0042, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0062, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0062, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0062, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0000, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0001, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0002, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0003, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0004, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x00, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0005, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0006, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x01, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0008, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0082, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0082, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0082, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0142, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0142, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0142, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0242, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0242, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0242, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0442, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0442, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0442, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x0842, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x0842, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x0842, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x1842, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x1842, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x1842, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x00, + insert_len_offset: 0x5842, + copy_len_offset: 0x0002, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x01, + insert_len_offset: 0x5842, + copy_len_offset: 0x0003, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x02, + insert_len_offset: 0x5842, + copy_len_offset: 0x0004, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0005, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0006, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0007, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0008, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x00, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0009, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000a, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x02, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x000e, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0012, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x03, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x001a, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0022, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x04, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0032, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0042, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x05, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0062, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x000a, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x01, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x000c, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x000e, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x02, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0012, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0016, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x03, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x001e, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0026, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x04, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0036, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x06, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0082, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x07, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x00c2, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x08, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0142, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x09, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0242, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x0a, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0442, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x0c, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x0842, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x0e, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x1842, + copy_len_offset: 0x0846, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0046, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x05, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0066, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x06, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0086, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x07, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x00c6, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x08, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0146, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x09, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0246, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x0a, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0446, + }, + CmdLutElement { + insert_len_extra_bits: 0x18, + copy_len_extra_bits: 0x18, + distance_code: -1, + context: 0x03, + insert_len_offset: 0x5842, + copy_len_offset: 0x0846, + }]; diff --git a/rust/vendor/brotli-decompressor/src/reader.rs b/rust/vendor/brotli-decompressor/src/reader.rs new file mode 100644 index 0000000..d6b9a97 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/reader.rs @@ -0,0 +1,422 @@ +#[cfg(feature="std")] +use std::io::{self, Error, ErrorKind, Read}; +#[cfg(feature="std")] +pub use alloc_stdlib::StandardAlloc; +#[cfg(all(feature="unsafe",feature="std"))] +pub use alloc_stdlib::HeapAlloc; +pub use huffman::{HuffmanCode, HuffmanTreeGroup}; +pub use state::BrotliState; +// use io_wrappers::write_all; +pub use io_wrappers::{CustomRead, CustomWrite}; +#[cfg(feature="std")] +pub use io_wrappers::{IntoIoReader, IoReaderWrapper, IoWriterWrapper}; +pub use super::decode::{BrotliDecompressStream, BrotliResult}; +pub use alloc::{AllocatedStackMemory, Allocator, SliceWrapper, SliceWrapperMut, StackAllocator}; + +#[cfg(feature="std")] +pub struct DecompressorCustomAlloc<R: Read, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> >(DecompressorCustomIo<io::Error, + IntoIoReader<R>, + BufferType, + AllocU8, AllocU32, AllocHC>); + + +#[cfg(feature="std")] +impl<R: Read, + BufferType : SliceWrapperMut<u8>, + AllocU8, + AllocU32, + AllocHC> DecompressorCustomAlloc<R, BufferType, AllocU8, AllocU32, AllocHC> + where AllocU8 : Allocator<u8>, AllocU32 : Allocator<u32>, AllocHC : Allocator<HuffmanCode> + { + + pub fn new(r: R, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC) -> Self { + DecompressorCustomAlloc::<R, BufferType, AllocU8, AllocU32, AllocHC>( + DecompressorCustomIo::<Error, + IntoIoReader<R>, + BufferType, + AllocU8, AllocU32, AllocHC>::new(IntoIoReader::<R>(r), + buffer, + alloc_u8, alloc_u32, alloc_hc, + Error::new(ErrorKind::InvalidData, + "Invalid Data"))) + } + + pub fn new_with_custom_dictionary(r: R, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, + dict: AllocU8::AllocatedMemory) -> Self { + DecompressorCustomAlloc::<R, BufferType, AllocU8, AllocU32, AllocHC>( + DecompressorCustomIo::<Error, + IntoIoReader<R>, + BufferType, + AllocU8, AllocU32, AllocHC>::new_with_custom_dictionary(IntoIoReader::<R>(r), + buffer, + alloc_u8, alloc_u32, alloc_hc, + dict, + Error::new(ErrorKind::InvalidData, + "Invalid Data"))) + } + + pub fn get_ref(&self) -> &R { + &self.0.get_ref().0 + } + pub fn get_mut(&mut self) -> &mut R { + &mut self.0.get_mut().0 + } + pub fn into_inner(self) -> R { + self.0.into_inner().0 + } +} +#[cfg(feature="std")] +impl<R: Read, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > Read for DecompressorCustomAlloc<R, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> { + self.0.read(buf) + } +} + + +#[cfg(not(any(feature="unsafe", not(feature="std"))))] +pub struct Decompressor<R: Read>(DecompressorCustomAlloc<R, + <StandardAlloc + as Allocator<u8>>::AllocatedMemory, + StandardAlloc, + StandardAlloc, + StandardAlloc>); + + +#[cfg(not(any(feature="unsafe", not(feature="std"))))] +impl<R: Read> Decompressor<R> { + pub fn new(r: R, buffer_size: usize) -> Self { + let dict = <StandardAlloc as Allocator<u8>>::AllocatedMemory::default(); + Self::new_with_custom_dict(r, buffer_size, dict) + } + pub fn new_with_custom_dict(r: R, buffer_size: usize, dict: <StandardAlloc as Allocator<u8>>::AllocatedMemory) -> Self { + let mut alloc = StandardAlloc::default(); + let buffer = <StandardAlloc as Allocator<u8>>::alloc_cell(&mut alloc, if buffer_size == 0 {4096} else {buffer_size}); + Decompressor::<R>(DecompressorCustomAlloc::<R, + <StandardAlloc + as Allocator<u8>>::AllocatedMemory, + StandardAlloc, + StandardAlloc, + StandardAlloc>::new_with_custom_dictionary(r, + buffer, + alloc, + StandardAlloc::default(), + StandardAlloc::default(), + dict)) + } + + pub fn get_ref(&self) -> &R { + &self.0.get_ref() + } + pub fn get_mut(&mut self) -> &mut R { + &mut ((self.0).0).get_mut().0 + } + pub fn into_inner(self) -> R { + self.0.into_inner() + } +} + + +#[cfg(all(feature="unsafe", feature="std"))] +pub struct Decompressor<R: Read>(DecompressorCustomAlloc<R, + <HeapAlloc<u8> + as Allocator<u8>>::AllocatedMemory, + HeapAlloc<u8>, + HeapAlloc<u32>, + HeapAlloc<HuffmanCode> >); + + +#[cfg(all(feature="unsafe", feature="std"))] +impl<R: Read> Decompressor<R> { + pub fn new(r: R, buffer_size: usize) -> Self { + let dict = <HeapAlloc<u8> as Allocator<u8>>::AllocatedMemory::default(); + Self::new_with_custom_dictionary(r, buffer_size, dict) + } + pub fn new_with_custom_dictionary(r: R, buffer_size: usize, dict: <HeapAlloc<u8> + as Allocator<u8>>::AllocatedMemory) -> Self { + let mut alloc_u8 = HeapAlloc::<u8>::new(0); + let buffer = alloc_u8.alloc_cell(if buffer_size == 0 {4096} else {buffer_size}); + let alloc_u32 = HeapAlloc::<u32>::new(0); + let alloc_hc = HeapAlloc::<HuffmanCode>::new(HuffmanCode{ + bits:0, value: 0, + }); + Decompressor::<R>(DecompressorCustomAlloc::<R, + <HeapAlloc<u8> + as Allocator<u8>>::AllocatedMemory, + HeapAlloc<u8>, + HeapAlloc<u32>, + HeapAlloc<HuffmanCode> > + ::new_with_custom_dictionary(r, buffer, alloc_u8, alloc_u32, alloc_hc, dict)) + } + + pub fn get_ref(&self) -> &R { + self.0.get_ref() + } + pub fn get_mut(&mut self) -> &mut R { + &mut (self.0).0.get_mut().0 + } + pub fn into_inner(self) -> R { + self.0.into_inner() + } +} + + +#[cfg(feature="std")] +impl<R: Read> Read for Decompressor<R> { + fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> { + self.0.read(buf) + } +} + +pub struct DecompressorCustomIo<ErrType, + R: CustomRead<ErrType>, + BufferType: SliceWrapperMut<u8>, + AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>> +{ + input_buffer: BufferType, + total_out: usize, + input_offset: usize, + input_len: usize, + input: R, + error_if_invalid_data: Option<ErrType>, + state: BrotliState<AllocU8, AllocU32, AllocHC>, + done: bool, +} + +impl<ErrType, + R: CustomRead<ErrType>, + BufferType : SliceWrapperMut<u8>, + AllocU8, + AllocU32, + AllocHC> DecompressorCustomIo<ErrType, R, BufferType, AllocU8, AllocU32, AllocHC> + where AllocU8 : Allocator<u8>, AllocU32 : Allocator<u32>, AllocHC : Allocator<HuffmanCode> +{ + + pub fn new(r: R, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, + invalid_data_error_type : ErrType) -> Self { + let dict = AllocU8::AllocatedMemory::default(); + Self::new_with_custom_dictionary(r, buffer, alloc_u8, alloc_u32, alloc_hc, dict, invalid_data_error_type) + } + pub fn new_with_custom_dictionary(r: R, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, + dict: AllocU8::AllocatedMemory, + invalid_data_error_type : ErrType) -> Self { + DecompressorCustomIo::<ErrType, R, BufferType, AllocU8, AllocU32, AllocHC>{ + input_buffer : buffer, + total_out : 0, + input_offset : 0, + input_len : 0, + input: r, + state : BrotliState::new_with_custom_dictionary(alloc_u8, + alloc_u32, + alloc_hc, + dict), + error_if_invalid_data : Some(invalid_data_error_type), + done: false, + } + } + + pub fn get_ref(&self) -> &R { + &self.input + } + pub fn get_mut(&mut self) -> &mut R { + &mut self.input + } + pub fn into_inner(self) -> R { + match self { + DecompressorCustomIo { + input_buffer: _ib, + total_out: _to, + state: _state, + input_offset: _io, + input_len: _il, + error_if_invalid_data:_eiid, + input, + done: _done, + } =>{ + input + } + } + } + + pub fn copy_to_front(&mut self) { + let avail_in = self.input_len - self.input_offset; + if self.input_offset == self.input_buffer.slice_mut().len() { + self.input_offset = 0; + self.input_len = 0; + } else if self.input_offset + 256 > self.input_buffer.slice_mut().len() && avail_in < self.input_offset { + let (first, second) = self.input_buffer.slice_mut().split_at_mut(self.input_offset); + self.input_len -= self.input_offset; + first[0..avail_in].clone_from_slice(&second[0..avail_in]); + self.input_offset = 0; + } + } +} + +impl<ErrType, + R: CustomRead<ErrType>, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > CustomRead<ErrType> for DecompressorCustomIo<ErrType, + R, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + /// This variant of read will return Ok(number of bytes read) until the file + /// Is completed at which point it will return Ok(0). + /// However if there are additional unconsumed bytes in the buffer, it will + /// return Err(InvalidData) at that point. Otherwise it will keep returning + /// Ok(0). + /// + /// # Arguments + /// + /// * `buf` - The buffer to read into + /// + /// # Errors + /// + /// Returns Ok(0) if the file has been fully decompressed. + /// If the file has been fully decompressed but there are additional + /// non-brotli bytes in the buffer, then return an InvalidData error. + /// Also upstream errors from the reader are returned. + fn read(&mut self, buf: &mut [u8]) -> Result<usize, ErrType > { + let mut output_offset : usize = 0; + let mut avail_out = buf.len() - output_offset; + let mut avail_in = self.input_len - self.input_offset; + while avail_out == buf.len() { + match BrotliDecompressStream(&mut avail_in, + &mut self.input_offset, + &self.input_buffer.slice_mut()[..], + &mut avail_out, + &mut output_offset, + buf, + &mut self.total_out, + &mut self.state) { + BrotliResult::NeedsMoreInput => { + self.copy_to_front(); + if output_offset != 0 { + // The decompressor successfully decoded some bytes, but still requires more + // we do not wish to risk self.input.read returning an error, so instead we + // opt to return what we have and do not invoke the read trait method + return Ok(output_offset); + } + match self.input.read(&mut self.input_buffer.slice_mut()[self.input_len..]) { + Err(e) => { + return Err(e); + }, + Ok(size) => if size == 0 { + return self.error_if_invalid_data.take().map(|e| Err(e)).unwrap_or(Ok(0)); + }else { + self.input_len += size; + avail_in = self.input_len - self.input_offset; + }, + } + }, + BrotliResult::NeedsMoreOutput => { + break; + }, + BrotliResult::ResultSuccess => { + if output_offset == 0 { + if !self.done { + self.done = true; + } else if self.input_len != self.input_offset { + // Did not consume entire input; report error. + return self.error_if_invalid_data.take().map(|e| Err(e)).unwrap_or(Ok(output_offset)); + } + } + return Ok(output_offset); + } + BrotliResult::ResultFailure => return self.error_if_invalid_data.take().map(|e| Err(e)).unwrap_or(Ok(0)), + } + } + Ok(output_offset) + } +} + +#[cfg(feature="std")] +#[test] +fn test_no_vanishing_bytes() { + use std::string::ToString; + + // Output from this command: + let compressed_with_extra = b"\x8f\x02\x80\x68\x65\x6c\x6c\x6f\x0a\x03\x67\x6f\x6f\x64\x62\x79\x65\x0a"; + // Make sure that read_to_string returns the data. + let cursor = std::io::Cursor::new(compressed_with_extra); + let mut reader = super::Decompressor::new(cursor, 8000); + assert_eq!(std::io::read_to_string(&mut reader).unwrap(), "hello\n"); + + // However you can call read extra times to make sure there's no data. + let cursor = std::io::Cursor::new(compressed_with_extra); + let mut reader = super::Decompressor::new(cursor, 8000); + let mut data = std::vec::Vec::<u8>::default(); + loop { + let mut buf = [0u8;5]; + let offset = reader.read(&mut buf).unwrap(); + if offset == 0 { + break; + } + data.extend_from_slice(&buf[..offset]); + } + assert_eq!( + &data, + &['h' as u8, 'e' as u8, 'l' as u8, 'l' as u8, 'o' as u8, '\n' as u8]); + + // But calling read, one last time, results in an error because there + // were leftover bytes in the buffer. + let mut buf = [0u8;5]; + assert_eq!(reader.read(&mut buf).unwrap_err().kind(), + io::ErrorKind::InvalidData); + data.clear(); + + +} + +#[cfg(feature="std")] +#[test] +fn test_repeated_read_returns_zero() { + use std::string::ToString; + + // Output from this command: + let compressed_without_extra = b"\x8f\x02\x80\x68\x65\x6c\x6c\x6f\x0a\x03"; + // Make sure that read_to_string returns the data. + let cursor = std::io::Cursor::new(compressed_without_extra); + let mut reader = super::Decompressor::new(cursor, 8000); + assert_eq!(std::io::read_to_string(&mut reader).unwrap(), "hello\n"); + + // However you can call read extra times to make sure there's no data. + let cursor = std::io::Cursor::new(compressed_without_extra); + let mut reader = super::Decompressor::new(cursor, 8000); + let mut data = std::vec::Vec::<u8>::default(); + loop { + let mut buf = [0u8;5]; + let offset = reader.read(&mut buf).unwrap(); + if offset == 0 { + break; + } + data.extend_from_slice(&buf[..offset]); + } + assert_eq!(&data, &['h' as u8, 'e' as u8, 'l' as u8, 'l' as u8, 'o' as u8, '\n' as u8]); + let mut buf = [0u8;5]; + assert_eq!(reader.read(&mut buf).unwrap(), 0); + data.clear(); + + +} + diff --git a/rust/vendor/brotli-decompressor/src/state.rs b/rust/vendor/brotli-decompressor/src/state.rs new file mode 100644 index 0000000..e4ac242 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/state.rs @@ -0,0 +1,575 @@ +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] + + +use alloc; +use core; +use context::kContextLookup; +use bit_reader::{BrotliBitReader, BrotliGetAvailableBits, BrotliInitBitReader}; +use huffman::{BROTLI_HUFFMAN_MAX_CODE_LENGTH, BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE, + BROTLI_HUFFMAN_MAX_TABLE_SIZE, HuffmanCode, HuffmanTreeGroup}; +use alloc::SliceWrapper; + +#[allow(dead_code)] +pub enum WhichTreeGroup { + LITERAL, + INSERT_COPY, + DISTANCE, +} +#[repr(C)] +#[derive(Clone,Copy, Debug)] +pub enum BrotliDecoderErrorCode{ + BROTLI_DECODER_NO_ERROR = 0, + /* Same as BrotliDecoderResult values */ + BROTLI_DECODER_SUCCESS = 1, + BROTLI_DECODER_NEEDS_MORE_INPUT = 2, + BROTLI_DECODER_NEEDS_MORE_OUTPUT = 3, + + /* Errors caused by invalid input */ + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE = -1, + BROTLI_DECODER_ERROR_FORMAT_RESERVED = -2, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5, + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE = -6, + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE = -7, + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 = -9, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 = -10, + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM = -11, + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY = -12, + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS = -13, + BROTLI_DECODER_ERROR_FORMAT_PADDING_1 = -14, + BROTLI_DECODER_ERROR_FORMAT_PADDING_2 = -15, + BROTLI_DECODER_ERROR_FORMAT_DISTANCE = -16, + + /* -17..-18 codes are reserved */ + + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET = -19, + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS = -20, + + /* Memory allocation problems */ + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES = -21, + /* Literal = insert and distance trees together */ + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS = -22, + /* -23..-24 codes are reserved for distinct tree groups */ + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP = -25, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 = -26, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 = -27, + /* -28..-29 codes are reserved for dynamic ring-buffer allocation */ + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES = -30, + + /* "Impossible" states */ + BROTLI_DECODER_ERROR_UNREACHABLE = -31, +} + +#[derive(Debug)] +pub enum BrotliRunningState { + BROTLI_STATE_UNINITED, + BROTLI_STATE_LARGE_WINDOW_BITS, + BROTLI_STATE_INITIALIZE, + BROTLI_STATE_METABLOCK_BEGIN, + BROTLI_STATE_METABLOCK_HEADER, + BROTLI_STATE_METABLOCK_HEADER_2, + BROTLI_STATE_CONTEXT_MODES, + BROTLI_STATE_COMMAND_BEGIN, + BROTLI_STATE_COMMAND_INNER, + BROTLI_STATE_COMMAND_POST_DECODE_LITERALS, + BROTLI_STATE_COMMAND_POST_WRAP_COPY, + BROTLI_STATE_UNCOMPRESSED, + BROTLI_STATE_METADATA, + BROTLI_STATE_COMMAND_INNER_WRITE, + BROTLI_STATE_METABLOCK_DONE, + BROTLI_STATE_COMMAND_POST_WRITE_1, + BROTLI_STATE_COMMAND_POST_WRITE_2, + BROTLI_STATE_HUFFMAN_CODE_0, + BROTLI_STATE_HUFFMAN_CODE_1, + BROTLI_STATE_HUFFMAN_CODE_2, + BROTLI_STATE_HUFFMAN_CODE_3, + BROTLI_STATE_CONTEXT_MAP_1, + BROTLI_STATE_CONTEXT_MAP_2, + BROTLI_STATE_TREE_GROUP, + BROTLI_STATE_DONE, +} + +pub enum BrotliRunningMetablockHeaderState { + BROTLI_STATE_METABLOCK_HEADER_NONE, + BROTLI_STATE_METABLOCK_HEADER_EMPTY, + BROTLI_STATE_METABLOCK_HEADER_NIBBLES, + BROTLI_STATE_METABLOCK_HEADER_SIZE, + BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED, + BROTLI_STATE_METABLOCK_HEADER_RESERVED, + BROTLI_STATE_METABLOCK_HEADER_BYTES, + BROTLI_STATE_METABLOCK_HEADER_METADATA, +} +pub enum BrotliRunningUncompressedState { + BROTLI_STATE_UNCOMPRESSED_NONE, + BROTLI_STATE_UNCOMPRESSED_WRITE, +} + +pub enum BrotliRunningTreeGroupState { + BROTLI_STATE_TREE_GROUP_NONE, + BROTLI_STATE_TREE_GROUP_LOOP, +} + +pub enum BrotliRunningContextMapState { + BROTLI_STATE_CONTEXT_MAP_NONE, + BROTLI_STATE_CONTEXT_MAP_READ_PREFIX, + BROTLI_STATE_CONTEXT_MAP_HUFFMAN, + BROTLI_STATE_CONTEXT_MAP_DECODE, + BROTLI_STATE_CONTEXT_MAP_TRANSFORM, +} + +pub enum BrotliRunningHuffmanState { + BROTLI_STATE_HUFFMAN_NONE, + BROTLI_STATE_HUFFMAN_SIMPLE_SIZE, + BROTLI_STATE_HUFFMAN_SIMPLE_READ, + BROTLI_STATE_HUFFMAN_SIMPLE_BUILD, + BROTLI_STATE_HUFFMAN_COMPLEX, + BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS, +} + +pub enum BrotliRunningDecodeUint8State { + BROTLI_STATE_DECODE_UINT8_NONE, + BROTLI_STATE_DECODE_UINT8_SHORT, + BROTLI_STATE_DECODE_UINT8_LONG, +} + +pub enum BrotliRunningReadBlockLengthState { + BROTLI_STATE_READ_BLOCK_LENGTH_NONE, + BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX, +} + +pub const kLiteralContextBits: usize = 6; + +pub struct BlockTypeAndLengthState<AllocHC: alloc::Allocator<HuffmanCode>> { + pub substate_read_block_length: BrotliRunningReadBlockLengthState, + pub num_block_types: [u32; 3], + pub block_length_index: u32, + pub block_length: [u32; 3], + pub block_type_trees: AllocHC::AllocatedMemory, + pub block_len_trees: AllocHC::AllocatedMemory, + pub block_type_rb: [u32; 6], +} + +pub struct BrotliState<AllocU8: alloc::Allocator<u8>, + AllocU32: alloc::Allocator<u32>, + AllocHC: alloc::Allocator<HuffmanCode>> +{ + pub state: BrotliRunningState, + + // This counter is reused for several disjoint loops. + pub loop_counter: i32, + pub br: BrotliBitReader, + pub alloc_u8: AllocU8, + pub alloc_u32: AllocU32, + pub alloc_hc: AllocHC, + // void* memory_manager_opaque, + pub buffer: [u8; 8], + pub buffer_length: u32, + pub pos: i32, + pub max_backward_distance: i32, + pub max_backward_distance_minus_custom_dict_size: i32, + pub max_distance: i32, + pub ringbuffer_size: i32, + pub ringbuffer_mask: i32, + pub dist_rb_idx: i32, + pub dist_rb: [i32; 4], + pub ringbuffer: AllocU8::AllocatedMemory, + // pub ringbuffer_end : usize, + pub htree_command_index: u16, + pub context_lookup: &'static [u8;512], + pub context_map_slice_index: usize, + pub dist_context_map_slice_index: usize, + + pub sub_loop_counter: u32, + + // This ring buffer holds a few past copy distances that will be used by */ + // some special distance codes. + pub literal_hgroup: HuffmanTreeGroup<AllocU32, AllocHC>, + pub insert_copy_hgroup: HuffmanTreeGroup<AllocU32, AllocHC>, + pub distance_hgroup: HuffmanTreeGroup<AllocU32, AllocHC>, + // This is true if the literal context map histogram type always matches the + // block type. It is then not needed to keep the context (faster decoding). + pub trivial_literal_context: i32, + // Distance context is actual after command is decoded and before distance + // is computed. After distance computation it is used as a temporary variable + pub distance_context: i32, + pub meta_block_remaining_len: i32, + pub block_type_length_state: BlockTypeAndLengthState<AllocHC>, + pub distance_postfix_bits: u32, + pub num_direct_distance_codes: u32, + pub distance_postfix_mask: i32, + pub num_dist_htrees: u32, + pub dist_context_map: AllocU8::AllocatedMemory, + // NOT NEEDED? the index below seems to supersede it pub literal_htree : AllocHC::AllocatedMemory, + pub literal_htree_index: u8, + pub dist_htree_index: u8, + pub large_window: bool, + pub should_wrap_ringbuffer: bool, + pub error_code: BrotliDecoderErrorCode, + pub repeat_code_len: u32, + pub prev_code_len: u32, + + pub copy_length: i32, + pub distance_code: i32, + + // For partial write operations + pub rb_roundtrips: usize, // How many times we went around the ringbuffer + pub partial_pos_out: usize, // How much output to the user in total (<= rb) + + // For ReadHuffmanCode + pub symbol: u32, + pub repeat: u32, + pub space: u32, + + pub table: [HuffmanCode; 32], + // List of of symbol chains. + pub symbol_lists_index: usize, // AllocU16::AllocatedMemory, + // Storage from symbol_lists. + pub symbols_lists_array: [u16; BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE], + // Tails of symbol chains. + pub next_symbol: [i32; 32], + pub code_length_code_lengths: [u8; 18], + // Population counts for the code lengths + pub code_length_histo: [u16; 16], + + // For HuffmanTreeGroupDecode + pub htree_index: i32, + pub htree_next_offset: u32, + + // For DecodeContextMap + pub context_index: u32, + pub max_run_length_prefix: u32, + pub code: u32, + // always pre-allocated on state creation + pub context_map_table: AllocHC::AllocatedMemory, + + // For InverseMoveToFrontTransform + pub mtf_upper_bound: u32, + pub mtf_or_error_string: Result<[u8; 256], [u8; 256]>, + + // For custom dictionaries + pub custom_dict: AllocU8::AllocatedMemory, + pub custom_dict_size: i32, + // less used attributes are in the end of this struct */ + // States inside function calls + pub substate_metablock_header: BrotliRunningMetablockHeaderState, + pub substate_tree_group: BrotliRunningTreeGroupState, + pub substate_context_map: BrotliRunningContextMapState, + pub substate_uncompressed: BrotliRunningUncompressedState, + pub substate_huffman: BrotliRunningHuffmanState, + pub substate_decode_uint8: BrotliRunningDecodeUint8State, + + pub is_last_metablock: u8, + pub is_uncompressed: u8, + pub is_metadata: u8, + pub size_nibbles: u8, + pub window_bits: u32, + + pub num_literal_htrees: u32, + pub context_map: AllocU8::AllocatedMemory, + pub context_modes: AllocU8::AllocatedMemory, + pub trivial_literal_contexts: [u32; 8], +} +macro_rules! make_brotli_state { + ($alloc_u8 : expr, $alloc_u32 : expr, $alloc_hc : expr, $custom_dict : expr, $custom_dict_len: expr) => (BrotliState::<AllocU8, AllocU32, AllocHC>{ + state : BrotliRunningState::BROTLI_STATE_UNINITED, + loop_counter : 0, + br : BrotliBitReader::default(), + alloc_u8 : $alloc_u8, + alloc_u32 : $alloc_u32, + alloc_hc : $alloc_hc, + buffer : [0u8; 8], + buffer_length : 0, + pos : 0, + max_backward_distance : 0, + max_backward_distance_minus_custom_dict_size : 0, + max_distance : 0, + ringbuffer_size : 0, + ringbuffer_mask: 0, + dist_rb_idx : 0, + dist_rb : [16, 15, 11, 4], + ringbuffer : AllocU8::AllocatedMemory::default(), + htree_command_index : 0, + context_lookup : &kContextLookup[0], + context_map_slice_index : 0, + dist_context_map_slice_index : 0, + sub_loop_counter : 0, + + literal_hgroup : HuffmanTreeGroup::<AllocU32, AllocHC>::default(), + insert_copy_hgroup : HuffmanTreeGroup::<AllocU32, AllocHC>::default(), + distance_hgroup : HuffmanTreeGroup::<AllocU32, AllocHC>::default(), + trivial_literal_context : 0, + distance_context : 0, + meta_block_remaining_len : 0, + block_type_length_state : BlockTypeAndLengthState::<AllocHC> { + block_length_index : 0, + block_length : [0; 3], + num_block_types : [0;3], + block_type_rb: [0;6], + substate_read_block_length : BrotliRunningReadBlockLengthState::BROTLI_STATE_READ_BLOCK_LENGTH_NONE, + block_type_trees : AllocHC::AllocatedMemory::default(), + block_len_trees : AllocHC::AllocatedMemory::default(), + }, + distance_postfix_bits : 0, + num_direct_distance_codes : 0, + distance_postfix_mask : 0, + num_dist_htrees : 0, + dist_context_map : AllocU8::AllocatedMemory::default(), + //// not needed literal_htree : AllocHC::AllocatedMemory::default(), + literal_htree_index : 0, + dist_htree_index : 0, + repeat_code_len : 0, + prev_code_len : 0, + copy_length : 0, + distance_code : 0, + rb_roundtrips : 0, /* How many times we went around the ringbuffer */ + partial_pos_out : 0, /* How much output to the user in total (<= rb) */ + symbol : 0, + repeat : 0, + space : 0, + table : [HuffmanCode::default(); 32], + //symbol_lists: AllocU16::AllocatedMemory::default(), + symbol_lists_index : BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1, + symbols_lists_array : [0;BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE], + next_symbol : [0; 32], + code_length_code_lengths : [0; 18], + code_length_histo : [0; 16], + htree_index : 0, + htree_next_offset : 0, + + /* For DecodeContextMap */ + context_index : 0, + max_run_length_prefix : 0, + code : 0, + context_map_table : AllocHC::AllocatedMemory::default(), + + /* For InverseMoveToFrontTransform */ + mtf_upper_bound : 255, + mtf_or_error_string : Ok([0; 256]), + + /* For custom dictionaries */ + custom_dict : $custom_dict, + custom_dict_size : $custom_dict_len as i32, + + /* less used attributes are in the end of this struct */ + /* States inside function calls */ + substate_metablock_header : BrotliRunningMetablockHeaderState::BROTLI_STATE_METABLOCK_HEADER_NONE, + substate_tree_group : BrotliRunningTreeGroupState::BROTLI_STATE_TREE_GROUP_NONE, + substate_context_map : BrotliRunningContextMapState::BROTLI_STATE_CONTEXT_MAP_NONE, + substate_uncompressed : BrotliRunningUncompressedState::BROTLI_STATE_UNCOMPRESSED_NONE, + substate_huffman : BrotliRunningHuffmanState::BROTLI_STATE_HUFFMAN_NONE, + substate_decode_uint8 : BrotliRunningDecodeUint8State::BROTLI_STATE_DECODE_UINT8_NONE, + + is_last_metablock : 0, + is_uncompressed : 0, + is_metadata : 0, + size_nibbles : 0, + window_bits : 0, + large_window: false, + should_wrap_ringbuffer: false, + error_code: BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS, + num_literal_htrees : 0, + context_map : AllocU8::AllocatedMemory::default(), + context_modes : AllocU8::AllocatedMemory::default(), + trivial_literal_contexts : [0u32; 8], + } + ); +} +impl <'brotli_state, + AllocU8 : alloc::Allocator<u8>, + AllocU32 : alloc::Allocator<u32>, + AllocHC : alloc::Allocator<HuffmanCode> > BrotliState<AllocU8, AllocU32, AllocHC> { + pub fn new(alloc_u8 : AllocU8, + alloc_u32 : AllocU32, + alloc_hc : AllocHC) -> Self{ + let mut retval = make_brotli_state!(alloc_u8, alloc_u32, alloc_hc, AllocU8::AllocatedMemory::default(), 0); + retval.large_window = true; + retval.context_map_table = retval.alloc_hc.alloc_cell( + BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize); + BrotliInitBitReader(&mut retval.br); + retval + } + pub fn new_with_custom_dictionary(alloc_u8 : AllocU8, + alloc_u32 : AllocU32, + alloc_hc : AllocHC, + custom_dict: AllocU8::AllocatedMemory) -> Self{ + let custom_dict_len = custom_dict.slice().len(); + let mut retval = make_brotli_state!(alloc_u8, alloc_u32, alloc_hc, custom_dict, custom_dict_len); + retval.context_map_table = retval.alloc_hc.alloc_cell( + BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize); + retval.large_window = true; + BrotliInitBitReader(&mut retval.br); + retval + } + pub fn new_strict(alloc_u8 : AllocU8, + alloc_u32 : AllocU32, + alloc_hc : AllocHC) -> Self{ + let mut retval = make_brotli_state!(alloc_u8, alloc_u32, alloc_hc, AllocU8::AllocatedMemory::default(), 0); + retval.context_map_table = retval.alloc_hc.alloc_cell( + BROTLI_HUFFMAN_MAX_TABLE_SIZE as usize); + retval.large_window = false; + BrotliInitBitReader(&mut retval.br); + retval + } + pub fn BrotliStateMetablockBegin(self : &mut Self) { + self.meta_block_remaining_len = 0; + self.block_type_length_state.block_length[0] = 1u32 << 24; + self.block_type_length_state.block_length[1] = 1u32 << 24; + self.block_type_length_state.block_length[2] = 1u32 << 24; + self.block_type_length_state.num_block_types[0] = 1; + self.block_type_length_state.num_block_types[1] = 1; + self.block_type_length_state.num_block_types[2] = 1; + self.block_type_length_state.block_type_rb[0] = 1; + self.block_type_length_state.block_type_rb[1] = 0; + self.block_type_length_state.block_type_rb[2] = 1; + self.block_type_length_state.block_type_rb[3] = 0; + self.block_type_length_state.block_type_rb[4] = 1; + self.block_type_length_state.block_type_rb[5] = 0; + self.alloc_u8.free_cell(core::mem::replace(&mut self.context_map, + AllocU8::AllocatedMemory::default())); + self.alloc_u8.free_cell(core::mem::replace(&mut self.context_modes, + AllocU8::AllocatedMemory::default())); + self.alloc_u8.free_cell(core::mem::replace(&mut self.dist_context_map, + AllocU8::AllocatedMemory::default())); + self.context_map_slice_index = 0; + self.literal_htree_index = 0; + self.dist_context_map_slice_index = 0; + self.dist_htree_index = 0; + self.context_lookup = &kContextLookup[0]; + self.literal_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + self.insert_copy_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + self.distance_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + } + pub fn BrotliStateCleanupAfterMetablock(self : &mut Self) { + self.alloc_u8.free_cell(core::mem::replace(&mut self.context_map, + AllocU8::AllocatedMemory::default())); + self.alloc_u8.free_cell(core::mem::replace(&mut self.context_modes, + AllocU8::AllocatedMemory::default())); + self.alloc_u8.free_cell(core::mem::replace(&mut self.dist_context_map, + AllocU8::AllocatedMemory::default())); + + + self.literal_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + self.insert_copy_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + self.distance_hgroup.reset(&mut self.alloc_u32, &mut self.alloc_hc); + } + + fn BrotliStateCleanup(self : &mut Self) { + self.BrotliStateCleanupAfterMetablock(); + self.alloc_u8.free_cell(core::mem::replace(&mut self.ringbuffer, + AllocU8::AllocatedMemory::default())); + self.alloc_hc.free_cell(core::mem::replace(&mut self.block_type_length_state.block_type_trees, + AllocHC::AllocatedMemory::default())); + self.alloc_hc.free_cell(core::mem::replace(&mut self.block_type_length_state.block_len_trees, + AllocHC::AllocatedMemory::default())); + self.alloc_hc.free_cell(core::mem::replace(&mut self.context_map_table, + AllocHC::AllocatedMemory::default())); + self.alloc_u8.free_cell(core::mem::replace(&mut self.custom_dict, + AllocU8::AllocatedMemory::default())); + + //FIXME?? BROTLI_FREE(s, s->legacy_input_buffer); + //FIXME?? BROTLI_FREE(s, s->legacy_output_buffer); + } + + pub fn BrotliStateIsStreamStart(self : &Self) -> bool { + match self.state { + BrotliRunningState::BROTLI_STATE_UNINITED => + BrotliGetAvailableBits(&self.br) == 0, + _ => false, + } + } + + pub fn BrotliStateIsStreamEnd(self : &Self) -> bool { + match self.state { + BrotliRunningState::BROTLI_STATE_DONE => true, + _ => false + } + } + pub fn BrotliHuffmanTreeGroupInit(self :&mut Self, group : WhichTreeGroup, + alphabet_size : u16, max_symbol: u16, ntrees : u16) { + match group { + WhichTreeGroup::LITERAL => self.literal_hgroup.init(&mut self.alloc_u32, + &mut self.alloc_hc, + alphabet_size, max_symbol, ntrees), + WhichTreeGroup::INSERT_COPY => self.insert_copy_hgroup.init(&mut self.alloc_u32, + &mut self.alloc_hc, + alphabet_size, max_symbol, ntrees), + WhichTreeGroup::DISTANCE => self.distance_hgroup.init(&mut self.alloc_u32, + &mut self.alloc_hc, + alphabet_size, max_symbol, ntrees), + } + } + pub fn BrotliHuffmanTreeGroupRelease(self :&mut Self, group : WhichTreeGroup) { + match group { + WhichTreeGroup::LITERAL => self.literal_hgroup.reset(&mut self.alloc_u32, + &mut self.alloc_hc), + WhichTreeGroup::INSERT_COPY => self.insert_copy_hgroup.reset(&mut self.alloc_u32, + &mut self.alloc_hc), + WhichTreeGroup::DISTANCE => self.distance_hgroup.reset(&mut self.alloc_u32, + &mut self.alloc_hc), + } + } +} + +impl <'brotli_state, + AllocU8 : alloc::Allocator<u8>, + AllocU32 : alloc::Allocator<u32>, + AllocHC : alloc::Allocator<HuffmanCode> > Drop for BrotliState<AllocU8, AllocU32, AllocHC> { + fn drop(&mut self) { + self.BrotliStateCleanup(); + } +} + + + +pub fn BrotliDecoderErrorStr(c: BrotliDecoderErrorCode) -> &'static str { + match c { + BrotliDecoderErrorCode::BROTLI_DECODER_NO_ERROR => "NO_ERROR\0", + /* Same as BrotliDecoderResult values */ + BrotliDecoderErrorCode::BROTLI_DECODER_SUCCESS => "SUCCESS\0", + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_INPUT => "NEEDS_MORE_INPUT\0", + BrotliDecoderErrorCode::BROTLI_DECODER_NEEDS_MORE_OUTPUT => "NEEDS_MORE_OUTPUT\0", + + /* Errors caused by invalid input */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE => "ERROR_FORMAT_EXUBERANT_NIBBLE\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_RESERVED => "ERROR_FORMAT_RESERVED\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE => "ERROR_FORMAT_EXUBERANT_META_NIBBLE\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET => "ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME => "ERROR_FORMAT_SIMPLE_HUFFMAN_SAME\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_CL_SPACE => "ERROR_FORMAT_FL_SPACE\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE => "ERROR_FORMAT_HUFFMAN_SPACE\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT => "ERROR_FORMAT_CONTEXT_MAP_REPEAT\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 =>"ERROR_FORMAT_BLOCK_LENGTH_1\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 =>"ERROR_FORMAT_BLOCK_LENGTH_2\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_TRANSFORM => "ERROR_FORMAT_TRANSFORM\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_DICTIONARY =>"ERROR_FORMAT_DICTIONARY\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS =>"ERROR_FORMAT_WINDOW_BITS\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_PADDING_1 =>"ERROR_FORMAT_PADDING_1\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_PADDING_2 =>"ERROR_FORMAT_PADDING_2\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_FORMAT_DISTANCE =>"ERROR_FORMAT_DISTANCE\0", + + /* -17..-18 codes are reserved */ + + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET => "ERROR_DICTIONARY_NOT_SET\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_INVALID_ARGUMENTS => "ERROR_INVALID_ARGUMENTS\0", + + /* Memory allocation problems */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES => "ERROR_ALLOC_CONTEXT_MODES\0", + /* Literal => insert and distance trees together */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS => "ERROR_ALLOC_TREE_GROUPS\0", + /* -23..-24 codes are reserved for distinct tree groups */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP => "ERROR_ALLOC_CONTEXT_MAP\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 => "ERROR_ALLOC_RING_BUFFER_1\0", + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 => "ERROR_ALLOC_RING_BUFFER_2\0", + /* -28..-29 codes are reserved for dynamic ring-buffer allocation */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES => "ERROR_ALLOC_BLOCK_TYPE_TREES\0", + + /* "Impossible" states */ + BrotliDecoderErrorCode::BROTLI_DECODER_ERROR_UNREACHABLE => "ERROR_UNREACHABLE\0", + } +} diff --git a/rust/vendor/brotli-decompressor/src/test.rs b/rust/vendor/brotli-decompressor/src/test.rs new file mode 100644 index 0000000..3e41e02 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/test.rs @@ -0,0 +1,270 @@ +#![cfg(test)] + +extern crate alloc_no_stdlib as alloc; +use alloc::{AllocatedStackMemory, Allocator, SliceWrapper, SliceWrapperMut, StackAllocator, bzero}; +#[cfg(feature="std")] +use std::vec::Vec; +#[cfg(feature="std")] +use std::io; + +use core::ops; + + +pub use super::{BrotliDecompressStream, BrotliResult, BrotliState, HuffmanCode}; + +declare_stack_allocator_struct!(MemPool, 4096, stack); + + + +fn oneshot(input: &mut [u8], mut output: &mut [u8]) -> (BrotliResult, usize, usize) { + let mut available_out: usize = output.len(); + let mut stack_u8_buffer = define_allocator_memory_pool!(4096, u8, [0; 300 * 1024], stack); + let mut stack_u32_buffer = define_allocator_memory_pool!(4096, u32, [0; 12 * 1024], stack); + let mut stack_hc_buffer = define_allocator_memory_pool!(4096, + super::HuffmanCode, + [HuffmanCode::default(); 18 * 1024], + stack); + let stack_u8_allocator = MemPool::<u8>::new_allocator(&mut stack_u8_buffer, bzero); + let stack_u32_allocator = MemPool::<u32>::new_allocator(&mut stack_u32_buffer, bzero); + let stack_hc_allocator = MemPool::<HuffmanCode>::new_allocator(&mut stack_hc_buffer, bzero); + let mut available_in: usize = input.len(); + let mut input_offset: usize = 0; + let mut output_offset: usize = 0; + let mut written: usize = 0; + let mut brotli_state = + BrotliState::new(stack_u8_allocator, stack_u32_allocator, stack_hc_allocator); + let result = BrotliDecompressStream(&mut available_in, + &mut input_offset, + &input[..], + &mut available_out, + &mut output_offset, + &mut output, + &mut written, + &mut brotli_state); + return (result, input_offset, output_offset); +} + +#[test] +fn test_10x10y() { + const BUFFER_SIZE: usize = 2048; + let mut input: [u8; 12] = [0x1b, 0x13, 0x00, 0x00, 0xa4, 0xb0, 0xb2, 0xea, 0x81, 0x47, 0x02, + 0x8a]; + let mut output = [0u8; BUFFER_SIZE]; + let (result, input_offset, output_offset) = oneshot(&mut input[..], &mut output[..]); + match result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + let mut i: usize = 0; + while i < 10 { + assert_eq!(output[i], 'X' as u8); + assert_eq!(output[i + 10], 'Y' as u8); + i += 1; + } + assert_eq!(output_offset, 20); + assert_eq!(input_offset, input.len()); +} + + + +#[test] +fn test_x() { + const BUFFER_SIZE: usize = 128; + let mut input: [u8; 5] = [0x0b, 0x00, 0x80, 0x58, 0x03]; + let mut output = [0u8; BUFFER_SIZE]; + let (result, input_offset, output_offset) = oneshot(&mut input[..], &mut output[..]); + match result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + assert_eq!(output[0], 'X' as u8); + assert_eq!(output_offset, 1); + assert_eq!(input_offset, input.len()); +} + +#[test] +fn test_empty() { + const BUFFER_SIZE: usize = 128; + let mut input: [u8; 1] = [0x06]; + let mut output = [0u8; BUFFER_SIZE]; + let (result, input_offset, output_offset) = oneshot(&mut input[..], &mut output[..]); + match result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + assert_eq!(output_offset, 0); + assert_eq!(input_offset, input.len()); +} +const QF_BUFFER_SIZE: usize = 180 * 1024; +static mut quick_fox_output: [u8; QF_BUFFER_SIZE] = [0u8; QF_BUFFER_SIZE]; + +#[test] +fn test_quickfox_repeated_custom() { + let mut input: [u8; 58] = + [0x5B, 0xFF, 0xAF, 0x02, 0xC0, 0x22, 0x79, 0x5C, 0xFB, 0x5A, 0x8C, 0x42, 0x3B, 0xF4, 0x25, + 0x55, 0x19, 0x5A, 0x92, 0x99, 0xB1, 0x35, 0xC8, 0x19, 0x9E, 0x9E, 0x0A, 0x7B, 0x4B, 0x90, + 0xB9, 0x3C, 0x98, 0xC8, 0x09, 0x40, 0xF3, 0xE6, 0xD9, 0x4D, 0xE4, 0x6D, 0x65, 0x1B, 0x27, + 0x87, 0x13, 0x5F, 0xA6, 0xE9, 0x30, 0x96, 0x7B, 0x3C, 0x15, 0xD8, 0x53, 0x1C]; + + let (result, input_offset, output_offset) = oneshot(&mut input[..], &mut unsafe{&mut quick_fox_output[..]}); + match result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + assert_eq!(output_offset, 176128); + assert_eq!(input_offset, input.len()); + const fox: [u8; 0x2b] = [0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6B, 0x20, 0x62, 0x72, + 0x6F, 0x77, 0x6E, 0x20, 0x66, 0x6F, 0x78, 0x20, 0x6A, 0x75, 0x6D, 0x70, + 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x7A, 0x79, 0x20, 0x64, 0x6F, 0x67]; + let mut index: usize = 0; + for item in unsafe{quick_fox_output[0..176128].iter()} { + assert_eq!(*item, fox[index]); + index += 1; + if index == 0x2b { + index = 0; + } + } +} + +static mut quick_fox_exported_output: [u8; QF_BUFFER_SIZE * 3] = [0u8; QF_BUFFER_SIZE * 3]; +#[test] +fn test_quickfox_repeated_exported() { + let input: [u8; 58] = + [0x5B, 0xFF, 0xAF, 0x02, 0xC0, 0x22, 0x79, 0x5C, 0xFB, 0x5A, 0x8C, 0x42, 0x3B, 0xF4, 0x25, + 0x55, 0x19, 0x5A, 0x92, 0x99, 0xB1, 0x35, 0xC8, 0x19, 0x9E, 0x9E, 0x0A, 0x7B, 0x4B, 0x90, + 0xB9, 0x3C, 0x98, 0xC8, 0x09, 0x40, 0xF3, 0xE6, 0xD9, 0x4D, 0xE4, 0x6D, 0x65, 0x1B, 0x27, + 0x87, 0x13, 0x5F, 0xA6, 0xE9, 0x30, 0x96, 0x7B, 0x3C, 0x15, 0xD8, 0x53, 0x1C]; + let res = ::brotli_decode(&input[..], unsafe{&mut quick_fox_exported_output[..]}); + match res.result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + assert_eq!(res.decoded_size, 176128); + const fox: [u8; 0x2b] = [0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6B, 0x20, 0x62, 0x72, + 0x6F, 0x77, 0x6E, 0x20, 0x66, 0x6F, 0x78, 0x20, 0x6A, 0x75, 0x6D, 0x70, + 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x7A, 0x79, 0x20, 0x64, 0x6F, 0x67]; + let mut index: usize = 0; + for item in unsafe{quick_fox_exported_output[0..176128].iter()} { + assert_eq!(*item, fox[index]); + index += 1; + if index == 0x2b { + index = 0; + } + } +} + +static mut quick_fox_prealloc_output: [u8; QF_BUFFER_SIZE * 3] = [0u8; QF_BUFFER_SIZE * 3]; +#[test] +fn test_quickfox_repeated_exported_prealloc() { + let input: [u8; 58] = + [0x5B, 0xFF, 0xAF, 0x02, 0xC0, 0x22, 0x79, 0x5C, 0xFB, 0x5A, 0x8C, 0x42, 0x3B, 0xF4, 0x25, + 0x55, 0x19, 0x5A, 0x92, 0x99, 0xB1, 0x35, 0xC8, 0x19, 0x9E, 0x9E, 0x0A, 0x7B, 0x4B, 0x90, + 0xB9, 0x3C, 0x98, 0xC8, 0x09, 0x40, 0xF3, 0xE6, 0xD9, 0x4D, 0xE4, 0x6D, 0x65, 0x1B, 0x27, + 0x87, 0x13, 0x5F, 0xA6, 0xE9, 0x30, 0x96, 0x7B, 0x3C, 0x15, 0xD8, 0x53, 0x1C]; + let (qf, scratch) = unsafe{quick_fox_prealloc_output.split_at_mut(QF_BUFFER_SIZE)}; + let res = ::brotli_decode_prealloc(&input[..], qf, scratch, &mut[0u32;65536][..], &mut[HuffmanCode::default();65536][..]); + match res.result { + BrotliResult::ResultSuccess => {} + _ => assert!(false), + } + assert_eq!(res.decoded_size, 176128); + const fox: [u8; 0x2b] = [0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6B, 0x20, 0x62, 0x72, + 0x6F, 0x77, 0x6E, 0x20, 0x66, 0x6F, 0x78, 0x20, 0x6A, 0x75, 0x6D, 0x70, + 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x7A, 0x79, 0x20, 0x64, 0x6F, 0x67]; + let mut index: usize = 0; + for item in qf[0..176128].iter() { + assert_eq!(*item, fox[index]); + index += 1; + if index == 0x2b { + index = 0; + } + } +} + + +#[cfg(feature="std")] +struct Buffer { + data: Vec<u8>, + read_offset: usize, +} +#[cfg(feature="std")] +impl Buffer { + pub fn new(buf: &[u8]) -> Buffer { + let mut ret = Buffer { + data: Vec::<u8>::new(), + read_offset: 0, + }; + ret.data.extend(buf); + return ret; + } +} +#[cfg(feature="std")] +impl io::Read for Buffer { + fn read(self: &mut Self, buf: &mut [u8]) -> io::Result<usize> { + let bytes_to_read = ::core::cmp::min(buf.len(), self.data.len() - self.read_offset); + if bytes_to_read > 0 { + buf[0..bytes_to_read] + .clone_from_slice(&self.data[self.read_offset..self.read_offset + bytes_to_read]); + } + self.read_offset += bytes_to_read; + return Ok(bytes_to_read); + } +} +#[cfg(feature="std")] +impl io::Write for Buffer { + fn write(self: &mut Self, buf: &[u8]) -> io::Result<usize> { + self.data.extend(buf); + return Ok(buf.len()); + } + fn flush(self: &mut Self) -> io::Result<()> { + return Ok(()); + } +} + + +#[test] +#[cfg(feature="std")] +fn test_reader_quickfox_repeated() { + let in_buf: [u8; 58] = [0x5B, 0xFF, 0xAF, 0x02, 0xC0, 0x22, 0x79, 0x5C, 0xFB, 0x5A, 0x8C, 0x42, + 0x3B, 0xF4, 0x25, 0x55, 0x19, 0x5A, 0x92, 0x99, 0xB1, 0x35, 0xC8, 0x19, + 0x9E, 0x9E, 0x0A, 0x7B, 0x4B, 0x90, 0xB9, 0x3C, 0x98, 0xC8, 0x09, 0x40, + 0xF3, 0xE6, 0xD9, 0x4D, 0xE4, 0x6D, 0x65, 0x1B, 0x27, 0x87, 0x13, 0x5F, + 0xA6, 0xE9, 0x30, 0x96, 0x7B, 0x3C, 0x15, 0xD8, 0x53, 0x1C]; + + let mut output = Buffer::new(&[]); + let mut input = super::Decompressor::new(Buffer::new(&in_buf), 4096); + match super::copy_from_to(&mut input, &mut output) { + Ok(_) => {} + Err(e) => panic!("Error {:?}", e), + } + + assert_eq!(output.data.len(), 176128); + const fox: [u8; 0x2b] = [0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6B, 0x20, 0x62, 0x72, + 0x6F, 0x77, 0x6E, 0x20, 0x66, 0x6F, 0x78, 0x20, 0x6A, 0x75, 0x6D, 0x70, + 0x73, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6C, + 0x61, 0x7A, 0x79, 0x20, 0x64, 0x6F, 0x67]; + let mut index: usize = 0; + for item in output.data[0..176128].iter_mut() { + assert_eq!(*item, fox[index]); + index += 1; + if index == 0x2b { + index = 0; + } + } +} + +#[test] +fn test_early_eof() { + const BUFFER_SIZE: usize = 128; + let mut input: [u8; 47] = [17, 17, 32, 32, 109, 109, 32, 32, 32, 181, 2, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 151, 32, 42, 181, 32, 149, 59, 0, 0, 0, 0, 42, 42, 42, 42, 42, 5, 255, 255, 255, 255, 255]; + let mut output = [0u8; BUFFER_SIZE]; + let (result, input_offset, _output_offset) = oneshot(&mut input[..], &mut output[..]); + match result { + BrotliResult::ResultFailure => {} + _ => assert!(false), + } + assert_eq!(input_offset, input.len()); +} diff --git a/rust/vendor/brotli-decompressor/src/transform.rs b/rust/vendor/brotli-decompressor/src/transform.rs new file mode 100644 index 0000000..d656e0a --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/transform.rs @@ -0,0 +1,795 @@ +#![allow(non_upper_case_globals)] + +const kIdentity: u8 = 0; +const kOmitLast1: u8 = 1; +const kOmitLast2: u8 = 2; +const kOmitLast3: u8 = 3; +const kOmitLast4: u8 = 4; +const kOmitLast5: u8 = 5; +const kOmitLast6: u8 = 6; +const kOmitLast7: u8 = 7; +const kOmitLast8: u8 = 8; +const kOmitLast9: u8 = 9; +const kUppercaseFirst: u8 = 10; +const kUppercaseAll: u8 = 11; +const kOmitFirst1: u8 = 12; +const kOmitFirst2: u8 = 13; +const kOmitFirst3: u8 = 14; +const kOmitFirst4: u8 = 15; +const kOmitFirst5: u8 = 16; +const kOmitFirst6: u8 = 17; +const kOmitFirst7: u8 = 18; +// const kOmitFirst8 : u8 = 19; // <-- unused (reserved) +const kOmitFirst9: u8 = 20; + + +pub struct Transform { + pub prefix_id: u8, + pub transform: u8, + pub suffix_id: u8, +} + +const kPrefixSuffix: [u8; 208] = + [0x00, 0x20, 0x00, 0x2c, 0x20, 0x00, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x00, 0x20, + 0x6f, 0x66, 0x20, 0x00, 0x73, 0x20, 0x00, 0x2e, 0x00, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x00, 0x20, + 0x69, 0x6e, 0x20, 0x00, 0x22, 0x00, 0x20, 0x74, 0x6f, 0x20, 0x00, 0x22, 0x3e, 0x00, 0x0a, 0x00, + 0x2e, 0x20, 0x00, 0x5d, 0x00, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x00, 0x20, 0x61, 0x20, 0x00, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x00, 0x27, 0x00, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x00, 0x20, + 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x00, 0x20, 0x62, 0x79, 0x20, 0x00, 0x28, 0x00, 0x2e, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x00, 0x20, 0x6f, 0x6e, 0x20, 0x00, 0x20, 0x61, 0x73, 0x20, 0x00, 0x20, 0x69, + 0x73, 0x20, 0x00, 0x69, 0x6e, 0x67, 0x20, 0x00, 0x0a, 0x09, 0x00, 0x3a, 0x00, 0x65, 0x64, 0x20, + 0x00, 0x3d, 0x22, 0x00, 0x20, 0x61, 0x74, 0x20, 0x00, 0x6c, 0x79, 0x20, 0x00, 0x2c, 0x00, 0x3d, + 0x27, 0x00, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x00, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x00, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x00, 0x65, 0x72, 0x20, 0x00, 0x61, 0x6c, 0x20, 0x00, 0x66, 0x75, + 0x6c, 0x20, 0x00, 0x69, 0x76, 0x65, 0x20, 0x00, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x00, 0x65, 0x73, + 0x74, 0x20, 0x00, 0x69, 0x7a, 0x65, 0x20, 0x00, 0xc2, 0xa0, 0x00, 0x6f, 0x75, 0x73, 0x20, 0x00]; +// "\0 \0, \0 of the \0 of \0s \0.\0 and \0 in \0\"\0 to \0\">\0\n\0. \0]\0" +// " for \0 a \0 that \0\'\0 with \0 from \0 by \0(\0. The \0 on \0 as \0" +// " is \0ing \0\n\t\0:\0ed \0=\"\0 at \0ly \0,\0=\'\0.com/\0. This \0" +// " not \0er \0al \0ful \0ive \0less \0est \0ize \0\xc2\xa0\0ous "; + +// EMPTY = "" +// SP = " " +// DQUOT = "\"" +// SQUOT = "'" +// CLOSEBR = "]" +// OPEN = "(" +// SLASH = "/" +// NBSP = non-breaking space "\0xc2\xa0" +// +const kPFix_EMPTY: u8 = 0; +const kPFix_SP: u8 = 1; +const kPFix_COMMASP: u8 = 3; +const kPFix_SPofSPtheSP: u8 = 6; +const kPFix_SPtheSP: u8 = 9; +const kPFix_eSP: u8 = 12; +const kPFix_SPofSP: u8 = 15; +const kPFix_sSP: u8 = 20; +const kPFix_DOT: u8 = 23; +const kPFix_SPandSP: u8 = 25; +const kPFix_SPinSP: u8 = 31; +const kPFix_DQUOT: u8 = 36; +const kPFix_SPtoSP: u8 = 38; +const kPFix_DQUOTGT: u8 = 43; +const kPFix_NEWLINE: u8 = 46; +const kPFix_DOTSP: u8 = 48; +const kPFix_CLOSEBR: u8 = 51; +const kPFix_SPforSP: u8 = 53; +const kPFix_SPaSP: u8 = 59; +const kPFix_SPthatSP: u8 = 63; +const kPFix_SQUOT: u8 = 70; +const kPFix_SPwithSP: u8 = 72; +const kPFix_SPfromSP: u8 = 79; +const kPFix_SPbySP: u8 = 86; +const kPFix_OPEN: u8 = 91; +const kPFix_DOTSPTheSP: u8 = 93; +const kPFix_SPonSP: u8 = 100; +const kPFix_SPasSP: u8 = 105; +const kPFix_SPisSP: u8 = 110; +const kPFix_ingSP: u8 = 115; +const kPFix_NEWLINETAB: u8 = 120; +const kPFix_COLON: u8 = 123; +const kPFix_edSP: u8 = 125; +const kPFix_EQDQUOT: u8 = 129; +const kPFix_SPatSP: u8 = 132; +const kPFix_lySP: u8 = 137; +const kPFix_COMMA: u8 = 141; +const kPFix_EQSQUOT: u8 = 143; +const kPFix_DOTcomSLASH: u8 = 146; +const kPFix_DOTSPThisSP: u8 = 152; +const kPFix_SPnotSP: u8 = 160; +const kPFix_erSP: u8 = 166; +const kPFix_alSP: u8 = 170; +const kPFix_fulSP: u8 = 174; +const kPFix_iveSP: u8 = 179; +const kPFix_lessSP: u8 = 184; +const kPFix_estSP: u8 = 190; +const kPFix_izeSP: u8 = 195; +const kPFix_NBSP: u8 = 200; +const kPFix_ousSP: u8 = 203; + +pub const kNumTransforms: i32 = 121; +pub const kTransforms: [Transform; kNumTransforms as usize] = [Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst1, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPtheSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_sSP, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPofSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPandSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst2, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast1, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_COMMASP, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPinSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPtoSP, + }, + Transform { + prefix_id: kPFix_eSP, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DQUOTGT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_NEWLINE, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast3, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_CLOSEBR, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPforSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst3, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast2, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPaSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPthatSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_DOT, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst4, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPwithSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPfromSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPbySP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst5, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst6, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_SPtheSP, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast4, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DOTSPTheSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPonSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPasSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPisSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast7, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast1, + suffix_id: kPFix_ingSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_NEWLINETAB, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_COLON, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_edSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst9, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitFirst7, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast6, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_OPEN, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast8, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPatSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_lySP, + }, + Transform { + prefix_id: kPFix_SPtheSP, + transform: kIdentity, + suffix_id: kPFix_SPofSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast5, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kOmitLast9, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_DQUOT, + }, + Transform { + prefix_id: kPFix_DOT, + transform: kIdentity, + suffix_id: kPFix_OPEN, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_DQUOTGT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_DOTcomSLASH, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_SPtheSP, + transform: kIdentity, + suffix_id: kPFix_SPofSPtheSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_SQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_DOTSPThisSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_COMMA, + }, + Transform { + prefix_id: kPFix_DOT, + transform: kIdentity, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_OPEN, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_SPnotSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_erSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_SP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_alSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_EQSQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_DQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_OPEN, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_fulSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_iveSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_lessSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_SQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_estSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_DQUOTGT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_EQSQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_COMMA, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_izeSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_NBSP, + transform: kIdentity, + suffix_id: kPFix_EMPTY, + }, + Transform { + prefix_id: kPFix_SP, + transform: kIdentity, + suffix_id: kPFix_COMMA, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kIdentity, + suffix_id: kPFix_ousSP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseFirst, + suffix_id: kPFix_EQSQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_COMMA, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_COMMASP, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_COMMA, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_OPEN, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_DOT, + }, + Transform { + prefix_id: kPFix_EMPTY, + transform: kUppercaseAll, + suffix_id: kPFix_EQSQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_DOTSP, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_EQDQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseAll, + suffix_id: kPFix_EQSQUOT, + }, + Transform { + prefix_id: kPFix_SP, + transform: kUppercaseFirst, + suffix_id: kPFix_EQSQUOT, + }]; + + + +fn ToUpperCase(p: &mut [u8]) -> i32 { + if (fast!((p)[0]) < 0xc0) { + if (fast!((p)[0]) >= b'a' && fast!((p)[0]) <= b'z') { + fast_mut!((p)[0]) ^= 32; + } + return 1; + } + // An overly simplified uppercasing model for utf-8. + if (fast!((p)[0]) < 0xe0) { + fast_mut!((p)[1]) ^= 32; + return 2; + } + // An arbitrary transform for three byte characters. + fast_mut!((p)[2]) ^= 5; + 3 +} + +pub fn TransformDictionaryWord(dst: &mut [u8], + mut word: &[u8], + mut len: i32, + transform: i32) + -> i32 { + let mut idx: i32 = 0; + { + let prefix = + &fast!((kPrefixSuffix)[fast_inner!((kTransforms)[transform as usize]).prefix_id as usize;]); + while (fast!((prefix)[idx as usize]) != 0) { + fast_mut!((dst)[idx as usize]) = fast!((prefix)[idx as usize]); + idx += 1; + } + } + { + let t = fast_ref!((kTransforms)[transform as usize]).transform; + let mut skip: i32 = if t < kOmitFirst1 { + 0 + } else { + t as i32 - (kOmitFirst1 - 1) as i32 + }; + let mut i: i32 = 0; + if (skip > len) { + skip = len; + } + word = fast!((word)[skip as usize;]); + len -= skip; + if (t <= kOmitLast9) { + len -= t as i32; + } + while (i < len) { + fast_mut!((dst)[idx as usize]) = fast!((word)[i as usize]); + idx += 1; + i += 1; + } + let uppercase = &mut fast_mut!((dst)[(idx - len) as usize ;]); + if (t == kUppercaseFirst) { + ToUpperCase(uppercase); + } else if (t == kUppercaseAll) { + let mut uppercase_offset: usize = 0; + while (len > 0) { + let step = ToUpperCase(&mut fast_mut!((uppercase)[uppercase_offset;])); + uppercase_offset += step as usize; + len -= step; + } + } + } + { + let suffix = + &fast!((kPrefixSuffix)[fast_inner!((kTransforms)[transform as usize]).suffix_id as usize ; ]); + let mut i: usize = 0; + while (fast!((suffix)[i as usize]) != 0) { + fast_mut!((dst)[idx as usize]) = fast!((suffix)[i]); + idx += 1; + i += 1; + } + idx + } +} diff --git a/rust/vendor/brotli-decompressor/src/writer.rs b/rust/vendor/brotli-decompressor/src/writer.rs new file mode 100644 index 0000000..9a46303 --- /dev/null +++ b/rust/vendor/brotli-decompressor/src/writer.rs @@ -0,0 +1,399 @@ +use core; +#[cfg(feature="std")] +use std::io::{self, Error, ErrorKind, Write}; +#[cfg(feature="std")] +pub use alloc_stdlib::StandardAlloc; +#[cfg(all(feature="unsafe",feature="std"))] +pub use alloc_stdlib::HeapAlloc; +pub use huffman::{HuffmanCode, HuffmanTreeGroup}; +pub use state::BrotliState; +// use io_wrappers::write_all; +pub use io_wrappers::{CustomWrite}; +#[cfg(feature="std")] +pub use io_wrappers::{IntoIoWriter, IoWriterWrapper}; +pub use super::decode::{BrotliDecompressStream, BrotliResult}; +pub use alloc::{AllocatedStackMemory, Allocator, SliceWrapper, SliceWrapperMut, StackAllocator}; + +#[cfg(feature="std")] +pub struct DecompressorWriterCustomAlloc<W: Write, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> >(DecompressorWriterCustomIo<io::Error, + IntoIoWriter<W>, + BufferType, + AllocU8, AllocU32, AllocHC>); + + +#[cfg(feature="std")] +impl<W: Write, + BufferType : SliceWrapperMut<u8>, + AllocU8, + AllocU32, + AllocHC> DecompressorWriterCustomAlloc<W, BufferType, AllocU8, AllocU32, AllocHC> + where AllocU8 : Allocator<u8>, AllocU32 : Allocator<u32>, AllocHC : Allocator<HuffmanCode> + { + pub fn new(w: W, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC) -> Self { + let dict = AllocU8::AllocatedMemory::default(); + Self::new_with_custom_dictionary(w, buffer, alloc_u8, alloc_u32, alloc_hc, dict) + + } + pub fn new_with_custom_dictionary(w: W, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, dict: AllocU8::AllocatedMemory) -> Self { + DecompressorWriterCustomAlloc::<W, BufferType, AllocU8, AllocU32, AllocHC>( + DecompressorWriterCustomIo::<Error, + IntoIoWriter<W>, + BufferType, + AllocU8, AllocU32, AllocHC>::new_with_custom_dictionary(IntoIoWriter::<W>(w), + buffer, + alloc_u8, alloc_u32, alloc_hc, + dict, + Error::new(ErrorKind::InvalidData, + "Invalid Data"))) + } + + pub fn get_ref(&self) -> &W { + &self.0.get_ref().0 + } + pub fn get_mut(&mut self) -> &mut W { + &mut self.0.get_mut().0 + } + pub fn into_inner(self) -> Result<W, W> { + match self.0.into_inner() { + Ok(w) => Ok(w.0), + Err(w) => Err(w.0), + } + } +} +#[cfg(feature="std")] +impl<W: Write, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > Write for DecompressorWriterCustomAlloc<W, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + fn write(&mut self, buf: &[u8]) -> Result<usize, Error> { + self.0.write(buf) + } + fn flush(&mut self) -> Result<(), Error> { + self.0.flush() + } +} + +#[cfg(feature="std")] +impl<W: Write, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > DecompressorWriterCustomAlloc<W, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + pub fn close(&mut self) -> Result<(), Error>{ + self.0.close() + } +} + + +#[cfg(not(any(feature="unsafe", not(feature="std"))))] +pub struct DecompressorWriter<W: Write>(DecompressorWriterCustomAlloc<W, + <StandardAlloc + as Allocator<u8>>::AllocatedMemory, + StandardAlloc, + StandardAlloc, + StandardAlloc>); + + +#[cfg(not(any(feature="unsafe", not(feature="std"))))] +impl<W: Write> DecompressorWriter<W> { + pub fn new(w: W, buffer_size: usize) -> Self { + Self::new_with_custom_dictionary(w, buffer_size, <StandardAlloc as Allocator<u8>>::AllocatedMemory::default()) + } + pub fn new_with_custom_dictionary(w: W, buffer_size: usize, dict: <StandardAlloc as Allocator<u8>>::AllocatedMemory) -> Self { + let mut alloc = StandardAlloc::default(); + let buffer = <StandardAlloc as Allocator<u8>>::alloc_cell(&mut alloc, if buffer_size == 0 {4096} else {buffer_size}); + DecompressorWriter::<W>(DecompressorWriterCustomAlloc::<W, + <StandardAlloc + as Allocator<u8>>::AllocatedMemory, + StandardAlloc, + StandardAlloc, + StandardAlloc>::new_with_custom_dictionary(w, + buffer, + alloc, + StandardAlloc::default(), + StandardAlloc::default(), + dict)) + } + + pub fn get_ref(&self) -> &W { + self.0.get_ref() + } + pub fn get_mut(&mut self) -> &mut W { + self.0.get_mut() + } + pub fn into_inner(self) -> Result<W, W> { + self.0.into_inner() + } +} + + +#[cfg(all(feature="unsafe", feature="std"))] +pub struct DecompressorWriter<W: Write>(DecompressorWriterCustomAlloc<W, + <HeapAlloc<u8> + as Allocator<u8>>::AllocatedMemory, + HeapAlloc<u8>, + HeapAlloc<u32>, + HeapAlloc<HuffmanCode> >); + + +#[cfg(all(feature="unsafe", feature="std"))] +impl<W: Write> DecompressorWriter<W> { + pub fn new(w: W, buffer_size: usize) -> Self { + let dict = <HeapAlloc<u8> as Allocator<u8>>::AllocatedMemory::default(); + Self::new_with_custom_dictionary(w, buffer_size, dict) + } + pub fn new_with_custom_dictionary(w: W, buffer_size: usize, dict: <HeapAlloc<u8> as Allocator<u8>>::AllocatedMemory) -> Self { + let mut alloc_u8 = HeapAlloc::<u8>::new(0); + let buffer = alloc_u8.alloc_cell(buffer_size); + let alloc_u32 = HeapAlloc::<u32>::new(0); + let alloc_hc = HeapAlloc::<HuffmanCode>::new(HuffmanCode{bits:2, value: 1}); + DecompressorWriter::<W>(DecompressorWriterCustomAlloc::<W, + <HeapAlloc<u8> + as Allocator<u8>>::AllocatedMemory, + HeapAlloc<u8>, + HeapAlloc<u32>, + HeapAlloc<HuffmanCode> > + ::new_with_custom_dictionary(w, buffer, alloc_u8, alloc_u32, alloc_hc, dict)) + } + + pub fn get_ref(&self) -> &W { + self.0.get_ref() + } + pub fn get_mut(&mut self) -> &mut W { + &mut (self.0).0.get_mut().0 + } + pub fn into_inner(self) -> Result<W, W> { + self.0.into_inner() + } +} + +#[cfg(feature="std")] +impl<W: Write> DecompressorWriter<W> { + pub fn close(&mut self) -> Result<(), Error>{ + self.0.close() + } +} +#[cfg(feature="std")] +impl<W: Write> Write for DecompressorWriter<W> { + fn write(&mut self, buf: &[u8]) -> Result<usize, Error> { + self.0.write(buf) + } + fn flush(&mut self) -> Result<(), Error> { + self.0.flush() + } +} + +pub struct DecompressorWriterCustomIo<ErrType, + W: CustomWrite<ErrType>, + BufferType: SliceWrapperMut<u8>, + AllocU8: Allocator<u8>, + AllocU32: Allocator<u32>, + AllocHC: Allocator<HuffmanCode>> +{ + output_buffer: BufferType, + total_out: usize, + output: Option<W>, + error_if_invalid_data: Option<ErrType>, + state: BrotliState<AllocU8, AllocU32, AllocHC>, +} + + +pub fn write_all<ErrType, W: CustomWrite<ErrType>>(writer: &mut W, mut buf : &[u8]) -> Result<(), ErrType> { + while buf.len() != 0 { + match writer.write(buf) { + Ok(bytes_written) => buf = &buf[bytes_written..], + Err(e) => return Err(e), + } + } + Ok(()) +} + + +impl<ErrType, + W: CustomWrite<ErrType>, + BufferType : SliceWrapperMut<u8>, + AllocU8, + AllocU32, + AllocHC> DecompressorWriterCustomIo<ErrType, W, BufferType, AllocU8, AllocU32, AllocHC> + where AllocU8 : Allocator<u8>, AllocU32 : Allocator<u32>, AllocHC : Allocator<HuffmanCode> +{ + + pub fn new(w: W, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, + invalid_data_error_type : ErrType) -> Self { + let dict = AllocU8::AllocatedMemory::default(); + Self::new_with_custom_dictionary(w, buffer, alloc_u8, alloc_u32, alloc_hc, dict, invalid_data_error_type) + } + pub fn new_with_custom_dictionary(w: W, buffer : BufferType, + alloc_u8 : AllocU8, alloc_u32 : AllocU32, alloc_hc : AllocHC, + dict: AllocU8::AllocatedMemory, + invalid_data_error_type : ErrType) -> Self { + DecompressorWriterCustomIo::<ErrType, W, BufferType, AllocU8, AllocU32, AllocHC>{ + output_buffer : buffer, + total_out : 0, + output: Some(w), + state : BrotliState::new_with_custom_dictionary(alloc_u8, + alloc_u32, + alloc_hc, + dict), + error_if_invalid_data : Some(invalid_data_error_type), + } + } + pub fn close(&mut self) -> Result<(), ErrType>{ + loop { + let mut avail_in : usize = 0; + let mut input_offset : usize = 0; + let mut avail_out : usize = self.output_buffer.slice_mut().len(); + let mut output_offset : usize = 0; + let ret = BrotliDecompressStream( + &mut avail_in, + &mut input_offset, + &[], + &mut avail_out, + &mut output_offset, + self.output_buffer.slice_mut(), + &mut self.total_out, + &mut self.state); + // already closed. + if self.error_if_invalid_data.is_none() { + return Ok(()); + } + match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) { + Ok(_) => {}, + Err(e) => return Err(e), + } + match ret { + BrotliResult::NeedsMoreInput => return self.error_if_invalid_data.take().map(|e|Err(e)).unwrap_or(Ok(())), + BrotliResult::NeedsMoreOutput => {}, + BrotliResult::ResultSuccess => { + return Ok(()); + }, + BrotliResult::ResultFailure => return self.error_if_invalid_data.take().map(|e|Err(e)).unwrap_or(Ok(())) + } + } + } + + pub fn get_ref(&self) -> &W { + self.output.as_ref().unwrap() + } + pub fn get_mut(&mut self) -> &mut W { + self.output.as_mut().unwrap() + } + pub fn into_inner(mut self) -> Result<W, W> { + match self.close() { + Ok(_) => Ok((core::mem::replace(&mut self.output, None).unwrap())), + Err(_) => Err((core::mem::replace(&mut self.output, None).unwrap())), + } + } +} + +impl<ErrType, + W: CustomWrite<ErrType>, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > Drop for DecompressorWriterCustomIo<ErrType, + W, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + fn drop(&mut self) { + if self.output.is_some() { + match self.close() { + Ok(_) => {}, + Err(_) => {}, + } + } + } +} + +impl<ErrType, + W: CustomWrite<ErrType>, + BufferType : SliceWrapperMut<u8>, + AllocU8 : Allocator<u8>, + AllocU32 : Allocator<u32>, + AllocHC : Allocator<HuffmanCode> > CustomWrite<ErrType> for DecompressorWriterCustomIo<ErrType, + W, + BufferType, + AllocU8, + AllocU32, + AllocHC> { + fn write(&mut self, buf: &[u8]) -> Result<usize, ErrType > { + let mut avail_in = buf.len(); + let mut input_offset : usize = 0; + loop { + let mut output_offset = 0; + let mut avail_out = self.output_buffer.slice_mut().len(); + let op_result = BrotliDecompressStream(&mut avail_in, + &mut input_offset, + &buf[..], + &mut avail_out, + &mut output_offset, + self.output_buffer.slice_mut(), + &mut self.total_out, + &mut self.state); + match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) { + Ok(_) => {}, + Err(e) => return Err(e), + } + match op_result { + BrotliResult::NeedsMoreInput => assert_eq!(avail_in, 0), + BrotliResult::NeedsMoreOutput => continue, + BrotliResult::ResultSuccess => { + return Ok(input_offset); + } + BrotliResult::ResultFailure => return self.error_if_invalid_data.take().map(|e|Err(e)).unwrap_or(Ok(0)), + } + if avail_in == 0 { + break + } + } + Ok(buf.len()) + } + fn flush(&mut self) -> Result<(), ErrType> { + self.output.as_mut().unwrap().flush() + } +} + +#[cfg(feature="std")] +#[cfg(test)] +mod test { + use super::DecompressorWriter; + use std::vec::Vec; + use std::io::Write; + // Brotli-compressed "hello\n" and 2 extra bytes + + + #[test] + fn write_extra() { + let contents = b"\x8f\x02\x80\x68\x65\x6c\x6c\x6f\x0a\x03\x67\x6f\x6f\x64\x62\x79\x65\x0a"; + let mut decoder = DecompressorWriter::new(Vec::new(), 0); + let n = decoder.write(contents).unwrap(); + assert_eq!(n, 10); + // Ensure that we can continue to not send data to the writer + // as it has consumed the entire file. + let n = decoder.write(contents).unwrap(); + assert_eq!(n, 0); + + let mut decoder = DecompressorWriter::new(Vec::new(), 0); + let e = decoder.write_all(contents).unwrap_err(); + assert!(e.kind() == std::io::ErrorKind::WriteZero); + assert_eq!(decoder.get_ref().as_slice(), b"hello\n"); + } +} |