Merge commit '8b0602a5824199d495f6720ef2447f695179257a' as 'src/snappy/snappy'

src/snappy/snappy/AUTHORS

@@ -0,0 +1 @@
+opensource@google.com

src/snappy/snappy/COPYING

@@ -0,0 +1,54 @@
+Copyright 2011, Google 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:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. 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
+OWNER 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.
+
+===
+
+Some of the benchmark data in util/zippy/testdata is licensed differently:
+
+ - fireworks.jpeg is Copyright 2013 Steinar H. Gunderson, and
+   is licensed under the Creative Commons Attribution 3.0 license
+   (CC-BY-3.0). See https://creativecommons.org/licenses/by/3.0/
+   for more information.
+
+ - kppkn.gtb is taken from the Gaviota chess tablebase set, and
+   is licensed under the MIT License. See
+   https://sites.google.com/site/gaviotachessengine/Home/endgame-tablebases-1
+   for more information.
+
+ - paper-100k.pdf is an excerpt (bytes 92160 to 194560) from the paper
+   “Combinatorial Modeling of Chromatin Features Quantitatively Predicts DNA
+   Replication Timing in _Drosophila_” by Federico Comoglio and Renato Paro,
+   which is licensed under the CC-BY license. See
+   http://www.ploscompbiol.org/static/license for more ifnormation.
+
+ - alice29.txt, asyoulik.txt, plrabn12.txt and lcet10.txt are from Project
+   Gutenberg. The first three have expired copyrights and are in the public
+   domain; the latter does not have expired copyright, but is still in the
+   public domain according to the license information
+   (http://www.gutenberg.org/ebooks/53).

src/snappy/snappy/Makefile.am

@@ -0,0 +1,23 @@
+ACLOCAL_AMFLAGS = -I m4
+
+# Library.
+lib_LTLIBRARIES = libsnappy.la
+libsnappy_la_SOURCES = snappy.cc snappy-sinksource.cc snappy-stubs-internal.cc snappy-c.cc
+libsnappy_la_LDFLAGS = -version-info $(SNAPPY_LTVERSION)
+
+include_HEADERS = snappy.h snappy-sinksource.h snappy-stubs-public.h snappy-c.h
+noinst_HEADERS = snappy-internal.h snappy-stubs-internal.h snappy-test.h
+
+# Unit tests and benchmarks.
+snappy_unittest_CPPFLAGS = $(gflags_CFLAGS) $(GTEST_CPPFLAGS)
+snappy_unittest_SOURCES = snappy_unittest.cc snappy-test.cc
+snappy_unittest_LDFLAGS = $(GTEST_LDFLAGS)
+snappy_unittest_LDADD = libsnappy.la $(UNITTEST_LIBS) $(gflags_LIBS) $(GTEST_LIBS)
+TESTS = snappy_unittest
+noinst_PROGRAMS = $(TESTS)
+
+EXTRA_DIST = autogen.sh testdata/alice29.txt testdata/asyoulik.txt testdata/baddata1.snappy testdata/baddata2.snappy testdata/baddata3.snappy testdata/geo.protodata testdata/fireworks.jpeg testdata/html testdata/html_x_4 testdata/kppkn.gtb testdata/lcet10.txt testdata/paper-100k.pdf testdata/plrabn12.txt testdata/urls.10K
+dist_doc_DATA = ChangeLog COPYING INSTALL NEWS README format_description.txt framing_format.txt
+
+libtool: $(LIBTOOL_DEPS)
+	$(SHELL) ./config.status --recheck

src/snappy/snappy/NEWS

@@ -0,0 +1,128 @@
+Snappy v1.1.2, February 28th 2014:
+
+This is a maintenance release with no changes to the actual library
+source code.
+
+  * Stop distributing benchmark data files that have unclear
+    or unsuitable licensing.
+
+  * Add support for padding chunks in the framing format.
+
+
+Snappy v1.1.1, October 15th 2013:
+
+  * Add support for uncompressing to iovecs (scatter I/O).
+    The bulk of this patch was contributed by Mohit Aron.
+
+  * Speed up decompression by ~2%; much more so (~13-20%) on
+    a few benchmarks on given compilers and CPUs.
+
+  * Fix a few issues with MSVC compilation.
+
+  * Support truncated test data in the benchmark.
+
+
+Snappy v1.1.0, January 18th 2013:
+
+  * Snappy now uses 64 kB block size instead of 32 kB. On average,
+    this means it compresses about 3% denser (more so for some
+    inputs), at the same or better speeds.
+
+  * libsnappy no longer depends on iostream.
+
+  * Some small performance improvements in compression on x86
+    (0.5–1%).
+
+  * Various portability fixes for ARM-based platforms, for MSVC,
+    and for GNU/Hurd.
+
+
+Snappy v1.0.5, February 24th 2012:
+
+  * More speed improvements. Exactly how big will depend on
+    the architecture:
+
+    - 3–10% faster decompression for the base case (x86-64).
+
+    - ARMv7 and higher can now use unaligned accesses,
+      and will see about 30% faster decompression and
+      20–40% faster compression.
+
+    - 32-bit platforms (ARM and 32-bit x86) will see 2–5%
+      faster compression.
+
+    These are all cumulative (e.g., ARM gets all three speedups).
+
+  * Fixed an issue where the unit test would crash on system
+    with less than 256 MB address space available,
+    e.g. some embedded platforms.
+
+  * Added a framing format description, for use over e.g. HTTP,
+    or for a command-line compressor. We do not have any
+    implementations of this at the current point, but there seems
+    to be enough of a general interest in the topic.
+    Also make the format description slightly clearer.
+
+  * Remove some compile-time warnings in -Wall
+    (mostly signed/unsigned comparisons), for easier embedding
+    into projects that use -Wall -Werror.
+
+
+Snappy v1.0.4, September 15th 2011:
+
+  * Speeded up the decompressor somewhat; typically about 2–8%
+    for Core i7, in 64-bit mode (comparable for Opteron).
+    Somewhat more for some tests, almost no gain for others.
+  
+  * Make Snappy compile on certain platforms it didn't before
+    (Solaris with SunPro C++, HP-UX, AIX).
+
+  * Correct some minor errors in the format description.
+
+
+Snappy v1.0.3, June 2nd 2011:
+
+  * Speeded up the decompressor somewhat; about 3-6% for Core 2,
+    6-13% for Core i7, and 5-12% for Opteron (all in 64-bit mode).
+
+  * Added compressed format documentation. This text is new,
+    but an earlier version from Zeev Tarantov was used as reference.
+
+  * Only link snappy_unittest against -lz and other autodetected
+    libraries, not libsnappy.so (which doesn't need any such dependency).
+
+  * Fixed some display issues in the microbenchmarks, one of which would
+    frequently make the test crash on GNU/Hurd.
+
+
+Snappy v1.0.2, April 29th 2011:
+
+  * Relicense to a BSD-type license.
+
+  * Added C bindings, contributed by Martin Gieseking.
+
+  * More Win32 fixes, in particular for MSVC.
+
+  * Replace geo.protodata with a newer version.
+
+  * Fix timing inaccuracies in the unit test when comparing Snappy
+    to other algorithms.
+
+
+Snappy v1.0.1, March 25th 2011:
+
+This is a maintenance release, mostly containing minor fixes.
+There is no new functionality. The most important fixes include:
+
+  * The COPYING file and all licensing headers now correctly state that
+    Snappy is licensed under the Apache 2.0 license.
+
+  * snappy_unittest should now compile natively under Windows,
+    as well as on embedded systems with no mmap().
+
+  * Various autotools nits have been fixed.
+
+
+Snappy v1.0, March 17th 2011:
+
+  * Initial version.

src/snappy/snappy/README

@@ -0,0 +1,135 @@
+Snappy, a fast compressor/decompressor.
+
+
+Introduction
+============
+
+Snappy is a compression/decompression library. It does not aim for maximum
+compression, or compatibility with any other compression library; instead,
+it aims for very high speeds and reasonable compression. For instance,
+compared to the fastest mode of zlib, Snappy is an order of magnitude faster
+for most inputs, but the resulting compressed files are anywhere from 20% to
+100% bigger. (For more information, see "Performance", below.)
+
+Snappy has the following properties:
+
+ * Fast: Compression speeds at 250 MB/sec and beyond, with no assembler code.
+   See "Performance" below.
+ * Stable: Over the last few years, Snappy has compressed and decompressed
+   petabytes of data in Google's production environment. The Snappy bitstream
+   format is stable and will not change between versions.
+ * Robust: The Snappy decompressor is designed not to crash in the face of
+   corrupted or malicious input.
+ * Free and open source software: Snappy is licensed under a BSD-type license.
+   For more information, see the included COPYING file.
+
+Snappy has previously been called "Zippy" in some Google presentations
+and the like.
+
+
+Performance
+===========
+ 
+Snappy is intended to be fast. On a single core of a Core i7 processor
+in 64-bit mode, it compresses at about 250 MB/sec or more and decompresses at
+about 500 MB/sec or more. (These numbers are for the slowest inputs in our
+benchmark suite; others are much faster.) In our tests, Snappy usually
+is faster than algorithms in the same class (e.g. LZO, LZF, FastLZ, QuickLZ,
+etc.) while achieving comparable compression ratios.
+
+Typical compression ratios (based on the benchmark suite) are about 1.5-1.7x
+for plain text, about 2-4x for HTML, and of course 1.0x for JPEGs, PNGs and
+other already-compressed data. Similar numbers for zlib in its fastest mode
+are 2.6-2.8x, 3-7x and 1.0x, respectively. More sophisticated algorithms are
+capable of achieving yet higher compression rates, although usually at the
+expense of speed. Of course, compression ratio will vary significantly with
+the input.
+
+Although Snappy should be fairly portable, it is primarily optimized
+for 64-bit x86-compatible processors, and may run slower in other environments.
+In particular:
+
+ - Snappy uses 64-bit operations in several places to process more data at
+   once than would otherwise be possible.
+ - Snappy assumes unaligned 32- and 64-bit loads and stores are cheap.
+   On some platforms, these must be emulated with single-byte loads 
+   and stores, which is much slower.
+ - Snappy assumes little-endian throughout, and needs to byte-swap data in
+   several places if running on a big-endian platform.
+
+Experience has shown that even heavily tuned code can be improved.
+Performance optimizations, whether for 64-bit x86 or other platforms,
+are of course most welcome; see "Contact", below.
+
+
+Usage
+=====
+
+Note that Snappy, both the implementation and the main interface,
+is written in C++. However, several third-party bindings to other languages
+are available; see the Google Code page at http://code.google.com/p/snappy/
+for more information. Also, if you want to use Snappy from C code, you can
+use the included C bindings in snappy-c.h.
+
+To use Snappy from your own C++ program, include the file "snappy.h" from
+your calling file, and link against the compiled library.
+
+There are many ways to call Snappy, but the simplest possible is
+
+  snappy::Compress(input.data(), input.size(), &output);
+
+and similarly
+
+  snappy::Uncompress(input.data(), input.size(), &output);
+
+where "input" and "output" are both instances of std::string.
+
+There are other interfaces that are more flexible in various ways, including
+support for custom (non-array) input sources. See the header file for more
+information.
+
+
+Tests and benchmarks
+====================
+
+When you compile Snappy, snappy_unittest is compiled in addition to the
+library itself. You do not need it to use the compressor from your own library,
+but it contains several useful components for Snappy development.
+
+First of all, it contains unit tests, verifying correctness on your machine in
+various scenarios. If you want to change or optimize Snappy, please run the
+tests to verify you have not broken anything. Note that if you have the
+Google Test library installed, unit test behavior (especially failures) will be
+significantly more user-friendly. You can find Google Test at
+
+  http://code.google.com/p/googletest/
+
+You probably also want the gflags library for handling of command-line flags;
+you can find it at
+
+  http://code.google.com/p/google-gflags/
+
+In addition to the unit tests, snappy contains microbenchmarks used to
+tune compression and decompression performance. These are automatically run
+before the unit tests, but you can disable them using the flag
+--run_microbenchmarks=false if you have gflags installed (otherwise you will
+need to edit the source).
+
+Finally, snappy can benchmark Snappy against a few other compression libraries
+(zlib, LZO, LZF, FastLZ and QuickLZ), if they were detected at configure time.
+To benchmark using a given file, give the compression algorithm you want to test
+Snappy against (e.g. --zlib) and then a list of one or more file names on the
+command line. The testdata/ directory contains the files used by the
+microbenchmark, which should provide a reasonably balanced starting point for
+benchmarking. (Note that baddata[1-3].snappy are not intended as benchmarks; they
+are used to verify correctness in the presence of corrupted data in the unit
+test.)
+
+
+Contact
+=======
+
+Snappy is distributed through Google Code. For the latest version, a bug tracker,
+and other information, see
+
+  http://code.google.com/p/snappy/

src/snappy/snappy/autogen.sh

@@ -0,0 +1,7 @@
+#! /bin/sh -e
+rm -rf autom4te.cache
+aclocal -I m4
+autoheader
+libtoolize --copy
+automake --add-missing --copy
+autoconf

src/snappy/snappy/configure.ac

@@ -0,0 +1,133 @@
+m4_define([snappy_major], [1])
+m4_define([snappy_minor], [1])
+m4_define([snappy_patchlevel], [2])
+
+# Libtool shared library interface versions (current:revision:age)
+# Update this value for every release!  (A:B:C will map to foo.so.(A-C).C.B)
+# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
+m4_define([snappy_ltversion], [3:1:2])
+
+AC_INIT([snappy], [snappy_major.snappy_minor.snappy_patchlevel])
+AC_CONFIG_MACRO_DIR([m4])
+
+# These are flags passed to automake (though they look like gcc flags!)
+AM_INIT_AUTOMAKE([-Wall])
+
+LT_INIT
+AC_SUBST([LIBTOOL_DEPS])
+AC_PROG_CXX
+AC_LANG([C++])
+AC_C_BIGENDIAN
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_CHECK_HEADERS([stdint.h stddef.h sys/mman.h sys/resource.h windows.h byteswap.h sys/byteswap.h sys/endian.h sys/time.h])
+
+# Don't use AC_FUNC_MMAP, as it checks for mappings of already-mapped memory,
+# which we don't need (and does not exist on Windows).
+AC_CHECK_FUNC([mmap])
+
+GTEST_LIB_CHECK([], [true], [true # Ignore; we can live without it.])
+
+AC_ARG_WITH([gflags],
+  [AS_HELP_STRING(
+    [--with-gflags],
+    [use Google Flags package to enhance the unit test @<:@default=check@:>@])],
+    [],
+    [with_gflags=check])
+
+if test "x$with_gflags" != "xno"; then
+  PKG_CHECK_MODULES(
+    [gflags],
+    [libgflags],
+    [AC_DEFINE([HAVE_GFLAGS], [1], [Use the gflags package for command-line parsing.])],
+    [if test "x$with_gflags" != "xcheck"; then
+      AC_MSG_FAILURE([--with-gflags was given, but test for gflags failed])
+    fi])
+fi
+
+# See if we have __builtin_expect.
+# TODO: Use AC_CACHE.
+AC_MSG_CHECKING([if the compiler supports __builtin_expect])
+ 
+AC_TRY_COMPILE(, [
+    return __builtin_expect(1, 1) ? 1 : 0
+], [
+    snappy_have_builtin_expect=yes
+    AC_MSG_RESULT([yes])
+], [
+    snappy_have_builtin_expect=no
+    AC_MSG_RESULT([no])
+])
+if test x$snappy_have_builtin_expect = xyes ; then
+    AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler supports __builtin_expect.])
+fi
+
+# See if we have working count-trailing-zeros intrinsics.
+# TODO: Use AC_CACHE.
+AC_MSG_CHECKING([if the compiler supports __builtin_ctzll])
+
+AC_TRY_COMPILE(, [
+    return (__builtin_ctzll(0x100000000LL) == 32) ? 1 : 0
+], [
+    snappy_have_builtin_ctz=yes
+    AC_MSG_RESULT([yes])
+], [
+    snappy_have_builtin_ctz=no
+    AC_MSG_RESULT([no])
+])
+if test x$snappy_have_builtin_ctz = xyes ; then
+    AC_DEFINE([HAVE_BUILTIN_CTZ], [1], [Define to 1 if the compiler supports __builtin_ctz and friends.])
+fi
+
+# Other compression libraries; the unit test can use these for comparison
+# if they are available. If they are not found, just ignore.
+UNITTEST_LIBS=""
+AC_DEFUN([CHECK_EXT_COMPRESSION_LIB], [
+  AH_CHECK_LIB([$1])
+  AC_CHECK_LIB(
+    [$1],
+    [$2],
+    [
+      AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_LIB$1))
+      UNITTEST_LIBS="-l$1 $UNITTEST_LIBS"
+    ],
+    [true]
+  )
+])
+CHECK_EXT_COMPRESSION_LIB([z], [zlibVersion])
+CHECK_EXT_COMPRESSION_LIB([lzo2], [lzo1x_1_15_compress])
+CHECK_EXT_COMPRESSION_LIB([lzf], [lzf_compress])
+CHECK_EXT_COMPRESSION_LIB([fastlz], [fastlz_compress])
+CHECK_EXT_COMPRESSION_LIB([quicklz], [qlz_compress])
+AC_SUBST([UNITTEST_LIBS])
+
+# These are used by snappy-stubs-public.h.in.
+if test "$ac_cv_header_stdint_h" = "yes"; then
+    AC_SUBST([ac_cv_have_stdint_h], [1])
+else
+    AC_SUBST([ac_cv_have_stdint_h], [0])
+fi
+if test "$ac_cv_header_stddef_h" = "yes"; then
+    AC_SUBST([ac_cv_have_stddef_h], [1])
+else
+    AC_SUBST([ac_cv_have_stddef_h], [0])
+fi
+if test "$ac_cv_header_sys_uio_h" = "yes"; then
+    AC_SUBST([ac_cv_have_sys_uio_h], [1])
+else
+    AC_SUBST([ac_cv_have_sys_uio_h], [0])
+fi
+
+# Export the version to snappy-stubs-public.h.
+SNAPPY_MAJOR="snappy_major"
+SNAPPY_MINOR="snappy_minor"
+SNAPPY_PATCHLEVEL="snappy_patchlevel"
+
+AC_SUBST([SNAPPY_MAJOR])
+AC_SUBST([SNAPPY_MINOR])
+AC_SUBST([SNAPPY_PATCHLEVEL])
+AC_SUBST([SNAPPY_LTVERSION], snappy_ltversion)
+
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_FILES([Makefile snappy-stubs-public.h])
+AC_OUTPUT

src/snappy/snappy/format_description.txt

@@ -0,0 +1,110 @@
+Snappy compressed format description
+Last revised: 2011-10-05
+
+
+This is not a formal specification, but should suffice to explain most
+relevant parts of how the Snappy format works. It is originally based on
+text by Zeev Tarantov.
+
+Snappy is a LZ77-type compressor with a fixed, byte-oriented encoding.
+There is no entropy encoder backend nor framing layer -- the latter is
+assumed to be handled by other parts of the system.
+
+This document only describes the format, not how the Snappy compressor nor
+decompressor actually works. The correctness of the decompressor should not
+depend on implementation details of the compressor, and vice versa.
+
+
+1. Preamble
+
+The stream starts with the uncompressed length (up to a maximum of 2^32 - 1),
+stored as a little-endian varint. Varints consist of a series of bytes,
+where the lower 7 bits are data and the upper bit is set iff there are
+more bytes to be read. In other words, an uncompressed length of 64 would
+be stored as 0x40, and an uncompressed length of 2097150 (0x1FFFFE)
+would be stored as 0xFE 0xFF 0x7F.
+
+
+2. The compressed stream itself
+
+There are two types of elements in a Snappy stream: Literals and
+copies (backreferences). There is no restriction on the order of elements,
+except that the stream naturally cannot start with a copy. (Having
+two literals in a row is never optimal from a compression point of
+view, but nevertheless fully permitted.) Each element starts with a tag byte,
+and the lower two bits of this tag byte signal what type of element will
+follow:
+
+  00: Literal
+  01: Copy with 1-byte offset
+  10: Copy with 2-byte offset
+  11: Copy with 4-byte offset
+
+The interpretation of the upper six bits are element-dependent.
+
+
+2.1. Literals (00)
+
+Literals are uncompressed data stored directly in the byte stream.
+The literal length is stored differently depending on the length
+of the literal:
+
+ - For literals up to and including 60 bytes in length, the upper
+   six bits of the tag byte contain (len-1). The literal follows
+   immediately thereafter in the bytestream.
+ - For longer literals, the (len-1) value is stored after the tag byte,
+   little-endian. The upper six bits of the tag byte describe how
+   many bytes are used for the length; 60, 61, 62 or 63 for
+   1-4 bytes, respectively. The literal itself follows after the
+   length.
+
+
+2.2. Copies
+
+Copies are references back into previous decompressed data, telling
+the decompressor to reuse data it has previously decoded.
+They encode two values: The _offset_, saying how many bytes back
+from the current position to read, and the _length_, how many bytes
+to copy. Offsets of zero can be encoded, but are not legal;
+similarly, it is possible to encode backreferences that would
+go past the end of the block (offset > current decompressed position),
+which is also nonsensical and thus not allowed.
+
+As in most LZ77-based compressors, the length can be larger than the offset,
+yielding a form of run-length encoding (RLE). For instance,
+"xababab" could be encoded as
+
+  <literal: "xab"> <copy: offset=2 length=4>
+
+Note that since the current Snappy compressor works in 32 kB
+blocks and does not do matching across blocks, it will never produce
+a bitstream with offsets larger than about 32768. However, the
+decompressor should not rely on this, as it may change in the future.
+
+There are several different kinds of copy elements, depending on
+the amount of bytes to be copied (length), and how far back the
+data to be copied is (offset).
+
+
+2.2.1. Copy with 1-byte offset (01)
+
+These elements can encode lengths between [4..11] bytes and offsets
+between [0..2047] bytes. (len-4) occupies three bits and is stored
+in bits [2..4] of the tag byte. The offset occupies 11 bits, of which the
+upper three are stored in the upper three bits ([5..7]) of the tag byte,
+and the lower eight are stored in a byte following the tag byte.
+
+
+2.2.2. Copy with 2-byte offset (10)
+
+These elements can encode lengths between [1..64] and offsets from
+[0..65535]. (len-1) occupies six bits and is stored in the upper
+six bits ([2..7]) of the tag byte. The offset is stored as a
+little-endian 16-bit integer in the two bytes following the tag byte.
+
+
+2.2.3. Copy with 4-byte offset (11)
+
+These are like the copies with 2-byte offsets (see previous subsection),
+except that the offset is stored as a 32-bit integer instead of a
+16-bit integer (and thus will occupy four bytes).

src/snappy/snappy/framing_format.txt

@@ -0,0 +1,135 @@
+Snappy framing format description
+Last revised: 2013-10-25
+
+This format decribes a framing format for Snappy, allowing compressing to
+files or streams that can then more easily be decompressed without having
+to hold the entire stream in memory. It also provides data checksums to
+help verify integrity. It does not provide metadata checksums, so it does
+not protect against e.g. all forms of truncations.
+
+Implementation of the framing format is optional for Snappy compressors and
+decompressor; it is not part of the Snappy core specification.
+
+
+1. General structure
+
+The file consists solely of chunks, lying back-to-back with no padding
+in between. Each chunk consists first a single byte of chunk identifier,
+then a three-byte little-endian length of the chunk in bytes (from 0 to
+16777215, inclusive), and then the data if any. The four bytes of chunk
+header is not counted in the data length.
+
+The different chunk types are listed below. The first chunk must always
+be the stream identifier chunk (see section 4.1, below). The stream
+ends when the file ends -- there is no explicit end-of-file marker.
+
+
+2. File type identification
+
+The following identifiers for this format are recommended where appropriate.
+However, note that none have been registered officially, so this is only to
+be taken as a guideline. We use "Snappy framed" to distinguish between this
+format and raw Snappy data.
+
+  File extension:         .sz
+  MIME type:              application/x-snappy-framed
+  HTTP Content-Encoding:  x-snappy-framed
+
+
+3. Checksum format
+
+Some chunks have data protected by a checksum (the ones that do will say so
+explicitly). The checksums are always masked CRC-32Cs.
+
+A description of CRC-32C can be found in RFC 3720, section 12.1, with
+examples in section B.4.
+
+Checksums are not stored directly, but masked, as checksumming data and
+then its own checksum can be problematic. The masking is the same as used
+in Apache Hadoop: Rotate the checksum by 15 bits, then add the constant
+0xa282ead8 (using wraparound as normal for unsigned integers). This is
+equivalent to the following C code:
+
+  uint32_t mask_checksum(uint32_t x) {
+    return ((x >> 15) | (x << 17)) + 0xa282ead8;
+  }
+
+Note that the masking is reversible.
+
+The checksum is always stored as a four bytes long integer, in little-endian.
+
+
+4. Chunk types
+
+The currently supported chunk types are described below. The list may
+be extended in the future.
+
+
+4.1. Stream identifier (chunk type 0xff)
+
+The stream identifier is always the first element in the stream.
+It is exactly six bytes long and contains "sNaPpY" in ASCII. This means that
+a valid Snappy framed stream always starts with the bytes
+
+  0xff 0x06 0x00 0x00 0x73 0x4e 0x61 0x50 0x70 0x59
+
+The stream identifier chunk can come multiple times in the stream besides
+the first; if such a chunk shows up, it should simply be ignored, assuming
+it has the right length and contents. This allows for easy concatenation of
+compressed files without the need for re-framing.
+
+
+4.2. Compressed data (chunk type 0x00)
+
+Compressed data chunks contain a normal Snappy compressed bitstream;
+see the compressed format specification. The compressed data is preceded by
+the CRC-32C (see section 3) of the _uncompressed_ data.
+
+Note that the data portion of the chunk, i.e., the compressed contents,
+can be at most 16777211 bytes (2^24 - 1, minus the checksum).
+However, we place an additional restriction that the uncompressed data
+in a chunk must be no longer than 65536 bytes. This allows consumers to
+easily use small fixed-size buffers.
+
+
+4.3. Uncompressed data (chunk type 0x01)
+
+Uncompressed data chunks allow a compressor to send uncompressed,
+raw data; this is useful if, for instance, uncompressible or
+near-incompressible data is detected, and faster decompression is desired.
+
+As in the compressed chunks, the data is preceded by its own masked
+CRC-32C (see section 3).
+
+An uncompressed data chunk, like compressed data chunks, should contain
+no more than 65536 data bytes, so the maximum legal chunk length with the
+checksum is 65540.
+
+
+4.4. Padding (chunk type 0xfe)
+
+Padding chunks allow a compressor to increase the size of the data stream
+so that it complies with external demands, e.g. that the total number of
+bytes is a multiple of some value.
+
+All bytes of the padding chunk, except the chunk byte itself and the length,
+should be zero, but decompressors must not try to interpret or verify the
+padding data in any way.
+
+
+4.5. Reserved unskippable chunks (chunk types 0x02-0x7f)
+
+These are reserved for future expansion. A decoder that sees such a chunk
+should immediately return an error, as it must assume it cannot decode the
+stream correctly.
+
+Future versions of this specification may define meanings for these chunks.
+
+
+4.6. Reserved skippable chunks (chunk types 0x80-0xfd)
+
+These are also reserved for future expansion, but unlike the chunks
+described in 4.5, a decoder seeing these must skip them and continue
+decoding.
+
+Future versions of this specification may define meanings for these chunks.

src/snappy/snappy/m4/gtest.m4

@@ -0,0 +1,74 @@
+dnl GTEST_LIB_CHECK([minimum version [,
+dnl                  action if found [,action if not found]]])
+dnl
+dnl Check for the presence of the Google Test library, optionally at a minimum
+dnl version, and indicate a viable version with the HAVE_GTEST flag. It defines
+dnl standard variables for substitution including GTEST_CPPFLAGS,
+dnl GTEST_CXXFLAGS, GTEST_LDFLAGS, and GTEST_LIBS. It also defines
+dnl GTEST_VERSION as the version of Google Test found. Finally, it provides
+dnl optional custom action slots in the event GTEST is found or not.
+AC_DEFUN([GTEST_LIB_CHECK],
+[
+dnl Provide a flag to enable or disable Google Test usage.
+AC_ARG_ENABLE([gtest],
+  [AS_HELP_STRING([--enable-gtest],
+                  [Enable tests using the Google C++ Testing Framework.
+                  (Default is enabled.)])],
+  [],
+  [enable_gtest=])
+AC_ARG_VAR([GTEST_CONFIG],
+           [The exact path of Google Test's 'gtest-config' script.])
+AC_ARG_VAR([GTEST_CPPFLAGS],
+           [C-like preprocessor flags for Google Test.])
+AC_ARG_VAR([GTEST_CXXFLAGS],
+           [C++ compile flags for Google Test.])
+AC_ARG_VAR([GTEST_LDFLAGS],
+           [Linker path and option flags for Google Test.])
+AC_ARG_VAR([GTEST_LIBS],
+           [Library linking flags for Google Test.])
+AC_ARG_VAR([GTEST_VERSION],
+           [The version of Google Test available.])
+HAVE_GTEST="no"
+AS_IF([test "x${enable_gtest}" != "xno"],
+  [AC_MSG_CHECKING([for 'gtest-config'])
+   AS_IF([test "x${enable_gtest}" = "xyes"],
+     [AS_IF([test -x "${enable_gtest}/scripts/gtest-config"],
+        [GTEST_CONFIG="${enable_gtest}/scripts/gtest-config"],
+        [GTEST_CONFIG="${enable_gtest}/bin/gtest-config"])
+      AS_IF([test -x "${GTEST_CONFIG}"], [],
+        [AC_MSG_RESULT([no])
+         AC_MSG_ERROR([dnl
+Unable to locate either a built or installed Google Test.
+The specific location '${enable_gtest}' was provided for a built or installed
+Google Test, but no 'gtest-config' script could be found at this location.])
+         ])],
+     [AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
+   AS_IF([test -x "${GTEST_CONFIG}"],
+     [AC_MSG_RESULT([${GTEST_CONFIG}])
+      m4_ifval([$1],
+        [_gtest_min_version="--min-version=$1"
+         AC_MSG_CHECKING([for Google Test at least version >= $1])],
+        [_gtest_min_version="--min-version=0"
+         AC_MSG_CHECKING([for Google Test])])
+      AS_IF([${GTEST_CONFIG} ${_gtest_min_version}],
+        [AC_MSG_RESULT([yes])
+         HAVE_GTEST='yes'],
+        [AC_MSG_RESULT([no])])],
+     [AC_MSG_RESULT([no])])
+   AS_IF([test "x${HAVE_GTEST}" = "xyes"],
+     [GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
+      GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
+      GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
+      GTEST_LIBS=`${GTEST_CONFIG} --libs`
+      GTEST_VERSION=`${GTEST_CONFIG} --version`
+      AC_DEFINE([HAVE_GTEST],[1],[Defined when Google Test is available.])],
+     [AS_IF([test "x${enable_gtest}" = "xyes"],
+        [AC_MSG_ERROR([dnl
+Google Test was enabled, but no viable version could be found.])
+         ])])])
+AC_SUBST([HAVE_GTEST])
+AM_CONDITIONAL([HAVE_GTEST],[test "x$HAVE_GTEST" = "xyes"])
+AS_IF([test "x$HAVE_GTEST" = "xyes"],
+  [m4_ifval([$2], [$2])],
+  [m4_ifval([$3], [$3])])
+])

src/snappy/snappy/snappy-c.cc

@@ -0,0 +1,90 @@
+// Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+
+#include "snappy.h"
+#include "snappy-c.h"
+
+extern "C" {
+
+snappy_status snappy_compress(const char* input,
+                              size_t input_length,
+                              char* compressed,
+                              size_t *compressed_length) {
+  if (*compressed_length < snappy_max_compressed_length(input_length)) {
+    return SNAPPY_BUFFER_TOO_SMALL;
+  }
+  snappy::RawCompress(input, input_length, compressed, compressed_length);
+  return SNAPPY_OK;
+}
+
+snappy_status snappy_uncompress(const char* compressed,
+                                size_t compressed_length,
+                                char* uncompressed,
+                                size_t* uncompressed_length) {
+  size_t real_uncompressed_length;
+  if (!snappy::GetUncompressedLength(compressed,
+                                     compressed_length,
+                                     &real_uncompressed_length)) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  if (*uncompressed_length < real_uncompressed_length) {
+    return SNAPPY_BUFFER_TOO_SMALL;
+  }
+  if (!snappy::RawUncompress(compressed, compressed_length, uncompressed)) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  *uncompressed_length = real_uncompressed_length;
+  return SNAPPY_OK;
+}
+
+size_t snappy_max_compressed_length(size_t source_length) {
+  return snappy::MaxCompressedLength(source_length);
+}
+
+snappy_status snappy_uncompressed_length(const char *compressed,
+                                         size_t compressed_length,
+                                         size_t *result) {
+  if (snappy::GetUncompressedLength(compressed,
+                                    compressed_length,
+                                    result)) {
+    return SNAPPY_OK;
+  } else {
+    return SNAPPY_INVALID_INPUT;
+  }
+}
+
+snappy_status snappy_validate_compressed_buffer(const char *compressed,
+                                                size_t compressed_length) {
+  if (snappy::IsValidCompressedBuffer(compressed, compressed_length)) {
+    return SNAPPY_OK;
+  } else {
+    return SNAPPY_INVALID_INPUT;
+  }
+}
+
+}  // extern "C"

src/snappy/snappy/snappy-c.h

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. 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
+ * OWNER 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.
+ *
+ * Plain C interface (a wrapper around the C++ implementation).
+ */
+
+#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_
+#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+/*
+ * Return values; see the documentation for each function to know
+ * what each can return.
+ */
+typedef enum {
+  SNAPPY_OK = 0,
+  SNAPPY_INVALID_INPUT = 1,
+  SNAPPY_BUFFER_TOO_SMALL = 2
+} snappy_status;
+
+/*
+ * Takes the data stored in "input[0..input_length-1]" and stores
+ * it in the array pointed to by "compressed".
+ *
+ * <compressed_length> signals the space available in "compressed".
+ * If it is not at least equal to "snappy_max_compressed_length(input_length)",
+ * SNAPPY_BUFFER_TOO_SMALL is returned. After successful compression,
+ * <compressed_length> contains the true length of the compressed output,
+ * and SNAPPY_OK is returned.
+ *
+ * Example:
+ *   size_t output_length = snappy_max_compressed_length(input_length);
+ *   char* output = (char*)malloc(output_length);
+ *   if (snappy_compress(input, input_length, output, &output_length)
+ *       == SNAPPY_OK) {
+ *     ... Process(output, output_length) ...
+ *   }
+ *   free(output);
+ */
+snappy_status snappy_compress(const char* input,
+                              size_t input_length,
+                              char* compressed,
+                              size_t* compressed_length);
+
+/*
+ * Given data in "compressed[0..compressed_length-1]" generated by
+ * calling the snappy_compress routine, this routine stores
+ * the uncompressed data to
+ *   uncompressed[0..uncompressed_length-1].
+ * Returns failure (a value not equal to SNAPPY_OK) if the message
+ * is corrupted and could not be decrypted.
+ *
+ * <uncompressed_length> signals the space available in "uncompressed".
+ * If it is not at least equal to the value returned by
+ * snappy_uncompressed_length for this stream, SNAPPY_BUFFER_TOO_SMALL
+ * is returned. After successful decompression, <uncompressed_length>
+ * contains the true length of the decompressed output.
+ *
+ * Example:
+ *   size_t output_length;
+ *   if (snappy_uncompressed_length(input, input_length, &output_length)
+ *       != SNAPPY_OK) {
+ *     ... fail ...
+ *   }
+ *   char* output = (char*)malloc(output_length);
+ *   if (snappy_uncompress(input, input_length, output, &output_length)
+ *       == SNAPPY_OK) {
+ *     ... Process(output, output_length) ...
+ *   }
+ *   free(output);
+ */
+snappy_status snappy_uncompress(const char* compressed,
+                                size_t compressed_length,
+                                char* uncompressed,
+                                size_t* uncompressed_length);
+
+/*
+ * Returns the maximal size of the compressed representation of
+ * input data that is "source_length" bytes in length.
+ */
+size_t snappy_max_compressed_length(size_t source_length);
+
+/*
+ * REQUIRES: "compressed[]" was produced by snappy_compress()
+ * Returns SNAPPY_OK and stores the length of the uncompressed data in
+ * *result normally. Returns SNAPPY_INVALID_INPUT on parsing error.
+ * This operation takes O(1) time.
+ */
+snappy_status snappy_uncompressed_length(const char* compressed,
+                                         size_t compressed_length,
+                                         size_t* result);
+
+/*
+ * Check if the contents of "compressed[]" can be uncompressed successfully.
+ * Does not return the uncompressed data; if so, returns SNAPPY_OK,
+ * or if not, returns SNAPPY_INVALID_INPUT.
+ * Takes time proportional to compressed_length, but is usually at least a
+ * factor of four faster than actual decompression.
+ */
+snappy_status snappy_validate_compressed_buffer(const char* compressed,
+                                                size_t compressed_length);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  /* UTIL_SNAPPY_OPENSOURCE_SNAPPY_C_H_ */

src/snappy/snappy/snappy-internal.h

@@ -0,0 +1,150 @@
+// Copyright 2008 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// Internals shared between the Snappy implementation and its unittest.
+
+#ifndef UTIL_SNAPPY_SNAPPY_INTERNAL_H_
+#define UTIL_SNAPPY_SNAPPY_INTERNAL_H_
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+namespace internal {
+
+class WorkingMemory {
+ public:
+  WorkingMemory() : large_table_(NULL) { }
+  ~WorkingMemory() { delete[] large_table_; }
+
+  // Allocates and clears a hash table using memory in "*this",
+  // stores the number of buckets in "*table_size" and returns a pointer to
+  // the base of the hash table.
+  uint16* GetHashTable(size_t input_size, int* table_size);
+
+ private:
+  uint16 small_table_[1<<10];    // 2KB
+  uint16* large_table_;          // Allocated only when needed
+
+  DISALLOW_COPY_AND_ASSIGN(WorkingMemory);
+};
+
+// Flat array compression that does not emit the "uncompressed length"
+// prefix. Compresses "input" string to the "*op" buffer.
+//
+// REQUIRES: "input_length <= kBlockSize"
+// REQUIRES: "op" points to an array of memory that is at least
+// "MaxCompressedLength(input_length)" in size.
+// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+// REQUIRES: "table_size" is a power of two
+//
+// Returns an "end" pointer into "op" buffer.
+// "end - op" is the compressed size of "input".
+char* CompressFragment(const char* input,
+                       size_t input_length,
+                       char* op,
+                       uint16* table,
+                       const int table_size);
+
+// Return the largest n such that
+//
+//   s1[0,n-1] == s2[0,n-1]
+//   and n <= (s2_limit - s2).
+//
+// Does not read *s2_limit or beyond.
+// Does not read *(s1 + (s2_limit - s2)) or beyond.
+// Requires that s2_limit >= s2.
+//
+// Separate implementation for x86_64, for speed.  Uses the fact that
+// x86_64 is little endian.
+#if defined(ARCH_K8)
+static inline int FindMatchLength(const char* s1,
+                                  const char* s2,
+                                  const char* s2_limit) {
+  assert(s2_limit >= s2);
+  int matched = 0;
+
+  // Find out how long the match is. We loop over the data 64 bits at a
+  // time until we find a 64-bit block that doesn't match; then we find
+  // the first non-matching bit and use that to calculate the total
+  // length of the match.
+  while (PREDICT_TRUE(s2 <= s2_limit - 8)) {
+    if (PREDICT_FALSE(UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched))) {
+      s2 += 8;
+      matched += 8;
+    } else {
+      // On current (mid-2008) Opteron models there is a 3% more
+      // efficient code sequence to find the first non-matching byte.
+      // However, what follows is ~10% better on Intel Core 2 and newer,
+      // and we expect AMD's bsf instruction to improve.
+      uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
+      int matching_bits = Bits::FindLSBSetNonZero64(x);
+      matched += matching_bits >> 3;
+      return matched;
+    }
+  }
+  while (PREDICT_TRUE(s2 < s2_limit)) {
+    if (PREDICT_TRUE(s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    } else {
+      return matched;
+    }
+  }
+  return matched;
+}
+#else
+static inline int FindMatchLength(const char* s1,
+                                  const char* s2,
+                                  const char* s2_limit) {
+  // Implementation based on the x86-64 version, above.
+  assert(s2_limit >= s2);
+  int matched = 0;
+
+  while (s2 <= s2_limit - 4 &&
+         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
+    s2 += 4;
+    matched += 4;
+  }
+  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
+    uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
+    int matching_bits = Bits::FindLSBSetNonZero(x);
+    matched += matching_bits >> 3;
+  } else {
+    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    }
+  }
+  return matched;
+}
+#endif
+
+}  // end namespace internal
+}  // end namespace snappy
+
+#endif  // UTIL_SNAPPY_SNAPPY_INTERNAL_H_

src/snappy/snappy/snappy-sinksource.cc

@@ -0,0 +1,71 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+
+#include <string.h>
+
+#include "snappy-sinksource.h"
+
+namespace snappy {
+
+Source::~Source() { }
+
+Sink::~Sink() { }
+
+char* Sink::GetAppendBuffer(size_t length, char* scratch) {
+  return scratch;
+}
+
+ByteArraySource::~ByteArraySource() { }
+
+size_t ByteArraySource::Available() const { return left_; }
+
+const char* ByteArraySource::Peek(size_t* len) {
+  *len = left_;
+  return ptr_;
+}
+
+void ByteArraySource::Skip(size_t n) {
+  left_ -= n;
+  ptr_ += n;
+}
+
+UncheckedByteArraySink::~UncheckedByteArraySink() { }
+
+void UncheckedByteArraySink::Append(const char* data, size_t n) {
+  // Do no copying if the caller filled in the result of GetAppendBuffer()
+  if (data != dest_) {
+    memcpy(dest_, data, n);
+  }
+  dest_ += n;
+}
+
+char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {
+  return dest_;
+}
+
+}

src/snappy/snappy/snappy-sinksource.h

@@ -0,0 +1,137 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
+#define UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
+
+#include <stddef.h>
+
+
+namespace snappy {
+
+// A Sink is an interface that consumes a sequence of bytes.
+class Sink {
+ public:
+  Sink() { }
+  virtual ~Sink();
+
+  // Append "bytes[0,n-1]" to this.
+  virtual void Append(const char* bytes, size_t n) = 0;
+
+  // Returns a writable buffer of the specified length for appending.
+  // May return a pointer to the caller-owned scratch buffer which
+  // must have at least the indicated length.  The returned buffer is
+  // only valid until the next operation on this Sink.
+  //
+  // After writing at most "length" bytes, call Append() with the
+  // pointer returned from this function and the number of bytes
+  // written.  Many Append() implementations will avoid copying
+  // bytes if this function returned an internal buffer.
+  //
+  // If a non-scratch buffer is returned, the caller may only pass a
+  // prefix of it to Append().  That is, it is not correct to pass an
+  // interior pointer of the returned array to Append().
+  //
+  // The default implementation always returns the scratch buffer.
+  virtual char* GetAppendBuffer(size_t length, char* scratch);
+
+
+ private:
+  // No copying
+  Sink(const Sink&);
+  void operator=(const Sink&);
+};
+
+// A Source is an interface that yields a sequence of bytes
+class Source {
+ public:
+  Source() { }
+  virtual ~Source();
+
+  // Return the number of bytes left to read from the source
+  virtual size_t Available() const = 0;
+
+  // Peek at the next flat region of the source.  Does not reposition
+  // the source.  The returned region is empty iff Available()==0.
+  //
+  // Returns a pointer to the beginning of the region and store its
+  // length in *len.
+  //
+  // The returned region is valid until the next call to Skip() or
+  // until this object is destroyed, whichever occurs first.
+  //
+  // The returned region may be larger than Available() (for example
+  // if this ByteSource is a view on a substring of a larger source).
+  // The caller is responsible for ensuring that it only reads the
+  // Available() bytes.
+  virtual const char* Peek(size_t* len) = 0;
+
+  // Skip the next n bytes.  Invalidates any buffer returned by
+  // a previous call to Peek().
+  // REQUIRES: Available() >= n
+  virtual void Skip(size_t n) = 0;
+
+ private:
+  // No copying
+  Source(const Source&);
+  void operator=(const Source&);
+};
+
+// A Source implementation that yields the contents of a flat array
+class ByteArraySource : public Source {
+ public:
+  ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
+  virtual ~ByteArraySource();
+  virtual size_t Available() const;
+  virtual const char* Peek(size_t* len);
+  virtual void Skip(size_t n);
+ private:
+  const char* ptr_;
+  size_t left_;
+};
+
+// A Sink implementation that writes to a flat array without any bound checks.
+class UncheckedByteArraySink : public Sink {
+ public:
+  explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
+  virtual ~UncheckedByteArraySink();
+  virtual void Append(const char* data, size_t n);
+  virtual char* GetAppendBuffer(size_t len, char* scratch);
+
+  // Return the current output pointer so that a caller can see how
+  // many bytes were produced.
+  // Note: this is not a Sink method.
+  char* CurrentDestination() const { return dest_; }
+ private:
+  char* dest_;
+};
+
+
+}
+
+#endif  // UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_

src/snappy/snappy/snappy-stubs-internal.cc

@@ -0,0 +1,42 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+
+#include <algorithm>
+#include <string>
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+
+void Varint::Append32(string* s, uint32 value) {
+  char buf[Varint::kMax32];
+  const char* p = Varint::Encode32(buf, value);
+  s->append(buf, p - buf);
+}
+
+}  // namespace snappy

src/snappy/snappy/snappy-stubs-internal.h

@@ -0,0 +1,491 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// Various stubs for the open-source version of Snappy.
+
+#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
+#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif
+
+#include "snappy-stubs-public.h"
+
+#if defined(__x86_64__)
+
+// Enable 64-bit optimized versions of some routines.
+#define ARCH_K8 1
+
+#endif
+
+// Needed by OS X, among others.
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+// Pull in std::min, std::ostream, and the likes. This is safe because this
+// header file is never used from any public header files.
+using namespace std;
+
+// The size of an array, if known at compile-time.
+// Will give unexpected results if used on a pointer.
+// We undefine it first, since some compilers already have a definition.
+#ifdef ARRAYSIZE
+#undef ARRAYSIZE
+#endif
+#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
+
+// Static prediction hints.
+#ifdef HAVE_BUILTIN_EXPECT
+#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+#define PREDICT_FALSE(x) x
+#define PREDICT_TRUE(x) x
+#endif
+
+// This is only used for recomputing the tag byte table used during
+// decompression; for simplicity we just remove it from the open-source
+// version (anyone who wants to regenerate it can just do the call
+// themselves within main()).
+#define DEFINE_bool(flag_name, default_value, description) \
+  bool FLAGS_ ## flag_name = default_value
+#define DECLARE_bool(flag_name) \
+  extern bool FLAGS_ ## flag_name
+
+namespace snappy {
+
+static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF);
+static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
+
+// Potentially unaligned loads and stores.
+
+// x86 and PowerPC can simply do these loads and stores native.
+
+#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__)
+
+#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
+#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
+#define UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p))
+
+#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
+#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
+#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val))
+
+// ARMv7 and newer support native unaligned accesses, but only of 16-bit
+// and 32-bit values (not 64-bit); older versions either raise a fatal signal,
+// do an unaligned read and rotate the words around a bit, or do the reads very
+// slowly (trip through kernel mode). There's no simple #define that says just
+// “ARMv7 or higher”, so we have to filter away all ARMv5 and ARMv6
+// sub-architectures.
+//
+// This is a mess, but there's not much we can do about it.
+
+#elif defined(__arm__) && \
+      !defined(__ARM_ARCH_4__) && \
+      !defined(__ARM_ARCH_4T__) && \
+      !defined(__ARM_ARCH_5__) && \
+      !defined(__ARM_ARCH_5T__) && \
+      !defined(__ARM_ARCH_5TE__) && \
+      !defined(__ARM_ARCH_5TEJ__) && \
+      !defined(__ARM_ARCH_6__) && \
+      !defined(__ARM_ARCH_6J__) && \
+      !defined(__ARM_ARCH_6K__) && \
+      !defined(__ARM_ARCH_6Z__) && \
+      !defined(__ARM_ARCH_6ZK__) && \
+      !defined(__ARM_ARCH_6T2__)
+
+#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
+#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
+
+#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
+#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
+
+// TODO(user): NEON supports unaligned 64-bit loads and stores.
+// See if that would be more efficient on platforms supporting it,
+// at least for copies.
+
+inline uint64 UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+#else
+
+// These functions are provided for architectures that don't support
+// unaligned loads and stores.
+
+inline uint16 UNALIGNED_LOAD16(const void *p) {
+  uint16 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32 UNALIGNED_LOAD32(const void *p) {
+  uint32 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64 UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UNALIGNED_STORE16(void *p, uint16 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE32(void *p, uint32 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+#endif
+
+// This can be more efficient than UNALIGNED_LOAD64 + UNALIGNED_STORE64
+// on some platforms, in particular ARM.
+inline void UnalignedCopy64(const void *src, void *dst) {
+  if (sizeof(void *) == 8) {
+    UNALIGNED_STORE64(dst, UNALIGNED_LOAD64(src));
+  } else {
+    const char *src_char = reinterpret_cast<const char *>(src);
+    char *dst_char = reinterpret_cast<char *>(dst);
+
+    UNALIGNED_STORE32(dst_char, UNALIGNED_LOAD32(src_char));
+    UNALIGNED_STORE32(dst_char + 4, UNALIGNED_LOAD32(src_char + 4));
+  }
+}
+
+// The following guarantees declaration of the byte swap functions.
+#ifdef WORDS_BIGENDIAN
+
+#ifdef HAVE_SYS_BYTEORDER_H
+#include <sys/byteorder.h>
+#endif
+
+#ifdef HAVE_SYS_ENDIAN_H
+#include <sys/endian.h>
+#endif
+
+#ifdef _MSC_VER
+#include <stdlib.h>
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+
+#elif defined(__APPLE__)
+// Mac OS X / Darwin features
+#include <libkern/OSByteOrder.h>
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+
+#elif defined(HAVE_BYTESWAP_H)
+#include <byteswap.h>
+
+#elif defined(bswap32)
+// FreeBSD defines bswap{16,32,64} in <sys/endian.h> (already #included).
+#define bswap_16(x) bswap16(x)
+#define bswap_32(x) bswap32(x)
+#define bswap_64(x) bswap64(x)
+
+#elif defined(BSWAP_64)
+// Solaris 10 defines BSWAP_{16,32,64} in <sys/byteorder.h> (already #included).
+#define bswap_16(x) BSWAP_16(x)
+#define bswap_32(x) BSWAP_32(x)
+#define bswap_64(x) BSWAP_64(x)
+
+#else
+
+inline uint16 bswap_16(uint16 x) {
+  return (x << 8) | (x >> 8);
+}
+
+inline uint32 bswap_32(uint32 x) {
+  x = ((x & 0xff00ff00UL) >> 8) | ((x & 0x00ff00ffUL) << 8);
+  return (x >> 16) | (x << 16);
+}
+
+inline uint64 bswap_64(uint64 x) {
+  x = ((x & 0xff00ff00ff00ff00ULL) >> 8) | ((x & 0x00ff00ff00ff00ffULL) << 8);
+  x = ((x & 0xffff0000ffff0000ULL) >> 16) | ((x & 0x0000ffff0000ffffULL) << 16);
+  return (x >> 32) | (x << 32);
+}
+
+#endif
+
+#endif  // WORDS_BIGENDIAN
+
+// Convert to little-endian storage, opposite of network format.
+// Convert x from host to little endian: x = LittleEndian.FromHost(x);
+// convert x from little endian to host: x = LittleEndian.ToHost(x);
+//
+//  Store values into unaligned memory converting to little endian order:
+//    LittleEndian.Store16(p, x);
+//
+//  Load unaligned values stored in little endian converting to host order:
+//    x = LittleEndian.Load16(p);
+class LittleEndian {
+ public:
+  // Conversion functions.
+#ifdef WORDS_BIGENDIAN
+
+  static uint16 FromHost16(uint16 x) { return bswap_16(x); }
+  static uint16 ToHost16(uint16 x) { return bswap_16(x); }
+
+  static uint32 FromHost32(uint32 x) { return bswap_32(x); }
+  static uint32 ToHost32(uint32 x) { return bswap_32(x); }
+
+  static bool IsLittleEndian() { return false; }
+
+#else  // !defined(WORDS_BIGENDIAN)
+
+  static uint16 FromHost16(uint16 x) { return x; }
+  static uint16 ToHost16(uint16 x) { return x; }
+
+  static uint32 FromHost32(uint32 x) { return x; }
+  static uint32 ToHost32(uint32 x) { return x; }
+
+  static bool IsLittleEndian() { return true; }
+
+#endif  // !defined(WORDS_BIGENDIAN)
+
+  // Functions to do unaligned loads and stores in little-endian order.
+  static uint16 Load16(const void *p) {
+    return ToHost16(UNALIGNED_LOAD16(p));
+  }
+
+  static void Store16(void *p, uint16 v) {
+    UNALIGNED_STORE16(p, FromHost16(v));
+  }
+
+  static uint32 Load32(const void *p) {
+    return ToHost32(UNALIGNED_LOAD32(p));
+  }
+
+  static void Store32(void *p, uint32 v) {
+    UNALIGNED_STORE32(p, FromHost32(v));
+  }
+};
+
+// Some bit-manipulation functions.
+class Bits {
+ public:
+  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+  static int Log2Floor(uint32 n);
+
+  // Return the first set least / most significant bit, 0-indexed.  Returns an
+  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except
+  // that it's 0-indexed.
+  static int FindLSBSetNonZero(uint32 n);
+  static int FindLSBSetNonZero64(uint64 n);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Bits);
+};
+
+#ifdef HAVE_BUILTIN_CTZ
+
+inline int Bits::Log2Floor(uint32 n) {
+  return n == 0 ? -1 : 31 ^ __builtin_clz(n);
+}
+
+inline int Bits::FindLSBSetNonZero(uint32 n) {
+  return __builtin_ctz(n);
+}
+
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
+  return __builtin_ctzll(n);
+}
+
+#else  // Portable versions.
+
+inline int Bits::Log2Floor(uint32 n) {
+  if (n == 0)
+    return -1;
+  int log = 0;
+  uint32 value = n;
+  for (int i = 4; i >= 0; --i) {
+    int shift = (1 << i);
+    uint32 x = value >> shift;
+    if (x != 0) {
+      value = x;
+      log += shift;
+    }
+  }
+  assert(value == 1);
+  return log;
+}
+
+inline int Bits::FindLSBSetNonZero(uint32 n) {
+  int rc = 31;
+  for (int i = 4, shift = 1 << 4; i >= 0; --i) {
+    const uint32 x = n << shift;
+    if (x != 0) {
+      n = x;
+      rc -= shift;
+    }
+    shift >>= 1;
+  }
+  return rc;
+}
+
+// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
+  const uint32 bottombits = static_cast<uint32>(n);
+  if (bottombits == 0) {
+    // Bottom bits are zero, so scan in top bits
+    return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32));
+  } else {
+    return FindLSBSetNonZero(bottombits);
+  }
+}
+
+#endif  // End portable versions.
+
+// Variable-length integer encoding.
+class Varint {
+ public:
+  // Maximum lengths of varint encoding of uint32.
+  static const int kMax32 = 5;
+
+  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
+  // Never reads a character at or beyond limit.  If a valid/terminated varint32
+  // was found in the range, stores it in *OUTPUT and returns a pointer just
+  // past the last byte of the varint32. Else returns NULL.  On success,
+  // "result <= limit".
+  static const char* Parse32WithLimit(const char* ptr, const char* limit,
+                                      uint32* OUTPUT);
+
+  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v".
+  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the
+  //            byte just past the last encoded byte.
+  static char* Encode32(char* ptr, uint32 v);
+
+  // EFFECTS    Appends the varint representation of "value" to "*s".
+  static void Append32(string* s, uint32 value);
+};
+
+inline const char* Varint::Parse32WithLimit(const char* p,
+                                            const char* l,
+                                            uint32* OUTPUT) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
+  uint32 b, result;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result = b & 127;          if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
+  return NULL;       // Value is too long to be a varint32
+ done:
+  *OUTPUT = result;
+  return reinterpret_cast<const char*>(ptr);
+}
+
+inline char* Varint::Encode32(char* sptr, uint32 v) {
+  // Operate on characters as unsigneds
+  unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
+  static const int B = 128;
+  if (v < (1<<7)) {
+    *(ptr++) = v;
+  } else if (v < (1<<14)) {
+    *(ptr++) = v | B;
+    *(ptr++) = v>>7;
+  } else if (v < (1<<21)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = v>>14;
+  } else if (v < (1<<28)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = v>>21;
+  } else {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = (v>>21) | B;
+    *(ptr++) = v>>28;
+  }
+  return reinterpret_cast<char*>(ptr);
+}
+
+// If you know the internal layout of the std::string in use, you can
+// replace this function with one that resizes the string without
+// filling the new space with zeros (if applicable) --
+// it will be non-portable but faster.
+inline void STLStringResizeUninitialized(string* s, size_t new_size) {
+  s->resize(new_size);
+}
+
+// Return a mutable char* pointing to a string's internal buffer,
+// which may not be null-terminated. Writing through this pointer will
+// modify the string.
+//
+// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+// next call to a string method that invalidates iterators.
+//
+// As of 2006-04, there is no standard-blessed way of getting a
+// mutable reference to a string's internal buffer. However, issue 530
+// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
+// proposes this as the method. It will officially be part of the standard
+// for C++0x. This should already work on all current implementations.
+inline char* string_as_array(string* str) {
+  return str->empty() ? NULL : &*str->begin();
+}
+
+}  // namespace snappy
+
+#endif  // UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_

src/snappy/snappy/snappy-stubs-public.h.in

@@ -0,0 +1,98 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+// Author: sesse@google.com (Steinar H. Gunderson)
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// Various type stubs for the open-source version of Snappy.
+//
+// This file cannot include config.h, as it is included from snappy.h,
+// which is a public header. Instead, snappy-stubs-public.h is generated by
+// from snappy-stubs-public.h.in at configure time.
+
+#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
+#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
+
+#if @ac_cv_have_stdint_h@
+#include <stdint.h>
+#endif
+
+#if @ac_cv_have_stddef_h@
+#include <stddef.h>
+#endif
+
+#if @ac_cv_have_sys_uio_h@
+#include <sys/uio.h>
+#endif
+
+#define SNAPPY_MAJOR @SNAPPY_MAJOR@
+#define SNAPPY_MINOR @SNAPPY_MINOR@
+#define SNAPPY_PATCHLEVEL @SNAPPY_PATCHLEVEL@
+#define SNAPPY_VERSION \
+    ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
+
+#include <string>
+
+namespace snappy {
+
+#if @ac_cv_have_stdint_h@
+typedef int8_t int8;
+typedef uint8_t uint8;
+typedef int16_t int16;
+typedef uint16_t uint16;
+typedef int32_t int32;
+typedef uint32_t uint32;
+typedef int64_t int64;
+typedef uint64_t uint64;
+#else
+typedef signed char int8;
+typedef unsigned char uint8;
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+#endif
+
+typedef std::string string;
+
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+#if !@ac_cv_have_sys_uio_h@
+// Windows does not have an iovec type, yet the concept is universally useful.
+// It is simple to define it ourselves, so we put it inside our own namespace.
+struct iovec {
+	void* iov_base;
+	size_t iov_len;
+};
+#endif
+
+}  // namespace snappy
+
+#endif  // UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_

src/snappy/snappy/snappy-test.cc

@@ -0,0 +1,606 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// Various stubs for the unit tests for the open-source version of Snappy.
+
+#include "snappy-test.h"
+
+#ifdef HAVE_WINDOWS_H
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include <algorithm>
+
+DEFINE_bool(run_microbenchmarks, true,
+            "Run microbenchmarks before doing anything else.");
+
+namespace snappy {
+
+string ReadTestDataFile(const string& base, size_t size_limit) {
+  string contents;
+  const char* srcdir = getenv("srcdir");  // This is set by Automake.
+  string prefix;
+  if (srcdir) {
+    prefix = string(srcdir) + "/";
+  }
+  file::GetContents(prefix + "testdata/" + base, &contents, file::Defaults()
+      ).CheckSuccess();
+  if (size_limit > 0) {
+    contents = contents.substr(0, size_limit);
+  }
+  return contents;
+}
+
+string ReadTestDataFile(const string& base) {
+  return ReadTestDataFile(base, 0);
+}
+
+string StringPrintf(const char* format, ...) {
+  char buf[4096];
+  va_list ap;
+  va_start(ap, format);
+  vsnprintf(buf, sizeof(buf), format, ap);
+  va_end(ap);
+  return buf;
+}
+
+bool benchmark_running = false;
+int64 benchmark_real_time_us = 0;
+int64 benchmark_cpu_time_us = 0;
+string *benchmark_label = NULL;
+int64 benchmark_bytes_processed = 0;
+
+void ResetBenchmarkTiming() {
+  benchmark_real_time_us = 0;
+  benchmark_cpu_time_us = 0;
+}
+
+#ifdef WIN32
+LARGE_INTEGER benchmark_start_real;
+FILETIME benchmark_start_cpu;
+#else  // WIN32
+struct timeval benchmark_start_real;
+struct rusage benchmark_start_cpu;
+#endif  // WIN32
+
+void StartBenchmarkTiming() {
+#ifdef WIN32
+  QueryPerformanceCounter(&benchmark_start_real);
+  FILETIME dummy;
+  CHECK(GetProcessTimes(
+      GetCurrentProcess(), &dummy, &dummy, &dummy, &benchmark_start_cpu));
+#else
+  gettimeofday(&benchmark_start_real, NULL);
+  if (getrusage(RUSAGE_SELF, &benchmark_start_cpu) == -1) {
+    perror("getrusage(RUSAGE_SELF)");
+    exit(1);
+  }
+#endif
+  benchmark_running = true;
+}
+
+void StopBenchmarkTiming() {
+  if (!benchmark_running) {
+    return;
+  }
+
+#ifdef WIN32
+  LARGE_INTEGER benchmark_stop_real;
+  LARGE_INTEGER benchmark_frequency;
+  QueryPerformanceCounter(&benchmark_stop_real);
+  QueryPerformanceFrequency(&benchmark_frequency);
+
+  double elapsed_real = static_cast<double>(
+      benchmark_stop_real.QuadPart - benchmark_start_real.QuadPart) /
+      benchmark_frequency.QuadPart;
+  benchmark_real_time_us += elapsed_real * 1e6 + 0.5;
+
+  FILETIME benchmark_stop_cpu, dummy;
+  CHECK(GetProcessTimes(
+      GetCurrentProcess(), &dummy, &dummy, &dummy, &benchmark_stop_cpu));
+
+  ULARGE_INTEGER start_ulargeint;
+  start_ulargeint.LowPart = benchmark_start_cpu.dwLowDateTime;
+  start_ulargeint.HighPart = benchmark_start_cpu.dwHighDateTime;
+
+  ULARGE_INTEGER stop_ulargeint;
+  stop_ulargeint.LowPart = benchmark_stop_cpu.dwLowDateTime;
+  stop_ulargeint.HighPart = benchmark_stop_cpu.dwHighDateTime;
+
+  benchmark_cpu_time_us +=
+      (stop_ulargeint.QuadPart - start_ulargeint.QuadPart + 5) / 10;
+#else  // WIN32
+  struct timeval benchmark_stop_real;
+  gettimeofday(&benchmark_stop_real, NULL);
+  benchmark_real_time_us +=
+      1000000 * (benchmark_stop_real.tv_sec - benchmark_start_real.tv_sec);
+  benchmark_real_time_us +=
+      (benchmark_stop_real.tv_usec - benchmark_start_real.tv_usec);
+
+  struct rusage benchmark_stop_cpu;
+  if (getrusage(RUSAGE_SELF, &benchmark_stop_cpu) == -1) {
+    perror("getrusage(RUSAGE_SELF)");
+    exit(1);
+  }
+  benchmark_cpu_time_us += 1000000 * (benchmark_stop_cpu.ru_utime.tv_sec -
+                                      benchmark_start_cpu.ru_utime.tv_sec);
+  benchmark_cpu_time_us += (benchmark_stop_cpu.ru_utime.tv_usec -
+                            benchmark_start_cpu.ru_utime.tv_usec);
+#endif  // WIN32
+
+  benchmark_running = false;
+}
+
+void SetBenchmarkLabel(const string& str) {
+  if (benchmark_label) {
+    delete benchmark_label;
+  }
+  benchmark_label = new string(str);
+}
+
+void SetBenchmarkBytesProcessed(int64 bytes) {
+  benchmark_bytes_processed = bytes;
+}
+
+struct BenchmarkRun {
+  int64 real_time_us;
+  int64 cpu_time_us;
+};
+
+struct BenchmarkCompareCPUTime {
+  bool operator() (const BenchmarkRun& a, const BenchmarkRun& b) const {
+    return a.cpu_time_us < b.cpu_time_us;
+  }
+};
+
+void Benchmark::Run() {
+  for (int test_case_num = start_; test_case_num <= stop_; ++test_case_num) {
+    // Run a few iterations first to find out approximately how fast
+    // the benchmark is.
+    const int kCalibrateIterations = 100;
+    ResetBenchmarkTiming();
+    StartBenchmarkTiming();
+    (*function_)(kCalibrateIterations, test_case_num);
+    StopBenchmarkTiming();
+
+    // Let each test case run for about 200ms, but at least as many
+    // as we used to calibrate.
+    // Run five times and pick the median.
+    const int kNumRuns = 5;
+    const int kMedianPos = kNumRuns / 2;
+    int num_iterations = 0;
+    if (benchmark_real_time_us > 0) {
+      num_iterations = 200000 * kCalibrateIterations / benchmark_real_time_us;
+    }
+    num_iterations = max(num_iterations, kCalibrateIterations);
+    BenchmarkRun benchmark_runs[kNumRuns];
+
+    for (int run = 0; run < kNumRuns; ++run) {
+      ResetBenchmarkTiming();
+      StartBenchmarkTiming();
+      (*function_)(num_iterations, test_case_num);
+      StopBenchmarkTiming();
+
+      benchmark_runs[run].real_time_us = benchmark_real_time_us;
+      benchmark_runs[run].cpu_time_us = benchmark_cpu_time_us;
+    }
+
+    string heading = StringPrintf("%s/%d", name_.c_str(), test_case_num);
+    string human_readable_speed;
+
+    nth_element(benchmark_runs,
+                benchmark_runs + kMedianPos,
+                benchmark_runs + kNumRuns,
+                BenchmarkCompareCPUTime());
+    int64 real_time_us = benchmark_runs[kMedianPos].real_time_us;
+    int64 cpu_time_us = benchmark_runs[kMedianPos].cpu_time_us;
+    if (cpu_time_us <= 0) {
+      human_readable_speed = "?";
+    } else {
+      int64 bytes_per_second =
+          benchmark_bytes_processed * 1000000 / cpu_time_us;
+      if (bytes_per_second < 1024) {
+        human_readable_speed = StringPrintf("%dB/s", bytes_per_second);
+      } else if (bytes_per_second < 1024 * 1024) {
+        human_readable_speed = StringPrintf(
+            "%.1fkB/s", bytes_per_second / 1024.0f);
+      } else if (bytes_per_second < 1024 * 1024 * 1024) {
+        human_readable_speed = StringPrintf(
+            "%.1fMB/s", bytes_per_second / (1024.0f * 1024.0f));
+      } else {
+        human_readable_speed = StringPrintf(
+            "%.1fGB/s", bytes_per_second / (1024.0f * 1024.0f * 1024.0f));
+      }
+    }
+
+    fprintf(stderr,
+#ifdef WIN32
+            "%-18s %10I64d %10I64d %10d %s  %s\n",
+#else
+            "%-18s %10lld %10lld %10d %s  %s\n",
+#endif
+            heading.c_str(),
+            static_cast<long long>(real_time_us * 1000 / num_iterations),
+            static_cast<long long>(cpu_time_us * 1000 / num_iterations),
+            num_iterations,
+            human_readable_speed.c_str(),
+            benchmark_label->c_str());
+  }
+}
+
+#ifdef HAVE_LIBZ
+
+ZLib::ZLib()
+    : comp_init_(false),
+      uncomp_init_(false) {
+  Reinit();
+}
+
+ZLib::~ZLib() {
+  if (comp_init_)   { deflateEnd(&comp_stream_); }
+  if (uncomp_init_) { inflateEnd(&uncomp_stream_); }
+}
+
+void ZLib::Reinit() {
+  compression_level_ = Z_DEFAULT_COMPRESSION;
+  window_bits_ = MAX_WBITS;
+  mem_level_ =  8;  // DEF_MEM_LEVEL
+  if (comp_init_) {
+    deflateEnd(&comp_stream_);
+    comp_init_ = false;
+  }
+  if (uncomp_init_) {
+    inflateEnd(&uncomp_stream_);
+    uncomp_init_ = false;
+  }
+  first_chunk_ = true;
+}
+
+void ZLib::Reset() {
+  first_chunk_ = true;
+}
+
+// --------- COMPRESS MODE
+
+// Initialization method to be called if we hit an error while
+// compressing. On hitting an error, call this method before returning
+// the error.
+void ZLib::CompressErrorInit() {
+  deflateEnd(&comp_stream_);
+  comp_init_ = false;
+  Reset();
+}
+
+int ZLib::DeflateInit() {
+  return deflateInit2(&comp_stream_,
+                      compression_level_,
+                      Z_DEFLATED,
+                      window_bits_,
+                      mem_level_,
+                      Z_DEFAULT_STRATEGY);
+}
+
+int ZLib::CompressInit(Bytef *dest, uLongf *destLen,
+                       const Bytef *source, uLong *sourceLen) {
+  int err;
+
+  comp_stream_.next_in = (Bytef*)source;
+  comp_stream_.avail_in = (uInt)*sourceLen;
+  if ((uLong)comp_stream_.avail_in != *sourceLen) return Z_BUF_ERROR;
+  comp_stream_.next_out = dest;
+  comp_stream_.avail_out = (uInt)*destLen;
+  if ((uLong)comp_stream_.avail_out != *destLen) return Z_BUF_ERROR;
+
+  if ( !first_chunk_ )   // only need to set up stream the first time through
+    return Z_OK;
+
+  if (comp_init_) {      // we've already initted it
+    err = deflateReset(&comp_stream_);
+    if (err != Z_OK) {
+      LOG(WARNING) << "ERROR: Can't reset compress object; creating a new one";
+      deflateEnd(&comp_stream_);
+      comp_init_ = false;
+    }
+  }
+  if (!comp_init_) {     // first use
+    comp_stream_.zalloc = (alloc_func)0;
+    comp_stream_.zfree = (free_func)0;
+    comp_stream_.opaque = (voidpf)0;
+    err = DeflateInit();
+    if (err != Z_OK) return err;
+    comp_init_ = true;
+  }
+  return Z_OK;
+}
+
+// In a perfect world we'd always have the full buffer to compress
+// when the time came, and we could just call Compress().  Alas, we
+// want to do chunked compression on our webserver.  In this
+// application, we compress the header, send it off, then compress the
+// results, send them off, then compress the footer.  Thus we need to
+// use the chunked compression features of zlib.
+int ZLib::CompressAtMostOrAll(Bytef *dest, uLongf *destLen,
+                              const Bytef *source, uLong *sourceLen,
+                              int flush_mode) {   // Z_FULL_FLUSH or Z_FINISH
+  int err;
+
+  if ( (err=CompressInit(dest, destLen, source, sourceLen)) != Z_OK )
+    return err;
+
+  // This is used to figure out how many bytes we wrote *this chunk*
+  int compressed_size = comp_stream_.total_out;
+
+  // Some setup happens only for the first chunk we compress in a run
+  if ( first_chunk_ ) {
+    first_chunk_ = false;
+  }
+
+  // flush_mode is Z_FINISH for all mode, Z_SYNC_FLUSH for incremental
+  // compression.
+  err = deflate(&comp_stream_, flush_mode);
+
+  *sourceLen = comp_stream_.avail_in;
+
+  if ((err == Z_STREAM_END || err == Z_OK)
+      && comp_stream_.avail_in == 0
+      && comp_stream_.avail_out != 0 ) {
+    // we processed everything ok and the output buffer was large enough.
+    ;
+  } else if (err == Z_STREAM_END && comp_stream_.avail_in > 0) {
+    return Z_BUF_ERROR;                            // should never happen
+  } else if (err != Z_OK && err != Z_STREAM_END && err != Z_BUF_ERROR) {
+    // an error happened
+    CompressErrorInit();
+    return err;
+  } else if (comp_stream_.avail_out == 0) {     // not enough space
+    err = Z_BUF_ERROR;
+  }
+
+  assert(err == Z_OK || err == Z_STREAM_END || err == Z_BUF_ERROR);
+  if (err == Z_STREAM_END)
+    err = Z_OK;
+
+  // update the crc and other metadata
+  compressed_size = comp_stream_.total_out - compressed_size;  // delta
+  *destLen = compressed_size;
+
+  return err;
+}
+
+int ZLib::CompressChunkOrAll(Bytef *dest, uLongf *destLen,
+                             const Bytef *source, uLong sourceLen,
+                             int flush_mode) {   // Z_FULL_FLUSH or Z_FINISH
+  const int ret =
+    CompressAtMostOrAll(dest, destLen, source, &sourceLen, flush_mode);
+  if (ret == Z_BUF_ERROR)
+    CompressErrorInit();
+  return ret;
+}
+
+// This routine only initializes the compression stream once.  Thereafter, it
+// just does a deflateReset on the stream, which should be faster.
+int ZLib::Compress(Bytef *dest, uLongf *destLen,
+                   const Bytef *source, uLong sourceLen) {
+  int err;
+  if ( (err=CompressChunkOrAll(dest, destLen, source, sourceLen,
+                               Z_FINISH)) != Z_OK )
+    return err;
+  Reset();         // reset for next call to Compress
+
+  return Z_OK;
+}
+
+
+// --------- UNCOMPRESS MODE
+
+int ZLib::InflateInit() {
+  return inflateInit2(&uncomp_stream_, MAX_WBITS);
+}
+
+// Initialization method to be called if we hit an error while
+// uncompressing. On hitting an error, call this method before
+// returning the error.
+void ZLib::UncompressErrorInit() {
+  inflateEnd(&uncomp_stream_);
+  uncomp_init_ = false;
+  Reset();
+}
+
+int ZLib::UncompressInit(Bytef *dest, uLongf *destLen,
+                         const Bytef *source, uLong *sourceLen) {
+  int err;
+
+  uncomp_stream_.next_in = (Bytef*)source;
+  uncomp_stream_.avail_in = (uInt)*sourceLen;
+  // Check for source > 64K on 16-bit machine:
+  if ((uLong)uncomp_stream_.avail_in != *sourceLen) return Z_BUF_ERROR;
+
+  uncomp_stream_.next_out = dest;
+  uncomp_stream_.avail_out = (uInt)*destLen;
+  if ((uLong)uncomp_stream_.avail_out != *destLen) return Z_BUF_ERROR;
+
+  if ( !first_chunk_ )   // only need to set up stream the first time through
+    return Z_OK;
+
+  if (uncomp_init_) {    // we've already initted it
+    err = inflateReset(&uncomp_stream_);
+    if (err != Z_OK) {
+      LOG(WARNING)
+        << "ERROR: Can't reset uncompress object; creating a new one";
+      UncompressErrorInit();
+    }
+  }
+  if (!uncomp_init_) {
+    uncomp_stream_.zalloc = (alloc_func)0;
+    uncomp_stream_.zfree = (free_func)0;
+    uncomp_stream_.opaque = (voidpf)0;
+    err = InflateInit();
+    if (err != Z_OK) return err;
+    uncomp_init_ = true;
+  }
+  return Z_OK;
+}
+
+// If you compressed your data a chunk at a time, with CompressChunk,
+// you can uncompress it a chunk at a time with UncompressChunk.
+// Only difference bewteen chunked and unchunked uncompression
+// is the flush mode we use: Z_SYNC_FLUSH (chunked) or Z_FINISH (unchunked).
+int ZLib::UncompressAtMostOrAll(Bytef *dest, uLongf *destLen,
+                                const Bytef *source, uLong *sourceLen,
+                                int flush_mode) {  // Z_SYNC_FLUSH or Z_FINISH
+  int err = Z_OK;
+
+  if ( (err=UncompressInit(dest, destLen, source, sourceLen)) != Z_OK ) {
+    LOG(WARNING) << "UncompressInit: Error: " << err << " SourceLen: "
+                 << *sourceLen;
+    return err;
+  }
+
+  // This is used to figure out how many output bytes we wrote *this chunk*:
+  const uLong old_total_out = uncomp_stream_.total_out;
+
+  // This is used to figure out how many input bytes we read *this chunk*:
+  const uLong old_total_in = uncomp_stream_.total_in;
+
+  // Some setup happens only for the first chunk we compress in a run
+  if ( first_chunk_ ) {
+    first_chunk_ = false;                          // so we don't do this again
+
+    // For the first chunk *only* (to avoid infinite troubles), we let
+    // there be no actual data to uncompress.  This sometimes triggers
+    // when the input is only the gzip header, say.
+    if ( *sourceLen == 0 ) {
+      *destLen = 0;
+      return Z_OK;
+    }
+  }
+
+  // We'll uncompress as much as we can.  If we end OK great, otherwise
+  // if we get an error that seems to be the gzip footer, we store the
+  // gzip footer and return OK, otherwise we return the error.
+
+  // flush_mode is Z_SYNC_FLUSH for chunked mode, Z_FINISH for all mode.
+  err = inflate(&uncomp_stream_, flush_mode);
+
+  // Figure out how many bytes of the input zlib slurped up:
+  const uLong bytes_read = uncomp_stream_.total_in - old_total_in;
+  CHECK_LE(source + bytes_read, source + *sourceLen);
+  *sourceLen = uncomp_stream_.avail_in;
+
+  if ((err == Z_STREAM_END || err == Z_OK)  // everything went ok
+             && uncomp_stream_.avail_in == 0) {    // and we read it all
+    ;
+  } else if (err == Z_STREAM_END && uncomp_stream_.avail_in > 0) {
+    LOG(WARNING)
+      << "UncompressChunkOrAll: Received some extra data, bytes total: "
+      << uncomp_stream_.avail_in << " bytes: "
+      << string(reinterpret_cast<const char *>(uncomp_stream_.next_in),
+                min(int(uncomp_stream_.avail_in), 20));
+    UncompressErrorInit();
+    return Z_DATA_ERROR;       // what's the extra data for?
+  } else if (err != Z_OK && err != Z_STREAM_END && err != Z_BUF_ERROR) {
+    // an error happened
+    LOG(WARNING) << "UncompressChunkOrAll: Error: " << err
+                 << " avail_out: " << uncomp_stream_.avail_out;
+    UncompressErrorInit();
+    return err;
+  } else if (uncomp_stream_.avail_out == 0) {
+    err = Z_BUF_ERROR;
+  }
+
+  assert(err == Z_OK || err == Z_BUF_ERROR || err == Z_STREAM_END);
+  if (err == Z_STREAM_END)
+    err = Z_OK;
+
+  *destLen = uncomp_stream_.total_out - old_total_out;  // size for this call
+
+  return err;
+}
+
+int ZLib::UncompressChunkOrAll(Bytef *dest, uLongf *destLen,
+                               const Bytef *source, uLong sourceLen,
+                               int flush_mode) {  // Z_SYNC_FLUSH or Z_FINISH
+  const int ret =
+    UncompressAtMostOrAll(dest, destLen, source, &sourceLen, flush_mode);
+  if (ret == Z_BUF_ERROR)
+    UncompressErrorInit();
+  return ret;
+}
+
+int ZLib::UncompressAtMost(Bytef *dest, uLongf *destLen,
+                          const Bytef *source, uLong *sourceLen) {
+  return UncompressAtMostOrAll(dest, destLen, source, sourceLen, Z_SYNC_FLUSH);
+}
+
+// We make sure we've uncompressed everything, that is, the current
+// uncompress stream is at a compressed-buffer-EOF boundary.  In gzip
+// mode, we also check the gzip footer to make sure we pass the gzip
+// consistency checks.  We RETURN true iff both types of checks pass.
+bool ZLib::UncompressChunkDone() {
+  assert(!first_chunk_ && uncomp_init_);
+  // Make sure we're at the end-of-compressed-data point.  This means
+  // if we call inflate with Z_FINISH we won't consume any input or
+  // write any output
+  Bytef dummyin, dummyout;
+  uLongf dummylen = 0;
+  if ( UncompressChunkOrAll(&dummyout, &dummylen, &dummyin, 0, Z_FINISH)
+       != Z_OK ) {
+    return false;
+  }
+
+  // Make sure that when we exit, we can start a new round of chunks later
+  Reset();
+
+  return true;
+}
+
+// Uncompresses the source buffer into the destination buffer.
+// The destination buffer must be long enough to hold the entire
+// decompressed contents.
+//
+// We only initialize the uncomp_stream once.  Thereafter, we use
+// inflateReset, which should be faster.
+//
+// Returns Z_OK on success, otherwise, it returns a zlib error code.
+int ZLib::Uncompress(Bytef *dest, uLongf *destLen,
+                     const Bytef *source, uLong sourceLen) {
+  int err;
+  if ( (err=UncompressChunkOrAll(dest, destLen, source, sourceLen,
+                                 Z_FINISH)) != Z_OK ) {
+    Reset();                           // let us try to compress again
+    return err;
+  }
+  if ( !UncompressChunkDone() )        // calls Reset()
+    return Z_DATA_ERROR;
+  return Z_OK;  // stream_end is ok
+}
+
+#endif  // HAVE_LIBZ
+
+}  // namespace snappy

src/snappy/snappy/snappy-test.h

@@ -0,0 +1,582 @@
+// Copyright 2011 Google 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:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// Various stubs for the unit tests for the open-source version of Snappy.
+
+#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_
+#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_
+
+#include <iostream>
+#include <string>
+
+#include "snappy-stubs-internal.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include <string>
+
+#ifdef HAVE_GTEST
+
+#include <gtest/gtest.h>
+#undef TYPED_TEST
+#define TYPED_TEST TEST
+#define INIT_GTEST(argc, argv) ::testing::InitGoogleTest(argc, *argv)
+
+#else
+
+// Stubs for if the user doesn't have Google Test installed.
+
+#define TEST(test_case, test_subcase) \
+  void Test_ ## test_case ## _ ## test_subcase()
+#define INIT_GTEST(argc, argv)
+
+#define TYPED_TEST TEST
+#define EXPECT_EQ CHECK_EQ
+#define EXPECT_NE CHECK_NE
+#define EXPECT_FALSE(cond) CHECK(!(cond))
+
+#endif
+
+#ifdef HAVE_GFLAGS
+
+#include <gflags/gflags.h>
+
+// This is tricky; both gflags and Google Test want to look at the command line
+// arguments. Google Test seems to be the most happy with unknown arguments,
+// though, so we call it first and hope for the best.
+#define InitGoogle(argv0, argc, argv, remove_flags) \
+  INIT_GTEST(argc, argv); \
+  google::ParseCommandLineFlags(argc, argv, remove_flags);
+
+#else
+
+// If we don't have the gflags package installed, these can only be
+// changed at compile time.
+#define DEFINE_int32(flag_name, default_value, description) \
+  static int FLAGS_ ## flag_name = default_value;
+
+#define InitGoogle(argv0, argc, argv, remove_flags) \
+  INIT_GTEST(argc, argv)
+
+#endif
+
+#ifdef HAVE_LIBZ
+#include "zlib.h"
+#endif
+
+#ifdef HAVE_LIBLZO2
+#include "lzo/lzo1x.h"
+#endif
+
+#ifdef HAVE_LIBLZF
+extern "C" {
+#include "lzf.h"
+}
+#endif
+
+#ifdef HAVE_LIBFASTLZ
+#include "fastlz.h"
+#endif
+
+#ifdef HAVE_LIBQUICKLZ
+#include "quicklz.h"
+#endif
+
+namespace {
+
+namespace File {
+  void Init() { }
+}  // namespace File
+
+namespace file {
+  int Defaults() { }
+
+  class DummyStatus {
+   public:
+    void CheckSuccess() { }
+  };
+
+  DummyStatus GetContents(const string& filename, string* data, int unused) {
+    FILE* fp = fopen(filename.c_str(), "rb");
+    if (fp == NULL) {
+      perror(filename.c_str());
+      exit(1);
+    }
+
+    data->clear();
+    while (!feof(fp)) {
+      char buf[4096];
+      size_t ret = fread(buf, 1, 4096, fp);
+      if (ret == 0 && ferror(fp)) {
+        perror("fread");
+        exit(1);
+      }
+      data->append(string(buf, ret));
+    }
+
+    fclose(fp);
+  }
+
+  DummyStatus SetContents(const string& filename,
+                          const string& str,
+                          int unused) {
+    FILE* fp = fopen(filename.c_str(), "wb");
+    if (fp == NULL) {
+      perror(filename.c_str());
+      exit(1);
+    }
+
+    int ret = fwrite(str.data(), str.size(), 1, fp);
+    if (ret != 1) {
+      perror("fwrite");
+      exit(1);
+    }
+
+    fclose(fp);
+  }
+}  // namespace file
+
+}  // namespace
+
+namespace snappy {
+
+#define FLAGS_test_random_seed 301
+typedef string TypeParam;
+
+void Test_CorruptedTest_VerifyCorrupted();
+void Test_Snappy_SimpleTests();
+void Test_Snappy_MaxBlowup();
+void Test_Snappy_RandomData();
+void Test_Snappy_FourByteOffset();
+void Test_SnappyCorruption_TruncatedVarint();
+void Test_SnappyCorruption_UnterminatedVarint();
+void Test_Snappy_ReadPastEndOfBuffer();
+void Test_Snappy_FindMatchLength();
+void Test_Snappy_FindMatchLengthRandom();
+
+string ReadTestDataFile(const string& base, size_t size_limit);
+
+string ReadTestDataFile(const string& base);
+
+// A sprintf() variant that returns a std::string.
+// Not safe for general use due to truncation issues.
+string StringPrintf(const char* format, ...);
+
+// A simple, non-cryptographically-secure random generator.
+class ACMRandom {
+ public:
+  explicit ACMRandom(uint32 seed) : seed_(seed) {}
+
+  int32 Next();
+
+  int32 Uniform(int32 n) {
+    return Next() % n;
+  }
+  uint8 Rand8() {
+    return static_cast<uint8>((Next() >> 1) & 0x000000ff);
+  }
+  bool OneIn(int X) { return Uniform(X) == 0; }
+
+  // Skewed: pick "base" uniformly from range [0,max_log] and then
+  // return "base" random bits.  The effect is to pick a number in the
+  // range [0,2^max_log-1] with bias towards smaller numbers.
+  int32 Skewed(int max_log);
+
+ private:
+  static const uint32 M = 2147483647L;   // 2^31-1
+  uint32 seed_;
+};
+
+inline int32 ACMRandom::Next() {
+  static const uint64 A = 16807;  // bits 14, 8, 7, 5, 2, 1, 0
+  // We are computing
+  //       seed_ = (seed_ * A) % M,    where M = 2^31-1
+  //
+  // seed_ must not be zero or M, or else all subsequent computed values
+  // will be zero or M respectively.  For all other values, seed_ will end
+  // up cycling through every number in [1,M-1]
+  uint64 product = seed_ * A;
+
+  // Compute (product % M) using the fact that ((x << 31) % M) == x.
+  seed_ = (product >> 31) + (product & M);
+  // The first reduction may overflow by 1 bit, so we may need to repeat.
+  // mod == M is not possible; using > allows the faster sign-bit-based test.
+  if (seed_ > M) {
+    seed_ -= M;
+  }
+  return seed_;
+}
+
+inline int32 ACMRandom::Skewed(int max_log) {
+  const int32 base = (Next() - 1) % (max_log+1);
+  return (Next() - 1) & ((1u << base)-1);
+}
+
+// A wall-time clock. This stub is not super-accurate, nor resistant to the
+// system time changing.
+class CycleTimer {
+ public:
+  CycleTimer() : real_time_us_(0) {}
+
+  void Start() {
+#ifdef WIN32
+    QueryPerformanceCounter(&start_);
+#else
+    gettimeofday(&start_, NULL);
+#endif
+  }
+
+  void Stop() {
+#ifdef WIN32
+    LARGE_INTEGER stop;
+    LARGE_INTEGER frequency;
+    QueryPerformanceCounter(&stop);
+    QueryPerformanceFrequency(&frequency);
+
+    double elapsed = static_cast<double>(stop.QuadPart - start_.QuadPart) /
+        frequency.QuadPart;
+    real_time_us_ += elapsed * 1e6 + 0.5;
+#else
+    struct timeval stop;
+    gettimeofday(&stop, NULL);
+
+    real_time_us_ += 1000000 * (stop.tv_sec - start_.tv_sec);
+    real_time_us_ += (stop.tv_usec - start_.tv_usec);
+#endif
+  }
+
+  double Get() {
+    return real_time_us_ * 1e-6;
+  }
+
+ private:
+  int64 real_time_us_;
+#ifdef WIN32
+  LARGE_INTEGER start_;
+#else
+  struct timeval start_;
+#endif
+};
+
+// Minimalistic microbenchmark framework.
+
+typedef void (*BenchmarkFunction)(int, int);
+
+class Benchmark {
+ public:
+  Benchmark(const string& name, BenchmarkFunction function) :
+      name_(name), function_(function) {}
+
+  Benchmark* DenseRange(int start, int stop) {
+    start_ = start;
+    stop_ = stop;
+    return this;
+  }
+
+  void Run();
+
+ private:
+  const string name_;
+  const BenchmarkFunction function_;
+  int start_, stop_;
+};
+#define BENCHMARK(benchmark_name) \
+  Benchmark* Benchmark_ ## benchmark_name = \
+          (new Benchmark(#benchmark_name, benchmark_name))
+
+extern Benchmark* Benchmark_BM_UFlat;
+extern Benchmark* Benchmark_BM_UIOVec;
+extern Benchmark* Benchmark_BM_UValidate;
+extern Benchmark* Benchmark_BM_ZFlat;
+
+void ResetBenchmarkTiming();
+void StartBenchmarkTiming();
+void StopBenchmarkTiming();
+void SetBenchmarkLabel(const string& str);
+void SetBenchmarkBytesProcessed(int64 bytes);
+
+#ifdef HAVE_LIBZ
+
+// Object-oriented wrapper around zlib.
+class ZLib {
+ public:
+  ZLib();
+  ~ZLib();
+
+  // Wipe a ZLib object to a virgin state.  This differs from Reset()
+  // in that it also breaks any state.
+  void Reinit();
+
+  // Call this to make a zlib buffer as good as new.  Here's the only
+  // case where they differ:
+  //    CompressChunk(a); CompressChunk(b); CompressChunkDone();   vs
+  //    CompressChunk(a); Reset(); CompressChunk(b); CompressChunkDone();
+  // You'll want to use Reset(), then, when you interrupt a compress
+  // (or uncompress) in the middle of a chunk and want to start over.
+  void Reset();
+
+  // According to the zlib manual, when you Compress, the destination
+  // buffer must have size at least src + .1%*src + 12.  This function
+  // helps you calculate that.  Augment this to account for a potential
+  // gzip header and footer, plus a few bytes of slack.
+  static int MinCompressbufSize(int uncompress_size) {
+    return uncompress_size + uncompress_size/1000 + 40;
+  }
+
+  // Compresses the source buffer into the destination buffer.
+  // sourceLen is the byte length of the source buffer.
+  // Upon entry, destLen is the total size of the destination buffer,
+  // which must be of size at least MinCompressbufSize(sourceLen).
+  // Upon exit, destLen is the actual size of the compressed buffer.
+  //
+  // This function can be used to compress a whole file at once if the
+  // input file is mmap'ed.
+  //
+  // Returns Z_OK if success, Z_MEM_ERROR if there was not
+  // enough memory, Z_BUF_ERROR if there was not enough room in the
+  // output buffer. Note that if the output buffer is exactly the same
+  // size as the compressed result, we still return Z_BUF_ERROR.
+  // (check CL#1936076)
+  int Compress(Bytef *dest, uLongf *destLen,
+               const Bytef *source, uLong sourceLen);
+
+  // Uncompresses the source buffer into the destination buffer.
+  // The destination buffer must be long enough to hold the entire
+  // decompressed contents.
+  //
+  // Returns Z_OK on success, otherwise, it returns a zlib error code.
+  int Uncompress(Bytef *dest, uLongf *destLen,
+                 const Bytef *source, uLong sourceLen);
+
+  // Uncompress data one chunk at a time -- ie you can call this
+  // more than once.  To get this to work you need to call per-chunk
+  // and "done" routines.
+  //
+  // Returns Z_OK if success, Z_MEM_ERROR if there was not
+  // enough memory, Z_BUF_ERROR if there was not enough room in the
+  // output buffer.
+
+  int UncompressAtMost(Bytef *dest, uLongf *destLen,
+                       const Bytef *source, uLong *sourceLen);
+
+  // Checks gzip footer information, as needed.  Mostly this just
+  // makes sure the checksums match.  Whenever you call this, it
+  // will assume the last 8 bytes from the previous UncompressChunk
+  // call are the footer.  Returns true iff everything looks ok.
+  bool UncompressChunkDone();
+
+ private:
+  int InflateInit();       // sets up the zlib inflate structure
+  int DeflateInit();       // sets up the zlib deflate structure
+
+  // These init the zlib data structures for compressing/uncompressing
+  int CompressInit(Bytef *dest, uLongf *destLen,
+                   const Bytef *source, uLong *sourceLen);
+  int UncompressInit(Bytef *dest, uLongf *destLen,
+                     const Bytef *source, uLong *sourceLen);
+  // Initialization method to be called if we hit an error while
+  // uncompressing. On hitting an error, call this method before
+  // returning the error.
+  void UncompressErrorInit();
+
+  // Helper function for Compress
+  int CompressChunkOrAll(Bytef *dest, uLongf *destLen,
+                         const Bytef *source, uLong sourceLen,
+                         int flush_mode);
+  int CompressAtMostOrAll(Bytef *dest, uLongf *destLen,
+                          const Bytef *source, uLong *sourceLen,
+                          int flush_mode);
+
+  // Likewise for UncompressAndUncompressChunk
+  int UncompressChunkOrAll(Bytef *dest, uLongf *destLen,
+                           const Bytef *source, uLong sourceLen,
+                           int flush_mode);
+
+  int UncompressAtMostOrAll(Bytef *dest, uLongf *destLen,
+                            const Bytef *source, uLong *sourceLen,
+                            int flush_mode);
+
+  // Initialization method to be called if we hit an error while
+  // compressing. On hitting an error, call this method before
+  // returning the error.
+  void CompressErrorInit();
+
+  int compression_level_;   // compression level
+  int window_bits_;         // log base 2 of the window size used in compression
+  int mem_level_;           // specifies the amount of memory to be used by
+                            // compressor (1-9)
+  z_stream comp_stream_;    // Zlib stream data structure
+  bool comp_init_;          // True if we have initialized comp_stream_
+  z_stream uncomp_stream_;  // Zlib stream data structure
+  bool uncomp_init_;        // True if we have initialized uncomp_stream_
+
+  // These are used only with chunked compression.
+  bool first_chunk_;       // true if we need to emit headers with this chunk
+};
+
+#endif  // HAVE_LIBZ
+
+}  // namespace snappy
+
+DECLARE_bool(run_microbenchmarks);
+
+static void RunSpecifiedBenchmarks() {
+  if (!FLAGS_run_microbenchmarks) {
+    return;
+  }
+
+  fprintf(stderr, "Running microbenchmarks.\n");
+#ifndef NDEBUG
+  fprintf(stderr, "WARNING: Compiled with assertions enabled, will be slow.\n");
+#endif
+#ifndef __OPTIMIZE__
+  fprintf(stderr, "WARNING: Compiled without optimization, will be slow.\n");
+#endif
+  fprintf(stderr, "Benchmark            Time(ns)    CPU(ns) Iterations\n");
+  fprintf(stderr, "---------------------------------------------------\n");
+
+  snappy::Benchmark_BM_UFlat->Run();
+  snappy::Benchmark_BM_UIOVec->Run();
+  snappy::Benchmark_BM_UValidate->Run();
+  snappy::Benchmark_BM_ZFlat->Run();
+
+  fprintf(stderr, "\n");
+}
+
+#ifndef HAVE_GTEST
+
+static inline int RUN_ALL_TESTS() {
+  fprintf(stderr, "Running correctness tests.\n");
+  snappy::Test_CorruptedTest_VerifyCorrupted();
+  snappy::Test_Snappy_SimpleTests();
+  snappy::Test_Snappy_MaxBlowup();
+  snappy::Test_Snappy_RandomData();
+  snappy::Test_Snappy_FourByteOffset();
+  snappy::Test_SnappyCorruption_TruncatedVarint();
+  snappy::Test_SnappyCorruption_UnterminatedVarint();
+  snappy::Test_Snappy_ReadPastEndOfBuffer();
+  snappy::Test_Snappy_FindMatchLength();
+  snappy::Test_Snappy_FindMatchLengthRandom();
+  fprintf(stderr, "All tests passed.\n");
+
+  return 0;
+}
+
+#endif  // HAVE_GTEST
+
+// For main().
+namespace snappy {
+
+static void CompressFile(const char* fname);
+static void UncompressFile(const char* fname);
+static void MeasureFile(const char* fname);
+
+// Logging.
+
+#define LOG(level) LogMessage()
+#define VLOG(level) true ? (void)0 : \
+    snappy::LogMessageVoidify() & snappy::LogMessage()
+
+class LogMessage {
+ public:
+  LogMessage() { }
+  ~LogMessage() {
+    cerr << endl;
+  }
+
+  LogMessage& operator<<(const std::string& msg) {
+    cerr << msg;
+    return *this;
+  }
+  LogMessage& operator<<(int x) {
+    cerr << x;
+    return *this;
+  }
+};
+
+// Asserts, both versions activated in debug mode only,
+// and ones that are always active.
+
+#define CRASH_UNLESS(condition) \
+    PREDICT_TRUE(condition) ? (void)0 : \
+    snappy::LogMessageVoidify() & snappy::LogMessageCrash()
+
+class LogMessageCrash : public LogMessage {
+ public:
+  LogMessageCrash() { }
+  ~LogMessageCrash() {
+    cerr << endl;
+    abort();
+  }
+};
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() { }
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(const LogMessage&) { }
+};
+
+#define CHECK(cond) CRASH_UNLESS(cond)
+#define CHECK_LE(a, b) CRASH_UNLESS((a) <= (b))
+#define CHECK_GE(a, b) CRASH_UNLESS((a) >= (b))
+#define CHECK_EQ(a, b) CRASH_UNLESS((a) == (b))
+#define CHECK_NE(a, b) CRASH_UNLESS((a) != (b))
+#define CHECK_LT(a, b) CRASH_UNLESS((a) < (b))
+#define CHECK_GT(a, b) CRASH_UNLESS((a) > (b))
+
+}  // namespace
+
+using snappy::CompressFile;
+using snappy::UncompressFile;
+using snappy::MeasureFile;
+
+#endif  // UTIL_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_

src/snappy/snappy/snappy.h

@@ -0,0 +1,184 @@
+// Copyright 2005 and onwards Google Inc.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. 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
+// OWNER 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.
+//
+// A light-weight compression algorithm.  It is designed for speed of
+// compression and decompression, rather than for the utmost in space
+// savings.
+//
+// For getting better compression ratios when you are compressing data
+// with long repeated sequences or compressing data that is similar to
+// other data, while still compressing fast, you might look at first
+// using BMDiff and then compressing the output of BMDiff with
+// Snappy.
+
+#ifndef UTIL_SNAPPY_SNAPPY_H__
+#define UTIL_SNAPPY_SNAPPY_H__
+
+#include <stddef.h>
+#include <string>
+
+#include "snappy-stubs-public.h"
+
+namespace snappy {
+  class Source;
+  class Sink;
+
+  // ------------------------------------------------------------------------
+  // Generic compression/decompression routines.
+  // ------------------------------------------------------------------------
+
+  // Compress the bytes read from "*source" and append to "*sink". Return the
+  // number of bytes written.
+  size_t Compress(Source* source, Sink* sink);
+
+  // Find the uncompressed length of the given stream, as given by the header.
+  // Note that the true length could deviate from this; the stream could e.g.
+  // be truncated.
+  //
+  // Also note that this leaves "*source" in a state that is unsuitable for
+  // further operations, such as RawUncompress(). You will need to rewind
+  // or recreate the source yourself before attempting any further calls.
+  bool GetUncompressedLength(Source* source, uint32* result);
+
+  // ------------------------------------------------------------------------
+  // Higher-level string based routines (should be sufficient for most users)
+  // ------------------------------------------------------------------------
+
+  // Sets "*output" to the compressed version of "input[0,input_length-1]".
+  // Original contents of *output are lost.
+  //
+  // REQUIRES: "input[]" is not an alias of "*output".
+  size_t Compress(const char* input, size_t input_length, string* output);
+
+  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
+  // Original contents of "*uncompressed" are lost.
+  //
+  // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
+  //
+  // returns false if the message is corrupted and could not be decompressed
+  bool Uncompress(const char* compressed, size_t compressed_length,
+                  string* uncompressed);
+
+
+  // ------------------------------------------------------------------------
+  // Lower-level character array based routines.  May be useful for
+  // efficiency reasons in certain circumstances.
+  // ------------------------------------------------------------------------
+
+  // REQUIRES: "compressed" must point to an area of memory that is at
+  // least "MaxCompressedLength(input_length)" bytes in length.
+  //
+  // Takes the data stored in "input[0..input_length]" and stores
+  // it in the array pointed to by "compressed".
+  //
+  // "*compressed_length" is set to the length of the compressed output.
+  //
+  // Example:
+  //    char* output = new char[snappy::MaxCompressedLength(input_length)];
+  //    size_t output_length;
+  //    RawCompress(input, input_length, output, &output_length);
+  //    ... Process(output, output_length) ...
+  //    delete [] output;
+  void RawCompress(const char* input,
+                   size_t input_length,
+                   char* compressed,
+                   size_t* compressed_length);
+
+  // Given data in "compressed[0..compressed_length-1]" generated by
+  // calling the Snappy::Compress routine, this routine
+  // stores the uncompressed data to
+  //    uncompressed[0..GetUncompressedLength(compressed)-1]
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompress(const char* compressed, size_t compressed_length,
+                     char* uncompressed);
+
+  // Given data from the byte source 'compressed' generated by calling
+  // the Snappy::Compress routine, this routine stores the uncompressed
+  // data to
+  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompress(Source* compressed, char* uncompressed);
+
+  // Given data in "compressed[0..compressed_length-1]" generated by
+  // calling the Snappy::Compress routine, this routine
+  // stores the uncompressed data to the iovec "iov". The number of physical
+  // buffers in "iov" is given by iov_cnt and their cumulative size
+  // must be at least GetUncompressedLength(compressed). The individual buffers
+  // in "iov" must not overlap with each other.
+  //
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
+                            const struct iovec* iov, size_t iov_cnt);
+
+  // Given data from the byte source 'compressed' generated by calling
+  // the Snappy::Compress routine, this routine stores the uncompressed
+  // data to the iovec "iov". The number of physical
+  // buffers in "iov" is given by iov_cnt and their cumulative size
+  // must be at least GetUncompressedLength(compressed). The individual buffers
+  // in "iov" must not overlap with each other.
+  //
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
+                            size_t iov_cnt);
+
+  // Returns the maximal size of the compressed representation of
+  // input data that is "source_bytes" bytes in length;
+  size_t MaxCompressedLength(size_t source_bytes);
+
+  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
+  // Returns true and stores the length of the uncompressed data in
+  // *result normally.  Returns false on parsing error.
+  // This operation takes O(1) time.
+  bool GetUncompressedLength(const char* compressed, size_t compressed_length,
+                             size_t* result);
+
+  // Returns true iff the contents of "compressed[]" can be uncompressed
+  // successfully.  Does not return the uncompressed data.  Takes
+  // time proportional to compressed_length, but is usually at least
+  // a factor of four faster than actual decompression.
+  bool IsValidCompressedBuffer(const char* compressed,
+                               size_t compressed_length);
+
+  // The size of a compression block. Note that many parts of the compression
+  // code assumes that kBlockSize <= 65536; in particular, the hash table
+  // can only store 16-bit offsets, and EmitCopy() also assumes the offset
+  // is 65535 bytes or less. Note also that if you change this, it will
+  // affect the framing format (see framing_format.txt).
+  //
+  // Note that there might be older data around that is compressed with larger
+  // block sizes, so the decompression code should not rely on the
+  // non-existence of long backreferences.
+  static const int kBlockLog = 16;
+  static const size_t kBlockSize = 1 << kBlockLog;
+
+  static const int kMaxHashTableBits = 14;
+  static const size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
+}  // end namespace snappy
+
+
+#endif  // UTIL_SNAPPY_SNAPPY_H__

src/snappy/snappy/testdata/paper-100k.pdf

@@ -0,0 +1,598 @@
+     </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=10 M=100 Y=50 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>10.000002</xmpG:cyan>
+                           <xmpG:magenta>100.000000</xmpG:magenta>
+                           <xmpG:yellow>50.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=95 Y=20 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>94.999999</xmpG:magenta>
+                           <xmpG:yellow>19.999999</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=25 M=25 Y=40 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>25.000000</xmpG:cyan>
+                           <xmpG:magenta>25.000000</xmpG:magenta>
+                           <xmpG:yellow>39.999998</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=40 M=45 Y=50 K=5</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>39.999998</xmpG:cyan>
+                           <xmpG:magenta>44.999999</xmpG:magenta>
+                           <xmpG:yellow>50.000000</xmpG:yellow>
+                           <xmpG:black>5.000001</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=50 M=50 Y=60 K=25</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>50.000000</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>60.000002</xmpG:yellow>
+                           <xmpG:black>25.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=55 M=60 Y=65 K=40</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>55.000001</xmpG:cyan>
+                           <xmpG:magenta>60.000002</xmpG:magenta>
+                           <xmpG:yellow>64.999998</xmpG:yellow>
+                           <xmpG:black>39.999998</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=25 M=40 Y=65 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>25.000000</xmpG:cyan>
+                           <xmpG:magenta>39.999998</xmpG:magenta>
+                           <xmpG:yellow>64.999998</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=30 M=50 Y=75 K=10</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>30.000001</xmpG:cyan>
+                           <xmpG:magenta>50.000000</xmpG:magenta>
+                           <xmpG:yellow>75.000000</xmpG:yellow>
+                           <xmpG:black>10.000002</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=35 M=60 Y=80 K=25</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>35.000002</xmpG:cyan>
+                           <xmpG:magenta>60.000002</xmpG:magenta>
+                           <xmpG:yellow>80.000001</xmpG:yellow>
+                           <xmpG:black>25.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=40 M=65 Y=90 K=35</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>39.999998</xmpG:cyan>
+                           <xmpG:magenta>64.999998</xmpG:magenta>
+                           <xmpG:yellow>90.000004</xmpG:yellow>
+                           <xmpG:black>35.000002</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=40 M=70 Y=100 K=50</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>39.999998</xmpG:cyan>
+                           <xmpG:magenta>69.999999</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>50.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=50 M=70 Y=80 K=70</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>50.000000</xmpG:cyan>
+                           <xmpG:magenta>69.999999</xmpG:magenta>
+                           <xmpG:yellow>80.000001</xmpG:yellow>
+                           <xmpG:black>69.999999</xmpG:black>
+                        </rdf:li>
+                     </rdf:Seq>
+                  </xmpG:Colorants>
+               </rdf:li>
+               <rdf:li rdf:parseType="Resource">
+                  <xmpG:groupName>Grays</xmpG:groupName>
+                  <xmpG:groupType>1</xmpG:groupType>
+                  <xmpG:Colorants>
+                     <rdf:Seq>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=100</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>100.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=90</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>89.999402</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=80</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>79.998797</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=70</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>69.999701</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=60</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>59.999102</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=50</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>50.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=40</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>39.999402</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=30</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>29.998803</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=20</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>19.999701</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=10</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>9.999102</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=0 Y=0 K=5</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>0.000000</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>4.998803</xmpG:black>
+                        </rdf:li>
+                     </rdf:Seq>
+                  </xmpG:Colorants>
+               </rdf:li>
+               <rdf:li rdf:parseType="Resource">
+                  <xmpG:groupName>Brights</xmpG:groupName>
+                  <xmpG:groupType>1</xmpG:groupType>
+                  <xmpG:Colorants>
+                     <rdf:Seq>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=100 Y=100 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>100.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=75 Y=100 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>75.000000</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=0 M=10 Y=95 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>0.000000</xmpG:cyan>
+                           <xmpG:magenta>10.000002</xmpG:magenta>
+                           <xmpG:yellow>94.999999</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=85 M=10 Y=100 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>84.999996</xmpG:cyan>
+                           <xmpG:magenta>10.000002</xmpG:magenta>
+                           <xmpG:yellow>100.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=100 M=90 Y=0 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>100.000000</xmpG:cyan>
+                           <xmpG:magenta>90.000004</xmpG:magenta>
+                           <xmpG:yellow>0.000000</xmpG:yellow>
+                           <xmpG:black>0.000000</xmpG:black>
+                        </rdf:li>
+                        <rdf:li rdf:parseType="Resource">
+                           <xmpG:swatchName>C=60 M=90 Y=0 K=0</xmpG:swatchName>
+                           <xmpG:mode>CMYK</xmpG:mode>
+                           <xmpG:type>PROCESS</xmpG:type>
+                           <xmpG:cyan>60.000002</xmpG:cyan>
+                           <xmpG:magenta>90.000004</xmpG:magenta>
+                           <xmpG:yellow>0.003099</xmpG:yellow>
+                           <xmpG:black>0.003099</xmpG:black>
+                        </rdf:li>
+                     </rdf:Seq>
+                  </xmpG:Colorants>
+               </rdf:li>
+            </rdf:Seq>
+         </xmpTPg:SwatchGroups>
+      </rdf:Description>
+      <rdf:Description rdf:about=""
+            xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
+         <pdf:Producer>Adobe PDF library 9.00</pdf:Producer>
+      </rdf:Description>
+   </rdf:RDF>
+</x:xmpmeta>
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                           
+<?xpacket end="w"?>
+
+endstream
+endobj
+145 0 obj<</Metadata 144 0 R>>
+endobj
+1 0 obj<</Contents 3 0 R/Type/Page/Parent 102 0 R/Rotate 0/MediaBox[0 0 612.28302 790.866028]/CropBox[0 0 612.28302 790.866028]/Resources 2 0 R>>
+endobj
+2 0 obj<</ColorSpace<</Cs8 117 0 R>>/Font<</F2 122 0 R/F3 121 0 R/F6 118 0 R/F7 125 0 R/F8 56 0 R/F9 70 0 R/F10 71 0 R/F11 61 0 R/F12 65 0 R/F13 72 0 R>>/ProcSet[/PDF/Text]/ExtGState<</GS1 113 0 R>>>>
+endobj
+3 0 obj<</Length 8934/Filter/FlateDecode>>stream
+hޔ[Ms<4D>F<EFBFBD><46><EFBFBD>W<EFBFBD>n<>mU(s<><73>e{<7B><><EFBFBD><EFBFBD>kjw<0E>`7<>ƨhhҜ<68>_<EFBFBD><5F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>e<15>&<26>rl(B<><42>G<EFBFBD><47>2<EFBFBD><32>ˏ<EFBFBD><CB8F>_o<5F><6F><EFBFBD><EFBFBD>ͷ<1F>|<7C><><EFBFBD>H.>޽)V<>s<EFBFBD>"<22><EFBFBD><7F><EFBFBD>Wq<57>\X<17><>إ<1F>ob<6F><62><EFBFBD><EFBFBD><EFBFBD><EFBFBD>5<EFBFBD>{|<7C>)<29><>^<5E><>xy<78><79>l<EFBFBD>D<EFBFBD>]<5D>E~g<>*<2A>vM<76><4D><EFBFBD><EFBFBD>_Y<5F><59><EFBFBD>Aڨjq<6A><71><EFBFBD>ݷ?<3F>b<EFBFBD>*<2A>]<5D>P<EFBFBD><50>W<EFBFBD>r<EFBFBD><72><EFBFBD><EFBFBD>U<19><>m<1D><>?<3F><>04]<5D><><EFBFBD>\<5C>}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\<5C>ʲ<EFBFBD><CAB2>NVI<56>d=<3D>ɼ<EFBFBD>u<EFBFBD><75>p6w<36><77><EFBFBD>N~<7E>re<72>ߎU;6c565<><35>2<EFBFBD>
c<><63>v<EFBFBD><76>u<EFBFBD><75>
+g<EFBFBD><EFBFBD><EFBFBD><EFBFBD>S<EFBFBD><EFBFBD>3<EFBFBD>>_<><5F>D04<30><34><EFBFBD><EFBFBD><>Qw<1C>#<23>*<2A><><EFBFBD><EFBFBD><EFBFBD>ׇ}<7D><><EFBFBD>L<EFBFBD>%<25><><EFBFBD>m<EFBFBD><6D>_9f<39><66><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><12><17>^YצY<D7A6><1C>N<>9n<39>ps<70>e)<29><>9<EFBFBD><39><EFBFBD><EFBFBD><EFBFBD>&<26><>|<7C><>O<EFBFBD>"<22><>~l<><6C><EFBFBD><EFBFBD>ms<6D><73>=2yT<79><54>ǾZ?<3F><>'<04>=<3D>V<EFBFBD>W<EFBFBD>;<3B><><EFBFBD>`L)<29>T0<54>X<EFBFBD>A4&<26><><EFBFBD>q'<27><0F><>IGJd<4A>שŷ<0F>C7bb<62>1Q<31><51><EFBFBD><EFBFBD>t<EFBFBD>rJ1E<31><45>\ES<45>ñ<EFBFBD>R!<21>"<22><>d<EFBFBD>wǝ
+?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>G<15><08>q<EFBFBD> p<>ۢ<1A><>_<EFBFBD>⧑<EFBFBD>}}؉<><D889>+.<2E>D<EFBFBD><EFBFBD>A<04><><EFBFBD><EFBFBD>ɤ$&<26><>
+*<2A>v<EFBFBD>o<EFBFBD><6F>:U<>T<EFBFBD><54>i<1E>͑ks<6B><73><EFBFBD>?<3F>y'<27><>V<EFBFBD>^4<>m]O߽<4F><DFBD>A<EFBFBD><41><EFBFBD>$x<>I;#<23><><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>.|<7C><><EFBFBD>ý<EFBFBD>o<EFBFBD><6F><EFBFBD>Q<EFBFBD>w<EFBFBD>v<EFBFBD>K<EFBFBD>,ă<>2kd<6B>6<EFBFBD>X<EFBFBD><00>,<2C><>4#.C͛
<01> <20>]<5D><><EFBFBD>=<3D><>F6<46><1A>w<EFBFBD><77><EFBFBD>QD1<44>{~۴<>(<10>}<7D><>E<EFBFBD><45>K_<4B>w<>*hZ@Ct<43>EA<45>g<EFBFBD>/<2F>)rj<72><6A><EFBFBD>J<EFBFBD><4A>чvS<76><1B>\a<>#<23>xh<78>G<EFBFBD><47>F<EFBFBD><46>ؓ<EFBFBD><D893><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}l<><6C>cY<63>h<EFBFBD>)<13><><EFBFBD><EFBFBD>(<28><>ǍT<C78D><54>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Sb<53><62><EFBFBD><EFBFBD>[,ʔ<>W%<25>ʣMswW<77>/S2<><32><EFBFBD>X<EFBFBD>G<EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD>5<EFBFBD><35><EFBFBD><EFBFBD><EFBFBD>r><3E><><EFBFBD><EFBFBD>,<2C><><EFBFBD><0B><>b`'<27>%<25><><EFBFBD><EFBFBD>E,B<>><3E>|$<24>G0<47>,1
%<25><>@<40><><EFBFBD>T/<2F>2<EFBFBD>;<3B><>,<2C>BQC)e<0F><><EFBFBD>]<5D>M<EFBFBD>R<EFBFBD>ض<1B>~<7E>Rm<>[Q<><51><EFBFBD><EFBFBD>
+Pc<><0B>]<0B><>Q<EFBFBD>kO<6B>NF<19><>J_<4A><5F>
<01><>ɇ<1E><>z{θ<>C<EFBFBD>n<EFBFBD><6E>5<EFBFBD><35><EFBFBD><<3C><>e<EFBFBD><65><EFBFBD>H<EFBFBD><48><EFBFBD><EFBFBD>Q`S<>u/JCSI<53>c<EFBFBD><63>v<EFBFBD>f<EFBFBD>F<EFBFBD>M<EFBFBD><4D><EFBFBD><15>as֣<73>pΪ?<3F><><EFBFBD><EFBFBD>²<EFBFBD>y<><1B><><11><>'<27>#<23><><EFBFBD><1B><07>;<3B>n<EFBFBD>i*s<><73>#<23>}<7D><><EFBFBD><EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>m<EFBFBD>6<EFBFBD><17><><EFBFBD><EFBFBD>Y<1B><>^<5E><>z<>
+.R`c߭a<DFAD>Xg|_<><5F>~<7E><>"<22><>hj<>@<40><>ͼ<0C>,<2C><><EFBFBD>=qr<05><>f<EFBFBD>ή<EFBFBD>¥<EFBFBD><C2A5>40<34>P<EFBFBD><50>u}<7D><>`<18><>@4<><0B>;<3B>zR<7A>ϗ<EFBFBD>{<14><><EFBFBD>u,"<22>M<EFBFBD><4D>O<EFBFBD>&Sԛ&<26><><EFBFBD>"a<>*W`<60><><EFBFBD>"I<06>F$<24>,<2C>b<EFBFBD>O<EFBFBD><4F><EFBFBD><16>s=<<3C><>#j<><6A><EFBFBD><17><>{<11>~<7E><>r<>-"<22>"<22> .<2E>YF}V$<24>[<5B>'=ù<0E><><EFBFBD>J<EFBFBD>}<16>J<EFBFBD>Z<EFBFBD>g<EFBFBD><67>6`v<><76><EFBFBD>&v<><76><EFBFBD><EFBFBD>e<EFBFBD><65><EFBFBD>z|$<24><><EFBFBD>l
Ur
<01><><EFBFBD>iڃ<69>]<5D><><EFBFBD><14><>=X<00>3M7<><37><EFBFBD>-<2D>uծ<75><D5AE><0C><>Q/<2F>1y
<01><>8<EFBFBD><38><EFBFBD>8<EFBFBD><38>@<40><><EFBFBD>v<EFBFBD><76><EFBFBD><EFBFBD><EFBFBD>p<EFBFBD><70><EFBFBD>:c<><15>Ș<EFBFBD><C898><EFBFBD>ei$<24><>eTW=]C
+<EFBFBD><EFBFBD>]<5D><>E<EFBFBD><45>;<3B>Ȼp<C8BB>~<7E>
+<EFBFBD>U{<7B><>Q*0<>5<EFBFBD>.<2E>xr"<22>C<><43>뻡;l<>]u<><75><EFBFBD><EFBFBD>$<24>JĘ<06>C<EFBFBD>8<><38>22<32>?<3F><02><><EFBFBD>@<40>Hr<48><0C>4A<34><13><><EFBFBD>$[<5B><>Z<EFBFBD><5A>3<EFBFBD><33>X+!M<><4D><EFBFBD>?86<>[T<02><>><3E>y<EFBFBD>ٜh׏<07>Ұq	<09>P<EFBFBD>$<><1B>
+<EFBFBD>Y<EFBFBD>p%<16><1F>b<EFBFBD>#X<>5<EFBFBD>|<7C>b<EFBFBD>^Q*B;<3B>N<><00><13><>J:<3A><><EFBFBD>3R<33><52><1C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*<a_o<5F><6F><EFBFBD>j<14>"<22> <20><><1F>v<EFBFBD>w<EFBFBD><77>T<>xM<78>/Gt<16>Rf<52><66><04>w<EFBFBD><11><>#<23>T։<54>λ<>NБK<D091>"<22>	<09>m<EFBFBD><6D>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><07><>使<EFBFBD><E4BDBF>Qɽ<51>t<EFBFBD>A<00>mSj<><6A><1D>R.<2E><><EFBFBD>ij<69><6A>s<EFBFBD><08>NR<4E>j<EFBFBD><6A><EFBFBD>]<5D><>J<><4A><1A>.wŽ<77><C5BD><EFBFBD><EFBFBD>S<EFBFBD><10><><EFBFBD>Lm<06><><EFBFBD>Zt<>J<>fT3^<5E><00>dS<64><53><EFBFBD><EFBFBD>X<EFBFBD>F-<19>B<EFBFBD><42>@<40><>'<27>+N<><4E>K<EFBFBD><04>}<7D><><EFBFBD><EFBFBD>8<EFBFBD><38><EFBFBD>P<EFBFBD>x<EFBFBD>`t}<0B><>HM[<5B>Q}<7D><>9<EFBFBD><39>f4<>]<5D>YR<59>4{$~<7E>Sd<53>ȱx(<28><>3<EFBFBD>}<7D><><EFBFBD>ÞPK<50><4B>?<3F><>
+W<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>`<60>q"<22>
W<><57><EFBFBD><EFBFBD><04>u<04>ݴ,<2C>ם<EFBFBD>]<<11><>2<EFBFBD><32>.\<5C>%/m<>
+<03>f<EFBFBD>-T<1A><><EFBFBD><EFBFBD>|Д<>1tb<74>Ot<4F>򗘢<EFBFBD><03>֡<>3<> <20>l9<6C><39>2f<02><><EFBFBD><EFBFBD><EFBFBD>0k]<5D><>a#<23><>J݋<4A>ʇǾ<CA87>=p<><<3C>1$<24><><0C><>hD<68><44><EFBFBD>G<EFBFBD>-.8<EFBFBD>Y<EFBFBD><EFBFBD>p0<EFBFBD><EFBFBD>A?nu<6E>g<16><><_<><5F>;<3B>"<05><>ES<45><53><12>w<EFBFBD><77><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2<>Lt<4C>Tl<54><6C><<3C><1B>p<EFBFBD>`	v<><76>1Sd<03>j'<27><>Y<EFBFBD>bɁ<62>U<>t<EFBFBD>!l<><6C>3,<2C>f|:<3A>ß<EFBFBD><18><>j<EFBFBD>%<25>j<EFBFBD>ANAiW<69><11><><EFBFBD>
+U<EFBFBD><EFBFBD>v<EFBFBD><EFBFBD><15>q<EFBFBD>Qk<19>E<EFBFBD><45><0B><><1A><><EFBFBD>dc<64><19><><1D>%`<19><>l%<25><>R<EFBFBD>{<7B><>J<EFBFBD>?o<>	8-㹟<0E>D<EFBFBD><44>_/	L<>W<EFBFBD><57>y<EFBFBD><79><EFBFBD>		<09><><EFBFBD>1U#R<>]q<>;$ƺHX<>9<EFBFBD>H<EFBFBD>D	<09>z<EFBFBD><7A>I<05><>\<Z"<22>ml<6D><6C><EFBFBD>O<EFBFBD>u<EFBFBD><75>V<16>l*v\@<40>8<EFBFBD><38><10><>z<EFBFBD><7A>:/su<73>B<1D><04>Ċ<EFBFBD>Q<EFBFBD>?<3F><>,<2C><>!<21><>L^8d<38>"<22>%<25><>IG-<2D>=<3D>K<06>\<5C><><EFBFBD><EFBFBD><11><17><>Eh<11>Y<19><>B<00><><EFBFBD>0J<30>\x\+aJ<61>07<30>4><3E>ě9"<22>a<EFBFBD><61><EFBFBD>x<EFBFBD>pNA
+<04>
+S<EFBFBD>b'
+<EFBFBD>U<EFBFBD>p<EFBFBD>~t܅<74>6<EFBFBD>C׏<43>s$<24><>t<02>Wh<57>eޢ<65>+<2B>h<EFBFBD>q<EFBFBD>,GF<47>IH<49><48>[W5<57>S<EFBFBD>a<<3C>D<><44><EFBFBD><EFBFBD>X<EFBFBD><58><EFBFBD><EFBFBD>Sq-<2D>͘<EFBFBD>1<EFBFBD><EFBFBD>+<1F>"G[<5B><><EFBFBD>!&f,ݭp<DDAD>g<EFBFBD> <20><>|<11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>v0E<30>Q͝`ҎIYZ<59>)<29>+<2B>S<0B><><EFBFBD><EFBFBD><EFBFBD>wM<77><4D><EFBFBD>@<40>]<5D><><EFBFBD><EFBFBD>G\<5C>ѵc<D1B5>v[<5B><04>C<EFBFBD>?0<>!<21><><EFBFBD><EFBFBD><EFBFBD>8<1A><>C1R<31><<3C>*<2A><><EFBFBD><EFBFBD><EFBFBD>`yqY<71><17>!K
5<>_<EFBFBD><0F>q7<0E>|<07>M <20><>QS<51>:<3A>Y0<59><30><14><><1F>Yu<59>Iaf>]"B<><42><1A>]<5D><-W<>{0ps<70><73><EFBFBD>涹<EFBFBD>f^H<>G<EFBFBD><47><EFBFBD>Ѹ<EFBFBD><D1B8><EFBFBD><EFBFBD>dV`)0<><30><EFBFBD><EFBFBD><EFBFBD>YohjV<6A>B<EFBFBD>訅<EFBFBD><E8A885><EFBFBD><EFBFBD>aRpv<70>)<29><>P<EFBFBD><50><1C>O<EFBFBD><4F><EFBFBD><10>%<19><><EFBFBD>̹W<>-%
<01>~<7E>ח	><3E>-<18>@<40><>e<EFBFBD>\<5C>:<3A><19><>
<01><0E><0C>+p<>X<0E><><EFBFBD>I<EFBFBD><49>Rt/<2F><><EFBFBD><EFBFBD>'* <08><07>O<>.<2E><>XIMh=N`B<><42><EFBFBD><EFBFBD>epxc<78>_<EFBFBD><0C><>~<7E><>d<EFBFBD><64>~<7E><><EFBFBD><EFBFBD>R<EFBFBD><52>'%<25><>W<EFBFBD>(
+&<26><>o׷+,NyL'<27>$Rx<52>a9<61>KB<4B><42>YX
W<>2<07><><EFBFBD>Ө<EFBFBD><D3A8>/0<>,sJ<73>1yX>(f$<1A>W<EFBFBD>(<28>J
+쇋<EFBFBD><EFBFBD>ÏD~<7E><>1R<1E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Qg#<23>p<EFBFBD><70>p<15>2<EFBFBD>:
}R<><52>HX0<0C><><EFBFBD>=
+<16>#<23>1p<31><70><EFBFBD>:<3A><>]<05><>c<EFBFBD><63><EFBFBD>Q3&<26>s<EFBFBD>d<EFBFBD><0E><><EFBFBD>̤j<CCA4><6A><EFBFBD><EFBFBD>oF?<3F><><EFBFBD><1E><>8<EFBFBD>V&<26><><EFBFBD>Ӓ<EFBFBD><D392><16>Snޝ#<23><>:t<05>b0<62>2.<2E><><EFBFBD><EFBFBD><EFBFBD>žz<><7A>D-<2D><>;<00><>+,<2C>=߃`<60>p<EFBFBD><70>!jΰL<CEB0><06>D]asɠ<14><><EFBFBD><EFBFBD>F<EFBFBD>c<EFBFBD><63>T	<1E><>\0<><30>>I/LPa<50>f<EFBFBD><66><EFBFBD>rF<72><46>
+HK<EFBFBD>ؙe(<28><><EFBFBD>O/<2F>e<EFBFBD><65>;ex~<7E><>Z<EFBFBD>Y<EFBFBD>	<09>P<EFBFBD><50><EFBFBD>3c<33><63>d|<7C><>V<EFBFBD>4<05>dOЇ<4F>)<29><>Z~F<>$<24>֕K$tI<74><49>@[<5B>Au<41>0\<5C>d<EFBFBD><64><0E>Fd<46><64>Z<1F>s<12>j<EFBFBD>?K~<7E>oX<><58>&=x<><0E><1F><><EFBFBD>6U8<55>~.PTZ;@<00>WaNCnu<6E><04><><EFBFBD><EFBFBD><EFBFBD><0E>P<EFBFBD>(Ψ-<2D>&<26>fM<66><4D>Ȳ<13>!<<3C><><EFBFBD><EFBFBD>4<>l<><6C><EFBFBD><EFBFBD><EFBFBD>mC
+<00><><EFBFBD>5c<1E><>^A<>֍<EFBFBD>Y<EFBFBD>1xU_<><5F>2<EFBFBD>g<EFBFBD>t<EFBFBD>i<11><>Mc<4D><02>%='0<>><3E>ⷢ<EFBFBD>ړuWHh*ZC<12>w3<77><33><00><>H<EFBFBD><48><EFBFBD>VwA
<01><>к<EFBFBD>a	H<><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*^<5E><>I<EFBFBD>ؽSĮ<53>l֫p*><3E>Q<EFBFBD>!:M֥<><D6A5>Ml<14><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ղ"r<>9<EFBFBD>1LA<4C><19>D<><44>m]X؆<58>I<>)<29>W<>'Sz<53><7A><EFBFBD>S4CB<><42>lĉ<15><>&6<>q<EFBFBD>j<EFBFBD>Ȃ<EFBFBD><C882>:<3A>
+<EFBFBD><EFBFBD>S<EFBFBD><EFBFBD>H+z<><7A> <20>G?_KtɌb~<7E><><EFBFBD>>4=t<>U<><55><EFBFBD>
+	*<2A>8g2a<32><1D><>j<>D<0F><>&<26><><EFBFBD>_ߩB<DFA9><42><1D><>{<7B>
+<EFBFBD>
+<EFBFBD>g<EFBFBD>B$E<>ijM<C4B3>t|G
+<EFBFBD>Ǩ>#!<21>8<EFBFBD>JM:<3A>><3E><>3<>w<EFBFBD><77>y<17>.<2E>#<23><><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD><33>:0Q<30>I<EFBFBD>.<2E><>8k<38>"t<>N<EFBFBD>Z}<04>G<EFBFBD><47><EFBFBD>%@i"<22>ܷ<>L<EFBFBD><4C><EFBFBD><EFBFBD>5)<29><1C>w?/<2F>><3E>+<2B>$<24>.&<26><>N<EFBFBD><4E>3ꔈ{[<5B><>-R
+韹<EFBFBD>n
><3E>u<><75>e<08><><EFBFBD>P	4~<7E><>z<EFBFBD><7A><EFBFBD>Z<EFBFBD><5A>](<28>i<EFBFBD><69><EFBFBD>~<7E>|<7C>M
<01><>
+6A8<EFBFBD>*<2A><><EFBFBD><EFBFBD><0E>;<3B>:<3A><>M<EFBFBD><4D>
<01><><EFBFBD>h<EFBFBD>!<21><>GͰ<47><CDB0><EFBFBD>#;<3B>B<EFBFBD><42><08><06>jP<6A>D<>a<1D><>h<EFBFBD><68>S~<7E><>ȗwjyǡQ<C7A1>|<7C><><EFBFBD><EFBFBD>E<EFBFBD><45><EFBFBD>Q<EFBFBD><51><EFBFBD>'ࢳ<19><>X
+<EFBFBD>|J1c@<40><>"<22>A<EFBFBD>'c<>eI3Ȋ<33>Z<EFBFBD>G<EFBFBD>#s>]<5D>ME<4D><45>
n<>,<2C><>R\
<01>FuNT':<3A><>n<EFBFBD><1B><>j<EFBFBD>D<EFBFBD>J<1D>XI<><04><>gc<67><1F>q<EFBFBD><71><EFBFBD>m<EFBFBD><6D>7<>̰<EFBFBD><CCB0><14>5<1A>zڎDy<><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>F<0B>AN;<3B>etS?L<><4C><EFBFBD>م1g<31><67>B<EFBFBD><42><EFBFBD><EFBFBD>B<EFBFBD>@<40><>3V̶<56><CCB6><EFBFBD>u<EFBFBD>D<7F>|<7C><><EFBFBD><14>o<EFBFBD>nh<6E><68>A<EFBFBD>JF*<2A><>gy<67>hL<68><4C><EFBFBD>V<0E><><EFBFBD><EFBFBD><EFBFBD>V<EFBFBD>Bb<42>eh<65><14><><EFBFBD><EFBFBD>ה<EFBFBD>|<7C>0*n7AHRiD<69><44><EFBFBD>H<EFBFBD><48>§<EFBFBD>*<2A>H,puɢ<75>)?<0F>e<13><><EFBFBD>;<3B><1E><18><><h<>).x<>A<EFBFBD>7<>0z]<5D><>jߍJ<DF8D><4A><EFBFBD>!<?<3F>Z<<3C>6<><36>q<EFBFBD><71>0W<30><57>ɢ<0F><>gt<67><74>l<EFBFBD><6C>G<><47>&<26> <20>8<EFBFBD>
8g<38>f_<66>]<5D><Y:<3A>[9<>$<24>@<40><><EFBFBD><EFBFBD><7F><1D><02><>V<EFBFBD><0F><>X,<2C>"<1A><><EFBFBD>H2g<32><67>ip<69><70>~W<1D><1C><>Ը<EFBFBD><<13><07>cŢyIպ<49><D5BA><EFBFBD>O<EFBFBD>|Y<>+<2B>
+*Tnn<02><>qO<71>i<EFBFBD>&<26>b$q<><71>;<3B><EFBFBD><7F><EFBFBD><EFBFBD><EFBFBD><10><>Ҩ<17>b.<2E><><EFBFBD>X%8<><38><EFBFBD>b<18>HJ<10><>
޵<><DEB5>0
+	P-PJ!$<24><>R<EFBFBD>¼bk<62>Fs/<2F><>|<7C><>A<>2<EFBFBD>b<EFBFBD><62>!<21><02><>,<13><><05>M<EFBFBD><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><7F>~
<01>
+Iy|<1C> PPu9U<39>zF<7A>Z5ε<35> Cr6J<36><4A>n<EFBFBD>/<2F><><EFBFBD><EFBFBD><EFBFBD>x=<3D>H<EFBFBD>!<21>c<<3C><>Q<EFBFBD><51><EFBFBD><EFBFBD><EFBFBD>U:<3A>S^<5E>&7<><10><>onBYw<59><77><EFBFBD> s}W<1C><>QY<51>t<03><>a<EFBFBD><61><EFBFBD><EFBFBD>^A<>o<11>/r
+5y<EFBFBD><18>h"<22><>1/`<60><>2g<32>&<26>Z<05><><08>O<EFBFBD>A<03>[5H<35>RA
+(O	<09><>-<2D>E<EFBFBD><45>2<EFBFBD>n<EFBFBD><06><16><><EFBFBD><EFBFBD>&'i<1C><><1D><>tr<74>~<7E>E<>")<29><>#g)<>k<EFBFBD><6B>
+<0F><>@<40>mS+<2B><>U<EFBFBD>.j<><6A>"<22><>P<EFBFBD><10><><EFBFBD><0C>{<7B><>0z
<01>'e<><65>=MP<4D>S<EFBFBD>+5<>K
+<EFBFBD><19><>Q<1E><03><>F;<3B><>`<60><><EFBFBD><EFBFBD>!<21><>׺<EFBFBD>h'pq*bY	<09><>P{bـX<D980>!<21>0[<5B><>'<27>ȱ<EFBFBD><C8B1>3<EFBFBD>-sj<73>rM<72>:<1F>7<><37><EFBFBD><EFBFBD><12>}i;<3B>t<1E>;2<>jݽ<><14>b<>͜<19><>~<7E>S<EFBFBD><53>&<06><>h<EFBFBD>i<EFBFBD><69>\./<2F>Z<EFBFBD>S<EFBFBD>䓊Z<E4938A>a<EFBFBD><61><11>f <>n<EFBFBD><6E><EFBFBD><07>H<><48>y<EFBFBD>v<EFBFBD>{<7B>?<3F>S<EFBFBD><1F><>#ܓ#2<><1C>v<EFBFBD><76><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD>%<25><><EFBFBD><EFBFBD>!<21>;Nܗ<4E><DC97>s<EFBFBD><73>}<7D>.<2E>LxFf<46>x<><78>a/<2F><>9<EFBFBD><39>`C<19><><07>O<EFBFBD><0E>(<28>Ջ<>|F<18>8<>P<13><>,<2C><><0E><>2<EFBFBD><b
<01>$<1A><><EFBFBD><EFBFBD>Cj<43>%<25><>qr<71><72><EFBFBD>
+V<><56>ѨB<D1A8>6<16>C<EFBFBD><43>+!ԙ<>.<2E>{
+<EFBFBD><1A>
+<EFBFBD><EFBFBD>(
+<EFBFBD><EFBFBD><1E><>2<EFBFBD>H<EFBFBD>
+<EFBFBD><EFBFBD>Vr}PU<50><55><EFBFBD>}*p<>Ri<52><69><EFBFBD>K<EFBFBD><4B><EFBFBD>ٳc"l<><6C>+<2B>
<01>8&<26>y<EFBFBD><79><EFBFBD>ݨDo<44><6F><EFBFBD><EFBFBD>i<EFBFBD>@hr-<2D>u8Sd)<29>eW<65><57>D
+<EFBFBD><EFBFBD><00><>H<EFBFBD><07><>MZ<4D>
s
+<EFBFBD>X<EFBFBD>U;<3B>cb<63><62>C<EFBFBD><43>R<EFBFBD><52>$<24>L<1B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C>:<3A>Ue<55><65>Sts<74><73>s<EFBFBD><07><>
+<0E><>׭O<D7AD>
<01>1]dX#<23>d?
+li\<5C>I<EFBFBD>Q<><51>
+ T<>4>55<35><35><EFBFBD><EFBFBD>ܬ<18>_<EFBFBD><10><>8<EFBFBD>3<><1E>S<EFBFBD>Y<EFBFBD>Mو<4D>t<EFBFBD><74>m<EFBFBD>4<EFBFBD>BXI<58>ގA<DE8E><17><><.}<7D><>"!<21>.<2E><><EFBFBD><EFBFBD>d>?3Aq<41><71><EFBFBD>̋x<CC8B>H<EFBFBD>㗊<EFBFBD>t}	lh*Q<><51><EFBFBD><EFBFBD>LP<4C>3<EFBFBD>C{<7B>A+ͥ<>[ٲ<><D9B2><EFBFBD><07><><EFBFBD><EFBFBD><16>z'<27>w<EFBFBD><77>/<2F><><EFBFBD>Ki<4B><69><EFBFBD><EFBFBD>so<73>E<><45><EFBFBD><EFBFBD><EFBFBD><EFBFBD>$<24><0F><>(<28>
+{gi<67><69><EFBFBD><EFBFBD>0s<30>
+<10><>I<EFBFBD><0E><EFBFBD><7F><EFBFBD><EFBFBD><EFBFBD>8<EFBFBD>48<34>'e<><65>ŪLL"<22><>\Fx<>_<>BO<1A>!<21><><EFBFBD>'o<>=<3D>`$<24>j<EFBFBD><6A><0C>̵<EFBFBD>4<EFBFBD>ݩ<EFBFBD>#,$Y<18><><18><><1A><><EFBFBD><EFBFBD>۵<EFBFBD><DBB5><EFBFBD>R<EFBFBD><52>G<EFBFBD><47>,|{`<60><><EFBFBD><EFBFBD>WlЌ<6C><D08C>/<2F><><EFBFBD>p<EFBFBD><70><EFBFBD><EFBFBD>a՚<0F>%<25>/<19><><EFBFBD><EFBFBD><EFBFBD>[<5B>$<24>G<EFBFBD><47>R<EFBFBD>"/<2F>A<EFBFBD>i<EFBFBD><69><EFBFBD>;F<><46><EFBFBD>6䔒+um`P<><50>,<2C><><EFBFBD>k닀<6B><07><><02><><EFBFBD><EFBFBD><EFBFBD>^T<>t<EFBFBD><74>fT<66><54>'<27><>)<29>{.<2E>\<5C>Ur!|<7C><>O<EFBFBD><4F>
+<EFBFBD><EFBFBD><EFBFBD>S<EFBFBD><EFBFBD><1F><>v<EFBFBD><76>*
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ő!Xw<58>r<EFBFBD><72><EFBFBD>F<EFBFBD>,<2C><><EFBFBD><EFBFBD>Xѕvv<76>h<EFBFBD><68>0z
++<2B>'wJ)s²<0C><><EFBFBD>]h<><68>zo<7A><6F>/1#<17><>A<EFBFBD><41>-<2D><>+<0E>/<1A><>6<EFBFBD>=<3D>n<EFBFBD><6E><EFBFBD>f<EFBFBD>ݘ`7<><37><EFBFBD>t<EFBFBD><74>刏/<2F>-<2D><><EFBFBD>(<28><EFBFBD><7F><EFBFBD><EFBFBD><EFBFBD>e<EFBFBD><65>>Ίe<CE8A>h"<22>AO<41><4F>'<27><><EFBFBD><EFBFBD><EFBFBD>y<EFBFBD><79>m(<28>K@<0B>6<02>~J2U#<23>
+<EFBFBD><EFBFBD><<3C>↲<EFBFBD><E286B2><EFBFBD>r<EFBFBD>Jq<4A><71><EFBFBD><EFBFBD><EFBFBD>[<5B>
+$<24><><EFBFBD><EFBFBD>o0-<2D><>xf>f<>A<EFBFBD>Q'n<>C*<2A>9<EFBFBD><39>̤<EFBFBD>O<><10><><EFBFBD><EFBFBD>VJ|<7C>v<EFBFBD><76>؂<EFBFBD><D882>?2*<12><>(
+X<EFBFBD><EFBFBD>d<EFBFBD>\<5C><>0)IP<49><50><EFBFBD>sf<73><66>O<EFBFBD><18><><EFBFBD>.<2E>7<EFBFBD>'
<01><16>N<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>8<EFBFBD>ltG֚<0F><><EFBFBD>,̜<><CC9C><EFBFBD>K<EFBFBD><4B>d<EFBFBD><64>G<1F><>dO<64>H^e1g<31><67><EFBFBD>p<08>5<>%Ƌ$<24>$<24>A<EFBFBD><41>/9hoZK<1A><>`_Z%S<>B<EFBFBD>PV<50><56><EFBFBD>[<5B>Z<EFBFBD><5A><EFBFBD>P7<50><37>/<2F><><EFBFBD><EFBFBD>wV<77>S6p<36>O<EFBFBD><4F><EFBFBD>Qu<51>l6<6C>ה <20><>F<EFBFBD>ak<61>׊<EFBFBD><D78A>'d<16>yv<79><76>yi<79><69>*m4,<2C><EFBFBD>><3E>Ѡ<EFBFBD>G]<1A><><EFBFBD><EFBFBD>	9D7<44>"<1B><>*<2A>霨<EFBFBD>W<EFBFBD>A<07>h8<68>D\<5C><1A>1<EFBFBD>q<EFBFBD>u<EFBFBD>51<35>c<EFBFBD><63><EFBFBD>u<EFBFBD>Y<EFBFBD><59><EFBFBD>y<>תk<D7AA><08>̌<EFBFBD>ݱ+ezu<><75>ݡ80T,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>J<EFBFBD><4A><EFBFBD>*y<>+<2B><>”L^5<><35>F斵<46><E696B5>z<7A>V1<56>ܛg<DC9B><67><EFBFBD><EFBFBD>e<EFBFBD>u׭<75>L[yz<79><7A>#䷐<>c<EFBFBD><63><EFBFBD>A<EFBFBD>m<EFBFBD><6D><EFBFBD>G<EFBFBD><47>D<EFBFBD><44>L-d><3E><><EFBFBD><EFBFBD>{[sG<73><47>ɕ,<2C><>5y<35><79>i5,<2C>iK<69><4B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>v7e<37><65><EFBFBD>W
+<EFBFBD>ĺ<EFBFBD><EFBFBD>i<EFBFBD><EFBFBD>[v<><76><EFBFBD>x~<7E><>e@Up<55><70><08>RDO<44><4F><EFBFBD><EFBFBD>Uh<55><68>V<EFBFBD>F;<3B>uCǾ4<>&<26><>!<21>ּ<EFBFBD>3<EFBFBD>,<2C>3xe<78>(<28>CH<43>ϵ<><CFB5><EFBFBD><0E>,<2C>{ˢj	<09><>As<41>J<EFBFBD>6ǯB<C7AF><42>O<14><10><><1D>+<06>}<7D><>ɯp9)<11><>e<EFBFBD>;<3B>)<29>g<EFBFBD><67><EFBFBD>e<EFBFBD><0F>r<EFBFBD>b<06>Z<EFBFBD>Ñ7N}ǣ4)[V~<7E><>暋<EFBFBD><E69A8B>V<EFBFBD>@<40><><EFBFBD><EFBFBD><EFBFBD>P?<3F>e<EFBFBD><EFBFBD><7F>_~<08>
+<EFBFBD>%<12><>_<EFBFBD><5F> <20><><EFBFBD>-wQ[<5B><0C>l<EFBFBD><6C><EFBFBD>E<>6b٤<62><D9A4>jc{޷뫾<DEB7><EBABBE>s<EFBFBD><73><EFBFBD><EFBFBD>L<EFBFBD>2=<3D><><EFBFBD>Z%ˑH<k!+c5<63><35>Z<EFBFBD>}1<1F>њ3<D19A>@K	@<40><>5g!2n*"LLٰ8<D9B0><38><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD>1<EFBFBD>IL<49><4C><EFBFBD><EFBFBD><EFBFBD><08>4<EFBFBD><34>kjr<6A><72><EFBFBD>oʃ<6F>(<28>g<14><>
+U<EFBFBD><EFBFBD><10>{X<>e<EFBFBD><65>0<EFBFBD><30>U`ˆ<><CB86>g<EFBFBD>m<EFBFBD>)<29>m<EFBFBD><6D><EFBFBD>v<EFBFBD>?<3F><>>0<><30>i4>v:<3A>26<32>
+#<23>Di<44>y<EFBFBD>
+m<EFBFBD><EFBFBD>8#<08>u<>K<EFBFBD><4B><EFBFBD>h<EFBFBD><19>K#ziT<69>\<5C><><EFBFBD><EFBFBD>=e̽<65>ݲ<EFBFBD><DDB2>%<25>><3E><>'o?<3F><><13>ި'<27>{H4<48>y<EFBFBD>'<13><><EFBFBD><EFBFBD><EFBFBD>L<EFBFBD>=<3D><><EFBFBD>އx<DE87><78><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Nj<EFBFBD>j<EFBFBD><1D>1|}<7D>c<EFBFBD><63><EFBFBD>^i<><69><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>tB<74>}<7D>[<5B>~<7E><><EFBFBD>V<EFBFBD>;-9<>l<EFBFBD><6C>Nï<4E>[p<>#[r<>ٖ<EFBFBD><D996><EFBFBD><EFBFBD><EFBFBD><04>s<EFBFBD>
n!<21><><EFBFBD>O<EFBFBD>Et<17>p<EFBFBD>`<60><><EFBFBD><EFBFBD><EFBFBD>|v+b<><62>E<EFBFBD>R<EFBFBD><0E>yoXT<58>`<60><>z<EFBFBD>Uw(#<17>E<EFBFBD><0B><>R<EFBFBD>m<EFBFBD><6D>3O<33><4F>+<2B><>-<2D><>BoU`<60><><EFBFBD>{<7B>m<EFBFBD><6D><EFBFBD><EFBFBD>U<03><><EFBFBD>j<><6A>0<EFBFBD>vU0<55>{<7B><><1F><><EFBFBD>4A<>#x/kqC8<06><>&<26>(<28><>/^<5E>s<EFBFBD><73><13>Y<EFBFBD>g2<67><32>"@gr<67><1E><>6<EFBFBD><15><><EFBFBD>6<EFBFBD><0F><><EFBFBD><EFBFBD>L9<4C>9<EFBFBD>.o<>K<><4B>MP<0E>Wt<>u)="k<><6B>RfH<66><48>k<EFBFBD><6B><EFBFBD>o<EFBFBD>Q<EFBFBD>ΤļB[<5B>Hi}?<3F>q<EFBFBD><71>sS<73><16>g<EFBFBD><67><EFBFBD><EFBFBD>x<EFBFBD>Oh<1C><><EFBFBD><EFBFBD><0C>S )<29>C<EFBFBD><43>a)<29>ԺY<D4BA>:<3A>k=<3D>ƱY<C6B1><59>ї".<2E>S<53><7F>ar/{<7B>DҦL<D2A6><4C>t:<3A>
+h<EFBFBD>Ml<EFBFBD><EFBFBD><EFBFBD>ڲKL<4B><4C>bxD<78><44><EFBFBD><EFBFBD>A<EFBFBD>/<2F><>'<18>V<EFBFBD><56><EFBFBD>#<23>_l<5F><6C>wŨ<77>{<15>-<04><><EFBFBD>P3<06><><EFBFBD><14>a<EFBFBD><12><><EFBFBD><EFBFBD><EFBFBD>09<30>p<EFBFBD>,Ɯ,<2C><08>sՏ<73>;<3B>+<2B>W!<21>E<><45> _Eh<45><68><16>ԭ<EFBFBD>D6<44>v<EFBFBD>$<24>tx<74>d<EFBFBD><64><EFBFBD><EFBFBD><EFBFBD>&<26>w<EFBFBD>c<EFBFBD>my82<38>+p<><70>FO)<29>W%_6<5F>A<EFBFBD>gY<67><<3C>U<EFBFBD>*<n<><6E><EFBFBD><EFBFBD><07>3<EFBFBD>M<EFBFBD>ni5ӽ<19>q<EFBFBD>qb<71><62><EFBFBD>p}<07>
+K<17>W<EFBFBD>g<EFBFBD><67><EFBFBD>[<5B>PuW<75><57>X<EFBFBD>li<6C>
+&<26><><EFBFBD>~&
+.X<>9wu<><75><1F><><EFBFBD>K!^<5E><><EFBFBD>a<EFBFBD><61>#I<><<3C><><02>s<EFBFBD>'<1E><12><><EFBFBD><EFBFBD>V<EFBFBD><56><EFBFBD><EFBFBD>"<22>՚<EFBFBD><0E><>whגo<D792><6F>P<EFBFBD><50><EFBFBD><EFBFBD>?K1<4B>!<21>d<EFBFBD><64><05><1D><>D<EFBFBD><44><EFBFBD><EFBFBD><EFBFBD>!<21>0<EFBFBD><30><EFBFBD>Q.	ݷ<>n@<40><>)`<60><><EFBFBD>-<2D>
+<EFBFBD><EFBFBD><EFBFBD>M<pR<70><08>i<EFBFBD><69>OE<1C><><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>f<>(<<3C>IǨ<49>C<EFBFBD><43> <ۺ<><DBBA>~S=7<>W<EFBFBD><57>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Xbѕ<EFBFBD><EFBFBD>y<EFBFBD><EFBFBD><EFBFBD><EFBFBD>FT<EFBFBD>~<7E>jl<6A><6C><EFBFBD><EFBFBD>Ec<><63>!<21><><EFBFBD>B<EFBFBD><1B><><EFBFBD>	<09>+ƫ<><C6AB>h<EFBFBD>o*<2A>cZ]6<>ܬ<EFBFBD><DCAC>)<29>!oB9<42>jv<6A>A<EFBFBD><41><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD>k<EFBFBD>.<2E>d)<29><><EFBFBD>p<15><><EFBFBD><EFBFBD>kՎ<6B>q<EFBFBD><71><0B><>2<EFBFBD>o<>u<EFBFBD>h<EFBFBD><68><EFBFBD>tT<74>!N<><4E>]<5D>Ӌ<EFBFBD><D38B><EFBFBD><EFBFBD>?<3F><><EFBFBD><EFBFBD>P\<5C><><EFBFBD>Uv1<76><31>7<EFBFBD>;<3B>/laW<61><57><17>3OLr<4C>f<EFBFBD>*N<>E_<45><5F>{<7B><>ǯ<EFBFBD><C7AF>BY!ͳ<><1C>dKߊ<>@<>c<EFBFBD>G<1E><12><>X<EFBFBD>'<27>n<EFBFBD>{<7B><>z<EFBFBD><7A><EFBFBD><EFBFBD>0<EFBFBD>˚<EFBFBD><CB9A>

$<24>kS-}[<0B>D3Z<33>0%,?<3F><>p<EFBFBD>w1<77><31><EFBFBD><EFBFBD> <20><><EFBFBD> 'Eg<45>ە`<60>z<EFBFBD>Vo$џ<><D19F><1C>Ѻ<EFBFBD>mK<6D>D<EFBFBD>w<EFBFBD><77>I엤<49><EC97A4><EFBFBD><EFBFBD><EFBFBD>G<EFBFBD><0E><>`v<>´<EFBFBD>Q[<5B>|"<22><><EFBFBD>2 <20>g<EFBFBD><67>`WG<57>l<EFBFBD><6C>e<EFBFBD>gmٻ-⬛x<7F>9<EFBFBD><39><EFBFBD>c<EFBFBD><63><EFBFBD><EFBFBD><EFBFBD>yZ<79><5A><EFBFBD>w<EFBFBD>'<27>k<EFBFBD><6B>Ϸ<>ɠX<>AN<41>4<11><>mʹz<02><><EFBFBD>y4<79>n<EFBFBD>/ZX<5A><58>Y<59><7F>'<27><>g<EFBFBD>@H<><1A> <20>p
+~k!"<1E><0F><><EFBFBD><EFBFBD>#<23><><17>I<EFBFBD>+}<7D><><EFBFBD>"S<>.A<><16>w-<2D><>3\<5C><><EFBFBD>~l̮<6C>a였5(~u<12>1<00>u%<25>	;<3B><><EFBFBD>1(<28><>7<EFBFBD>n[fD<66>A<EFBFBD><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ۊ<EFBFBD>d<1D><>'
<01><><EFBFBD>K	<09>Ym<1A><><EFBFBD>hh$<24>5<>1<EFBFBD>p';<3B>X<EFBFBD><1B>{<7B><><EFBFBD><EFBFBD>({<7B>O<0E><><EFBFBD><EFBFBD>I<EFBFBD>6<EFBFBD>C<EFBFBD>9'<27>Q<EFBFBD>Jt<05><03>{<7B>Kl&B<15><>de<64><65><EFBFBD><17><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>V<1F><18>e%<25>H=<3D>V<EFBFBD><56>˟<<).L<>}<7D>2A
+\<5C>O<EFBFBD><4F><EFBFBD><<3C>mթ&P<><50>j<EFBFBD>BXd`<60><><EFBFBD><EFBFBD>rq~V<><56><EFBFBD>&<14><>Qݕ<0E><><0F>ݮ<EFBFBD>_<EFBFBD><5F>Id7L<37><4C>`<60>&K4<4B>	<09><>*m<><6D>Ξu<CE9E><13><>!O<><4F>!kZI<>V<19>z<EFBFBD><7A>`i2<69><32>É[g<>'<27><>a\<<3C><>e<EFBFBD>X<EFBFBD><58>R<EFBFBD><<3C><><EFBFBD><EFBFBD><EFBFBD>?y <20><><EFBFBD>ǁ<EFBFBD>J8<4A>f<EFBFBD>s<EFBFBD><73>qxY<0F>f9{<7B><>W<EFBFBD><57>*<2A>o9<6F><39>.
+<EFBFBD><EFBFBD> <20><03>9<EFBFBD>v_<76><5F>f<>}<7D>q<>@齞v6ee<65>%<25>f<EFBFBD>guiPPV<50>y$[
w	e<><65><EFBFBD>>:p|+<2B><<3C><1B><><EFBFBD><EFBFBD><EFBFBD>t}8<>,!e<><65><EFBFBD><0F>4@<08><><12>R\s!{<7B>><3E>%!<21>e
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><1D><>0<EFBFBD>Zw<1B>?<3F>O~c<>=L"R<>'mSQhk<68><6B>Y<><59>9
+<EFBFBD><EFBFBD><EFBFBD>t<EFBFBD><0B><>><3E><>}<7D><>T-<2D>w<0F>S0k<30>ͻ<EFBFBD>G<0C><><18><><EFBFBD><EFBFBD>K<EFBFBD><4B>V6U<36>g<EFBFBD><67><EFBFBD>l<><6C><EFBFBD><EFBFBD>"<22><>c<EFBFBD>OG<1B>Q<><51>e<EFBFBD><65>td=<3D><>yy<79><<3C>*<2A>J-V<>ީ<EFBFBD>oq<6F>	z[<5B><><08><><1E>X@4<12>Va`<60>) <20><>?<3F><>-aoN`,<2C><><EFBFBD>i<EFBFBD><69><EFBFBD><EFBFBD><EFBFBD>*<2A>́<EFBFBD><CD81><EFBFBD><EFBFBD><EFBFBD>v6j<><6A>i<EFBFBD>d<12><02><>S<EFBFBD>4D<1C><><EFBFBD><EFBFBD> :Q<14><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>><3E><>Z<EFBFBD><5A>l<EFBFBD><6C><EFBFBD>Q]g<11><><EFBFBD>Y<03><>"<22><><EFBFBD>b}$<><15> <20>P<EFBFBD>#<23><14><><EFBFBD><EFBFBD>q<EFBFBD>c<EFBFBD><63><1E>iGY^;<3B>;<3B><>aEv0<16><0F>qಙ<71>ޕ<EFBFBD><DE95><EFBFBD><EFBFBD>-<2D><><EFBFBD><EFBFBD><EFBFBD>^<5E>J<00>d49[<5B><>aAr<41>]<5D><><EFBFBD><EFBFBD><EFBFBD>vFMTQҨ8<D2A8><38>vǾ<76>=2I<32><49>>V<>l<EFBFBD><6C>;<3B><>Vy<0C>g<EFBFBD>;<3B><><EFBFBD><EFBFBD><EFBFBD>]<5D><><EFBFBD><EFBFBD>(<28>f<EFBFBD><66><EFBFBD>7#6v<36><76>7<EFBFBD><37>[M	<09>?o<>} 2<>
+<EFBFBD><EFBFBD><EFBFBD>Cf<EFBFBD>
+`<60>
+<EFBFBD>sthC<68><43><EFBFBD>BV.<2E>]<5D>XA<58>+Y<><14>DZ<EFBFBD>mG<6D>'̇
+<EFBFBD><06><><EFBFBD>Li7<69><37><EFBFBD>ӂF<D382><46><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF>[<5B><><EFBFBD><EFBFBD>Ф<EFBFBD><D0A4><EFBFBD>E<EFBFBD><45><EFBFBD>.e<><65>Qu<51>?<3F>姛<EFBFBD><E5A79B>w<EFBFBD><77>p9<17>b˿<62><CBBF><EFBFBD>I<EFBFBD>)<29>p6<00><><EFBFBD><EFBFBD><EFBFBD>:<3A><>A(?<3F>c<EFBFBD>𳫮Ǚ
+<EFBFBD>tZzy]:<16><><EFBFBD>j<EFBFBD>Z<EFBFBD>M<EFBFBD><4D>i<EFBFBD>X<19><>e<EFBFBD>
<01><><EFBFBD><1D><><EFBFBD><EFBFBD>=ar<61>?`KhŇa<C587>	&ˤk<CBA4><6B>%<25><>u<12><>&e/<2F>O<EFBFBD>
<00><>.<2E>
+endstream
+endobj
+4 0 obj<</Contents 6 0 R/Type/Page/Parent 102 0 R/Rotate 0/MediaBox[0 0 612.28302 790.866028]/CropBox[0 0 612.28302 790.866028]/Resources 5 0 R>>
+endobj
+5 0 obj<</Font<</F3 121 0 R/F6 118 0 R/F7 125 0 R/F10 71 0 R/F11 61 0 R/F12 65 0 R/F13 72 0 R>>/ProcSet[/PDF/Text]/ExtGState<</GS1 113 0 R>>>>
+endobj
+6 0 obj<</Length 7551/Filter/FlateDecode>>stream
+h<EFBFBD><EFBFBD>[ے<><DB92>q}<7D>W<EFBFBD><57>#0<><30>.u
<1C><>%)YT<59><12>][K>`z03<10>M=<3D>a8<61><19>^<5E>9Y<39>KO/I<>eK<65>.<2E>
<14><>2O<32><4F>ԯ<EFBFBD><D4AF>]<5D><>a<EFBFBD><61><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>M<EFBFBD><4D><EFBFBD><EFBFBD>'<27><>r<EFBFBD>x<EFBFBD><78><EFBFBD>Җ<EFBFBD><D296><16><>ϋ<EFBFBD>I3<49><33><EFBFBD><EFBFBD><EFBFBD><EFBFBD><0F>r<>~<7E><>=<>!<21><>p<EFBFBD><70>2<EFBFBD><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0~S$<24>U<EFBFBD><0C>C^<5E>?<3F><>O<EFBFBD>u<75>Y<EFBFBD>廦<EFBFBD>o<EFBFBD><6F><EFBFBD><EFBFBD><EFBFBD>*ߔI<DF94><49>^e<><65>&<26>0<EFBFBD>W<EFBFBD><57>"<22><>5<EFBFBD><35>I<EFBFBD><49><EFBFBD>n<EFBFBD>ɓn_<6E><5F>K<EFBFBD><4B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>뷻.<2E><>ox<><78>8<EFBFBD><38>*<2A><><EFBFBD><EFBFBD>5~<7E>x<EFBFBD><78>*<2A><><EFBFBD><1C>'<27>v<EFBFBD>1ˤ<1D><><EFBFBD><EFBFBD>﮾}<7D>;Y<>M<EFBFBD>ɼ<13>|.<2E>;<3B>
+^˓<>Vfh<66><68><EFBFBD>}<7D>r<><72><1F>g,-O<>2<EFBFBD><32>ae<61><65>r5Ȝ<35><C89C><07><>VF.<2E><><1A><>9<EFBFBD>z<EFBFBD>h<06><><EFBFBD><EFBFBD><EFBFBD>L<EFBFBD>"Z<7F><5A>I<EFBFBD><49><EFBFBD>L<EFBFBD><1F><><><7F><EFBFBD>˱<EFBFBD>܋y]C<>#<23><><EFBFBD><1F>Ś<EFBFBD><C59A>蚚Z̷H,=
<1F><>
+<EFBFBD><EFBFBD>=<3D><>-<2D>.<2E>!<21>n<EFBFBD><6E>mr<6D>j|T&<26><><EFBFBD>U<EFBFBD>b<EFBFBD>!|<7C><07><>SU26<32>S2ɮ<32>Mx<4D><78><EFBFBD><EFBFBD><EFBFBD><EFBFBD><19>u<EFBFBD><75><EFBFBD>Ve<56><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˢš<CBA2><C29A>3V<33><56>@<40>nw<6E><77><EFBFBD>A<1E>n<EFBFBD>L<EFBFBD>R
+<0F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>܃<><DC83>Ɉ.<2E><>G<EFBFBD><47><EFBFBD>Q<EFBFBD><51>v <20>h<10><><EFBFBD>y
+<EFBFBD><EFBFBD>l{<1D>J<EFBFBD>f<EFBFBD>U<EFBFBD><55>[̢H<CCA2><48><EFBFBD>I<>J<1E><>ϭl<15>3<EFBFBD><33>Q<EFBFBD>j<EFBFBD>^Q7<><37><EFBFBD><05><><EFBFBD><EFBFBD>*<2A>Ϗ<EFBFBD><CF8F>f<EFBFBD><66>Ã(~^z<19><0B>Ζ<EFBFBD><CE96>WN<57>>4?<3F>x<EFBFBD>{<7B>Lz<4C>an2<6E>p<EFBFBD><70>X<EFBFBD>3^)<29><>B<><42><EFBFBD>b<EFBFBD><62>ja<6A>VUϹI<CFB9><49>,<2C><>6<><36><EFBFBD>~S(<28>T"<22>#\<5C>ˈ'N.r<><72><EFBFBD><EFBFBD><0F>g<EFBFBD>X7NF<4E>b<EFBFBD><62><EFBFBD>X`<60>R<EFBFBD>ĴѼ<>ط<EFBFBD>'<27><>L<EFBFBD><4C><EFBFBD><EFBFBD>-ŎT^<16><11><11><>u><3E><><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD>ly<>OF<4F>a<EFBFBD>K*<2A><><EFBFBD>!K<>pE<><45><EFBFBD>q<EFBFBD><71><EFBFBD><EFBFBD>U<><55>c<EFBFBD><63>a<EFBFBD>A<05>[ƹ<>><3E><><EFBFBD>o<EFBFBD>,{<7B>d~E<>z<15>O<>
;$<24>ڎ<EFBFBD>!5z<35>Д<><D094><EFBFBD><EFBFBD><EFBFBD>;H[6y<36><08>yg<>n:(<28>B<13><><EFBFBD>fr<66>˄<EFBFBD>	<09>S3]%<16><>S<EFBFBD><53>C<EFBFBD><43>8<1A>;7͜s<CD9C>U<EFBFBD>l<EFBFBD><6C>Z<EFBFBD><5A>eT<0B>~<7E><><0E>VX\|<7C><><EFBFBD><EFBFBD>Q<EFBFBD><51><16><><EFBFBD>|9Yu$<24><18><>/<2F><><EFBFBD><EFBFBD><EFBFBD>IQ&]->7k<37><6B>B<EFBFBD><D?ԉ6OnG<6E><47><16>q<><71><EFBFBD><EFBFBD>%/@<40><><0C>.O!<21>c=<3D><>h'<27><><EFBFBD><EFBFBD>,<2C>1<EFBFBD><07><><EFBFBD><18><>)<29>r<EFBFBD>(<<3C><>I<EFBFBD><49>1m<31>&N	~<7E> <20><>S<EFBFBD>O=<3D><>J<EFBFBD>%<25><><EFBFBD><EFBFBD><EFBFBD>A<7F><41> <1D>isZ<><5A>ng1<67><31>X<EFBFBD><58><EFBFBD><EFBFBD><EFBFBD>%<25><>=5<>j<EFBFBD><6A><EFBFBD><EFBFBD><EFBFBD>vT<14>=<3D><><EFBFBD>%jMm
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>g<00><>
<01>dɡ<64><C9A1>lo!<21>ևQ<D687>X<EFBFBD><58><1D><><EFBFBD><00><>hGQ<47>Wl<><6C><EFBFBD><0E><><EFBFBD>J<EFBFBD>4[<5B>U7N*<2A><05><>Ꞙi<EA9E98>W<>Z<EFBFBD><15>6k$<05>Q<07>
+<EFBFBD>:ț<>Z<EFBFBD>h<EFBFBD><68>)<29><>USF<53><46><EFBFBD>'<27>V<EFBFBD>4<12><><EFBFBD>0qm<><6D><05>-f<><66>=<3D>J<EFBFBD><4A><EFBFBD>>.k<>3Mn~<7E><>7<EFBFBD><37><EFBFBD>q<EFBFBD>c<EFBFBD><63><EFBFBD>Gh<47>	<09>.<2E><>]<17>~<7E><>juk<75><17><><04><><EFBFBD><EFBFBD>W<EFBFBD><57><EFBFBD>3<EFBFBD>'<27><12>6-	S
+0F(=8G;<3B>qKk<4B>ola<10><><EFBFBD><EFBFBD>7<19>ۗ<EFBFBD><DB97>x<EFBFBD><03>~<7E>|<7C>(	<09>e<EFBFBD><0B><><EFBFBD>vн<76>v'U<><55><EFBFBD>	<09><>N
+J<EFBFBD><EFBFBD><EFBFBD>;%<19><03><>f<EFBFBD>C=<3D><>Y<EFBFBD>.<2E>_<EFBFBD><1D><><11>m<EFBFBD><6D>?1<><31><EFBFBD><EFBFBD>Y
+
+?f<><66><EFBFBD><EFBFBD>Q<EFBFBD><51><EFBFBD>
+J<EFBFBD>Lr<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><19><>O<EFBFBD>A<EFBFBD><41>͕`h
<01><><EFBFBD><EFBFBD>z<EFBFBD><7A>XE<58>o<EFBFBD><6F>Ȳp<C8B2><70>"<22><>N<EFBFBD><4E><08><>F<EFBFBD><46><1D>K ˁ3oj<6F><C<10>)<29><1E>Ə:v<><1C><><EFBFBD><EFBFBD>z<EFBFBD><1C> V<><0C><>4s<34>H<EFBFBD><48><EFBFBD>F<EFBFBD><46>Ў<EFBFBD>i<EFBFBD>h<EFBFBD><68><04><>NP0<50>QA<0C><>'<27><><0F>ʋQ%_^<5E><><EFBFBD><EFBFBD>#<23>r<>LA<4C><41>w<EFBFBD><77><EFBFBD>U<>m<EFBFBD><6D>Z<EFBFBD>D'NF<4E>d<EFBFBD><64><EFBFBD><EFBFBD>5<>g<EFBFBD>NyX<79>?<3F>)<1F>C<04><>J;<3B><><EFBFBD>qǗM<C797><4D><EFBFBD>A5w<35>w<0F><>5<>29<32>
<00>ċj<C48B><6A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>X+Ŷk<C5B6>5<EFBFBD><35><07><><EFBFBD><EFBFBD><EFBFBD>0*|<7C>Q<EFBFBD>@><<3C>y8<79>o<EFBFBD><6F>AA<>D<EFBFBD>d6<02><>v<EFBFBD>y船L{<7B>`<60>a<><61><EFBFBD>$=`<60>.<2E>;JEA<45><41>N<05><><EFBFBD>T<EFBFBD><04><>^U<>H<EFBFBD>m<><6D><0B><><EFBFBD><EFBFBD>K<EFBFBD>{_ou<6F><75>
+S*<2A><><EFBFBD><EFBFBD>͡C+<08>9<EFBFBD><39>u<EFBFBD><75>7<EFBFBD>Z<EFBFBD>
+s1@<40>4)Lj<4C>{<7B><>?5*<2A><13><0F><03><<3C> g<><67><EFBFBD>z Bě<>葾<EFBFBD><19><1E><><EFBFBD>1e<31>	<09><><EFBFBD>jE<<3C>Z<EFBFBD><5A>\&<26><>¦<1A>l )49<34>k<EFBFBD>v5Om <04>r;<18><>v<EFBFBD>u<EFBFBD><75>]<5D><18>BX6y$<24><0B>k<EFBFBD><6B>F<EFBFBD>t<EFBFBD><74><EFBFBD><02>=<3D><>p<EFBFBD>a<EFBFBD><61><EFBFBD><0B><><EFBFBD><EFBFBD>qi<71><69>i<EFBFBD><69><EFBFBD>İT9p}eW<19>hT<68><54><EFBFBD><0F>S0^<5E><><EFBFBD><EFBFBD>8{<7B><>XG<58>D|<7C><04>s<EFBFBD><73>AO<02>0<11>}<7D>d~<7E>eQ<1F><> /8<>ix<69><78><EFBFBD>]<5D><>e<EFBFBD>K<EFBFBD><4B>?<3F>dZn~8FF<11><><00><><EFBFBD><1C><>s#<23><><EFBFBD>cطnߩ<6E>F,
<01>p#QȓZh<0F>e= <20>X<EFBFBD><58><EFBFBD>i<EFBFBD><69><EFBFBD><0B><><EFBFBD>+1<>v<>٧_j<>Y<59><C281>v<۠<><DBA0><EFBFBD><EFBFBD>)<29>UKЈ+<2B><><<0B><><EFBFBD><EFBFBD><EFBFBD> <20>Z3,?<3F><><EFBFBD>v<EFBFBD>At<04>X~<7E><I,<2C>M̱<4D><CCB1>D<EFBFBD><44><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>]<5D><>F<EFBFBD>02n?<3F><>z_<0C><>~j><07><>Ew<45>~<7E><><EFBFBD>HT<48>)<19>&z<><7A><EFBFBD><1E>lE<1E>^<5E><1E>P<EFBFBD><50><EFBFBD>9<EFBFBD><03><>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>NVE<56>n<EFBFBD><18><>QGP<><50><EFBFBD><EFBFBD>7<EFBFBD>Ë /.<2E><><EFBFBD><EFBFBD><EFBFBD>Ҙ<02>I<EFBFBD>$A<><41>ɇl<C987>g<EFBFBD>M<>"<22><>$<24>!<21>)<29><17><>,<2C><><EFBFBD><EFBFBD><EFBFBD><05>T%<25><1E><><EFBFBD><EFBFBD>><3E><><EFBFBD><0B><><EFBFBD>=<3D><1C>	lW.<2E>_<EFBFBD><5F><EFBFBD><0E>B<16>X<EFBFBD>
y߃A9<41><39>DqGl9<6C><39>n<EFBFBD>[°<>g<06>%<25>6y
<01><><EFBFBD>Qj<51>ڝ"<22><><EFBFBD>@<40>@<40><><EFBFBD>H	~N<><4E><02>)56OI<4F><49>?1<>'<27><1D><>lt<6C><74>"<22>k}BwChh<68>}<7D><>Qx<51><78>.z@<40><>{<7B>\e,<>+<2B><>be<62><65><EFBFBD>	<09>£P<12><10><>˜<EFBFBD> <20>A˜a^2<>v<EFBFBD><0F><>(<28><10>[|a<><61><EFBFBD>
+<EFBFBD>[Q<><51>vG<76><47>!<21>&<26><>J<EFBFBD><4A><EFBFBD>r<EFBFBD><72>GsHy!<21>ɭRm<P-_<><5F><EFBFBD><EFBFBD>k1<><31>M&sT<73>}<7D>b<EFBFBD><62>l<EFBFBD>q<EFBFBD>ݨX^<5E>[U}<7D>—@<40><><EFBFBD>%<25><>t<><1F><>eC<16><>w<EFBFBD>c͔\<5C>B<EFBFBD>'ƭ<>	j<>.:P|<7C><><19><>ך2Q<16><><EFBFBD>l<EFBFBD><6C><EFBFBD>޾(<0F>*+B+Þ8<C39E><38>N8<0C><EFBFBD><7F>%	Q<14><><EFBFBD>q<EFBFBD>-Y
+pbڭ<EFBFBD><EFBFBD>><3E>/<2F><><+<2B>P<EFBFBD><50>?<3F>L<EFBFBD>u<EFBFBD>$<24><>'<ܾ<><07>Tf.`<60><1A>r<EFBFBD>BH<>&F<>h<EFBFBD>R<EFBFBD><52>3ڀ<33>Np<4E>z<EFBFBD><7A><EFBFBD>s<13> \<5C>:<3A><>d<EFBFBD>`<60>j<1C>{<7B>18<31><38>c1;<3B><><EFBFBD>YL<59>
1Üڧ&f<><66><EFBFBD>3y<02><>bF<1F>mx <20>'<27>#<23><>3<EFBFBD><33>ѽ<EFBFBD>
+<EFBFBD>Y<><59>'*<2A>#yS<79>q9<71><39><EFBFBD>t
+G<>(zh<7A><68><EFBFBD>ݵtܑ<74><DC91>qL<71>#F<><46><EFBFBD><EFBFBD><EFBFBD><EFBFBD>d<11><>,<2C><>p<EFBFBD>&<26>5<EFBFBD><35>B<EFBFBD>QX<51><58>rb<>^c<>,כ<1B>
+<EFBFBD>p<EFBFBD><EFBFBD>­4<EFBFBD><EFBFBD><EFBFBD><EFBFBD>N<1A>dᎩ*n<><6E><EFBFBD>K<EFBFBD><4B><EFBFBD>[6]<5D>1HI|<7C><><EFBFBD><EFBFBD><EFBFBD>.\<5C>d<EFBFBD><64><EFBFBD>E<EFBFBD>!<21><>;%<25><><0B><><EFBFBD><EFBFBD>A<14><>t<EFBFBD>ڔ<EFBFBD><DA94><EFBFBD><EFBFBD><EFBFBD>o<><6F>y<EFBFBD><79>Suiֳ"N<><4E><00>2Ro<0E><1D><EFBFBD><EE89BE>><R<11><>D<EFBFBD><44>O<EFBFBD>V<EFBFBD>P<EFBFBD><0B>)<29><><EFBFBD><EFBFBD><06><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܵO<DCB5>xe5<65><35><02>sCR<>e<EFBFBD>k0o<00><><EFBFBD><EFBFBD><EFBFBD>alQ<6C><51>
+V5<19><>&<26><><EFBFBD><EFBFBD>y<>9rx<72><78>ڇ<15>f??<3F><><EFBFBD>\m<><6D><EFBFBD>⅀\<5C><>wwm<77><6D>*
+<EFBFBD>Kֵd<06>}jt<6A>OPq<50><71><EFBFBD>i<EFBFBD><69><18><08><><EFBFBD>2<EFBFBD>
<01><><EFBFBD>j<EFBFBD><6A>*(<28><04>ЈY<D088><59>t<EFBFBD><1D>f<EFBFBD><66>/O<><4F>V<>ӎ1?<3F>4q<34>.U<>\<5C><><EFBFBD>^<5E>hҽB<D2BD>#S@<40><1F><1C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӛ<EFBFBD>$<24><>!s<>$`<60>u<EFBFBD>ʿr<CABF><1B><><EFBFBD><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD>S<><53>)<29>U<EFBFBD>ї<EFBFBD>&<26>V<><56><EFBFBD>Lpm_<6D><5F><EFBFBD>@u/<2F>CTp~k<_<>Ə<EFBFBD>*<2A>o<EFBFBD>3<EFBFBD>+<2B><><EFBFBD>	<09><06>y<EFBFBD>	@ <20><><EFBFBD><EFBFBD>".<2E>><3E><>#<23>-Ϭ<><CFAC>?<3F><>'<27><>͕<06>7^<5E>d<EFBFBD><64>}8=<<3C>J<EFBFBD><4A><EFBFBD>W<EFBFBD><57><EFBFBD><EFBFBD>Խ<><D4BD><EFBFBD> A	<09>p)a|<7C>a<EFBFBD>5<EFBFBD>!<0C><>2<EFBFBD>>h<>he<68><65>*<2A>k$W{3<><33>EMY2<59><{J<><4A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>f<7F>ﻱ<EFBFBD>ݽ@P<>	9ay<19><>Hf*<18>EКMC
+<EFBFBD>zH<>u&j~D<>m<1C><>l<EFBFBD>M<EFBFBD><12><><EFBFBD><EFBFBD>*<2A>C7<43>k\ȃ<>~x<>u<EFBFBD>A<EFBFBD>n<EFBFBD>:*~R<><52>><3E>L<EFBFBD>E<13><><EFBFBD>,<2C><>J<><4A>e<EFBFBD>hGl1<6C><31>$*<2A><><EFBFBD>i<EFBFBD>o<>cW,<2C>=<3D><><EFBFBD>*E<><45>vasB<73>c>GY|<7C>72<37>A<03><05><><EFBFBD><EFBFBD>N<EFBFBD><4E>*
+<EFBFBD><EFBFBD>]<5D>7"<22>F<EFBFBD><46><EFBFBD>z
a<><61>r
+<EFBFBD>`<60><><EFBFBD><EFBFBD><EFBFBD><13>Zh<5A>B\<5C>&<1D>_@<40>W<EFBFBD>,<2C>䫵G<><47>yZF<5A><46>׫<EFBFBD>́<EFBFBD>
+<EFBFBD>e  %<25>ԙ<19><12><1A>ȕ<EFBFBD>:<3A>_q<5F>&<26><><EFBFBD>Ҡ<04><><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1D><><EFBFBD><03>
+<EFBFBD><EFBFBD>S<EFBFBD>Hڵ6><3E><>,<2C>%<25>]NR<4E><52><EFBFBD>YYKb<4B><62><EFBFBD>f<EFBFBD>w[:^<5E><><EFBFBD><EFBFBD><EFBFBD>I<EFBFBD><49>[<5B><><EFBFBD>L[`~<7E>)<29>CY2<59>=+<2B>$T<><54><EFBFBD><EFBFBD><EFBFBD>K^><3E>1<EFBFBD><05><>fV<66>h<EFBFBD><68>3<EFBFBD>>
+`<60><><EFBFBD>e<04><><EFBFBD>'<27><><EFBFBD>ke<6B>Z<EFBFBD>D<16>.)<29>S-<2D>+<2B>P<>*<2A>ڱ,<2C><><EFBFBD>bsf<73>&<26><><EFBFBD>[<16><><EFBFBD><EFBFBD><EFBFBD>0Q<30>b<EFBFBD>GDž<47>3f<>"<12><><EFBFBD>Tz<54>?.-g<><67>E<EFBFBD>,ÿ<>q<>6<04>:<0F><04>Ҽ<1B>D<EFBFBD><44>`=<<3C>6l<36>X<EFBFBD>ܶ-c<><63>+\6C,`<0B>6<EFBFBD>},<2C><>R/C<><43><EFBFBD><EFBFBD><EFBFBD><EFBFBD><11><><16>6<EFBFBD><36>E<EFBFBD><45><04><><EFBFBD>CV<43>>m<>N1`-dnCLOê<4F>?<3F>-<2D>?]C<><43>Y.<2E>"n"5,<2C>	<16>)<29>8<EFBFBD>)<29>e7[%
7<>
+<EFBFBD><EFBFBD>%<25>s5lQ<6C><51>rYx<59><78><EFBFBD>Z,<2C>"<22>p<EFBFBD>	<09> ?<3F><>9~<7E>9<EFBFBD><39>!`<60><><EFBFBD><EFBFBD>R9r@<40>:<3A><><EFBFBD><EFBFBD><EFBFBD>M<EFBFBD><1D><><EFBFBD><EFBFBD>4~@K`^!<21>A<EFBFBD>l)<29><><EFBFBD>Omw<05><13>L<>8<13>h<EFBFBD><68>@/<2F>ok<6F>ē<EFBFBD><C493><EFBFBD><EFBFBD>*<2A><>B<EFBFBD>6<EFBFBD><36><EFBFBD>W<0C><><EFBFBD>8ag*<2A><1E><><EFBFBD>Y̸9<CCB8><39><EFBFBD>A,g<><67>aa<61>N<EFBFBD>ч<EFBFBD>K<EFBFBD><4B>y
+c<EFBFBD>1<><31>ٛG<>6<EFBFBD><36><EFBFBD><12>f)J<><4A><EFBFBD><EFBFBD>'<27>^<03><>N<EFBFBD><1D>a<04><><EFBFBD>@<40><>=-<2D>
+[w<><77><EFBFBD><08>I
+`3<>&"<22>BSݨ<53>S<EFBFBD><53><EFBFBD>iH<69>ܗ<EFBFBD>h#Sc<53>ɦږŶ<DA96><C5B6>><0C><>m<EFBFBD>ah<61><10>q%<25><><17>qUHn<48>o<><6F><EFBFBD>K5%<25><><EFBFBD><08>&<26>b'l1<6C>}`<60>)<29>4<EFBFBD><34><EFBFBD>ʘ<EFBFBD><CA98> H<>ݮ{<7B><><EFBFBD>-?Z<>><3E><>(ﳼi,<2C><><EFBFBD><0B>Ʊ<EFBFBD>%fH1<>̾<EFBFBD>)d4lc<6C><63>Kg<4B><67><EFBFBD>Y<EFBFBD>xa<78><61>Ot<4F>u<EFBFBD><75>K{<7B>W<EFBFBD><57><EFBFBD>Ƅm<C684><6D><EFBFBD><EFBFBD>}<7D>uB<75>OI<4F><49>/j<><6A><EFBFBD>g/<2F>$<24>Y<EFBFBD><59>2<EFBFBD><32>Η<EFBFBD>Sh<53><68>P1e<31><65><12><><EFBFBD><EFBFBD>v'<27><><EFBFBD><EFBFBD>FM<7F>،<><D88C>ڜ<0B><><EFBFBD>z`r~<7E>plT<7F><54>=<3D><><EFBFBD><EFBFBD><EFBFBD>1<00><>G<EFBFBD>43<34>"<22><><EFBFBD>et<65><74><EFBFBD>P<EFBFBD>A<EFBFBD>׍V`<60>wK<77><4B><EFBFBD>e<EFBFBD>V<>}
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>W!X<><58>)C<>K<EFBFBD>f<EFBFBD><66>0`<60><>#<23>R<EFBFBD><52><EFBFBD><1A><>&4RB<52>.l<00><><EFBFBD><EFBFBD>71<13>
+ <20>j<EFBFBD><6A>*xބ<78><DE84><EFBFBD><EFBFBD>x<EFBFBD><78><EFBFBD>W{6ݮ|<7C>'\D<>⍦{<7B>U<EFBFBD><55>1$<24><><EFBFBD><EFBFBD><1F>]<5D><12>|<7C>p<EFBFBD><70><EFBFBD>h<EFBFBD><68>GL<47>3<EFBFBD>-k<>n<16><>uP<75><50><EFBFBD>o<EFBFBD><6F><EFBFBD>T)ց<>k91<><31><EFBFBD>p<EFBFBD><70>)<29><><0C>t<EFBFBD><74>,Vr[*6.<2E>ck*<2A>?<3F><>Q<EFBFBD><51>`<60><w<>5<>E`<60>Cz{<16><>!Ȝ$a]E6<45>Z<EFBFBD>ULt<>ܲ<EFBFBD><DCB2>	3><12>Y\X<><58>^y<><79>Џh\<15><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<><D8B4>&<26>#<23>p<EFBFBD><70><EFBFBD>XV<58><56>z<EFBFBD><7A>=*
<01><><EFBFBD>š~/؜<>C"](<28><>ɿ<EFBFBD><C9BF>F<00>Z,<2C><><EFBFBD>_+9<>Z<EFBFBD>g<EFBFBD><19>V<EFBFBD><56><EFBFBD>4}g\5(<28><><EFBFBD>oP;<3B><><05>6I<36><49><EFBFBD>)<29>zD<0E>HYr<59>_<EFBFBD><5F>)
+<EFBFBD>;<3B><><18>Q<EFBFBD><15><>Z63<36><33><03><>E	<09>ֆ<EFBFBD>)krA<72><11>Cl<1F><1B><>"<22><><EFBFBD>S"
+<EFBFBD>l<EFBFBD>,<2C><><EFBFBD>fۄ2<DB84><32>oi5q<35>kUt<><74>S<16>ل[2F<32><46><EFBFBD><EFBFBD>޶c<DEB6><1A>uϚ|<7C>3<>֟
+
+#S7<53>c<EFBFBD><63>HG<48>[<5B><><1D><>i<EFBFBD><69>.<2E><>M<>2<EFBFBD><32><EFBFBD>>u<>8Lt<4C><74>}T<>cӏS<D38F>:kyh<0E><><GB<><42>
+<EFBFBD><EFBFBD>"]<5D>Sv<53>-<2D>
+C<EFBFBD><EFBFBD>#6<>c'<27>Sô_<C3B4><11><16><12>\<5C><>s;<3B>F<0E><><EFBFBD>`vFB><3E><>y<><79>Q<EFBFBD><51>N<EFBFBD><4E><EFBFBD><EFBFBD>a¯֒<C2AF><D692><EFBFBD>lb<6C>`<60><><EFBFBD><07>z<EFBFBD>d<7F> \<5C><><16>/vZ<76>1<EFBFBD><31><06>C|<7C>s<EFBFBD>l<EFBFBD><6C>+<2B>'!<15>u"<22>,<18><><EFBFBD><EFBFBD>XeN<>2`8<>P-<2D>Y<EFBFBD>w<1F>R<EFBFBD>U/h<>ᴿՂ<E1B4BF><D582><EFBFBD><08>,<><EF9BBE>T<EFBFBD>ڶ<EFBFBD><DAB6>Ԏ<EFBFBD>A<EFBFBD><08>>F<><46>S<>e(<28><>x<EFBFBD> <><7F><EFBFBD>E<EFBFBD>6<>o׭s<14><>}_!<21>N<><4E>@<40>5<EFBFBD>F<EFBFBD>@ї<>b<EFBFBD><62>w<EFBFBD>)y'xsv<73><76><19>~<16>D<EFBFBD>d<18><><13>a<EFBFBD>B<EFBFBD>W<EFBFBD>"<22>V-f<>I<EFBFBD>՛z<>Uy<55><79><18><>ҟerY<1B><<3C><>j<EFBFBD><14><>C<EFBFBD><43>–0<C296>8;<3B><>G<EFBFBD>Yk,1)<29><1E><><EFBFBD>S<EFBFBD><07>uK<>T<EFBFBD>`<60>S<EFBFBD>! i<>zA<1F><>W)<29>Y!!<21><>ߐg<06>`I<>&<26>.<2E><>lv<6C><76><EFBFBD><EFBFBD>C
+SM<EFBFBD>t<14>|,<14>1=<3D><><EFBFBD>j<EFBFBD>+<2B><>!<14>$<24><><EFBFBD><EFBFBD>-sYH<><48>P<EFBFBD>)
+=<3D><><EFBFBD>\<5C><><EFBFBD>Yfy6}<7D><>mZU<5A>l_<6C>f<EFBFBD>R<EFBFBD>,<2C><><EFBFBD>c\,Jp#<23><>Y<EFBFBD><59><EFBFBD>1<EFBFBD>˒<><02><><EFBFBD>!<21>/X2;?<3F>1<EFBFBD><31>xR<78><52>P<>fw]<5D><>V)<18>Wy3<15>Z.&<26>1<18>V<EFBFBD>Tڎ<54>T<EFBFBD><54><17>Ȃ<EFBFBD><<0F>Bn<><6E>sY<73>Q<>(<28><1B>(<28><>ѱs<D1B1>F<EFBFBD>d<15>\n&<26>zPg<50>
<01>i<EFBFBD><69><EFBFBD>I-<2D>ʲ<EFBFBD>S<EFBFBD><53><EFBFBD><EFBFBD>IF|<1C>tn><3E>`<60>L<EFBFBD><4C><EFBFBD>\2<>Ưs<>j<7F><6A>l<EFBFBD><6C><EFBFBD>u̢<75>F*<2A>8;p<08><>ٽ<EFBFBD><D9BD>	<09>^.<2E><>"<22><>('ƙ<><C699><EFBFBD><EFBFBD><17>վ<EFBFBD>A]Y<>5<EFBFBD>i<EFBFBD>T`<00><><EFBFBD>^
+<EFBFBD>٤}<7D><><EFBFBD>u<EFBFBD><75>,v\bߡ㑜<><E3919C><EFBFBD><EFBFBD>r_<72>#
+<EFBFBD>j<EFBFBD>a<07><>Y<EFBFBD><59><EFBFBD><EFBFBD>K5y<35><79>?2_<><5F><EFBFBD><EFBFBD>B<EFBFBD><42>L><3E>0<>ȝ<EFBFBD><C89D>в2<D0B2>Tڴ,<2C><><EFBFBD>S<EFBFBD>]*<05>Z<EFBFBD><5A><EFBFBD><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>W<EFBFBD><57>M2MJ<>y9<79><39>y<19><>.<2E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>$<24><><1C><><EFBFBD>3<EFBFBD><33>Ǽ<EFBFBD><C7BC><EFBFBD>4<>A<>3<EFBFBD>2<EFBFBD><32>x<EFBFBD>Kh<4B><68>x6t<36>3
|<7C><><EFBFBD><EFBFBD>#<23>!XPq-c<><JpF<70><46>&<26><><EFBFBD> ?<3F>j<EFBFBD>lDC<44>rN<72>I4<49><34>><3E>_<EFBFBD><5F>[
+R<1B>)<FjSB<>u<>|vf{<7B><><EFBFBD>Z<EFBFBD>(ω<><CF89><08>
+<EFBFBD>]<5D>ǟ<>ʯ<EFBFBD>Z<EFBFBD>p[<5B><><EFBFBD><EFBFBD>7<EFBFBD><37>շ5<D5B7>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"0]<5D><><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD>{*<2A>aޓ<61><DE93><EFBFBD><17><>(]<5D>w<EFBFBD><77>g?Y<>7<EFBFBD><37>V<19><>L<EFBFBD>{&'<27><15><><EFBFBD>G<13><><15>Bj;T}j<>y(܆<>y51<35><31>'cu1<04><`<60><>ų<EFBFBD>S[s<<3C>k3<6B>@\<5C>/<2F><><EFBFBD><EFBFBD><EFBFBD>iy<69>cJ<63><4A>y>?<3F><>GT<10><0C><><EFBFBD><EFBFBD><EFBFBD>;<3B>1Q[<00>=;mts9C<><43><<3C>x<EFBFBD>i_<>><3E><>9xqy$<24><>¢	<09><0C>4r<34>w<EFBFBD>fc<66><63>[<1E>q<EFBFBD>=Pm<50><6D>"c<>O<EFBFBD><EFBFBD>G<EFBFBD><47><EFBFBD><EFBFBD><EFBFBD><04><><08><><EFBFBD><EFBFBD>י <20><><EFBFBD>+J<><dȜZΚ<5A><CE9A><EFBFBD><EFBFBD><EFBFBD>_zݼжzx<7A><78>Y<EFBFBD><59><EFBFBD><EFBFBD>r<EFBFBD>T<><54><EFBFBD><EFBFBD><0E>}<7D>ya<79><61>k<EFBFBD>Npo<70>Ө<EFBFBD>ƝSE<53><45>5U<0C><>獴v<E78DB4><76>Z<><5A>*n<><6E>;%<25><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Mm<4D>><3E>X<EFBFBD><58><12>dZ<>Ў<EFBFBD><D08E> m<18>G<EFBFBD><47>F<EFBFBD>墕P<E5A295><50><EFBFBD>hN^O;j<><6A>,ln<6C><6E>f<>w<EFBFBD><77><EFBFBD>t<EFBFBD><74>c<>#<23>Q<EFBFBD>*<2A>F<<3C>-<1A>쵊<><04>k<EFBFBD>Aro<72><07><><EFBFBD>0{<7B>l<><6C><EFBFBD><EFBFBD>2'FB'`,<2C><>[
+Mb<0B>7,<2C><><EFBFBD>!t<>M<EFBFBD><4D><18><>*L<>iW<69>^j<><6A>at<61><74>Q8Z<38><5A><EFBFBD>DG-;Ft<><74>Z<EFBFBD><5A><EFBFBD><EFBFBD>?<3F><>ޕZ<><0F><> <20><><04><><EFBFBD><EFBFBD><EFBFBD>T>.<16>pV1̔<31>*<2A>a<EFBFBD>Ҷ2<D2B6>:0<><02><>:<3A>lh<6C>*%ԺA[<5B><><EFBFBD>r`<60><>а5I{<7B><>
+Tmd<EFBFBD><EFBFBD>9
+mQF<51><46><EFBFBD><EFBFBD>LusW<73><57><0C><><EFBFBD>b<17>4
<01><>%>
+c<EFBFBD><EFBFBD>eS<EFBFBD>D<EFBFBD> 8iHc<48><63>C"<22>]:<3A>m<EFBFBD><6D>L1<4C><05><>e<><65><EFBFBD><EFBFBD>hC3<43>v<EFBFBD>,	<09>:<3A>/<2F>Xd<1D>I<EFBFBD><49>-<2D>6<EFBFBD><36><EFBFBD>|<7C><>15k<35>G}1<><31>c><3E><><13><>iw<69>G<EFBFBD>S&<26>Z{<7B>mr<6D><0C>vl<76>n<EFBFBD><6E><EFBFBD><EFBFBD>\Cq<43>GyWY<57>,<0B>*<0C>V<EFBFBD>
+<EFBFBD>?<3F><><EFBFBD><EFBFBD>'<27><>#>ȣh>ۼ纽<DBBC><11>g<EFBFBD><67>빢<EFBFBD>9<EFBFBD><39><15>ɣ<EFBFBD><C9A3><17><>R{y<>j<EFBFBD><6A>,<2C><>_	<09><>g<>#4<><34>'7<><37><EFBFBD>$v뱜<a<><61>0<EFBFBD>H<EFBFBD>Q1!̔<><CC94>lb<6C><62>{<7B>P[<5B>)st<73><74>9<EFBFBD><39>p<EFBFBD>²<0E><>]X\<5C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+,[D<><44>F-NyHX<48>ww<77>P<EFBFBD><50>Pᄋ5<0B><>1q<31><71><EFBFBD>B<><42><EFBFBD><EFBFBD>")&J<>;<3B><><EFBFBD><EFBFBD>\<5C><><EFBFBD>{΢Oq<4F>7<EFBFBD><37><EFBFBD><EFBFBD>';3W<33>o.#P<>2<EFBFBD><32>\<5C><><EFBFBD><EFBFBD>J<19>e<EFBFBD><65>x"<22>0<<3C>\L<1A>7<>m<EFBFBD><6D>t<EFBFBD>%<1D>D_B؅<42><D885><EFBFBD>%2	<09><><EFBFBD>)b<1C>E<EFBFBD>?<1A>B<EFBFBD>O<><4F>b<EFBFBD><62>i<02>״<EFBFBD>qQ1@5<><35><EFBFBD>z<EFBFBD><7A>!4zd<7A><64>߅]<1E><><EFBFBD>~.^i<><69>u|'<27><><>C><3E><><EFBFBD>
G>׭<1C>2<>rJk<4A>!<21>Y,<2C>3<><1A>!ј<><D198><EFBFBD><EFBFBD><EFBFBD>U?<3F>tVQ<56>%<25><><EFBFBD>Ty<54>b<EFBFBD>7g<37><67><EFBFBD><EFBFBD><EFBFBD>ς,m	'<27><><1B><13>.<2E><><EFBFBD><EFBFBD>L> <20><>'<27><00><>8<EFBFBD>Tr<54>BS6*<2A><>w<EFBFBD><77><EFBFBD>m<EFBFBD>v6<76>/<2F>2x<32>dRf<><66>Y<EFBFBD><59>V<EFBFBD>k-<2D><>J<EFBFBD>}<11><>C\<5C>аeg>;<3B>d<EFBFBD>y<EFBFBD><79>0U<30>><3E>a<1E>!<21>fT<66>9+K<16><>	M
+V<EFBFBD>B<EFBFBD><EFBFBD> џ<>N<EFBFBD>7<EFBFBD>y<0B><>x<EFBFBD>U<EFBFBD>csɆG$<24><><EFBFBD><17><>J<EFBFBD><4A>/3<><33><EFBFBD><EFBFBD>"<22><0F>>
+D<EFBFBD>v˅<><4јΛ|؀`<60>ܾ<EFBFBD>y<EFBFBD>l\[<5B>>k<><6B><07>kG<><47>Si<53>%<25>MB!<16>MB<4D><42>k<1E><><EFBFBD><0C>_<EFBFBD><5F><EFBFBD>_ȕ<5F><C895>r<EFBFBD>
+]<5D>d<>>͙0<0F> <20>^<5E><>Ƌ<EFBFBD>*_M<><4D><EFBFBD><EFBFBD>n<EFBFBD>g<><67>x<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD><EFBFBD>CH<05><17><>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD>p<EFBFBD><70><EFBFBD><15>iL<69><4C>͊<EFBFBD>͍<EFBFBD>[<5B>[(<28><><EFBFBD><EFBFBD>û<EFBFBD><13>쬆<EFBFBD><ECAC86><EFBFBD><EFBFBD><EFBFBD>:{<7B><>5<EFBFBD><35><EFBFBD>ІN<><4E><EFBFBD>ys<79>u<EFBFBD><75><EFBFBD>4Y^Eڦ<7F><DAA6>'<27>x<EFBFBD><78><EFBFBD><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD>'M<>QG<51>438ŀ<38><C580><06><>nwڳcAX<41><58><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>%_N<><0F><><EFBFBD>e<EFBFBD><65>M<EFBFBD><4D><EFBFBD>ɴM<C9B4><4D><EFBFBD>?<3F>
W)ݻ
+endstream
+endobj
+7 0 obj<</Contents 9 0 R/Type/Page/Parent 102 0 R/Rotate 0/MediaBox[0 0 612.28302 790.866028]/CropBox[0 0 612.28302 790.866028]/Resources 8 0 R>>
+endobj
+8 0 obj<</Font<</F2 122 0 R/F3 121 0 R/F4 120 0 R/F6 118 0 R/F8 56 0 R/F10 71 0 R/F11 61 0 R/F12 65 0 R/F13 72 0 R/F14 80 0 R/F15 83 0 R>>/XObject<</Im1 14 0 R>>/ProcSet[/PDF/Text/ImageC]/ExtGState<</GS1 113 0 R>>>>
+endobj
+9 0 obj<</Length 4318/Filter/FlateDecode>>stream
+hޜZ<EFBFBD>r<EFBFBD>F<12><>+t<>pF<70>QP<><50>7<EFBFBD><37><EFBFBD>Ҷ<14><><EFBFBD><00> 7<08>(Z<><5A><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɗY<C997><59>-M8&<1C><0B>d<EFBFBD><64><EFBFBD>eB_<42><5F>V]oƫ<6F>wW_|<7C>_<EFBFBD><5F><EFBFBD><EFBFBD><EFBFBD>O<EFBFBD><7<><19><1E>O3gܵ*<2A><>4><3E><><EFBFBD>^e<a<><61><EFBFBD><EFBFBD><12><1C>>$M7<4D>C<EFBFBD><43><EFBFBD><EFBFBD>gs<67>UZ&<26>z:<3A>u<EFBFBD><75>6u<36><75><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD>I<EFBFBD><49><EFBFBD>ǻo<C7BB>`e<>d<EFBFBD>R<EFBFBD><17><><EFBFBD>{{<7B><0C><>_<EFBFBD>R<EFBFBD><52>ԹL<D4B9>W<EFBFBD><0E><><EFBFBD>.<2E>H<EFBFBD><48>.<0B>TXf<58>҅W_^.<2E><>\^V<><56><EFBFBD><EFBFBD><EFBFBD>!<21><><EFBFBD>:-<2D><><EFBFBD>n<EFBFBD><6E>ۺ<EFBFBD><DBBA><EFBFBD>	7*R<>|<7C>l<EFBFBD>C<EFBFBD>_&<26>ɭ}}?<3F><><EFBFBD><EFBFBD>]<5D>4<EFBFBD>z<EFBFBD>R<EFBFBD>}!<21>-<2D>n<EFBFBD>ۦ<><DBA6><EFBFBD><EFBFBD>*RI<52>-i<>6<EFBFBD><36>W<EFBFBD><57><EFBFBD><EFBFBD>#O<>dz<64>&<z<><7A>"<22><>,
+<EFBFBD><EFBFBD>j[<1F><><13><><EFBFBD><EFBFBD>P<EFBFBD><1A>>o<>T<EFBFBD><54><EFBFBD><EFBFBD><EFBFBD><EFBFBD>#<23>s<EFBFBD>w:<3A>Q-<2D><><EFBFBD>'1E<31>T<18>t<EFBFBD><74><EFBFBD><EFBFBD><07><>4J<34><4A><EFBFBD>o<EFBFBD><6F><EFBFBD>3<EFBFBD>C<EFBFBD>5<EFBFBD>
+z<EFBFBD>j1q<31>t<EFBFBD><74><EFBFBD>W<EFBFBD><16>)뺚H5c_<>6ۦ<36><DBA6><EFBFBD><EFBFBD><EFBFBD>$<24>z?<3F>V<EFBFBD><56><EFBFBD>9<EFBFBD><39><EFBFBD><7F>n<EFBFBD>+XW<58>F<EFBFBD><46>u<EFBFBD><75><1A>2<1A><><EFBFBD><EFBFBD><EFBFBD><0F>,<2C><><EFBFBD><EFBFBD><EFBFBD>4ݲ݇<DDB2><DD87><0B><>ҟx5<78><35><EFBFBD>/<2F><>^<5E><><EFBFBD><EFBFBD>.A<>5L<>e<><65>u<EFBFBD>֏u_͋T<CD8B><54><EFBFBD>-=<3D>D:<3A>ಏ<<3C>6<EFBFBD><36><EFBFBD><EFBFBD>ݷS<DDB7>X
+M5<EFBFBD>=<3D><><EFBFBD>f<EFBFBD>b<EFBFBD>'<27><><EFBFBD><EFBFBD>j<EFBFBD><6A>?<3F>N<EFBFBD><1E>"<22>-9<>N<EFBFBD>tN5<4E><35>6ÝƉ<C39D><1B>WA'<27><1B>?⧧<>"<22><>Jz&<26><><EFBFBD><EFBFBD>͏o<CD8F>ɀ<EFBFBD><C980><EFBFBD><EFBFBD><EFBFBD><EFBFBD>U<EFBFBD>bu<62><11><><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD>f<EFBFBD>,<2C>nj<6E>D<EFBFBD>F<EFBFBD>4<EFBFBD><34><EFBFBD>?<3F><><EFBFBD>ҥ0b<30>S<EFBFBD><53>-<2D>,<2C><>%<25><><EFBFBD><EFBFBD>(<28><><EFBFBD>Q<EFBFBD><51>e<EFBFBD><EFBFBD>p<EFBFBD><70><EFBFBD>B<EFBFBD>)<29><><EFBFBD><15>n<EFBFBD><6E>s<EFBFBD>RE<52><45><0C>U5qd<>3gA1><3E><><EFBFBD>~<7E>F<EFBFBD><46><EFBFBD>><3E>1	<09>T2<54><32>~{#<23>b<EFBFBD><62>#<23>IN<49> O"w<18>NMGJ<14><><EFBFBD>*6<><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>IrΝF<CE9D>1R:m%d<>ƾբų<D5A2><C5B3>|<7C>?G̮e<CCAE>pړ<0B>m<EFBFBD>y`<60>:$E<>!<21><>Mt.<2E>\<5C>e<65>0<19><><EFBFBD><1D><>(<28>8s@<13>HĠ<48>?<3F><>PF<50><1F>]<5D><><EFBFBD>Y<EFBFBD>d<EFBFBD><64>npz<70><7A>6p<36>q<EFBFBD><71><EFBFBD><EFBFBD>$<24><><EFBFBD><EFBFBD>V<EFBFBD>6Ay<41><79>t<EFBFBD>e<EFBFBD>\<5C><>Δ9<>L#<03>෥߄T<DF84>蠄<EFBFBD>v<EFBFBD>05U%<25><><EFBFBD>s<EFBFBD><73>3h<33><68><EFBFBD><EFBFBD><EFBFBD>
+<EFBFBD>c<EFBFBD> <20>6<1E><>[<5B><>7'<27>.S&<26>j	V7<<3C>ԝ<EFBFBD><D49D>X<>a{<7B><><EFBFBD>,<2C>%ZB<5A><42><EFBFBD>s<EFBFBD>s.
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,)^r<>Zc9<63>~H<>H)9<><39><EFBFBD><EFBFBD>7<0F>Np<>،]<5D>Oc<03><><EFBFBD>-<2D>XW`F<>|<7C><><EFBFBD>=<3D><>骘<EFBFBD>
+<EFBFBD>+<04>Zi%<11>Ќ<13><>2<EFBFBD>
+<0C>tZ3<5A><33>.<2E>`s<>D<EFBFBD>0<EFBFBD>C5,<2C><><EFBFBD>%E<02><>
+<EFBFBD>س<EFBFBD>Kh<10><>><3E>
+<06>-b<04>JjcS<63><53><EFBFBD>*X<>jA<6A>G<EFBFBD><47>#l<>S<EFBFBD><53> ݛ<><DD9B><EFBFBD><EFBFBD>t8<74>#8B<38>ጢ<>	<0E>a<EFBFBD>rzO<7A>#XS<58><53><EFBFBD>k
+<1D>g<EFBFBD><67>.,{<7B>e<EFBFBD><65>ܒ4ȏ3
+/oV4<56>$<24>i!Ua<55>O<EFBFBD><4F>ƙ<EFBFBD><C699>
+<EFBFBD><EFBFBD>T<EFBFBD><EFBFBD>ř<EFBFBD><EFBFBD>a9<EFBFBD><16><><EFBFBD><EFBFBD>,9<><39><EFBFBD>T<EFBFBD>@@<08>l<EFBFBD>=DTn<54>˛<EFBFBD><02><0F>;z
+!<0C><><EFBFBD>"%ߝ1<DF9D><31><EFBFBD><EFBFBD>8א<38><D790>r<EFBFBD><72>-m<04>6SH<53><48><EFBFBD>l<EFBFBD>8<0E><>Jp<19>xP<78>-=<3D>F?:HO<48><4F>><3E>1S`"@<40><><EFBFBD>Qx<51><78>=<10>3"<11><><EFBFBD><EFBFBD>
+D@%V$ʲYhz<68><7A>,]-<2D>*`c<><1A>h!<21><>@<40><14>8<EFBFBD><38>غ<EFBFBD>q<EFBFBD><71><EFBFBD>4#<23><>:<3A><1C>B<EFBFBD><42> <20><><EFBFBD>[$j/>E<l<>@[<5B><><EFBFBD>cO<>x"<22><><EFBFBD><EFBFBD>!<04>n<EFBFBD><6E>t<EFBFBD><74>E<EFBFBD>U<EFBFBD>t
+<EFBFBD>v	<09>>N7⛶<10>t<EFBFBD>X<EFBFBD>R<EFBFBD><52>n<><6E><06><><EFBFBD><EFBFBD>W<EFBFBD>a<EFBFBD><61>\bH'<27>&<26>u<EFBFBD>T<14><><EFBFBD><1E><<3C>/<2F>)x<><78><10><><EFBFBD>D1 *僆y9b<39>ۑ<>ʾdC<64>m<EFBFBD><6D>W-<2D><><04><><02><18><><EFBFBD>+lkޓL<14><3<07>3!<21><>J<EFBFBD><4A>\<5C><10>yW0Z`P<>sH0ɢ<30>X<EFBFBD><00><>I<EFBFBD>d<EFBFBD>.h<>s<EFBFBD>c<EFBFBD>$mV<0B>bxΑ<06><><EFBFBD><1C><>1:oι<6F>Z$~<7E><><EFBFBD>$<24>
Ę<>U<EFBFBD><55> <20>ѓ<EFBFBD><D193>PrD&S<>%<25><>f^<5E>8<><38><16><>hm!;=<q<>;A<><02>A<EFBFBD>~<7E><>8%<25>:<3A><><EFBFBD>CR<43><02><><EFBFBD><EFBFBD><11><05><>S<1C><>fLP<4C><50><EFBFBD>%>U`<60>M<EFBFBD>sx<73>"<22>44<12>K<EFBFBD><4B>a!2܄<32>0<EFBFBD>B)<29><>N<EFBFBD><4E>I<EFBFBD><49><EFBFBD>7,<2C>Jv<4A>(<28><>{<18>+<2B>8<>8G;<3B>)<><7F>^<10><><EFBFBD>
+6<> Ib=8=<3D>	<09><><1C><>)<29>%$<10>9f<05>u<EFBFBD>
+
+<EFBFBD>;ܢ<><DCA2> <<3C><><12><>4<EFBFBD>X=R,<2C> <20><>4B^2<><32><EFBFBD>:l<><6C><EFBFBD>P<EFBFBD><50>(<28><><EFBFBD>3<EFBFBD>t"<22>'<27>T<EFBFBD><54><EFBFBD><EFBFBD>E_<45>;#tZ<74>|	u<>$`<60>2`P<> <20>jv+b<>eD<65>wwW<77>]Yh<59>jNPTm<54>%U<>\<5C><>k<EFBFBD><6B><EFBFBD><EFBFBD><EFBFBD>r{<7B><>7[u<><75><EFBFBD><EFBFBD>I<EFBFBD><49><EFBFBD><EFBFBD>i<EFBFBD>"<22><><EFBFBD>1<16>sJo^R[,Z-Wu*<2A>nt<6E>|<7C>A<EFBFBD><41>RcX$W<><13>$<0E><><EFBFBD>5ZuL疣<4C>		<09>?<3F>P#5<><35><EFBFBD>+U<>A)8<>Y2P<>^r`<60><>Y<EFBFBD>6q9<71>1<EFBFBD><31>\*r<>s<12><>lR<6C><52><EFBFBD><EFBFBD><EFBFBD>`[.<2E><>b)q<><71><EFBFBD><EFBFBD>qU<10><>^D<Ž.T<><03>[*/<2F><><EFBFBD>ĉ<00>DI<44>
+rѵ<EFBFBD>(<28>6<EFBFBD><36>B<1B><>\E<><45><1D><>2ac<15>y<EFBFBD>1胰<31>X)5<02><><EFBFBD><EFBFBD>[w<><77>7<EFBFBD><37>2v<32><76><EFBFBD><EFBFBD>tRMbiˠ<69><CBA0>U<1C>#<23><>eڨ$<24>ޣd<>h3X<33>X<EFBFBD>yѝ3i<33><15><>[_<>ad<61>—<EFBFBD>v<EFBFBD><76>0(<28><><EFBFBD>g)<29><>+<2B>w<EFBFBD>²<EFBFBD>}Ԓ<>[<02>k.<2E>
+bd<EFBFBD>|ΰ<>
+<EFBFBD><EFBFBD>*<2A><><1C><>Ӈ$Mg(ϣ<>O!<21><>a27<32><37>f<EFBFBD>X6f<36><66>*<2A>_<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><02>lc^<5E>60P<30>]<5D><>ñd<> .O<><4F>(<28><><EFBFBD>4<EFBFBD><34><EFBFBD><19>U<EFBFBD><55>`
+<EFBFBD>l<EFBFBD>ml<0B><><EFBFBD>Tu<54><75>alS0<0F>PG<08>mOT+r<>s<EFBFBD>w<1E><>F<EFBFBD>b`<60><>D^<5E>Oܸ)l(<28>䈊ћ<E4888A>R<EFBFBD>l<>i<EFBFBD>!8<><38><EFBFBD><EFBFBD>$<24>S<EFBFBD><53>h<EFBFBD><68>p<EFBFBD>^<5E>ox^#<23><04><><EFBFBD>Vv<56>WIA]c<>8Ey},<2C>%T
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>!<21><>X<EFBFBD>{<7B><><EFBFBD><EFBFBD>C<EFBFBD>{LL
+x?W<>gi<67><04>{<7B>,<2C>i<EFBFBD><69><EFBFBD>wD<02><13>s<EFBFBD>h,
+<V<><56>'А<>dO
+ <20><>'}3<>Nu<4E><75><EFBFBD><EFBFBD>+<2B>jAʔ"<0E>l8<0F><><EFBFBD><EFBFBD>~<7E>%8<>@V<>z<><7A><EFBFBD>R*5]<0F>!4<>^<5E><><EFBFBD>!9<><39>0<EFBFBD>8<EFBFBD>ɤ
R<>(<28>G<EFBFBD>{<7B><05><><EFBFBD>8<EFBFBD><38><EFBFBD><EFBFBD><EFBFBD><1F><>3<EFBFBD><33><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD>g[WgJ.<2E><><EFBFBD>a<EFBFBD><61><EFBFBD>c<><63><EFBFBD>8W<38><0F><><EFBFBD>"<16><02>9tL<74>F)8<><12>MRՄB
<01>"m:<3A>p<><70>l<EFBFBD>$M<><4D><EFBFBD><EFBFBD>?<3F><>Ɉ<EFBFBD><C988><EFBFBD>!<21><><EFBFBD><EFBFBD>0/<2F>t<EFBFBD><74><0B><><EFBFBD>(<28>T<EFBFBD><54><1A>ˬ,<2C>]
+x9ޗ -\<5C>R<><52><EFBFBD>0<EFBFBD>"<22><><14><><EFBFBD><EFBFBD><EFBFBD>oW<6F>h[=<3D><><02>~<7E><>f%<25>
<19>K<EFBFBD><4B>M^A67	=-<2D><>x<08><>X?E<><45><EFBFBD><EFBFBD>6!}<7D><>p<EFBFBD><70>Q<EFBFBD><51><EFBFBD><EFBFBD>4U<34>7ך\<5C><>F<EFBFBD>/@<40>I_#<23>|Y
+<EFBFBD><EFBFBD>s$<24>O)H_<04>!<21><1D><>9<EFBFBD>~<7E>pKx<>8<EFBFBD>g<EFBFBD><67><EFBFBD>8.<13><>`c<>W¿]<5D><><EFBFBD><1B>U'<27>D<EFBFBD><1A><1B>/j<19>RlDfbGv<47><76><1D><><EFBFBD><EFBFBD><EFBFBD>?<3F>k<>#P<06>#â<><C3A2><EFBFBD><EFBFBD><EFBFBD>;6<0E>#<23>҇<EFBFBD>-7<><37>ݖ<11><>喇<EFBFBD>f
+<EFBFBD>D~<7E><14>I|_@-<2D>1<EFBFBD>K<EFBFBD><4B><EFBFBD>C5ʾ6j8?<3F><19>B4<42>ZT<5A>I\K<><4B>\༾<><15>
+8'T;6<><36>Ў<EFBFBD>|<05>{<7B>x<EFBFBD>Q<<3C>ID<49>cC<15><><11><><$<24><>H	<09>s99<39><39><EFBFBD>\<5C><><EFBFBD><EFBFBD>v̙<76>r<EFBFBD>TEW<45>^ &J#<13><>i<EFBFBD>h<EFBFBD>d<>O<14>C9<43>qJ3<4A>
+<EFBFBD>>g=4<><34>I<EFBFBD>)<29>=,AiS<69><53>Av<41>t<EFBFBD><74>V<EFBFBD>H<EFBFBD>8<EFBFBD><38><EFBFBD><EFBFBD>'
+<18>.<2E>{<7B><>fg<66>@<40><> <20><><1C>3<05>%<25>1t͕_<CD95>}v<><76><EFBFBD><EFBFBD><EFBFBD>q<19><>2<EFBFBD>
><3E><><EFBFBD><EFBFBD>l<EFBFBD><6C><EFBFBD>BM><3E>d(<28><><EFBFBD>.~<7E>)<29><>E%Ӣ<><D3A2>8<1B>;<EFBFBD><CDBE><EFBFBD><EFBFBD>x<EFBFBD>TaW<61>brR<72>ڜl<><6C><0B><><EFBFBD><EFBFBD><17><><06>eʪ<65><18><>vEi<45>k<EFBFBD>q<>w<EFBFBD>F!m<>H<EFBFBD><48><1F><><EFBFBD>|aˢ<61><CBA2><EFBFBD>~<16><>[<5B>P<00>%T<><54>E<EFBFBD>6̝<36><CC9D>F<EFBFBD><46>D<>(<28>Ŀ<EFBFBD><C4BF>j!s<><73>48م<38><05>M	ֱ<<3C><>X裸<58><EFA492>HW<48><57><15><>Ն<D586>5Ŧ<35>X<EFBFBD><58><18>v<EFBFBD><76><EFBFBD> ^<5E><>v
%<25><>
+<EFBFBD><EFBFBD>OEЀ<EFBFBD><EFBFBD>D<EFBFBD><04>0yl<79><6C>oe<6F><65><EFBFBD>
<0B>=<3D>)
+<EFBFBD><EFBFBD>s
VCu<43><75>u<EFBFBD><75>3W<33><57> <20><>p(wxJ4l_E<5F>@<17><><EFBFBD>[X<><58>'4<><34>T<18><>\8&+<2B>ԓ	&!xd|0<>0<EFBFBD>}G<>D}<7D>@<40>:Fh<46><68>Ͼ<13>d:<>}<7D>\<5C><>><3E>S<02>FYlWDำp<E0B8B3>|<7C><><EFBFBD><ʝ<><CA9D>1<EFBFBD><31>b&<26><1A>`<60>D<EFBFBD>Thc<68>o<EFBFBD>
+i<EFBFBD><EFBFBD>m*<2A><>HT<48>%#<23>2<EFBFBD>|<7C><08>;!<21><>s{)<29><14>).Xl<58>3<EFBFBD><33>Z<><5A>%<25>~F<><46>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD><12><>@<40><><EFBFBD>֤<EFBFBD>U*<2A>&<0B><><0F>
~<7E>^<5E>$
+E<EFBFBD>Nn2<EFBFBD>G<EFBFBD><EFBFBD><0B><>i<EFBFBD><69>s<>+ŕ<><C595><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>	<09><>q7<71>
<01>t<EFBFBD>|,<2C><>X<EFBFBD><58><EFBFBD>E<EFBFBD><45>۾<EFBFBD>d<><64><EFBFBD>[<5B><>崴‡<E5B4B4><C287>)6<>F[<5B><>B<EFBFBD>]<5D>O<EFBFBD><4F>S<EFBFBD>)WޔϹ<DE94><CFB9>t<G\<5C>|s$<24><><EFBFBD><1C>e߭<65>ܰV|<07>ٟVH<56><EFBFBD><7F><EFBFBD><EFBFBD><16>B.<2E>Y,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>o<EFBFBD>+M<0F>d<EFBFBD><64>JF<4A>D<EFBFBD>P<EFBFBD><50><12><>֚<EFBFBD><D69A>>|!<21>Gw<47><1B>y$<24>|<7C><0B><><EFBFBD><17><>&<26>f<EFBFBD><66><EFBFBD>t<EFBFBD><74><EFBFBD>[<5B><><EFBFBD>L&<26>β<EFBFBD>]<5D>q<EFBFBD>֭BqM<71>V^<5E>=K<><4B><EFBFBD>g<EFBFBD>W#<23><>64<36>δ9<CEB4>C<EFBFBD><43>^<5E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>^<5E><>&<26>&<26>?.<2E>ʑ<EFBFBD>"R<05>䞹<EFBFBD>;f<><66><EFBFBD><EFBFBD><0B>QJ<51><16>|<7C>cڄ<63>.T򾮆<54>g<EFBFBD>J<EFBFBD><4A><EFBFBD>1<EFBFBD>k.<<3C><><EFBFBD>YrA!<21><>P<EFBFBD><50>ɏ(Ck<43>h%<0B>/M<><4D><EFBFBD><EFBFBD><EFBFBD>,<2C><>\<5C><>H=<3D><>~f<>e/<2F>𔣍<><14><>x<0E><><EFBFBD>s<EFBFBD>nF<6E>K&<26><><EFBFBD><EFBFBD>&<26><>"bꇋ<62><EA878B>!<21>R<EFBFBD>6<EFBFBD>ӟ<EFBFBD><D39F><EFBFBD><EFBFBD>+<2B>_<18><><1F>DL<44><4C>%:H<>$]<5D>,V}<7D>%)SQ53㯜_<E3AF9C><5F>j<EF87AE><6A>rѤ<<3C>:M<>
+<EFBFBD>(<28><><EFBFBD>-m<><6D>z<EFBFBD><7A><EFBFBD><EFBFBD>~<7E>̈́ <20><><EFBFBD><EFBFBD><0F>VpD
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><14><><EFBFBD>S<EFBFBD><03><>9<EFBFBD><1A><>w"<22><>x<EFBFBD>M<>"<22><><EFBFBD><EFBFBD>o<>3Q<33><51>鷻P<E9B7BB>s<EFBFBD><73>@<40><>
+a<EFBFBD><><7F>4<EFBFBD>_<EFBFBD>F<EFBFBD><46><0E><><EFBFBD>n\<5C>#<23><><05>L<EFBFBD><4C><EFBFBD><EFBFBD><1C>d`g<>2/<2F>]<5D><><EFBFBD>}<7D><>(@<40>&R<><52>y a<>
+<EFBFBD><EFBFBD><EFBFBD>]G<0F>F<1C><>*<2A><04><><EFBFBD><EFBFBD>q<EFBFBD><71>f<EFBFBD><66><EFBFBD><EFBFBD>e괾V<EAB4BE><56><EFBFBD>0<EFBFBD><30><00><><EFBFBD>
+endstream
+endobj
+10 0 obj<</Type/Encoding/Differences[46/period]>>
+endobj
+11 0 obj<</Length 214/Filter/FlateDecode>>stream
+h<EFBFBD>TP<EFBFBD>n<EFBFBD>0<0C><>St<53>mt4<74><34>
x<><03><>]<5D>hW@M	<09><<3C><>+)N<><<3C>G<1E>H<EFBFBD>o-<2D><00><><EFBFBD><EFBFBD>0<EFBFBD>`<60>0<EFBFBD>na<6E>p<EFBFBD><70><12><18><><EFBFBD>eԓ<65> <20><>[<5B><>SK<53><4B><EFBFBD><16>;<0E><>+<2B>N<EFBFBD><4E>k<EFBFBD><02><>
+<EFBFBD><EFBFBD>v}<7D>s<EFBFBD>D<EFBFBD>x<EFBFBD><78>R<><02>B<>ߕ<EFBFBD>P<13>̺ٯ<1E><>}<7D>Y;<3B><>WYшPW<50>\
<01><<3C>n<EFBFBD>ˠ<15><>fQT<51>F<EFBFBD>ݍM<DD8D>t<EFBFBD>=<3D>^<5E>c<EFBFBD>|q<><71><EFBFBD>-<2D><>)<29><><EFBFBD><EFBFBD>J<EFBFBD>0fdi`
+endstream
+endobj
+12 0 obj<</Length 117/Filter/FlateDecode/Subtype/Type1C>>stream
+h<EFBFBD>bd`ad`dd<14>
+<EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD>vL)0q6q5<71><04><><EFBFBD><EFBFBD><EFBFBD><11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>g<13>y<EFBFBD>+<2B><><EFBFBD>y<EFBFBD>@<12>Hꀀ<48><EA8080><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>IH<49><48><EFBFBD><EFBFBD>ﳾ<EFBFBD>mX<6D><58><EFBFBD>rj.+<2B>r@tE<74>⼼<EFBFBD>⼼<EFBFBD><E2BCBC>+V,^<5E>B<EFBFBD> <20><00><>'c
+endstream
+endobj
+13 0 obj<</Type/FontDescriptor/FontFile3 12 0 R/FontBBox[-31 -250 1000 750]/FontName/MPJMPL+AdvP4C4E59/Flags 6/StemV 0/CapHeight 677/XHeight 431/Ascent 694/Descent -206/ItalicAngle 0/CharSet(/space/period)>>
+endobj
+14 0 obj<</Length 409790/Filter/FlateDecode/Width 2032/Height 1612/BitsPerComponent 8/ColorSpace/DeviceRGB/Type/XObject/Subtype/Image>>stream
+h<EFBFBD><EFBFBD><EFBFBD>O<EFBFBD>+<2B><>'<27><><11>lf<6C><66>+<2B>:Aٽ<41>
+<EFBFBD><EFBFBD><EFBFBD>zg6Yi<59><69><EFBFBD> !ۃ<><DB83><EFBFBD>?<3F><>p
+Z_o<EFBFBD>t6<EFBFBD><0C>ޅ!<21>p `4'<0B><>p<EFBFBD><70><EFBFBD><EFBFBD>vW<76>ӿsԭ硸<D4AD>#u<>ZUݭ<55>_U?>p6<70><36><EFBFBD>E<EFBFBD><45>t<EFBFBD>}<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>	<09>o-<2D><><EFBFBD>z<EFBFBD><7A><EFBFBD><EFBFBD>'<00><><EFBFBD>K<EFBFBD><4B>˳<EFBFBD>v<EFBFBD><76>F<><46><<3C>"<22>]J<>
.'<27><><EFBFBD>d<EFBFBD>~=<3D><>F<><46>y~n0<6E>뵆<00><>p<EFBFBD><70>y=<3D>繆<18><><EFBFBD><EFBFBD><05>><00>%<25><><EFBFBD><EFBFBD>+<2B>,<2C>4<00><>\(<28><0F>ۭ<EFBFBD>8<><38>~<7E><>2l:<3A>j+<00><><EFBFBD>\<5C><>F<00><>V<EFBFBD><56><EFBFBD>7<>)ϟN<CF9F><4E>.<2E>7<EFBFBD><37><EFBFBD>Z<00>K<EFBFBD>B<EFBFBD><42><EFBFBD>/<2F>K<EFBFBD>02My~x<><78><EFBFBD><EFBFBD><EFBFBD>v6<76>5<EFBFBD>H.-p<16><>标%<25><<3C>hcrb<72><1F>[ŦH:<3A>ja<00><>X,<16>W\MWbY<62>i4<00>19=<3D>l<7F>-<2D><>
N<><4E>y<EFBFBD><79><EFBFBD>d2<64><32><EFBFBD>fV܂<><DC82><EFBFBD><EFBFBD><<00>r<EFBFBD>,<2C><><EFBFBD>Z<EFBFBD>V<EFBFBD>ݦ)<29><><EFBFBD>V<EFBFBD>
<00><>E<EFBFBD><45><EFBFBD>d<EFBFBD><64>
Nה<4E><D794>v<EFBFBD><76><EFBFBD>z<EFBFBD><7A>}w<>\j:<00><>8K<38>n$k+Y,Z<00>DM<44>Z<EFBFBD><5A><EFBFBD>X <20><><EFBFBD><EFBFBD>%<25>[`Β<>/<2F><><EFBFBD>J<EFBFBD><4A><EFBFBD>8QӵV<D3B5>e-<00><><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>'<27>
p<><70>dR{<7B><><EFBFBD><EFBFBD><EFBFBD>2<EFBFBD><32><EFBFBD>%<00><>5<EFBFBD><35><EFBFBD><EFBFBD>r<EFBFBD>j<EFBFBD>^<5E>V<EFBFBD>p<EFBFBD><70><EFBFBD>p<EFBFBD>f<EFBFBD>Ѽ'
+]<5D><>Z<EFBFBD><5A><EFBFBD><EFBFBD>dӅY<D385>rӌ#Д<><D094>h<EFBFBD>\j[<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˭<EFBFBD>z]Y<>e<EFBFBD><65>f<18>K<EFBFBD><4B><EFBFBD>N
+p<><70>~<7E>tŕ<74><C595>)08<30><38><EFBFBD>'<27>I:U<00><>:<3A><>i2<32>e`<60>.1?<>X<EFBFBD><58>{mp<><70>tZ{<7B><><EFBFBD>lj<6C>_<EFBFBD>׵ˇz4&<00><>]"<22>7
+<00>t<EFBFBD><74><EFBFBD><EFBFBD><EFBFBD>ȦU<C8A6><<0F>֮jӤ<00>v<EFBFBD><?<08>ka<00><>,<2C><><EFBFBD>K<EFBFBD><4B>ju<6A>Z<EFBFBD>uM
+0hMy<4D>|><3E>kn$<24>2<EFBFBD>٬=<3D>oz<00>y<>7]_<>v<EFBFBD><76><15>f<EFBFBD><07>N
+0\My~<7E><><EFBFBD><EFBFBD><EFBFBD>0,<2C><>d<EFBFBD>t:<3A><><00>Z<EFBFBD><5A>gv2ԩa
<00><><EFBFBD><<3C><><EFBFBD><EFBFBD><EFBFBD>9<00>K<EFBFBD>S<EFBFBD>GujX<00><>:W<><57>R<EFBFBD>b<EFBFBD><62><EFBFBD><00><>̔8Q<38>Y<EFBFBD><0C><19><><EFBFBD>~_[<5B>t:<3A><><00><>V<EFBFBD><0B><><EFBFBD><EFBFBD>R<EFBFBD><0C><19><><EFBFBD><EFBFBD><EFBFBD>Q;<00>7<EFBFBD>L.<2E>燚<EFBFBD><<3C><>C$<24><00>*<2A><><EFBFBD><EFBFBD>%<25><>52<00><10>1<EFBFBD><31><EFBFBD>v<EFBFBD>|<00>-<16><><0B><>t:?DX<44><58><EFBFBD><EFBFBD>l<EFBFBD><6C>
<00><><EFBFBD>y~ӽg<D3BD><67><EFBFBD><EFBFBD>}<7D><><EFBFBD><EFBFBD>	<12><>株Z<E6A0AA>Z<EFBFBD><5A>45<00><><EFBFBD>+<2B>ϲ<EFBFBD><CFB2><EFBFBD>q<EFBFBD>Zig<00>><3E><><EFBFBD>&<26><><11>5M<35>_.<2E><>`pN<70><4E><EFBFBD><EFBFBD><EFBFBD>z<EFBFBD><7A><EFBFBD><EFBFBD>/<2F><><00><>y<13><>с<ϵ6<00><>4<EFBFBD><34><EFBFBD>2<EFBFBD><32>52@<1F><><EFBFBD><EFBFBD>$<24><o<>p<EFBFBD>^kp<00>a<EFBFBD>t<EFBFBD>or>@O<><4F><EFBFBD><EFBFBD><EFBFBD>j:<3A>]<5D>b<EFBFBD><62><EFBFBD>s6<73>ip<00>a<EFBFBD>h<EFBFBD>*<2A><>}<7D>y><3E>L<EFBFBD>~M<><4D>l̻<18><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><00><>^<5E><>.<2E><><EFBFBD><EFBFBD>)57
+<13>Z<18>K<EFBFBD><4B><EFBFBD><EFBFBD>1<EFBFBD>2m<00><>l6<6C><36><EFBFBD>
+<EFBFBD><EFBFBD>X<EFBFBD>j<EFBFBD>j<EFBFBD>f<EFBFBD><EFBFBD>\<5C><0C>y<EFBFBD><79>pWnO<>Bpk<70><<3C>7<EFBFBD>l6'V<><56><EFBFBD><EFBFBD>*<2A>n<EFBFBD>`(<28><><EFBFBD><EFBFBD><04><><EFBFBD><EFBFBD><EFBFBD>,<2C>­<EFBFBD><C2AD><00><><EFBFBD><EFBFBD><07>W<><57>,<2C><><EFBFBD>K<EFBFBD><00><><EFBFBD><EFBFBD>׿<EFBFBD><D7BF><EFBFBD>g<EFBFBD>|<7C>)<00><><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><7F><EFBFBD>k<EFBFBD>
W<>5cu<7F>իW<D5AB>
<00><><7F><EFBFBD>_<EFBFBD>Ǵ(<28>g<EFBFBD><67>Ã6<C383><36><EFBFBD><EFBFBD><EFBFBD>x<>f<EFBFBD><66>{<7B><>p<12>4<><34><EFBFBD><EFBFBD>y~(<28><><EFBFBD><EFBFBD>9<EFBFBD>p<EFBFBD><70>|<7C><>x<EFBFBD>&<1C>Zcd>ϲй<CFB2><D0B9><EFBFBD>c<EFBFBD><63>4<><34>G<1F>#<23>"P<><50><EFBFBD>_k<19>6<0F>A<EFBFBD><41>_<EFBFBD><5F><EFBFBD>_|<7C>A<EFBFBD>$<24><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>K
+@<40><><EFBFBD><EFBFBD><16>>\<5C>?<3F><><0F> <20><><EFBFBD>޼~<7E>MF#th<74><0C>)<00><><EFBFBD><EFBFBD>ի<EFBFBD>}<7D>q,<2C>g١<67><D9A1>O><3E><><EFBFBD><EFBFBD><EFBFBD>p!᠋<><E1A08B><EFBFBD>3<EFBFBD><33>!_9H<39><48><EFBFBD>?~<7E>ěׯ<C49B>'<27>CWOGWî<57><C3AE><EFBFBD><EFBFBD>a
<00><><EFBFBD>,kI<6B><49>U>|<7C><>CSG<53><47><EFBFBD>><3E>8\<5C>>t<><74><EFBFBD><EFBFBD>7<EFBFBD>#4<><12><11>><3E><>}<7D>u<EFBFBD>_]=<3D>`z<>չ<00><>4y~<7E><>L<16>ӝ<EFBFBD><D39D><EFBFBD><EFBFBD>On:B<05><><EFBFBD><EFBFBD><?<3F><><EFBFBD><EFBFBD><EFBFBD>s
<00><>)<29><><EFBFBD>}<7D><>Y<EFBFBD>p<EFBFBD><13><>Jh<4A><06><EFBFBD>ӟ<EFBFBD><D39F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;=<3D><><EFBFBD>ի<EFBFBD>AU<41>0P<50><7F><EFBFBD>J<EFBFBD>~D霖/<1E>3*t<><74><EFBFBD>g١<67><D9A1><00>W<EFBFBD>^i<><69><EFBFBD><EFBFBD>˗<EFBFBD>.8<EFBFBD>g{v<><><07>08<30>O<07><><EFBFBD>oI<6F>?ϲ<><CFB2><07>g<>9<EFBFBD>v<EFBFBD><76><EFBFBD>'<27>j<EFBFBD>'<27><>L<><4C><EFBFBD>_<EFBFBD><5F>B<EFBFBD><0C><>y~e<><65>$.<2E>	<09><><EFBFBD><EFBFBD>y7<1C><0E>'<27>4y~<7E><>/_<>Թ<00>sz<73><7A><EFBFBD>;<3B>V<EFBFBD>"I>\<5C>E<EFBFBD><45>P<EFBFBD><50>/_j<5F>gq<67><?tn8<6E>kg<00><>:1<><EFBFBD><7F>uy<75>?<3F><><0F><><EFBFBD>Z.<2E><><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>σ<EFBFBD>o<6F>a<>u<EFBFBD><<3C>th϶<0C><>\<00>81<38><31><EFBFBD><EFBFBD>Oc<4F><63>իW<D5AB><13>@9<><39><<3C>Z<><5A><EFBFBD>A<EFBFBD>{<7B>N<!<21><><EFBFBD><EFBFBD>\<00>;1>z<><7A>w<EFBFBD>Z<5A>ӟ4&<<3C>S<EFBFBD><53>/_<>,<1F><><0E>h<EFBFBD>+q<>	9<><0C><>5<EFBFBD>
+0&<26><>G_<47>z<EFBFBD><7A>_<EFBFBD>FO<><4F><<3C><><EFBFBD>?(<28>k$e<EEAA9C><65><EFBFBD><00><>wJ|<7C>y<EFBFBD><79>y<EFBFBD>Z<1B>;:Ͽ<><CFBF>/<2F><><EFBFBD><EFBFBD><1C>W<EFBFBD><57>r<><72>b<EFBFBD><62>{<7B><>֘<00>s<EFBFBD>tP<74><50><1D>燅<EFBFBD>*<2A>}<7D><>6<EFBFBD>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F><>0n<30>|<18><><EFBFBD><EFBFBD><0F><><EFBFBD><EFBFBD>W<EFBFBD>4<EFBFBD><34>:<3A><><EFBFBD><EFBFBD>;<3B><>յ!<00><><EFBFBD><EFBFBD>ap<61><70><EFBFBD>߼~<7E><><EFBFBD><EFBFBD><EFBFBD>'<27><><EFBFBD>4 <00><><EFBFBD><EFBFBD>ap<61><70><EFBFBD><EFBFBD>rN<72><00><1F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>	<00><16>#y<>X9!<00>B|<04>#<23>+'dZ<><5A>`p<><70>c<EFBFBD><63>@<0B><0C><<><7F><EFBFBD>
h!><3E><><EFBFBD>珕2-<2D>G08<30><38><EFBFBD>rB<00><><EFBFBD>G<>?VN<56><00><1F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>	<00><16>#y<>X9!<00>B|<04>#<23>+'dZ<><5A>`p<><70>c<EFBFBD><63>@<0B><0C><<><7F><EFBFBD>
<00><><EFBFBD><EFBFBD>݋<EFBFBD><DD8B><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD><6C><EFBFBD>P<EFBFBD><50><EFBFBD>~<1D>5x<16><><EFBFBD>rBn<>~<7E><>6<EFBFBD><36><EFBFBD>i<EFBFBD><69>fs<66><73>z<EFBFBD><0E>t~<7E>n<EFBFBD>+<2B>ϲ,<2C><>vy<><79>BO<42><4F>cK<07><><EFBFBD><EFBFBD><13>,Vi<56>&y><3E>N<EFBFBD>?V<>|<00><><EFBFBD><08>Vm`<60><>l<EFBFBD><6C>ie<69><65>j<EFBFBD><6A><11><>n><3E>W<EFBFBD><0F><><EFBFBD><05><><EFBFBD><EFBFBD><08>Vm<56>޿_
+<EFBFBD><EFBFBD><EFBFBD>rYY><3E>	<09>(<28><<3C>g'<27>+y>p<><70>D<EFBFBD>=<3D>_<EFBFBD><5F><EFBFBD><EFBFBD>7<EFBFBD>L&ş<><C59F>2<EFBFBD><EFBFBD><7F><EFBFBD>f<>YX><3E><05>?+ѱ<<3C>h<EFBFBD><68>2i<32>~P<><<3C>
+<EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><0F><>?C=<3D>H_<48>ϳ<EFBFBD>珕<<00>eE<65><45>3w<33><77>v1<76><31><EFBFBD><EFBFBD>ŋ<EFBFBD><C58B>w<EFBFBD>^<5E><>o)<29>d2)G<>q<EFBFBD>we@<40><EFBFBD><7F><EFBFBD>Bo<42>Y<EFBFBD><59>~	<16>E<EFBFBD>VV<56>F<EFBFBD><46>N<EFBFBD><4E><EFBFBD><EFBFBD><<3C>g'<27>+y>pˊ<70>u<EFBFBD><75><EFBFBD>Y8N<38><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>]<5D>uc><3E>%yZ<79>*<2A><<3C><><13><>:<3A>I<EFBFBD><49>ڻf<DABB>Z<EFBFBD><5A><EFBFBD><EFBFBD>~<7E><><EFBFBD>b<EFBFBD>h<EFBFBD><68><<3C>#<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>J<EFBFBD>ܬ<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>i<EFBFBD>v<EFBFBD>Z<EFBFBD>Ҩ<EFBFBD><D2A8>^	<09><0B><>&<26><>k<EFBFBD><6B><EFBFBD><EFBFBD><0E>ja3<61><33><EFBFBD>w<<3C><><EFBFBD>1>*<2A><>>߽xD<78>g~~h<><68>y<EFBFBD><79><EFBFBD>B܅<42>Qm<7F>\<5C><>O,<2C><>3<EFBFBD>
<01><<><7F><EFBFBD><00>͊<EFBFBD>k<EFBFBD><6B><EFBFBD>,k<>̟F<CC9F><46>ݮx<DDAE>i<EFBFBD>x<EFBFBD><78>|><3E><><EFBFBD><EFBFBD><EFBFBD><<3C>ÊŴ<C38A>B<EFBFBD>X M<><4D>Go<>e<EFBFBD>k<10><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1C>/E{<7B>f<EFBFBD><66><EFBFBD>,<2C>E<EFBFBD><45>!<21>9<EFBFBD>B<>Gj<47><6A><EFBFBD><16><><EFBFBD>><3E><>`4<>珕<<00>Y<EFBFBD><59><EFBFBD>i<EFBFBD>vj<76>X<EFBFBD>c<EFBFBD>T%n<><6E><1F>r<EFBFBD><72><EFBFBD><EFBFBD>U<EFBFBD>	<09><><EFBFBD>zebzܲ<7A>d29:
+<EFBFBD><EFBFBD><?>:<3A>g<12><><EFBFBD>ҙ<EFBFBD><D299>OU<4F><55><EFBFBD>8<EFBFBD><38>O<EFBFBD>t<EFBFBD><15><>֑K'y<>X<EFBFBD><58>
<00><>U$<24><><EFBFBD>d<EFBFBD><64>b<EFBFBD><08>4<EFBFBD><34>E<EFBFBD>n<><6E><EFBFBD>Mgqǘ<71><C798>˜<EFBFBD><C298>|><3E>RTU<54><55><EFBFBD><EFBFBD>l<EFBFBD><6C><EFBFBD>J<EFBFBD><1C><>"<22><0F>"<22><><EFBFBD><EFBFBD>c:<3A>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><05>?M<><14><1F>/<2F><><EFBFBD>!-F<><46>q<><71>+=<12>\<5C>)<29>c<EFBFBD>7~<7E><>z<EFBFBD><7A>8<10>g؂'<27>+y><00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD>pǺMq<><18>	w<><77>F8<46><07><>:܇6<DC87>Y<EFBFBD>
+<EFBFBD>n<><6E>-py<70>a<11><><EFBFBD>-<2D>MV<0C><><$V<18><><03><15><><EFBFBD>i2<69>Yv<59>g<EFBFBD><67>a<1F><>Y9l9<6C>@<00><>it<>ih<69>;<1D>ߧ*<2A><><EFBFBD><EFBFBD><EFBFBD><15><><EFBFBD><EFBFBD>J<EFBFBD>4<EFBFBD>p:<3A>?a<>SSL<53><4C><EFBFBD><EFBFBD><EFBFBD><0F><><EFBFBD><EFBFBD>M<EFBFBD><4D><EFBFBD><?&<26><15><>4<EFBFBD><34>8<EFBFBD>_<EFBFBD>n<EFBFBD>(<28><>?<3F>GZ<47><5A>b<>_['<27><><EFBFBD><EFBFBD>J<EFBFBD>08<30><38><EFBFBD><EFBFBD>n<EFBFBD> <20><><EFBFBD><EFBFBD>C<EFBFBD>C%娼<><E5A8BC>uE<75><45><EFBFBD>w<EFBFBD>-jÖZᶺ<(вmϘ-_<>J㜱e<E39CB1>)<29><19><><EFBFBD><EFBFBD><EFBFBD>ݥ<EFBFBD>j<EFBFBD><6A><EFBFBD><EFBFBD>,<2C>3<EFBFBD><33><EFBFBD><07><>1<EFBFBD><31><EFBFBD>o<EFBFBD>W<EFBFBD>)<29><><EFBFBD>O<EFBFBD><4F>uy<75>~<<3C><>m<EFBFBD>~<7E><><EFBFBD><EFBFBD>Lѿ<4C><?\Z<><5A>q<EFBFBD>X<EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD>)<29><>C{<7B><>g<EFBFBD><67><EFBFBD>_~<7E>j<><6A><EFBFBD>J<EFBFBD>08<17><>k<EFBFBD><6B>pڿ<><DABF>)<29><>ZF
+<EFBFBD><EFBFBD>i<EFBFBD><EFBFBD><EFBFBD>e<EFBFBD>bE<EFBFBD><EFBFBD><EFBFBD><EFBFBD>rBr<EFBFBD>F<EFBFBD><EFBFBD>׎^<1D>燝d^r<>|W<>:<3A><><EFBFBD><EFBFBD>b<11>y<EFBFBD>o=e<><65>tb	<09><><EFBFBD>f<EFBFBD><66>j<EFBFBD><6A>k<EFBFBD>m=<3D>M<EFBFBD>?ϯm<CFAF><6D><EFBFBD><0E><><19>2<EFBFBD>?<3F>Gjw<6A><77>xUc<02><><EFBFBD>c%<25><18>K<EFBFBD><4B><EFBFBD>ݮ)<29><><EFBFBD>K_8(<28>o<EFBFBD><6F>=4<><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30>F<><46><EFBFBD>ɍG<C98D><47>&<26><> <20>g<EFBFBD><67><EFBFBD>l<<3C><>?1O<31>緜u<E7B79C>8͓S<CD93><53><EFBFBD>O<1D>cݧc{<7B>ٟ2<D99F>?<3F>G:<3A><>pa槇><3E><>c%<25><18>K<EFBFBD><4B>-3<><33>$<24>M<EFBFBD><4D>l6+f/<2F><>yo<79><6F><EFBFBD>S<EFBFBD><53><EFBFBD>D<EFBFBD><44><EFBFBD>,ϻ묭<CFBB>m<EFBFBD><6D><04>6<EFBFBD><?<3F>*<2A>s(<28>ΰ<EFBFBD><CEB0>j<EFBFBD>2y><0C>)y~LM<4C><1C>e<EFBFBD>t1\~b<>?<3F><>P<EFBFBD><50><EFBFBD>ci<63>9<EFBFBD><39><EFBFBD>*-g<>4<EFBFBD><34><EFBFBD><1E><><EFBFBD><EFBFBD>p<EFBFBD><70><EFBFBD>8C<38><43><0E><>ؼM<D8BC><07><><EFBFBD>YG<>Hg<48>ߧfx<66>珗<`p.<2E><>7MW.<2E><>2<>ߤ<EFBFBD>bQ<62>G<EFBFBD><47>v<EFBFBD>b<EFBFBD>H$|P<><50><EFBFBD><EFBFBD><EFBFBD><EFBFBD><06><><EFBFBD>t<EFBFBD><74>q<EFBFBD>ڇB<>Y<EFBFBD><59>+<0C><0F><><EFBFBD>#1ݽMc<4D><63><EFBFBD>OO;:<3A>w%<25>w<EFBFBD><77><EFBFBD>-H<><48><EFBFBD>yݕU:#<23><><EFBFBD>[<5B><>[<5B><>)<29>AG4re<72><65><EFBFBD>M+<2B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>c%<25><18><><EFBFBD><EFBFBD>i<EFBFBD>]	<09><>f<EFBFBD>Ei<45><69><EFBFBD><7F>Qj<1A>f
+wi<><1F><><EFBFBD><EFBFBD><EFBFBD>LSD<53><44><EFBFBD><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD>[p;y<>釡PF)<29>Q<EFBFBD>
l<><6C>I<EFBFBD>=<3D><><EFBFBD>x<EFBFBD>i<EFBFBD>9+~<7E><>?7}R<>b<EFBFBD><62><14>c<EFBFBD><63>7|<7C><>Oz#<23><><EFBFBD><EFBFBD>	G<>K<EFBFBD>Nڶ<07>Hy<48>A<EFBFBD>H<><48><EFBFBD><EFBFBD>.3J<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><0C><><EFBFBD><EFBFBD><EFBFBD>Py<0C><>
+fg><3E>X<EFBFBD><58><EFBFBD><EFBFBD>`<60>c<07><><EFBFBD>b<><62>j<EFBFBD>~6*?<10><EFBFBD>|<7C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>څ<><DA85>mI<6D><49>PI<50>j<EFBFBD><6A><EFBFBD><EFBFBD>W<EFBFBD>-<2D>Q,<2C>Z<EFBFBD>6<EFBFBD>M<EFBFBD>O<0C><><15><><EFBFBD><EFBFBD>PIh<49><68>O<16>l<EFBFBD>A<EFBFBD>V<0C>IQI<51>O<EFBFBD><4F>e<1B>'<27>E˔<45>`g<><67><EFBFBD>j<EFBFBD><6A>9<EFBFBD><39>b<EFBFBD><12>/wel<65><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lVy<<3C><><EFBFBD><EFBFBD>Х<EFBFBD>|<7C><>p^JW<4A><57><EFBFBD><EFBFBD><EFBFBD>=<3D><>|c%MQs<51>6ĪZ~<7E>[<5B><>Ӡ<EFBFBD><D3A0>4<EFBFBD>?<3F>_j<5F><6A>B<EFBFBD>cP<63><50><EFBFBD>{<7B>i<EFBFBD>B<EFBFBD>-<2D>2y<32>X<EFBFBD><58>
<06><>y~e<><65>r<EFBFBD>\<5C>ו<EFBFBD>h<EFBFBD>gL<67><4C><EFBFBD>,z<>K<EFBFBD>y~<7E><><EFBFBD>v<EFBFBD>JU<4A>(5<>*|<7C>Φ<EFBFBD>m:<3A><><EFBFBD><14>}<7D>j<EFBFBD>zQ'~<7E><><EFBFBD>J<17><>[<5B><>~<7E>O<EFBFBD><4F><EFBFBD>z{<7B>*o<><6F>Ȉ<EFBFBD><C888><EFBFBD>E/4m<34>l6<6C>]<5D>O<EFBFBD>6<><36><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>G<EFBFBD><EFBFBD>K<EFBFBD>ڦ<EFBFBD><EFBFBD><EFBFBD>~<7E><><18><><EFBFBD>V<EFBFBD>銇<EFBFBD><E98A87>y<EFBFBD>r<EFBFBD>o<>˯<7F>3mz><3E>Q<1E><><EFBFBD><EFBFBD>J=<3D>Z<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD>ځ<EFBFBD>X<EFBFBD>q<EFBFBD>
+7Ϗc<EFBFBD><EFBFBD><EFBFBD><EFBFBD>C<EFBFBD>%^<1A>
+?<3F>|IS<49><53>ڹ
q<>J<EFBFBD><4A><EFBFBD>(<28>j<EFBFBD><6A><EFBFBD>I<EFBFBD>?V<>|<00><>9o<39><6F><EFBFBD>l<EFBFBD>4><3E><><EFBFBD>Y<EFBFBD>i6{<7B>=f<1A>;ԶR<D4B6><52><EFBFBD><EFBFBD><14><><EFBFBD>K<EFBFBD><4B><EFBFBD>'ҡ<>ӡ<EFBFBD>J^<1B><><EFBFBD><EFBFBD>h5<><08>Vf<56><66><EFBFBD><1F>y~<7E>ƷlCg<43>߹y
+<EFBFBD>D<EFBFBD>|<7C>"<22>Nk<4E><6B>xLO2<4F><32>Wy+<2B>R9<52><39><EFBFBD><EFBFBD>*<2A><><EFBFBD>z<EFBFBD><7A><EFBFBD><EFBFBD>V<EFBFBD>W <20>[9۔ϫ<DB94><CFAB>*_*~V:<0C>ӕ<EFBFBD><D395><EFBFBD><EFBFBD>q<EFBFBD><71>񋧃#<23><><EFBFBD>ci(<28>|E<>+<1F><>#<23>ݴG<DDB4>Z<EFBFBD><5A>ʗ*<2A><><EFBFBD><EFBFBD><EFBFBD>7B<37>?V<>|<00><>9o<39>_<EFBFBD>m<EFBFBD><6D><EFBFBD>qrZ<72><5A><EFBFBD><EFBFBD>u1i<31><69>Ͳ<EFBFBD>6$i<>ƼEdn<><0F><1F><><EFBFBD><EFBFBD>bq<62>~\<5C>V<EFBFBD><56>3rO?<3F>i<EFBFBD>|Y<>0<EFBFBD>%<25>o<EFBFBD>Tߙuz<><7A><EFBFBD><EFBFBD>Й<EFBFBD><1F>y-<2D>M<EFBFBD>;<3B><n\<5C>#8<><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>x<EFBFBD>mT<><54><EFBFBD>p/֊<>Ԟ<04><>#<23>\|P<><50>M<EFBFBD><4D>b<EFBFBD><62><EFBFBD><EFBFBD>q<><71><EFBFBD>mq<6D>3<EFBFBD>Ք<0F>e<EFBFBD>GT<47><54>E<EFBFBD>t-<2D><<3C>/~<7E>B[<5B>o<1D><1F>J\<5C><<3C><>ǫ<EFBFBD><C7AB><EFBFBD><EFBFBD>R<EFBFBD>¸p<C2B8>)a<><61>m<EFBFBD>K<EFBFBD><4B>G<EFBFBD><47>U<EFBFBD><1C>~<7E>V<EFBFBD><56>-<2D>6<EFBFBD><36><<><7F><EFBFBD><00>s<EFBFBD><?ܫV<DCAB><56>8-Mk[<5B><>J<EFBFBD>_<EFBFBD>a<1E>:<3A>9<EFBFBD>}6<>%<25>.ni<6E>LHK<48>/蟲<><E89FB2><EFBFBD>(<28>v<"F1-<2D>T|<7C><>X<EFBFBD><58><EFBFBD><11>(<28><>S<><53><1A>&j<><6A>P@Z<><5A>t<EFBFBD>)}*<2A>Sy<1B><>؞<EFBFBD><D89E><EFBFBD><EFBFBD><EFBFBD>YG֤<>H[
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>m<EFBFBD><EFBFBD>[<5B><><EFBFBD>p
+Z<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>t<EFBFBD><0F><>;<3B>ښV<DA9A>}\+<2B><>Ҝ<EFBFBD><D29C>C<7F><43><EFBFBD><EFBFBD><EFBFBD>K'{?<3F>2=<3D>=ɇ<><C987><EFBFBD>a<EFBFBD><61><EFBFBD><EFBFBD><EFBFBD>Y<EFBFBD><59><EFBFBD>¶\<5C><><EFBFBD><EFBFBD>Bh<42><68>篶mc<6D><6<><05><><EFBFBD>q<><71><EFBFBD><EFBFBD><EFBFBD>~t<>[#<23>+y><00><><EFBFBD>1<EFBFBD>Oo<4F><6F>
+i|=ʚojs<6A><73>l<EFBFBD>e<EFBFBD>:<3A>?<3F><>Ӧ<EFBFBD><D3A6>t{<7B><><EFBFBD><EFBFBD><1B><><EFBFBD><EFBFBD><EFBFBD>s+<2B>5<EFBFBD><0E><><EFBFBD><EFBFBD><ͫ<>AD<41>ei|<7C>~J<1C>)<29>QI<51><49>Ļ<EFBFBD><0E>VJ<56>><3E><>Y<EFBFBD>L؞<4C>W>=<1D>I<EFBFBD>`Ӟг<D39E>:<3A><>t<EFBFBD><74>\<18>p)<29>\<5C>o<EFBFBD><6F><EFBFBD>|<7C>,<2C>L<EFBFBD><4C><EFBFBD>X+<2B><>:,B<>a<EFBFBD>b<EFBFBD><62>b<EFBFBD><62>_1n<18>
+<EFBFBD><EFBFBD>j<EFBFBD>
+-<2D><><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*<2A>1>
+_omi<6D><69>q<EFBFBD>Gگ<13><><EFBFBD>(<28>d<EFBFBD><64><EFBFBD><EFBFBD>R۶<52><DBB6>b<EFBFBD><62><EFBFBD>g<EFBFBD>)<29><><EFBFBD>?+8<><38>Gn<47><<><7F><EFBFBD><00>s<EFBFBD><<3C>2<EFBFBD><32>2<15><><EFBFBD><EFBFBD>?[<5B><><EFBFBD>
+<EFBFBD>$|P<><50>m<EFBFBD><6D><EFBFBD>
+<EFBFBD><EFBFBD>L<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>z<EFBFBD><EFBFBD>4I<EFBFBD>̵K疧-YހJ<DE80><4A><EFBFBD>k<EFBFBD>1<EFBFBD><31>KGj*i!<21><>_ތʷ<DE8C>M?<3F>̿<EFBFBD><CCBF>Z<EFBFBD><5A>ھ<EFBFBD>l^v<>]<5D><<18>J<EFBFBD>v<7F><76>'<27>4<EFBFBD>
+<EFBFBD><EFBFBD>珕2<00><><EFBFBD>+<2B><><EFBFBD><EFBFBD>=<3D>MgA<67><41>
+<EFBFBD>n<EFBFBD>i<08><1E>7M<37>]<5D><>y<EFBFBD>t<EFBFBD>r<EFBFBD>}=y~g<><67>g<EFBFBD>7U7<><37>C<13>a<EFBFBD>f<EFBFBD><66><EFBFBD>ܞ.7<>Rye(J<>6~<7E>Ay~<7E>?<3F><><18>ږ4_Q<5F><0F><>߾<EFBFBD><DFBE><EFBFBD>,+ʗ/_><3E><><EFBFBD><EFBFBD>{
+={-|<7C>+<2B>By><3E>"<22>+y><00><><EFBFBD>+<2B>O<EFBFBD><4F>o6<6F><36><02><><EFBFBD><EFBFBD><EFBFBD>v<EFBFBD>\.{<06><>ɤi<C9A4>~<7E><><EFBFBD>Ţg<C5A2>_<EFBFBD><5F>P<><50>nXK<58>:<3A>O_<><5F>[8<08><><EFBFBD><EFBFBD><EFBFBD>#M<><11><><EFBFBD>A<EFBFBD><0E><>P<EFBFBD><50><EFBFBD>	<09><><EFBFBD>a<EFBFBD>h<EFBFBD><68>O<EFBFBD>M<EFBFBD>|<7C><>,<2C>q<EFBFBD><71>><3E><>y7F<37><46><EFBFBD><EFBFBD>'<27><>|ngo<67>8<EFBFBD>|<00><>9W<39>?<3F><>:gYW<59><57>N<0F>b<EFBFBD><62>v<EFBFBD><76><EFBFBD>3ۯ<Pk<50><6B>fY֙<59><D699>)<29><>HDX<44><58>f<EFBFBD>%z*<2A><><EFBFBD><17><>Ӡ<EFBFBD><D3A0>~<12><><EFBFBD><EFBFBD>S<EFBFBD>7<EFBFBD><37><EFBFBD>e<EFBFBD>*<2A><>><3E>8<EFBFBD><38>*#PO<50>M<EFBFBD>|@<40>?D<>|n<><<><7F><EFBFBD><00>s<EFBFBD><?M<>kgYW<59><57><EFBFBD>	<09>-<2D></&<26><>N<EFBFBD>?t˳,K7<4B>ڧS<DAA7>{֟<><D69F><EFBFBD><7F><EFBFBD>g<EFBFBD><67><1F><06>|<7C>#<23>ס<EFBFBD><D7A1><8y<><10><><EFBFBD><1D><><EFBFBD><EFBFBD><EFBFBD><0C>Y<EFBFBD><59>,ˎ<>dW<64><57>)<1B><><EFBFBD>Ӝ<EFBFBD><D39C>1<EFBFBD>4<EFBFBD>-
+<EFBFBD><EFBFBD>|<7C>i<EFBFBD>y<EFBFBD>=<10>(<28>?_<>_hJ<>=t<>w<><<1F><><?<3F><><EFBFBD>ߊ<EFBFBD><DF8A><EFBFBD><EFBFBD><<3C><><14>x<EFBFBD><78>bo<62>8<EFBFBD>|<00><>9K<39>_;<3B><><EFBFBD><EFBFBD><EFBFBD>zѸ^<5E><>S<EFBFBD>;<3B><><EFBFBD>@KP\_o<5F>\.<2E><>"<22>7<><37>-Ҥ<><D2A4><1B>K<EFBFBD><4B>iӵRT<52>MB[<5B>n@ڡ<><DAA1>	<09><><19><><EFBFBD>#<23><10><><EFBFBD><EFBFBD>ˇ<EFBFBD>Z,<16>ɤv<C9A4><76><EFBFBD><EFBFBD>ɺI<C9BA>\U<>i<7F>|<7C><>s%<25><><00>sz<73><7A><EFBFBD><EFBFBD>^<5E><>2<EFBFBD><32><EFBFBD>=<3D>I<EFBFBD><49>Z<EFBFBD><5A><EFBFBD><EFBFBD><EFBFBD>Ţ<EFBFBD><C5A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>w<EFBFBD><77><EFBFBD><1D>M<EFBFBD>⃞<1D>t<EFBFBD><74>~<7E><>ѓ4<D193><34>~<7E><>K<1B>vP<76>eإ<65><D8A5><EFBFBD>=~PC<50>^<5E><>R<EFBFBD><52><EFBFBD><EFBFBD>R驃<52>A<EFBFBD><0F><><<>$<24><>{<7B>X<EFBFBD><58>
<06><><?<3F><>~<7E><>\<5C>4<1F>Zo<19>O<EFBFBD>1{<7B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>S<06>ϖw<CF96>Z"<22><><EFBFBD>+v<>t<EFBFBD><74><EFBFBD>̺o<CCBA><1B><12>o6<6F>>O.<2E><>7#<23>a<EFBFBD><61>PgZC<5A><43><EFBFBD>qZ*}<7D>v<EFBFBD>!<21>O<>M<EFBFBD>|@<40>?DNn<4E><6E>}<7D><><EFBFBD><00>S<1B><><11><>J&\N<>k<EFBFBD>υN<CF85>Ѱ@S<>^o<><6F><EFBFBD>:lj:C<><43>m<EFBFBD><6D>\.+<0B>V<EFBFBD><56>
++>.#<23><><EFBFBD>i<EFBFBD>_	<09><>x<EFBFBD><?m<>ʷ<EFBFBD><CAB7><EFBFBD><1C><><EFBFBD>!<21>?+m<>NίlF<6C>PF%u<0F><>6i<36><69><EFBFBD><EFBFBD>総<1F>n<EFBFBD><6E><EFBFBD><EFBFBD>O{
=y<>I8<49><1D><><EFBFBD><EFBFBD><EFBFBD>N<><4E><EFBFBD>T䱻ݮ<E4B1BB><DDAE>b<EFBFBD>h<EFBFBD><68>49<34><39>Ǯ
+ç<EFBFBD>iX1<EFBFBD><EFBFBD><0E>R<EFBFBD><52><0B><>:ֳ<><D6B3>k<EFBFBD>	<09><>V<EFBFBD>XUS<0B><13><>-O+<2B><><EFBFBD><EFBFBD><18><><13><>i_<><5F><EFBFBD><19>b<EFBFBD>_j<5F>re`"]<5D><18>i<EFBFBD><69>RI<52> Nh<4E>b<EFBFBD>(T<><54><19><13><><EFBFBD>J<EFBFBD>7<EFBFBD>Rl^<5E><><EFBFBD><EFBFBD>J#t<><74>g<EFBFBD><67>tD<74>أ<EFBFBD><D8A3>30n<30><6E>!<21>pr;<3B><>c%<25><18><13><>4<EFBFBD><34>L 7<>M{ֽ<><D6BD>js<6A>Ni[;3<><33><EFBFBD>'jg<6A><67><11>jf<7F><66><13><><EFBFBD><EFBFBD><EFBFBD>.<2E>:^;(<28>s<EFBFBD><73><EFBFBD>b<EFBFBD>><3E><><EFBFBD>P<EFBFBD>V<1C>mO<6D>MM<4D>a<EFBFBD>Q`<60><><EFBFBD>C$<24><>v<EFBFBD><76><EFBFBD>J<EFBFBD>08'<27><>i<EFBFBD><69>'<27><><EFBFBD><15><>,pD<70>ߔ<EFBFBD><11><>̥?"<22>?.<2E>|<7C><<3C><>&jj<6A><6A><EFBFBD>
+ֹ=#<23><>tZyt<79><74><EFBFBD><0E><07>
<01>'<27><>,<2C><><EFBFBD>p<EFBFBD><70><EFBFBD>C$<24><>v<EFBFBD><76><EFBFBD>J<EFBFBD>08<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>t<EFBFBD>|<7C>4<EFBFBD>
+UU<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>-
+H<EFBFBD>¦N<EFBFBD><EFBFBD>><3E>L&<26>tKRi:}܆<>{<7B><<3C><><EFBFBD>,<2C><>&
+-<2D><>]Z"<22>"!<21><><19><>aKG<>4Tg<54><67>w<EFBFBD>|<7C><>B<EFBFBD><42>4N$χ<>!<21>"	'<27><><EFBFBD>>V<>|<00><>Y<EFBFBD><59>wG<77><47><EFBFBD><EFBFBD>ͦ<EFBFBD>bmH<6D>
+<EFBFBD>UVlJ<EFBFBD>w<EFBFBD><EFBFBD>j<EFBFBD>j<EFBFBD>^ϲ<>2[<5B>I<EFBFBD><49><EFBFBD>rٔZ/<16><><14>'҇%<25>G7<47>8<1C>aM<61><4D><EFBFBD>V<EFBFBD>쾴<EFBFBD><ECBEB4>JZ<4A>*<2A>ڡ<>ڡ<EFBFBD><DAA1>wߥO˄eB<65>q<EFBFBD><71>dj<><6A>t<EFBFBD>f<EFBFBD>{*lC<6C>
+<EFBFBD><EFBFBD>ptC<15>j<0E>@ew
+<1E><>g隸<67><EFA6B8><EFBFBD>9/9<>a
`<60><><EFBFBD>C$<24><>v<EFBFBD><76><EFBFBD>J<EFBFBD><00><><EFBFBD>v<EFBFBD><76>Ϛ<EFBFBD>ݞ<EFBFBD>%'<27><><EFBFBD><EFBFBD>0n<><<>$<24><>{<7B>X<EFBFBD><58>
<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD>b<EFBFBD><62><EFBFBD>˗Mk<4D><6B>믛<EFBFBD>
+o5<EFBFBD>մJ(a3ݼs<DDBC>rV<72><56>;<><EF9EBD> <20>S<EFBFBD><53><EFBFBD><17><>誶<EFBFBD><E8AAB6><EFBFBD><EFBFBD><EFBFBD><1F>o<EFBFBD><6F>?<3F>y(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ġ<EFBFBD><C4A1>c%<25><00><>AAe<41>ri<72><69>^<5E><>^)-qS<71>*E<>|<7C><>)<29>͖<EFBFBD>c<EFBFBD><63>xi:0[<5B>e<EFBFBD><65>=ؿ<><D8BF>׿)<29>9<1E><>rͥ<.Y<1C>ʍ<EFBFBD>/_<>|<7C>a<EFBFBD><61><EFBFBD><EFBFBD><EFBFBD>U<EFBFBD>f\?:<3A><><EFBFBD><EFBFBD><EFBFBD>M<EFBFBD><4D><EFBFBD><EFBFBD><EFBFBD>jZ<6A><5A>m<EFBFBD><6D>
<00><><EFBFBD><EFBFBD>+<2B><_<><5F>(<28><>t^n<><6E><EFBFBD><EFBFBD><EFBFBD><02><><EFBFBD>Q<EFBFBD><51><EFBFBD><EFBFBD>t<EFBFBD><00><>E<EFBFBD><45><EFBFBD>><3E>T<EFBFBD><54>(<28>|EQE<>/<2F>8<>E<EFBFBD><45><EFBFBD><EFBFBD>1y<31><79><EFBFBD><EFBFBD>EQy<>A<17>M<EFBFBD><4D><EFBFBD>
<00>1<><<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Sy~<7E><>E<EFBFBD><45>(<28><><EFBFBD><EFBFBD>
<00>ְ<EFBFBD><D6B0>#6OQ<4F><51><EFBFBD><EFBFBD>y<><79>(<28>"<22><00>Z<EFBFBD>|E<><45><EFBFBD><EFBFBD>EQy><00><>{<7B><>u<EFBFBD>i<EFBFBD><69><EFBFBD>b<EFBFBD><62><EFBFBD>'<27>6<EFBFBD><15>jZ<6A>˗/+o6<6F><36><EFBFBD><EFBFBD><EFBFBD>v۴<76>q<EFBFBD>7<EFBFBD>"=P<><50><EFBFBD><EFBFBD>(<28><<3C>Q<EFBFBD>p<><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD>m6
+<EFBFBD>-{<7B><><EFBFBD>߾<EFBFBD><DFBE><EFBFBD>ꩭ<><EAA9AD><EFBFBD><EFBFBD>i<EFBFBD><69><EFBFBD><EFBFBD><EFBFBD>U<EFBFBD><55>g<EFBFBD>$<24><EFBFBD><7F>իϳLQ<4C>2<EFBFBD>1k<31><6B><EFBFBD><EFBFBD>wޕ<77>wn<77>k	<00><><EFBFBD><EFBFBD>~<7E><>&<26><><EFBFBD><EFBFBD>bqh<71><68>Bg<>2딉d<00><19><>
<00><><EFBFBD><EFBFBD>
<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}<7D><>A<EFBFBD><41><EFBFBD><EFBFBD><EFBFBD>.m><3E><><EFBFBD><EFBFBD><EFBFBD>ݝ
<00>+$<24><00><>'<27><00><>'<27><07><>~<7E><>r<EFBFBD>݋<17><>(<28><><EFBFBD><15>)y><3E>\v<>&<26>ob<6F>_<EFBFBD><5F><EFBFBD>HR<>|<7C>Yl6y<1A>e6{<7B>}<00>B<EFBFBD><<3C><><EFBFBD>_<EFBFBD>I~,<2C>սV<00>2y><3E>IJ<EFBFBD><C4B2><EFBFBD>0<EFBFBD>(<28>M<EFBFBD><4D> <20><>Oi<4F><69><EFBFBD>O<EFBFBD><1F>d<EFBFBD>M<EFBFBD><4D><EFBFBD><EFBFBD><00> <20><07>L<EFBFBD>0<EFBFBD>(<28><><EFBFBD>
+<00><1B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~<7E>/<2F>(<28><07>@<40><>4<EFBFBD><34>9(<28>/<2F><><EFBFBD>?<3F>5k<7F>ۥo<DBA5>&<26><><15><>^<5E>\<5C><>a~Q<><51>kC<6B>o<EFBFBD><6F>15<><35>v?h<>JˬV<CBAC><56><EFBFBD><EFBFBD>E	<09><><EFBFBD><EFBFBD>gKɲt<00>hE<68><45><EFBFBD>nӷj<13><>w<EFBFBD><77><EFBFBD>E<EFBFBD>v?L<>?:<3A>%<25><><EFBFBD>?iIh<49><68><EFBFBD><EFBFBD>^<5E>k<EFBFBD><6B><EFBFBD>r<EFBFBD><72><EFBFBD><EFBFBD>J<EFBFBD>Y<><59><EFBFBD>'<27><>&׌J<><0C>n<EFBFBD><6E>d<EFBFBD><64>)ZQ<16>hLH<4C><48>,<2C>><1D>GYx׈<78>f<EFBFBD><66>~"<22><>G<><47><03><><EFBFBD><EFBFBD><EFBFBD>,a~Q<><51>{M
+=3<>JY.<2E><><EFBFBD>v;<3B>)<29><>,};!<07><>?<3F><>&_,<2C>1<EFBFBD><1B>r<EFBFBD><72>~<7E><>6<EFBFBD><36>z<EFBFBD><7A><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD>f<EFBFBD><66>!P<>K<EFBFBD><4B>4,7(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><0C><>s<EFBFBD><73><EFBFBD>O	}a<><00>?y<>3Z.<2E><><EFBFBD><EFBFBD>O&߸<><DFB8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><<3C>)<29><12><><EFBFBD>*<2A><>p;V<><56><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>7ۆ皜<><7F><EFBFBD>.'<27><>n6<6E><36>_
+/<2F>v;<3B><0C><<3C><>d<EFBFBD><64>Mw<4D><77><EFBFBD>߷<EFBFBD>k"x<><1B>j	˱X8<58>:W	<09>kanǹ<6E><C7B9><EFBFBD>l6<6C>
+<EFBFBD><EFBFBD>y'<27>;
\B<><42>Y<EFBFBD><59>f<EFBFBD><17>&<26><>b<EFBFBD>X<EFBFBD><58>Zy<><79><EFBFBD><08>|s<><73>q<EFBFBD><71><EFBFBD><EFBFBD>@<40>OzF<><46>-<2D><><o
+=<3D><><EFBFBD><06><><EFBFBD><EFBFBD><EFBFBD>c<EFBFBD><63>~<7E><><02><>f<EFBFBD><66>L&/1<>N<EFBFBD>Z<EFBFBD>
+y<EFBFBD><EFBFBD><0B><><EFBFBD><EFBFBD>7}n<><6E>b<EFBFBD>FnV<6E>y<EFBFBD>-<2D>[g<>7<EFBFBD>G<EFBFBD>~<7E><><EFBFBD>f<EFBFBD><66><EFBFBD>oϞB<CF9E><42><EFBFBD><EFBFBD>I<EFBFBD>,%<25><>]<14>t<EFBFBD><74><EFBFBD>v<1E><><EFBFBD><EFBFBD><EFBFBD>i<EFBFBD><69><EFBFBD><EFBFBD><00>P<EFBFBD>8<EFBFBD><<3C>Py<50>S<EFBFBD>0<EFBFBD>|<7C>/o<><06><><07>><3E><15><><EFBFBD>#n6{<7B><><19><><EFBFBD>ߗH<DF97><48><EFBFBD>uSϑ]hr~Q6<51>܎
+p<EFBFBD><EFBFBD>v[<5B>r<EFBFBD>eY<65><59><EFBFBD>h<EFBFBD>ۅef<65>Y\<5C>,}`<10><>O)<29><EFBFBD><7F>-l$<<3C><><1F><<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>V<EFBFBD>ڜ<11>\<10><>t<EFBFBD><74>tN<74><4E>[l_=<3D><><15><14>Ţ<EFBFBD>Ͳ<><CDB2><15><>q@3<00>o~<7E><>c<EFBFBD><63><EFBFBD>v<EFBFBD><76>?N<>M<EFBFBD><4D><EFBFBD>v<EFBFBD>o͈<6F><CD88><EFBFBD><18>:<3A>r<EFBFBD>]<5D><><EFBFBD><EFBFBD>b<EFBFBD><62><EFBFBD><EFBFBD>Cg݇0<><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD>c,<2C>F<EFBFBD><46><EFBFBD>v<EFBFBD><76>ƯV<C6AF><06>
.<2E><>	],G<><47>Z<EFBFBD><5A><EFBFBD>ۧ<EFBFBD><00><><<3C>E<EFBFBD>D<EFBFBD>OY,<2C><><EFBFBD>?iOF<4F>s"<22>d<EFBFBD>M<EFBFBD>4<EFBFBD><34><EFBFBD>јP<D198>#<23><>	{uط<75><D8B7><17><1F><><EFBFBD><EFBFBD>u>,3<>;<3B>f<EFBFBD><66><EFBFBD>g{#<23>^<5E><>g!<21><>m<EFBFBD><6D><EFBFBD>&t<><74><1C><>~<7E>w<00>&y~<7E><><EFBFBD>_g	<09><>-<>}<7D>U<19><><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD>V<><<3C>n!<21><><EFBFBD>t<EFBFBD>	<0B><>?<3F>W<0E><>J<EFBFBD>o܈۰3<DBB0><33><EFBFBD><7F>X.<2E><><EFBFBD>!<21><>GO<47>w<00>&y~<7E><>ɍǕ<C98D><C795><EFBFBD>#RM<52>W<EFBFBD><57>tw<74><77><EFBFBD>wE1.Sk:<3A>{˞t<7F><74>;<0F><>;ڟ<><DA9F><1C>
+<EFBFBD>Z<EFBFBD>z:<1F>	<09><>xbyg~<7E><><EFBFBD><EFBFBD>~~<0B>/;<3B>b<><62>^<5E><>X<EFBFBD><58>|<00>f<EFBFBD><66>S<EFBFBD>Ƽ}^_<>!<21>9<EFBFBD><39>\<13>yƝa6{S<><53><EFBFBD>ʈs<CA88>#l6y<36>nJs-<16><><<3C>S<>F<EFBFBD><46><EFBFBD>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD>j<>cag<61><67>_<EFBFBD><<3C>yP<08>8<EFBFBD>M<EFBFBD>l6;b<>p<EFBFBD>z<EFBFBD><7A>~<00><><EFBFBD><EFBFBD>W<EFBFBD><57>O<EFBFBD>3<EFBFBD>BY.<2E>+<2B><><EFBFBD>{oyV䘬<56><E498AC>j
+<EFBFBD><EFBFBD><0E>cW<63>~b[<5B>9$<24><06>F༹qg<71><1D><><EFBFBD>_3<5F>wr~<7E>s<EFBFBD><73><EFBFBD>:
X,<16>}h<>O<EFBFBD><4F><EFBFBD>W̲<57>Xq2<71>hF<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>><3E>|X<><58>b<EFBFBD>}<7D>gJ<67><4A>gE<67>I<EFBFBD><49>VMT<4D><54><EFBFBD>t<EFBFBD>j<><<3C>FKrk:<3A><>}%<25>6<EFBFBD><1C><1E><>O<EFBFBD>/<2F><><EFBFBD><1C><>j<><6A><EFBFBD>[<5B><>d<EFBFBD>\.7<EFBFBD>MK<EFBFBD><1F>ϲl:<3A>ƵŸ<C6B5><00>5<EFBFBD><35><EFBFBD><EFBFBD><EFBFBD><EFBFBD>>a~<7E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Y<EFBFBD>'<27>2<<3C><><EFBFBD>:fcڧž+<2B><><EFBFBD>p<EFBFBD>Z<EFBFBD><5A><EFBFBD><1B>}C<13><><EFBFBD><EFBFBD>$3<><33><EFBFBD>E<EFBFBD><45>h<0E><><EFBFBD><EFBFBD>γ<EFBFBD><CEB3>Ne<4E><65><EFBFBD>_<EFBFBD><5F>BȲ<42><C8B2><EFBFBD><00>Z<EFBFBD><5A>/<2F><><EFBFBD><7F><EFBFBD>G<EFBFBD><47>R<00>s<EFBFBD><73><EFBFBD>OI<4F>u<><00>L&ߴ<><DFB4><EFBFBD>M<EFBFBD>9<EFBFBD><39>i<EFBFBD>?<3F>`<60><>w<EFBFBD>G-<2D><><14>w<EFBFBD><77><EFBFBD>_<EFBFBD>;Y}<7D>~l<>ڎ<EFBFBD>e<EFBFBD><65><EFBFBD><7F>/Ď<><<3C>z<EFBFBD>CD*a<>!	<09>&<0F>,<2C><>;<10><><EFBFBD>Y<EFBFBD><59><12>Z{`<60>Y<EFBFBD>S/Ơ<04><1E><><0C>f<EFBFBD>,fm<66><6D>d<cte<><13>B3a<33>Z<EFBFBD><5A><EFBFBD><EFBFBD>8<EFBFBD><38><EFBFBD><EFBFBD>-w<><77>ղ:]O<>붺u{<7B>tWw?<3F>x<EFBFBD><78>ԟ<EFBFBD><D49F>[OU}?<3F><><EFBFBD><EFBFBD>=u<><75><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1D><1E><><EFBFBD><EFBFBD>0G<30><47>f<EFBFBD><66>_SC<53>*C_<><5F>嫷<EFBFBD><19><>lu}D<04>s<EFBFBD> <20>,<2C><>2<18>A<EFBFBD><41>AA<><13><>`0X]]<5D><><EFBFBD>=~2<>h<>6<EFBFBD>ס<EFBFBD><D7A1><EFBFBD><EFBFBD>g<06>*
+W%<25>^<5E>UBp<>i4<69><34><EFBFBD><EFBFBD>Ɗ<EFBFBD>+<2B>f<EFBFBD><66><EFBFBD><EFBFBD><EFBFBD>6<EFBFBD>%<25>i%<25>4$<08>p<EFBFBD><70>{Ke<4B>HL`<60>c<EFBFBD>i<>w<EFBFBD><77><EFBFBD>t<EFBFBD>Xg<58>Nu<4E><75><EFBFBD><EFBFBD>S<04> "7<><37><EFBFBD>q<1C>0p<30>oY<16>_k<5F>,GA<10>nA <20>o<EFBFBD>뺱'<27>0d?<3F>߈<EFBFBD>7E><3E>q<EFBFBD>NU<4E><55>R<EFBFBD><03><>Ӊ<EFBFBD><11>3<EFBFBD>Y:Es<45><73><EFBFBD>XL<12><>g<><67><EFBFBD><EFBFBD>γKi<4B>|Xz<58><18>Kq<4B>H<EFBFBD>a<EFBFBD>봝Dg<44><67> <20><>"<22>ÃF<1A><>@Ч<><D0A7>|<7C>t=<3D>	<09> 
+o<><6F><EFBFBD>^<5E>W<06>
<01><><EFBFBD><EFBFBD><EFBFBD>K<EFBFBD><4B> <08> <20><>0<08>.<2E>_<EFBFBD><5F>-`YS<><53><EFBFBD>q<EFBFBD><71>-<2D>z<EFBFBD><17><> <20><><EFBFBD><EFBFBD>|IwRE<52>=<03>F<EFBFBD>h<EFBFBD>T<EFBFBD>s隺<73>H%a<>Y<>=<3D>d<EFBFBD><14>&<26><><EFBFBD><EFBFBD>Z<>4<EFBFBD><34><EFBFBD>Q<EFBFBD>KH<13>;<10><>:9<><39>oJ<6F><4A>:ADKA^<5E>	<09> <08><><EFBFBD><EFBFBD>ۍG<<3C><><EFBFBD><EFBFBD>wguun<>4M~<7E>Q%<25><07>,<0B><><EFBFBD>~͵*g/<2F><><EFBFBD>+<2B><><EFBFBD><EFBFBD>V<EFBFBD>.<08><><EFBFBD><EFBFBD>_<EFBFBD>fQ<66><51>Л$E9<45>=<3D>V<EFBFBD><56><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4$g<><67>|
+EiK=~X<>a<EFBFBD><61>pX=<3D><>i<><69><EFBFBD><EFBFBD>
AQ'<27>"<22>"7~<7E><><EFBFBD><EFBFBD><EFBFBD>K<EFBFBD>f<>g/<2F><>!<08> :C<07><>a<18>{<7B><><EFBFBD><1C><>o<EFBFBD>6<EFBFBD><36>4M<34>u<EFBFBD><15>D<>KC=O<><4F>ϗ<EFBFBD><CF97>3-E<>ܗ<EFBFBD><DC97>øҥ<C3B8><D2A5><EFBFBD><EFBFBD>8;<3B>.<2E>4<EFBFBD>KO8o5<6F> <20>g<EFBFBD>C<EFBFBD><43>l<EFBFBD><6C>Ҕ<EFBFBD>(<28><>5ϣ5;>w<><77><EFBFBD>Q{<7B><><EFBFBD><EFBFBD>|<7C>t<EFBFBD><10>)
+l<EFBFBD> <20>r<EFBFBD>}<>1<EFBFBD><31><00><>K/<1F><>8<><38>O?<3F>M8<4D><38>G<EFBFBD><47>?<3F><>W<EFBFBD>~'<27><>?<3F>Qל>}<7D>̙3O=<3D><14><><EFBFBD>C]I]I<>ƓO><3E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><0F><><EFBFBD>{I<><49>AT<41><54><EFBFBD>Ą<C484><7F><10>b@<40><>>_jڙ,j<EEBEA4>ļAb)<29><>K4]dAէO)'<<0B>(<o\<5C><><EFBFBD><EFBFBD>C<EFBFBD>Ú <20><><EFBFBD>n9<6E><39>Ej<45><6A><EFBFBD>39<33>!
+<04><>;<3B> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>`<60><>}lo;<3B>hF<>0<EFBFBD>;l%V<><56>|(9<><39><EFBFBD><EFBFBD>#<23><>/<2F>ÏF<>Y><1F>ɬ}<7D><0B><><EFBFBD><EFBFBD><EFBFBD>999<39><39><EFBFBD>j<EFBFBD>+<2B>+	<09><><EFBFBD><0C><>.<2E>|<7C>uS<1F><0C>#<23><>_?|+<2B><>8*<2A><><EFBFBD><EFBFBD>K5<4B>a\)%;g<>j<EFBFBD><6A><EFBFBD><EFBFBD>^5<>Hs,<2C><><EFBFBD><EFBFBD>G<EFBFBD>öGH<47>9<EFBFBD>Nu<4E>v<EFBFBD>[<1D><><EFBFBD>,<17><1C>Gj<47>K<EFBFBD><4B>
+<EFBFBD>w<EFBFBD><EFBFBD>7<EFBFBD>ؒu&<26>7<EFBFBD>wA]%<25>"<22><>-b<>&<26><><EFBFBD>E;<3B>a1<>_<04><>_<EFBFBD>=f<><66><EFBFBD><EFBFBD>~<7E><<3C>"><3E>ڝG<DA9D><47><EFBFBD><EFBFBD><EFBFBD>K{<7B>6'<27>؂<EFBFBD><D882><EFBFBD><EFBFBD>t<EFBFBD><74><EFBFBD>1
+<EFBFBD>VC]<5D>666<36>+<2B>+<2B><>c><3E>I<EFBFBD>,<2C>
+<EFBFBD><EFBFBD><EFBFBD>;<3B><<3C><><EFBFBD><EFBFBD>[U<>"<22><>竸<EFBFBD><1D>4<EFBFBD><34><EFBFBD><EFBFBD>kFjc(<28>!gx<67><78><08><><EFBFBD>U#<23>3<EFBFBD><33>i<EFBFBD><69><EFBFBD><EFBFBD>8;<3B><>4H#9<>x$<24><>;\<5C>!<21><>b|5<><35> <08><>*<2A><>hL<68><4C>[<5B>i<EFBFBD><69>7<EFBFBD>e<EFBFBD><65><EFBFBD>U<G<><47>W<05><>_<EFBFBD>s<EFBFBD>u=<3D>x{<7B><00><>k;Gp<47>wu<77>E<EFBFBD><45><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ۻ<EFBFBD><DBBB>4<1A><0E>ʽ=JE<4A><45>$<24>+<2B><>+<2B><0F>;<3B><>n<EFBFBD><6E><EFBFBD>?<3F><>Q<><51><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/R<><52>ζG<CEB6>i<EFBFBD>Ʊ<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD>s°y55<35>g<EFBFBD>א<EFBFBD><D790>ϦJwT<>4<EFBFBD><34>*<2A>a<EFBFBD><61><0F><><13>;<3B><>ju<6A><75><EFBFBD>HS<48><53>g<EFBFBD><67><EFBFBD>4ֺ<><D6BA><EFBFBD>i^<5E>2.
+<EFBFBD><EFBFBD><13> g0<18>r~<7E>1<EFBFBD><31><EFBFBD>߈<EFBFBD><1E><>Rܓ.<05><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><17><>Og<><1F>	<09>t}<7D> <08>h<0B><>A<><41><EFBFBD>g5<67><35>Z<EFBFBD>|~ͥi<CDA5><69>_TjQ<6A><51>@ H<><0F>Wp<57>l<EFBFBD><1A>{<7B><12><><EFBFBD>"M3<4D>w<EFBFBD><77><EFBFBD><EFBFBD><EFBFBD><EFBFBD><07>E<EFBFBD>mŸT<C29F><54><05><>S?<3F>ou;<3B><><EFBFBD><EFBFBD>pB<70>fM<66>Osq<73><71>W<EFBFBD>hkADg<10><o<7F>o<EFBFBD>G<EFBFBD><47>VLݗ<4C><DD97><EFBFBD><EFBFBD><EFBFBD><EFBFBD>E<EFBFBD>ϟߚ )<29><><EFBFBD><EFBFBD>܍HL<48>'<08> <20><>@><3E><11>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>><1F><19>q<EFBFBD><71>버<EFBFBD>6z<36>v<EFBFBD><76>`<60><>L<1D><>
ks<6B><73><EFBFBD>JG*x<>ʥ<EFBFBD>3U6<55><36>Q<EFBFBD><51>a<15><><03><0C>Lby<62><79><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6>AD@:K<7F><4B><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD><6C><EFBFBD><EFBFBD>><3E>|<7C><>/<2F><>C|<7C><>dvq<76>XL<58>'<08> <20><><EFBFBD>1<EFBFBD><31>2L<>\̀<><CD80><EFBFBD><EFBFBD>MՕ<4D>%<25>+<2B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>&<26>R<EFBFBD>%5l<35>{<7B><16><><08><>J<EFBFBD><4A><EFBFBD>5<EFBFBD>!<21><><EFBFBD>4Vf