primesieve-5.6.0/000077500000000000000000000000001263266076300137055ustar00rootroot00000000000000primesieve-5.6.0/AUTHORS000066400000000000000000000000451263266076300147540ustar00rootroot00000000000000Kim Walisch, primesieve-5.6.0/COPYING000066400000000000000000000024571263266076300147500ustar00rootroot00000000000000BSD 2-Clause License Copyright (c) 2010 - 2015, Kim Walisch. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 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. primesieve-5.6.0/ChangeLog000066400000000000000000000605021263266076300154620ustar00rootroot00000000000000Changes in version 5.6.0, 29/11/2015 ==================================== 1. The C API prime generation functions now return true C arrays which can be deallocated using free() in the user's code. 2. New high resolution icon size for primesieve GUI app. 3. primesieve GUI app: Bug fix for CPUs with L1 data cache size that is not a power of 2 e.g. Intel Z2480 Atom (24 KB L1 cache). 4. Renamed doxygen directory to doc. 5. doc/Doxyfile.in: Fix out of source builds. C++ API changes --------------- All parallel callback functions have been removed. This was just crazy functionality which I should never have implemented ... void parallel_callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime)); void parallel_callback_primes(uint64_t start, uint64_t stop, primesieve::Callback* callback); void parallel_callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime, int thread_id)); void parallel_callback_primes(uint64_t start, uint64_t stop, primesieve::Callback* callback); C API changes ------------- All parallel callback functions have been removed: void primesieve_parallel_callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime, int thread_id)); Changes in version 5.5.0, 06/11/2015 ==================================== This release contains many small incremental improvements. There are 2 minor backwards incompatible API changes which are described further down. 1. primesieve GUI app: Runtime detection of CPU L1 cache size. 2. primesieve.pc.in: Added support for pkg-config. 3. appveyor.yml: Automated Windows (MSVC++) testing. 4. README.md: New "Bindings for other languages" section. 5. include/config.h: tune for Intel Skylake CPUs. 6. include/WheelFactorization.hpp: Slightly faster initialization. 7. src/primesieve/EratMedium.cpp: Unroll sieving loop, up to 5% speed up. 8. src/primesieve/popcount.cpp: Faster popcount algorithm. 9. examples/c/previous_prime.c: Shows how to use primesieve_previous_prime(). C++ API changes --------------- primesieve::test() has been renamed to primesieve::primesieve_test() in order to prevent naming collisions. primesieve::iterator::previous_prime() now returns 0 if input <= 2, previously an error was thrown. Rationale of this change: https://github.com/kimwalisch/primesieve/issues/11#issuecomment-148939336 C API changes ------------- primesieve_previous_prime() now returns 0 if input <= 2, previously PRIMESIEVE_ERROR was returned. Rationale of this change: https://github.com/kimwalisch/primesieve/issues/11#issuecomment-148939336 Changes in version 5.4.2, 04/04/2015 ==================================== This is a minor new release, the API and ABI are backwards compatible. 1. Use silent building on Unix-like operating systems. 2. Add screenshot to README.md. 3. Makefile.am: Add autogen.sh to EXTRA_DIST. Changes in version 5.4.1, 09/11/2014 ==================================== This is a minor new release, the API and ABI are backwards compatible. 1. Fixed a bug in the configure.ac script which used SIEVESIZE=0 instead of SIEVESIZE=32 on QEMU virtual machines. 2. Introduce patch version (3rd version number) in order not to increase the minor version for bug fix only releases. Changes in version 5.4, 14/09/2014 ================================== This is a minor new release which fixes two bugs in the computation of prime k-tuplets (twin primes, prime triplets, ...). 1. The primesieve::print_*() functions for prime k-tuplets have been fixed, they were broken since primesieve-5.1. https://github.com/kimwalisch/primesieve/commit/ff2fb6f7acfb7c83827803dbb09a73f4a47ab222 2. Prime 7-tuplets have been removed from primesieve (see API changes further down). Below are the two modulo 30 patterns for prime 7-tuplets: 1) 30*k + { 7, 11, 13, 17, 19, 23, 29} 2) 30*k + {29, 31, 37, 41, 43, 47, 49} Up until now primesieve only found prime 7-tuplets of the first pattern e.g. it missed 5610 + {29, 31, ...}. Unfortunately this bug cannot be fixed because of implementation constraints. Thus I have decided to completely remove prime 7-tuplets from primesieve. C++ API changes --------------- All functions related to prime 7-tuplets have been removed: uint64_t primesieve::print_septuplets(uint64_t start, uint64_t stop); uint64_t primesieve::count_septuplets(uint64_t start, uint64_t stop); uint64_t primesieve::parallel_count_septuplets(uint64_t start, uint64_t stop); C API changes ------------- All functions related to prime 7-tuplets have been removed: uint64_t primesieve_print_septuplets(uint64_t start, uint64_t stop); uint64_t primesieve_count_septuplets(uint64_t start, uint64_t stop); uint64_t primesieve_parallel_count_septuplets(uint64_t start, uint64_t stop); Changes in version 5.3, 06/07/2014 ================================== This is a minor new release with an important bug fix and improved documentation, the API and ABI are backwards compatible. 1. Fix use of uninitialized variable bug in primesieve::iterator: https://github.com/kimwalisch/primesieve/commit/006d572ea8fa4958eaf46c1db24c983b1ce27e1b 2. README.md update: Explain how to build from master-branch. 3. New file HACKING.md: Explains source tree, useful for developers. Changes in version 5.2, 13/04/2014 ================================== 1. Added backwards nth prime search, if n < 0 primesieve::nth_prime(int64_t n, uint64_t start); will find the nth prime < start. 2. Faster nth prime implementation, more accurate guessing of the nth prime gives up to 20% speed up if n < 10^8. 3. Added continuous integration testing with Travis (travis-ci.org), files: .travis.yml, Readme.md (shows build status). API changes!!! In order to be compatible with other mathematical software like Mathematica, Maple and SymPy the functions below have been modified to return a prime > start (or < start), previously these functions returned a prime >= start (or <= start). uint64_t primesieve::nth_prime(int64_t n, uint64_t start); uint64_t primesieve::iterator::next_prime(); uint64_t primesieve::iterator::previous_prime(); Changes in version 5.1, 14/02/2014 ================================== primesieve-5.1 is a minor new release with mostly bug fixes. There is also one API change in the C bindings documented further down. 1. and are now compatible with , fixed CALLBACK and max() issues. 2. Fixed bug in primesieve::iterator::previous_prime(). 3. Fixed bug in primesieve_previous_prime(). 4. Added stop_hint optimization to primesieve::iterator which gives a significant speed up if only few primes are generated. 5. Replaced GENERATE_PRIMES() macro by templatized callbackPrimes() method (src/primesieve/PrimeFinder.cpp). C bindings API change: void primesieve_skipto(primesieve_iterator* pi, uint64_t start, uint64_t stop_hint); The signature of the primesieve_skipto() function has changed, a new 'stop_hint' parameter has been added. Please refer to http://primesieve.org/api/primesieve__iterator_8h.html for more information. Changes in version 5.0, 11/01/2014 ================================== primesieve-5.0 is a major new release that makes using the primesieve library much more convenient. primesieve now includes C bindings for all of its functions so that it can easily be used in languages other than C++. I moved primesieve's build system to GNU Autotools and Libtool which is more reliable than the hand written Makefile I used previously. primesieve-5.0 features a new API completely written from scratch that is easier to use and that will not break binary compatibility with every new release. The new API is not backwards compatible but porting your code to the new API should be done quickly. You can explore primesieve's new API online at: http://primesieve.org/api. I bought a domain for primesieve and moved primesieve's repository from Google Code (SVN) to GitHub (git): http://primesieve.org http://github.com/kimwalisch/primesieve Other changes: 1. New primesieve::iterator class that provides next_prime() and previous_prime() methods. 2. ParallelPrimeSieve now uses multi-threading by default, it does not care about arithmetic order anymore. Please do not use ParallelPrimeSieve directly anymore instead use the new API. 3. Renamed src/soe to src/primesieve. 4. Renamed PrimeSieveCallback class to Callback. 5. Moved most header files to include/primesieve. Changes in version 4.4, 19/09/2013 ================================== This is a minor release whose sole purpose is to fix a bug in the Makefile which is required for integrating primesieve into Sage (http://www.sagemath.org). 1. Fixed the following bug: $ make shared && make install PREFIX=/user-path 2. PrimeSieve does not throw an exception anymore if (start > stop) instead it simply ignores the invalid input. 3. `make SHARED=yes` has been deprecated, use `make shared` instead. Changes in version 4.3, 05/07/2013 ================================== This release improves primesieve as a library and adds an algorithm to find the nth prime. The API of primesieve 4.3 is backwards compatible but the ABI is not (you must recompile your application if you want to link against a shared libprimesieve 4.3). 1. Support for storing primes in C++ vectors: PrimeSieve::generatePrimes (start, stop, std::vector*); PrimeSieve::generate_N_Primes(start, n, std::vector*); 2. New algorithm to find the nth prime: PrimeSieve::nthPrime(n); PrimeSieve::nthPrime(start, n); 3. The Makefiles now build primesieve and a static libprimesieve by default. A shared libprimesieve can be built using: $ make shared 4. Added a header for this commonly used exception to abort sieving. 5. Updated the documentation files: INSTALL, doc/API, doc/EXAMPLES doc/LIBPRIMESIEVE, doc/FAQ 6. Updated the source code examples in ./examples. 7. Added the scripts/install_primesieve.sh shell script that automatically downloads, builds and installs the latest primesieve and libprimesieve version. Changes in version 4.2, 10/03/2013 ================================== 1. libprimesieve generates (callback) primes up to 5% faster on little-endian CPUs (x86, x86-64) due to improved endiansafe_cast.h (src/soe). 2. The best pre-sieve setting is now automatically chosen at runtime, this speeds up sieving small intervals. 3. The Makefile now supports the Solaris OS. 4. Updated documentation: README, INSTALL, doc/EXAMPLES, doc/FAQ and doc/LIBPRIMESIEVE. New files: AUTHORS and THANKS. 5. Fixed a bug in the primesieve GUI code (doc/BUGS). 6. Updated ExpressionParser.h (src/apps/*) to version 2.5. 7. Added more example programs: examples/store_primes_in_vector.cpp and examples/nth_prime.cpp. 8. Lots of refactoring to make the code easier to understand. API changes ----------- The undocumented pre-sieve methods have been removed (pre-sieving is now automatically configured at runtime). void PrimeSieve::getPreSieve(); void PrimeSieve::setPreSieve(int); Changes in version 4.1, 12/01/2013 ================================== 1. New PrimeSieveCallback interface class that simplifies prime number generation with classes, see doc/EXAMPLES. 2. The primesieve console (terminal) application now supports GNU-style long options e.g. --size=256. 3. Fixed a bug (for sizeof(int) > 4) in the bit population count algorithm, read BUGS file. 4. Updated files: README, INSTALL, doc/EXAMPLES. 5. The Makefile now uses the system's default C++ compiler instead of GNU g++ which makes it more portable. 6. The primesieve_error class has been moved into its own file src/soe/primesieve_error.h (previously PrimeSieve.h). API changes ----------- The following two overly complex PrimeSieve methods have been removed: void PrimeSieve::generatePrimes(uint32_t start, uint32_t stop, void (*)(uint32_t, void*), void*); void PrimeSieve::generatePrimes(uint64_t start, uint64_t stop, void (*)(uint64_t, void*), void*); They are replaced by the following two new methods that greatly simplify prime number generation with classes, please refer to doc/EXAMPLES for more information. void PrimeSieve::generatePrimes(uint32_t start, uint32_t stop, PrimeSieveCallback*); void PrimeSieve::generatePrimes(uint32_t start, uint32_t stop, PrimeSieveCallback*); Changes in version 4.0, 18/10/2012 ================================== primesieve 4.0 is a major new release. A lot of work has been put into documentation and improving primesieve as a library. The API of primesieve 4.0 is backward incompatible with primesieve 3.*, the few changes are documented further down. 1. Added support for OpenMP 2.*, useful for compilers that do not support OpenMP >= 3.0, e.g. MSVC, Apple g++. 2. New examples directory with 12 simple example programs. 3. New doc/API file that lists the public member functions of the PrimeSieve and ParallelPrimeSieve C++ classes. 4. The Makefile is now POSIX compatible, it works with any POSIX shell e.g. sh, bash, ash, ksh, zsh, ... 5. The Makefile now supports MinGW (with MSYS) and Cygwin. 6. Fixed a shared libprimesieve bug (read doc/BUGS). 7. Up to 10 percent faster prime number generation due to new internal 64-bit getNextPrime() (previously 32-bit). 8. New unsynchronized ParallelPrimeSieve::generatePrimes() method that calls back primes in parallel (read EXAMPLES). 9. Faster thread synchronization in ParallelPrimeSieve, replaced slow OpenMP critical directive with faster omp_test_lock(). 10. Optimized prime k-tuplet (twin primes, ...) counting for out-of-order CPUs (src/soe/PrimeNumberFinder.cpp). 11. New primesieve_error() exception used for all exceptions within PrimeSieve and ParallelPrimeSieve (read EXAMPLES). 12. New pre-sieve code (src/soe/PreSieve.cpp). 13. Ported the primesieve GUI application from Qt 4 to Qt 5. API changes ----------- The PrimeSieve 3.* count methods: uint64_t getPrimeCount(uint64_t start, uint64_t stop); uint64_t getTwinCount (uint64_t start, uint64_t stop); ... Have been renamed to: uint64_t countPrimes (uint64_t start, uint64_t stop); uint64_t countTwins (uint64_t start, uint64_t stop); uint64_t countTriplets (uint64_t start, uint64_t stop); uint64_t countQuadruplets(uint64_t start, uint64_t stop); uint64_t countQuintuplets(uint64_t start, uint64_t stop); uint64_t countSextuplets (uint64_t start, uint64_t stop); uint64_t countSeptuplets (uint64_t start, uint64_t stop); Changes in version 3.8, 13/07/2012 ================================== 1. Improved OOP design of WheelFactorization.h. 2. Minor speed up for big sieving primes ~2% (src/soe/EratBig.cpp), reduced the number of operations in the main sieving loop. 3. Minor speed up for small sieving primes ~3% (src/soe/EraSmall.cpp), new inner sieving loop without instruction dependencies that uses only 12 asm instructions (previously 16). 4. Improved OpenMP load balance in src/soe/ParallelPrimeSieve.cpp. 5. Improved code readability of EratSmall.cpp, EratMedium.cpp, EratBig.cpp, SieveOfEratosthenes.cpp and others. 6. The Makefile now automatically detects the CPU's L1 data cache size on Unix-like OSes (Linux, Mac OS X). 7. Renamed ./docs to ./doc 8. Revised README.txt, added 7. Motivation. 9. Updated INSTALL, LIBPRIMESIEVE and EXAMPLES. 10. Added version #defines to PrimeSieve.h, e.g. for this release: #define PRIMESIEVE_VERSION "3.8" #define PRIMESIEVE_MAJOR_VERSION 3 #define PRIMESIEVE_MINOR_VERSION 8 #define PRIMESIEVE_YEAR 2012 Changes in version 3.7, 31/05/2012 ================================== 1. More aggressive inlining (*-inline.h), up to 10 percent faster prime number generation, up to 20 percent faster initialization. 2. Reduced header file dependencies, libprimesieve now only depends on PrimeSieve.h or ParallelPrimeSieve.h (and PrimeSieve.h). 3. Updated Makefiles. 4. New template imath.h functions: isqrt(), ilog2(), isPowerOf2(), ... isqrt() has been rewritten using Newton's algorithm in order to avoid rounding errors of (int)sqrt((double)n) if n > 10^15. 5. New internal SieveOfEratosthenes::getNextPrime(...) member function. 6. Replaced old C-style comments with C++ comments. 7. Updated ExpressionParser to version 2.2. 8. uin32_t has been replaced by uint_t in src/soe/*. 9. New int API for PrimeSieve and ParallelPrimeSieve objects, getters and setters now use int instead of uint32_t. 10. Updated documentation files: README, INSTALL, LIBPRIMESIEVE, EXAMPLES, VALGRIND, TODO, BUGS. Changes in version 3.6, 22/04/2012 ================================== 1. Improved code readability and updated source code documentation (src/soe directory). 2. Removed unused source code. The deprecated API of PrimeSieve <= 3.4 is not supported anymore, use PrimeSieve::getStart() instead of PrimeSieve::getStartNumber() ... The file EXAMPLES contains the up-to-date API. 3. src/soe/EratSmall.cpp has been enhanced to better take advantage of Instruction-Level Parallelism. Changes in version 3.5, 07/02/2012 ================================== 1. Bug fix for big-endian CPUs (PowerPC, SPARC), see docs/BUGS. 2. The GNU Makefile now provides an option to build primesieve as a shared library e.g. `make lib SHARED=yes`. 3. I have rewritten the main documentation files docs/LIBPRIMESIEVE and docs/EXAMPLES. 4. I have added convenience functions to the PrimeSieve class: void printPrimes (uint64_t start, uint64_t stop); void printTwins (uint64_t start, uint64_t stop); void printTriplets (uint64_t start, uint64_t stop); void printQuadruplets(uint64_t start, uint64_t stop); void printQuintuplets(uint64_t start, uint64_t stop); void printSextuplets (uint64_t start, uint64_t stop); void printSeptuplets (uint64_t start, uint64_t stop); uint64_t getPrimeCount (uint64_t start, uint64_t stop); uint64_t getTwinCount (uint64_t start, uint64_t stop); uint64_t getTripletCount (uint64_t start, uint64_t stop); uint64_t getQuadrupletCount(uint64_t start, uint64_t stop); uint64_t getQuintupletCount(uint64_t start, uint64_t stop); uint64_t getSextupletCount (uint64_t start, uint64_t stop); uint64_t getSeptupletCount (uint64_t start, uint64_t stop); void sieve(uint64_t start, uint64_t stop); void sieve(uint64_t start, uint64_t stop, uint32_t flags); void sieve(); 5. src/soe/ParallelPrimeSieve.cpp has been rewritten using OpenMP 3.0 (previously OpenMP 2.0). The new OpenMP code is more elegant and scales better when lots of threads (> 32) are used. Compiler notes: OpenMP is now disabled by default for the Microsoft Visual C++ compiler as it currently only supports OpenMP 2.0. Some compilers e.g. g++ 4.2 even build primesieve with OpenMP <= 2.5 but the resulting binary miscalculates when sieving > 2^63. 6. Helper classes and functions within src/soe are now defined in the the newly introduced soe namespace. This makes PrimeSieve more usable as a library. 7. The header file src/soe/defs.h has been renamed to config.h and its code readability has been improved. 8. The code of src/console/test.cpp has been simplified. Changes in version 3.4, 05/01/2012 ================================== 1. I implemented a new algorithm for medium sieving primes that is up to 20 percent faster on todays out-of-order CPUs, see src/soe/EratMedium.cpp. 2. I adapted the constants in defs.h due to the new EratMedium algorithm, the maximum sieveSize is now 4096 kilobytes (previously 2048 kilobytes). 3. I revised the Makefiles and INSTALL file. 4. Added docs/LIBPRIMESIEVE and updated README and docs/EXAMPLES. Changes in version 3.3, 19/12/2011 ================================== 1. Minor optimizations in src/soe/EratBig.cpp (2% speed up). 2. Improved code readability and documentation of src/soe/ParallelPrimeSieve.cpp. 3. The sieveSize must be <= 2048 kilobytes now (previously 8192), this makes the WheelFactorization.h & EratBase.h code easier to understand. Changes in version 3.2, 13/11/2011 ================================== 1. Fixed a bug in src/soe/ParallelPrimeSieve.cpp, see ../docs/BUGS. 2. Added 32-bit prime number generation methods to PrimeSieve. 3. Added a PrimeSieve::cancel_sieving exception that allows to cancel sieving at run time (see docs/EXAMPLES). 4. ParallelPrimeSieve is now able to generate prime numbers using multiple threads (previously only multi-threaded counting). 5. The code readability and documentation of WheelFactorization.h/.cpp has been improved (e.g. renamed sieveIndex to multipleIndex). 6. PreSieve now initializes its preSieved_ array using a 2nd wheel (modulo 6), up to 40 percent faster. 7. I introduced a 'loopLimit' variable in EratSmall that saves some calculations and reduces the code size. 8. Added a testFlags(uint32_t) convenience function to PrimeSieve. 9. EratMedium has been simplified, it runs faster than v. 3.1 using Intel C++ 12.0 but slightly slower with most other compilers. Changes in version 3.1, 24/10/2011 ================================== 1. EratBig::sieve(uint8_t*) now processes multiple sieving primes per iteration, I measured a speed up of about 6 percent near 1E18. 2. STL containers are now used instead of dynamic memory allocation in Erat(Small|Medium) which improves multi-threading performance ~ 3%. 3. The Bucket data structure (WheelFactorization.h) has been modified and it performs well now with more compilers. 4. EratMedium has been simplifed, the new code is far easier to understand and it is faster with the GNU g++ compiler. 5. Fixed an integer overflow bug in EratMedium.cpp (see BUGS file). 6. The -test option (primesieve console) has been reviewed. 7. I improved the code readability and code documentation, the README and INSTALL files have also been revised. Changes in version 3.0, 09/07/2011 ================================== 1. The source code is now licensed under the New BSD License (previously GPL). 2. The source code is now standard C++03 and ISO C99 (stdint.h), i.e. I removed all compiler intrinsics and built-in functions: 80386 BSF, cpuid, SSE4.2 POPCNT. 3. The thread scheduling of ParallelPrimeSieve has been improved, 10 percent speed up. 4. Prime numbers are now generated using bitScanForward() instead of lookup tables, 10 percent speed up. 5. Implemented a fast bit population count function, see popcount_lauradoux() in bithacks.h. 6. Revised the option handling in the console version of primesieve, added two new options: -o and -r 7. README has been rewritten from scratch. 8. Improved the code readability and revised the comments of the sieve of Eratosthenes implementation. 9. ResetSieve has been renamed to PreSieve. Changes in version 2.2, 26/05/2011 ================================== 1. Added the file docs/EXAMPLES which shows how to use PrimeSieve and ParallelPrimeSieve objects. 2. Fixed 4 minor bugs (see BUGS). 3. 10% initialization speedup due to enhancement in ModuloWheel::setWheelPrime(uint64_t, uint32_t*, uint32_t*, uint32_t*) 4. Added prime number generation functions and a convenience function to count prime numbers to PrimeSieve. 5. The thread interface of ParallelPrimeSieve has been simplified. 6. The code now compiles and runs with the sunCC compiler. 7. The code readability has been improved. 8. The documentation has been updated. Changes in version 2.1, 11/04/2011 ================================== 1. Fixed a start number bug (read doc/BUGS). 2. Now supports integer arithmetic expressions as number input. 3. Uses OpenMP instead of processes. 4. Added qt-gui/README file. 5. Fixed a bug in the Makefile (clang++ compiler). 6. Updated the README file. Changes in version 2.0, 15/02/2011 ================================== 1. Added soe/ParallelPrimeSieve.cpp which counts primes in parallel using OpenMP. 2. Added an arithmetic expression parser (./expr) to ease number input. 3. Added a test suite to the console version of primesieve (option: -test) which runs various correctness tests. 4. The console version has been reviewed and is first released. 5. Fixed a minor bug in soe/PrimeNumberFinder.cpp which counts and prints the prime preceding the start number (see BUGS file). 6. Improved the memory pool of soe/EratBig.cpp, primesieve 1.0 ran into trouble when sieving near 2^64. 7. Makefile modified to better support GCC compatible compilers, e.g. make CXX=x86_64-w64-mingw32-g++ primesieve-5.6.0/HACKING.md000066400000000000000000000041411263266076300152730ustar00rootroot00000000000000Hacking on primesieve ===================== Benchmark your code changes: ```sh $ ./primesieve 1e13 --dist=1e11 ``` Fix all warnings: ```sh $ make clean $ make CXXFLAGS="-Wall -Wextra -Werror -Wno-long-long -pedantic -O2" ``` Run integration tests: ```sh $ make check ``` ### Where the source code lives * The sieve of Eratosthenes implementation lives in [src/primesieve](src/primesieve) * The sieve of Eratosthenes header files live in [include/primesieve](include/primesieve) * The primesieve console application lives in [src/apps/console](src/apps/console) * The primesieve GUI application (uses Qt framework) lives in [src/apps/gui](src/apps/gui) ### Adding a new source file * Add new cpp file to [src/primesieve](src/primesieve) * Add its header file to [include/primesieve](include/primesieve) * Add source and header files to [Makefile.am](Makefile.am) and [Makefile.msvc](Makefile.msvc) * Add source file to [src/apps/gui/primesieve.pro](src/apps/gui/primesieve.pro) ### Versioning * Increase version number in [include/primesieve.hpp](include/primesieve.hpp) * Increase version number in [include/primesieve.h](include/primesieve.h) * Increase version number in [configure.ac](configure.ac) in ```AC_INIT``` * [Increase Libtool version](http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html) number in [configure.ac](configure.ac) in ```AC_SUBST``` * Update current year in [src/apps/console/help.cpp](src/apps/console/help.cpp) * Update current year in [src/apps/gui/src/PrimeSieveGUI_const.hpp](src/apps/gui/src/PrimeSieveGUI_const.hpp) ### Release process * Run tests using ```make check``` * Increase version number (see Versioning) * Update [ChangeLog](ChangeLog) * Tag the new release in git * Build statically linked primesieve binaries and upload them to [https://bintray.com/kimwalisch/primesieve](https://bintray.com/kimwalisch/primesieve) * Create new release tarball using ```make dist``` and upload it to [https://bintray.com/kimwalisch/primesieve](https://bintray.com/kimwalisch/primesieve) * Update http://primesieve.org * Update http://primesieve.org/api primesieve-5.6.0/Makefile.am000066400000000000000000000112101263266076300157340ustar00rootroot00000000000000AM_CPPFLAGS = -I$(top_srcdir)/include lib_LTLIBRARIES = libprimesieve.la libprimesieve_la_CXXFLAGS = $(OPENMP_CXXFLAGS) libprimesieve_la_LDFLAGS = -version-info @primesieve_lib_version@ if FORCE_SHARED_LIBRARY libprimesieve_la_LDFLAGS += -no-undefined endif bin_PROGRAMS = primesieve primesieve_LDADD = libprimesieve.la pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = primesieve.pc if MAKE_EXAMPLES noinst_PROGRAMS = callback_cancel callback_cancel_LDADD = libprimesieve.la callback_cancel_SOURCES = examples/cpp/callback_cancel.cpp noinst_PROGRAMS += callback_primes callback_primes_LDADD = libprimesieve.la callback_primes_SOURCES = examples/cpp/callback_primes.cpp noinst_PROGRAMS += callback_primes_oop callback_primes_oop_LDADD = libprimesieve.la callback_primes_oop_SOURCES = examples/cpp/callback_primes_oop.cpp noinst_PROGRAMS += count_primes count_primes_LDADD = libprimesieve.la count_primes_SOURCES = examples/cpp/count_primes.cpp noinst_PROGRAMS += primesieve_iterator primesieve_iterator_LDADD = libprimesieve.la primesieve_iterator_SOURCES = examples/cpp/primesieve_iterator.cpp noinst_PROGRAMS += nth_prime nth_prime_LDADD = libprimesieve.la nth_prime_SOURCES = examples/cpp/nth_prime.cpp noinst_PROGRAMS += previous_prime previous_prime_LDADD = libprimesieve.la previous_prime_SOURCES = examples/cpp/previous_prime.cpp noinst_PROGRAMS += store_primes_in_vector store_primes_in_vector_LDADD = libprimesieve.la store_primes_in_vector_SOURCES = examples/cpp/store_primes_in_vector.cpp noinst_PROGRAMS += count_primes_c count_primes_c_LDADD = libprimesieve.la count_primes_c_SOURCES = examples/c/count_primes.c noinst_PROGRAMS += previous_prime_c previous_prime_c_LDADD = libprimesieve.la previous_prime_c_SOURCES = examples/c/previous_prime.c noinst_PROGRAMS += primesieve_iterator_c primesieve_iterator_c_LDADD = libprimesieve.la primesieve_iterator_c_SOURCES = examples/c/primesieve_iterator.c noinst_PROGRAMS += nth_prime_c nth_prime_c_LDADD = libprimesieve.la nth_prime_c_SOURCES = examples/c/nth_prime.c noinst_PROGRAMS += store_primes_in_array_c store_primes_in_array_c_LDADD = libprimesieve.la store_primes_in_array_c_SOURCES = examples/c/store_primes_in_array.c endif # Additional files to be deleted by 'make distclean' DISTCLEANFILES = \ doxygen/Doxyfile include_HEADERS = \ include/primesieve.hpp \ include/primesieve.h otherincludedir = $(includedir)/primesieve otherinclude_HEADERS = \ include/primesieve/Callback.hpp \ include/primesieve/cancel_callback.hpp \ include/primesieve/iterator.hpp \ include/primesieve/ParallelPrimeSieve.hpp \ include/primesieve/primesieve_error.hpp \ include/primesieve/PrimeSieve.hpp \ include/primesieve/primesieve_iterator.h \ include/primesieve/PushBackPrimes.hpp EXTRA_DIST = \ autogen.sh \ README.md \ Makefile.msvc \ doc/Doxyfile.in \ doc/README.md \ doc/mainpage.dox \ examples/README.md \ src/apps/gui \ src/msvc_compat \ src/primesieve/README libprimesieve_la_SOURCES = \ src/primesieve/EratBig.cpp \ src/primesieve/EratMedium.cpp \ src/primesieve/EratSmall.cpp \ src/primesieve/ParallelPrimeSieve.cpp \ src/primesieve/popcount.cpp \ src/primesieve/PreSieve.cpp \ src/primesieve/PrimeFinder.cpp \ src/primesieve/PrimeGenerator.cpp \ src/primesieve/iterator.cpp \ src/primesieve/primesieve_iterator.cpp \ src/primesieve/primesieve_test.cpp \ src/primesieve/PrimeSieve-nthPrime.cpp \ src/primesieve/PrimeSieve.cpp \ src/primesieve/primesieve-api.cpp \ src/primesieve/primesieve-api-c.cpp \ src/primesieve/SieveOfEratosthenes.cpp \ src/primesieve/WheelFactorization.cpp \ include/primesieve/bits.hpp \ include/primesieve/callback_t.hpp \ include/primesieve/config.hpp \ include/primesieve/EratBig.hpp \ include/primesieve/EratMedium.hpp \ include/primesieve/EratSmall.hpp \ include/primesieve/malloc_vector.hpp \ include/primesieve/pmath.hpp \ include/primesieve/littleendian_cast.hpp \ include/primesieve/ParallelPrimeSieve-lock.hpp \ include/primesieve/PreSieve.hpp \ include/primesieve/PrimeFinder.hpp \ include/primesieve/PrimeGenerator.hpp \ include/primesieve/PrimeSieve-lock.hpp \ include/primesieve/SieveOfEratosthenes.hpp \ include/primesieve/SieveOfEratosthenes-inline.hpp \ include/primesieve/toString.hpp \ include/primesieve/WheelFactorization.hpp primesieve_SOURCES = \ src/apps/console/main.cpp \ src/apps/console/help.cpp \ src/apps/console/cmdoptions.cpp \ src/apps/console/cmdoptions.hpp \ src/apps/console/calculator.hpp check: all ./primesieve --test # If installation directory is /usr/local/lib # execute ldconfig after installation install-exec-hook: test "$(prefix)" = "/usr/local" && command -v ldconfig 2>/dev/null && ldconfig /usr/local/lib 2>/dev/null || true primesieve-5.6.0/README.md000066400000000000000000000150331263266076300151660ustar00rootroot00000000000000primesieve ========== [![Build Status](https://travis-ci.org/kimwalisch/primesieve.svg)](https://travis-ci.org/kimwalisch/primesieve) [![Build Status](https://ci.appveyor.com/api/projects/status/github/kimwalisch/primesieve?branch=master&svg=true)](https://ci.appveyor.com/project/kimwalisch/primesieve) [![GitHub license](https://img.shields.io/badge/license-BSD%202-blue.svg)](https://github.com/kimwalisch/primesieve/blob/master/COPYING) primesieve is a program and C/C++ library that generates primes using a highly optimized sieve of Eratosthenes implementation. It counts the primes below 10^10 in just 0.45 seconds on an Intel Core i7-6700 CPU (4 x 3.4GHz). primesieve can generate primes and prime k-tuplets up to 2^64. - **Homepage:** http://primesieve.org - **Binaries:** http://primesieve.org/downloads - **API:** http://primesieve.org/api ![primesieve windows screenshot](https://github.com/kimwalisch/primesieve/blob/gh-pages/screenshots/primesieve_win10.png) Algorithm complexity -------------------- primesieve generates primes using the segmented sieve of Eratosthenes with [wheel factorization](http://en.wikipedia.org/wiki/Wheel_factorization), this algorithm has a complexity of operations and uses space. More precisely primesieve's memory usage per thread is about bytes. Requirements ------------ primesieve is very portable, it compiles with every C++ compiler and runs on most CPU architectures out there. The parallelization is implemented using [OpenMP](http://en.wikipedia.org/wiki/OpenMP). The primesieve GUI application (not built by default) uses the [Qt framework](http://qt-project.org). primesieve is also a library, it supports C++ and C directly and there are [bindings](#bindings-for-other-languages) available for a few other programming languages. The author's [primecount](https://github.com/kimwalisch/primecount) program uses libprimesieve extensively. Build instructions (Unix-like OSes) ----------------------------------- Download the latest release tarball from http://primesieve.org/downloads, extract it and cd into the newly created directory. Then build and install primesieve using: ```sh $ ./configure $ make $ sudo make install ``` If you have downloaded a zip archive from GitHub then Autotools (a.k.a. GNU Build System) must be installed and ```autogen.sh``` must be executed once. To install Autotools install [GNU Autoconf](http://www.gnu.org/software/autoconf/), [GNU Automake](http://www.gnu.org/software/automake/) and [GNU Libtool](http://www.gnu.org/software/libtool/) using your operating system's package manager. ```sh $ ./autogen.sh $ ./configure $ make $ sudo make install ``` To enable building the example programs use: ```sh $ ./configure --enable-examples ``` Build instructions (Microsoft Visual C++) ----------------------------------------- Open a Visual Studio Command Prompt, cd into the primesieve directory and run: ```sh > nmake -f Makefile.msvc ``` In order to get the best performance you can indicate your CPU's L1 data cache size in kilobytes per core (default 32), e.g. for a CPU with 64 kilobytes L1 data cache use: ```sh > nmake -f Makefile.msvc L1_DCACHE_SIZE=64 ``` To build the example programs use: ```sh > nmake -f Makefile.msvc > nmake -f Makefile.msvc examples ``` Console application ------------------- The primesieve console application can print and count primes and prime k-tuplets and find the nth prime. ```sh # Print the primes below 1000000 $ primesieve 1000000 --print # Print the twin primes below 1000000 $ primesieve 1000000 --print=2 # Count the primes below 1e10 using all CPU cores $ primesieve 1e10 --count # Count the primes within [1e10, 2e10] using 4 threads $ primesieve 1e10 2e10 --count --threads=4 # Print an option summary $ primesieve --help ``` C++ API ------- After having installed primesieve you can easily use it in your C++ program, below is an example. primesieve's API is documented online at http://primesieve.org/api. ```C++ #include #include #include int main() { // store the primes below 1000 std::vector primes; primesieve::generate_primes(1000, &primes); primesieve::iterator pi; uint64_t prime; // iterate over the primes below 10^9 while ((prime = pi.next_prime()) < 1000000000) std::cout << prime << std::endl; return 0; } ``` C API ----- All of primesieve's functions are exposed as C API (C99 or later) via the ```primesieve.h``` header. You can browse primesieve's C API online at http://primesieve.org/api. ```C #include #include #include int main() { uint64_t start = 0; uint64_t stop = 10000; size_t i; size_t size; /* get an array with primes below 10000 */ int* primes = (int*) primesieve_generate_primes(start, stop, &size, INT_PRIMES); for (i = 0; i < size; i++) printf("%i\n", primes[i]); /* deallocate primes array generated using primesieve */ primesieve_free(primes); return 0; } ``` Linking against libprimesieve ----------------------------- **Unix-like operating systems** ```sh $ c++ -O2 primes.cpp -lprimesieve $ cc -O2 primes.c -lprimesieve ``` Note that if you have built primesieve yourself the default installation path is ```/usr/local/lib``` which is not part of ```LD_LIBRARY_PATH``` on many systems. Hence you need to export some additional environment variables: ```sh $ export LIBRARY_PATH=/usr/local/lib:$LIBRARY_PATH $ export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH $ export CPLUS_INCLUDE_PATH=/usr/local/include:$CPLUS_INCLUDE_PATH $ export C_INCLUDE_PATH=/usr/local/include:$C_INCLUDE_PATH ``` **Microsoft Visual C++ (Windows)** ``` > cl /O2 /EHsc primes.cpp /I primesieve\include /link primesieve\primesieve.lib ``` Bindings for other languages ---------------------------- primesieve supports C++ and C directly, and has bindings available for a few other languages:
Python: primesieve-python
Ruby: primesieve-ruby
Many thanks to the developers of these bindings! primesieve-5.6.0/autogen.sh000077500000000000000000000013041263266076300157040ustar00rootroot00000000000000#!/bin/sh mkdir -p m4 || exit $? autoreconf --install || exit $? # This code patches ltmain.sh if GNU Libtool version < 2.4.2 # so that it correctly links in OpenMP if required command -v libtool >/dev/null 2>/dev/null if [ $? -eq 0 ] then libtool_version=$(libtool --version 2>/dev/null | head -n1 2>/dev/null | sed 's/[^0-9.]*\([0-9.]*\).*/\1/' 2>/dev/null) if [ "x$libtool_version" != "x" ]; then is_patch=$(echo $libtool_version 2.4.2 | awk '{print ($1 < $2)}' 2>/dev/null) if [ "$is_patch" = "1" ]; then sed 's/|-threads)/-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp)/g' ltmain.sh > ltmain2.sh mv -f ltmain2.sh ltmain.sh fi fi fi primesieve-5.6.0/configure.ac000066400000000000000000000071151263266076300161770ustar00rootroot00000000000000AC_INIT([primesieve], [5.6.0], [kim.walisch@gmail.com]) AC_SUBST([primesieve_lib_version], [6:0:0]) AC_PREREQ([2.62]) AC_LANG([C++]) AC_CONFIG_MACRO_DIR([m4]) AM_INIT_AUTOMAKE([subdir-objects foreign -Wall -Werror]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) AC_PROG_CC AC_PROG_CXX AC_OPENMP AC_CANONICAL_HOST # Silence warning: ar: 'u' modifier ignored since 'D' is the default AC_SUBST(AR_FLAGS, [cr]) AM_PROG_AR # Needed for automake <= 1.13 AM_PROG_CC_C_O LT_INIT # Check if graphviz is installed (for use with doxygen) AC_CHECK_PROG([HAVE_DOT], [dot], [YES], [NO]) AC_ARG_ENABLE(examples, [--enable-examples Compile the examples programs], ENABLE_EXAMPLES="yes") AM_CONDITIONAL(MAKE_EXAMPLES, test "x$ENABLE_EXAMPLES" = "xyes") # Force building shared library on Windows # Reference: case "$host_os" in cygwin*) AM_CONDITIONAL(FORCE_SHARED_LIBRARY, true);; mingw*) AM_CONDITIONAL(FORCE_SHARED_LIBRARY, true);; *) AM_CONDITIONAL(FORCE_SHARED_LIBRARY, false);; esac AC_ARG_VAR([L1_DCACHE_SIZE], [CPU L1 data cache size in kilobytes]) AS_IF([test "x$L1_DCACHE_SIZE" != "x"], [L1_DETECTED="yes"]) # This is a very portable shell script that finds the CPU's L1 # cache size (in kilobytes) on most Unix-like systems AS_IF([test "x$L1_DCACHE_SIZE" = "x"], [[ # Default L1 cache size L1_DCACHE_SIZE=32 command -v getconf >/dev/null 2>/dev/null if [ $? -eq 0 ]; then # Returns L1 cache size in bytes L1_DCACHE_BYTES=$(getconf LEVEL1_DCACHE_SIZE 2>/dev/null) fi if test "x$L1_DCACHE_BYTES" = "x" || test "$L1_DCACHE_BYTES" = "0"; then # Returns L1 cache size like e.g. 32K, 1M L1_DCACHE_BYTES=$(cat /sys/devices/system/cpu/cpu0/cache/index0/size 2>/dev/null) if test "x$L1_DCACHE_BYTES" != "x"; then is_kilobytes=$(echo $L1_DCACHE_BYTES | grep K) if test "x$is_kilobytes" != "x"; then L1_DCACHE_BYTES=$(expr $(echo $L1_DCACHE_BYTES | sed -e s'/K$//') '*' 1024) fi is_megabytes=$(echo $L1_DCACHE_BYTES | grep M) if test "x$is_megabytes" != "x"; then L1_DCACHE_BYTES=$(expr $(echo $L1_DCACHE_BYTES | sed -e s'/M$//') '*' 1024 '*' 1024) fi else command -v sysctl >/dev/null 2>/dev/null if [ $? -eq 0 ]; then # Returns L1 cache size in bytes L1_DCACHE_BYTES=$(sysctl hw.l1dcachesize 2>/dev/null | sed -e 's/^.* //') fi fi fi if test "x$L1_DCACHE_BYTES" != "x"; then if [ $L1_DCACHE_BYTES -ge 2048 2>/dev/null ]; then # Convert L1 cache size to kilobytes L1_DCACHE_SIZE=$(expr $L1_DCACHE_BYTES '/' 1024) L1_DETECTED="yes" fi fi]]) AC_DEFINE_UNQUOTED([L1_DCACHE_SIZE], [$L1_DCACHE_SIZE], [CPU L1 data cache size in kilobytes]) AC_ARG_VAR([SIEVESIZE], [Default sieve size in kilobytes]) AS_IF([test "x$SIEVESIZE" = "x"], [SIEVESIZE=$L1_DCACHE_SIZE]) AC_DEFINE_UNQUOTED([SIEVESIZE], [$SIEVESIZE], [Default sieve size in kilobytes]) AC_CONFIG_HEADERS([config.h]) AC_CONFIG_FILES([Makefile primesieve.pc doc/Doxyfile]) AC_OUTPUT AS_IF([test "x$L1_DETECTED" != "x"], [AC_MSG_NOTICE([NOTICE: using L1_DCACHE_SIZE=$L1_DCACHE_SIZE (kilobytes)])]) AS_IF([test "x$L1_DETECTED" = "x"], [AC_MSG_WARN([CPU L1 data cache size not detected, using L1_DCACHE_SIZE=$L1_DCACHE_SIZE (kilobytes)])]) AC_MSG_NOTICE([NOTICE: using SIEVESIZE=$SIEVESIZE (kilobytes)]) primesieve-5.6.0/doc/000077500000000000000000000000001263266076300144525ustar00rootroot00000000000000primesieve-5.6.0/doc/Doxyfile.in000066400000000000000000000037771263266076300166030ustar00rootroot00000000000000PROJECT_NAME = "primesieve" PROJECT_NUMBER = @PACKAGE_VERSION@ INPUT = @abs_top_srcdir@/doc/mainpage.dox \ @abs_top_srcdir@/include/primesieve.hpp \ @abs_top_srcdir@/include/primesieve.h \ @abs_top_srcdir@/include/primesieve/Callback.hpp \ @abs_top_srcdir@/include/primesieve/iterator.hpp \ @abs_top_srcdir@/include/primesieve/primesieve_error.hpp \ @abs_top_srcdir@/include/primesieve/primesieve_iterator.h \ @abs_top_srcdir@/examples/cpp/callback_primes.cpp \ @abs_top_srcdir@/examples/cpp/count_primes.cpp \ @abs_top_srcdir@/examples/cpp/primesieve_iterator.cpp \ @abs_top_srcdir@/examples/cpp/nth_prime.cpp \ @abs_top_srcdir@/examples/cpp/previous_prime.cpp \ @abs_top_srcdir@/examples/cpp/store_primes_in_vector.cpp \ @abs_top_srcdir@/examples/c/count_primes.c \ @abs_top_srcdir@/examples/c/previous_prime.c \ @abs_top_srcdir@/examples/c/primesieve_iterator.c \ @abs_top_srcdir@/examples/c/nth_prime.c \ @abs_top_srcdir@/examples/c/store_primes_in_array.c HTML_INDEX_NUM_ENTRIES = 3 HTML_TIMESTAMP = NO JAVADOC_AUTOBRIEF = YES MULTILINE_CPP_IS_BRIEF = NO SHOW_NAMESPACES = YES VERBATIM_HEADERS = NO EXTRACT_ALL = NO EXTRACT_STATIC = YES FILE_PATTERNS = *.cpp *.c *.h *.hpp EXCLUDE_SYMBOLS = primesieve_generate_next_primes \ primesieve_generate_previous_primes RECURSIVE = NO EXAMPLE_PATTERNS = *.cpp *.c EXAMPLE_PATH = @abs_top_srcdir@/examples EXAMPLE_RECURSIVE = YES GENERATE_LATEX = NO FULL_PATH_NAMES = NO HAVE_DOT = @HAVE_DOT@ primesieve-5.6.0/doc/README.md000066400000000000000000000002351263266076300157310ustar00rootroot00000000000000Build C/C++ API documentation ============================= Run the commands below from the parent directory. ```bash $ ./configure $ cd doc $ doxygen ``` primesieve-5.6.0/doc/mainpage.dox000066400000000000000000000036371263266076300167600ustar00rootroot00000000000000/// @mainpage /// @section About /// /// primesieve is a C/C++ library for fast prime number generation. It /// generates the primes below 10^9 in just 0.2 seconds on a single /// core of an Intel Core i7-6700 3.4GHz CPU. primesieve can generate /// primes and prime k-tuplets up to 2^64. primesieve's memory /// requirement is about pi(sqrt(n)) * 8 bytes per thread, its /// run-time complexity is O(n log log n) operations. For more /// information please visit http://primesieve.org. /// /// The recommended way to get started is to first have a look at a /// few C/C++ example programs. The most common use cases are storing /// primes in a vector (or array) and iterating over primes using /// next_prime() or previous_prime(). /// /// You can install libprimesieve either using your distribution's /// package manager (if it is available) or you can build and install /// it yourself, this is explained at http://primesieve.org/build.html. /// /// @section CPP_API C++ API /// /// @li @link primesieve.hpp primesieve.hpp @endlink - primesieve C++ header. /// @li @link store_primes_in_vector.cpp store_primes_in_vector.cpp @endlink - Example that shows how to store primes in a std::vector. /// @li @link primesieve_iterator.cpp primesieve_iterator.cpp @endlink - Example that shows how to iterate over primes using primesieve::iterator. /// @li @link count_primes.cpp count_primes.cpp @endlink - Example that shows how to count primes. /// /// @section C_API C API /// /// @li @link primesieve.h primesieve.h @endlink - primesieve C header. /// @li @link store_primes_in_array.c store_primes_in_array.c @endlink - Example that shows how to store primes in an array. /// @li @link primesieve_iterator.c primesieve_iterator.c @endlink - Example that shows how to iterate over primes using @link primesieve_iterator.h primesieve_iterator @endlink. /// @li @link count_primes.c count_primes.c @endlink - Example that shows how to count primes. /// primesieve-5.6.0/examples/000077500000000000000000000000001263266076300155235ustar00rootroot00000000000000primesieve-5.6.0/examples/README.md000066400000000000000000000021061263266076300170010ustar00rootroot00000000000000Example programs ================ This directory contains simple C and C++ example programs which use the primesieve library to generate primes. C++ examples ------------ Below are the most important C++ example programs. * [store_primes_in_vector.cpp](cpp/store_primes_in_vector.cpp) * [primesieve_iterator.cpp](cpp/primesieve_iterator.cpp) * [count_primes.cpp](cpp/count_primes.cpp) C examples ---------- Below are the most important C example programs. * [store_primes_in_array.c](c/store_primes_in_array.c) * [primesieve_iterator.c](c/primesieve_iterator.c) * [count_primes.c](c/count_primes.c) Build instructions (Unix-like OSes) ----------------------------------- Open a terminal and `cd' into the primesieve (parent) directory. Then run the commands below: ```sh $ ./configure --enable-examples $ make ``` Build instructions (Microsoft Visual C++) ----------------------------------------- Open a Visual Studio Command Prompt and `cd' into the primesieve (parent) directory. Then run the commands below: ```sh > nmake -f Makefile.msvc > nmake -f Makefile.msvc examples ``` primesieve-5.6.0/examples/c/000077500000000000000000000000001263266076300157455ustar00rootroot00000000000000primesieve-5.6.0/examples/c/count_primes.c000066400000000000000000000006711263266076300206240ustar00rootroot00000000000000/** @example count_primes.c * C program that shows how to count primes. */ #include #include #include int main() { uint64_t count = primesieve_count_primes(0, 1000); printf("Primes below 1000 = %" PRIu64 "\n", count); /* use multi-threading for large intervals */ count = primesieve_parallel_count_primes(0, 1000000000); printf("Primes below 10^9 = %" PRIu64 "\n", count); return 0; } primesieve-5.6.0/examples/c/nth_prime.c000066400000000000000000000005621263266076300201010ustar00rootroot00000000000000/** @example nth_prime.c * C program that finds the nth prime. */ #include #include #include #include int main(int argc, char** argv) { uint64_t n = 1000; if (argv[1]) n = atol(argv[1]); uint64_t prime = primesieve_nth_prime(n, 0); printf("%" PRIu64 "th prime = %" PRIu64 "\n", n, prime); return 0; } primesieve-5.6.0/examples/c/previous_prime.c000066400000000000000000000010611263266076300211570ustar00rootroot00000000000000/** @example previous_prime.c * Iterate backwards over primes using primesieve_iterator. */ #include #include #include int main() { primesieve_iterator pi; primesieve_init(&pi); /* primesieve_skipto(primesieve_iterator, start_number, stop_hint) */ primesieve_skipto(&pi, 2000, 1000); uint64_t prime; /* iterate backwards over the primes between 2000 and 1000 */ while ((prime = primesieve_previous_prime(&pi)) >= 1000) printf("%" PRIu64 "\n", prime); primesieve_free_iterator(&pi); return 0; } primesieve-5.6.0/examples/c/primesieve_iterator.c000066400000000000000000000007671263266076300222040ustar00rootroot00000000000000/** @example primesieve_iterator.c * Iterate over primes using C primesieve_iterator. */ #include #include #include int main() { primesieve_iterator pi; primesieve_init(&pi); uint64_t sum = 0; uint64_t prime = 0; /* iterate over the primes below 10^10 */ while ((prime = primesieve_next_prime(&pi)) < 10000000000ull) sum += prime; primesieve_free_iterator(&pi); printf("Sum of the primes below 10^10 = %" PRIu64 "\n", sum); return 0; } primesieve-5.6.0/examples/c/store_primes_in_array.c000066400000000000000000000011771263266076300225160ustar00rootroot00000000000000/** @example store_primes_in_array.c * Store primes in a C array. */ #include #include int main() { uint64_t start = 0; uint64_t stop = 1000; size_t i; size_t size; /* store the primes below 1000 */ int* primes = (int*) primesieve_generate_primes(start, stop, &size, INT_PRIMES); for (i = 0; i < size; i++) printf("%i\n", primes[i]); primesieve_free(primes); uint64_t n = 1000; /* store the first 1000 primes */ primes = (int*) primesieve_generate_n_primes(n, start, INT_PRIMES); for (i = 0; i < n; i++) printf("%i\n", primes[i]); primesieve_free(primes); return 0; } primesieve-5.6.0/examples/cpp/000077500000000000000000000000001263266076300163055ustar00rootroot00000000000000primesieve-5.6.0/examples/cpp/callback_cancel.cpp000066400000000000000000000011131263266076300220460ustar00rootroot00000000000000/// @example cancel_callback.cpp /// Cancel callback of primes by throwing a /// primesieve::cancel_callback() exception. Note that multi-threaded /// callback can currently not be cancelled this way. #include #include #include int i = 0; void callback(uint64_t prime) { if (++i == 1000000) { std::cout << "10^6th prime = " << prime << std::endl; throw primesieve::cancel_callback(); } } int main() { try { primesieve::callback_primes(0, 1000000000, callback); } catch (primesieve::cancel_callback&) { } return 0; } primesieve-5.6.0/examples/cpp/callback_primes.cpp000066400000000000000000000004561263266076300221310ustar00rootroot00000000000000/// @example callback_primes.cpp /// This example shows how to use callback functions. #include #include #include void callback(uint64_t prime) { std::cout << prime << std::endl; } int main() { primesieve::callback_primes(2, 1000, callback); return 0; } primesieve-5.6.0/examples/cpp/callback_primes_oop.cpp000066400000000000000000000007321263266076300230030ustar00rootroot00000000000000/// @example callback_primes_oop.cpp /// Objects derived from primesieve::Callback can /// be passed to the callback_primes() function. #include #include #include struct PrimeList : std::list, primesieve::Callback { void callback(uint64_t prime) { this->push_back(prime); } }; int main() { PrimeList primeList; primesieve::callback_primes(2, 1000, &primeList); return 0; } primesieve-5.6.0/examples/cpp/count_primes.cpp000066400000000000000000000007351263266076300215250ustar00rootroot00000000000000/// @example count_primes.cpp /// This example shows how to count primes. #include #include #include int main() { uint64_t count = primesieve::count_primes(0, 1000); std::cout << "Primes below 1000 = " << count << std::endl; uint64_t stop = 1000000000; // use multi-threading for large intervals count = primesieve::parallel_count_primes(0, stop); std::cout << "Primes below 10^9 = " << count << std::endl; return 0; } primesieve-5.6.0/examples/cpp/nth_prime.cpp000066400000000000000000000005451263266076300210020ustar00rootroot00000000000000/// @example nth_prime.cpp /// Find the nth prime. #include #include #include #include int main(int, char** argv) { uint64_t n = 1000; if (argv[1]) n = std::atol(argv[1]); uint64_t nth_prime = primesieve::nth_prime(n); std::cout << n << "th prime = " << nth_prime << std::endl; return 0; } primesieve-5.6.0/examples/cpp/previous_prime.cpp000066400000000000000000000005751263266076300220700ustar00rootroot00000000000000/// @example previous_prime.cpp /// This example shows how to iterate backwards over primes. #include #include int main() { primesieve::iterator pi; pi.skipto(2000); uint64_t prime; // iterate backwards over the primes between 2000 and 1000 while ((prime = pi.previous_prime()) >= 1000) std::cout << prime << std::endl; return 0; } primesieve-5.6.0/examples/cpp/primesieve_iterator.cpp000066400000000000000000000006431263266076300230750ustar00rootroot00000000000000/// @example primesieve_iterator.cpp /// Iterate over primes using a primesieve::iterator object. #include #include int main() { primesieve::iterator pi; uint64_t sum = 0; uint64_t prime; // iterate over primes below 10^10 while ((prime = pi.next_prime()) < 10000000000ull) sum += prime; std::cout << "Sum of the primes below 10^10 = " << sum << std::endl; return 0; } primesieve-5.6.0/examples/cpp/store_primes_in_vector.cpp000066400000000000000000000005631263266076300236000ustar00rootroot00000000000000/// @example store_primes_in_vector.cpp /// Store primes in a std::vector using primesieve. #include #include int main() { std::vector primes; // Store the primes <= 1000 primesieve::generate_primes(1000, &primes); primes.clear(); // Store the first 1000 primes primesieve::generate_n_primes(1000, &primes); return 0; } primesieve-5.6.0/include/000077500000000000000000000000001263266076300153305ustar00rootroot00000000000000primesieve-5.6.0/include/primesieve.h000066400000000000000000000213011263266076300176460ustar00rootroot00000000000000/** * @file primesieve.h * @brief primesieve C API. primesieve is a library for fast prime * number generation. In case an error occurs errno is set to * EDOM and PRIMESIEVE_ERROR is returned. * * Copyright (C) 2015 Kim Walisch, * * This file is distributed under the BSD License. */ #ifndef PRIMESIEVE_H #define PRIMESIEVE_H #define PRIMESIEVE_VERSION "5.6.0" #define PRIMESIEVE_VERSION_MAJOR 5 #define PRIMESIEVE_VERSION_MINOR 6 #define PRIMESIEVE_VERSION_PATCH 0 #include #include #include /** primesieve functions return PRIMESIEVE_ERROR * (UINT64_MAX) if any error occurs. */ #define PRIMESIEVE_ERROR ((uint64_t) ~((uint64_t) 0)) #ifdef __cplusplus extern "C" { #endif enum { /** Use all CPU cores for prime sieving. */ MAX_THREADS = - 1, /** Generate primes of short type. */ SHORT_PRIMES, /** Generate primes of unsigned short type. */ USHORT_PRIMES, /** Generate primes of int type. */ INT_PRIMES, /** Generate primes of unsigned int type. */ UINT_PRIMES, /** Generate primes of long type. */ LONG_PRIMES, /** Generate primes of unsigned long type. */ ULONG_PRIMES, /** Generate primes of long long type. */ LONGLONG_PRIMES, /** Generate primes of unsigned long long type. */ ULONGLONG_PRIMES, /** Generate primes of int16_t type. */ INT16_PRIMES, /** Generate primes of uint16_t type. */ UINT16_PRIMES, /** Generate primes of int32_t type. */ INT32_PRIMES, /** Generate primes of uint32_t type. */ UINT32_PRIMES, /** Generate primes of int64_t type. */ INT64_PRIMES, /** Generate primes of uint64_t type. */ UINT64_PRIMES }; /** Get an array with the primes inside the interval [start, stop]. * @param size The size of the returned primes array. * @param type The type of the primes to generate, e.g. INT_PRIMES. * @pre stop <= 2^64 - 2^32 * 10. */ void* primesieve_generate_primes(uint64_t start, uint64_t stop, size_t* size, int type); /** Get an array with the first n primes >= start. * @param type The type of the primes to generate, e.g. INT_PRIMES. * @pre stop <= 2^64 - 2^32 * 10. */ void* primesieve_generate_n_primes(uint64_t n, uint64_t start, int type); /** Find the nth prime. * @param n if n = 0 finds the 1st prime >= start,
* if n > 0 finds the nth prime > start,
* if n < 0 finds the nth prime < start (backwards). * @pre start <= 2^64 - 2^32 * 11. */ uint64_t primesieve_nth_prime(int64_t n, uint64_t start); /** Find the nth prime in parallel. * By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @param n if n = 0 finds the 1st prime >= start,
* if n > 0 finds the nth prime > start,
* if n < 0 finds the nth prime < start (backwards). * @pre start <= 2^64 - 2^32 * 11. */ uint64_t primesieve_parallel_nth_prime(int64_t n, uint64_t start); /** Count the primes within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_primes(uint64_t start, uint64_t stop); /** Count the twin primes within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_twins(uint64_t start, uint64_t stop); /** Count the prime triplets within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_triplets(uint64_t start, uint64_t stop); /** Count the prime quadruplets within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_quadruplets(uint64_t start, uint64_t stop); /** Count the prime quintuplets within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_quintuplets(uint64_t start, uint64_t stop); /** Count the prime sextuplets within the interval [start, stop]. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_count_sextuplets(uint64_t start, uint64_t stop); /** Count the primes within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_primes(uint64_t start, uint64_t stop); /** Count the twin primes within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_twins(uint64_t start, uint64_t stop); /** Count the prime triplets within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_triplets(uint64_t start, uint64_t stop); /** Count the prime quadruplets within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_quadruplets(uint64_t start, uint64_t stop); /** Count the prime quintuplets within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_quintuplets(uint64_t start, uint64_t stop); /** Count the prime sextuplets within the interval [start, stop] in * parallel. By default all CPU cores are used, use * primesieve_set_num_threads(int) to change the number of threads. * @pre stop <= 2^64 - 2^32 * 10. */ uint64_t primesieve_parallel_count_sextuplets(uint64_t start, uint64_t stop); /** Print the primes within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_primes(uint64_t start, uint64_t stop); /** Print the twin primes within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_twins(uint64_t start, uint64_t stop); /** Print the prime triplets within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_triplets(uint64_t start, uint64_t stop); /** Print the prime quadruplets within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_quadruplets(uint64_t start, uint64_t stop); /** Print the prime quintuplets within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_quintuplets(uint64_t start, uint64_t stop); /** Print the prime sextuplets within the interval [start, stop] * to the standard output. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_print_sextuplets(uint64_t start, uint64_t stop); /** Call back the primes within the interval [start, stop]. * @param callback A callback function. * @pre stop <= 2^64 - 2^32 * 10. */ void primesieve_callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime)); /** Get the current set sieve size in kilobytes. */ int primesieve_get_sieve_size(); /** Get the current set number of threads. * @note By default MAX_THREADS (-1) is returned. */ int primesieve_get_num_threads(); /** Returns the largest valid stop number for primesieve. * @return (2^64-1) - (2^32-1) * 10. */ uint64_t primesieve_get_max_stop(); /** Set the sieve size in kilobytes. * The best sieving performance is achieved with a sieve size of * your CPU's L1 data cache size (per core). For sieving >= 10^17 a * sieve size of your CPU's L2 cache size sometimes performs * better. * @param sieve_size Sieve size in kilobytes. * @pre sieve_size >= 1 && <= 2048. */ void primesieve_set_sieve_size(int sieve_size); /** Set the number of threads for use in subsequent * primesieve_parallel_* function calls. Note that this only * changes the number of threads for the current process. * @param num_threads Number of threads for sieving * or MAX_THREADS to use all CPU cores. */ void primesieve_set_num_threads(int num_threads); /** Deallocate a primes array created using the * primesieve_generate_primes() or primesieve_generate_n_primes() * functions. */ void primesieve_free(void* primes); /** Run extensive correctness tests. * The tests last about one minute on a quad core CPU from * 2013 and use up to 1 gigabyte of memory. * @return 1 if success, 0 if error. */ int primesieve_test(); /** Get the primesieve version number, in the form “i.j.kâ€. */ const char* primesieve_version(); #ifdef __cplusplus } /* extern "C" */ #endif #endif primesieve-5.6.0/include/primesieve.hpp000066400000000000000000000217131263266076300202150ustar00rootroot00000000000000/// /// @file primesieve.hpp /// @brief primesieve C++ API. primesieve is a library for fast prime /// number generation, in case an error occurs a /// primesieve::primesieve_error exception (derived form /// std::runtime_error) will be thrown. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. /// #ifndef PRIMESIEVE_HPP #define PRIMESIEVE_HPP #define PRIMESIEVE_VERSION "5.6.0" #define PRIMESIEVE_VERSION_MAJOR 5 #define PRIMESIEVE_VERSION_MINOR 6 #define PRIMESIEVE_VERSION_PATCH 0 #include #include #include #include #include #include #include #include #include #include /// All of primesieve's C++ functions and classes are declared /// inside this namespace. /// namespace primesieve { enum { /// Use all CPU cores for prime sieving. MAX_THREADS = -1 }; /// Store the primes <= stop in the primes vector. /// @pre stop <= 2^64 - 2^32 * 10. /// template inline void generate_primes(uint64_t stop, std::vector* primes) { if (primes) { PushBackPrimes > pb(*primes); pb.pushBackPrimes(0, stop); } } /// Store the primes within the interval [start, stop] /// in the primes vector. /// @pre stop <= 2^64 - 2^32 * 10. /// template inline void generate_primes(uint64_t start, uint64_t stop, std::vector* primes) { if (primes) { PushBackPrimes > pb(*primes); pb.pushBackPrimes(start, stop); } } /// Store the first n primes in the primes vector. template inline void generate_n_primes(uint64_t n, std::vector* primes) { if (primes) { PushBack_N_Primes > pb(*primes); pb.pushBack_N_Primes(n, 0); } } /// Store the first n primes >= start in the primes vector. /// @pre start <= 2^64 - 2^32 * 10. /// template inline void generate_n_primes(uint64_t n, uint64_t start, std::vector* primes) { if (primes) { PushBack_N_Primes > pb(*primes); pb.pushBack_N_Primes(n, start); } } /// Find the nth prime. /// @param n if n = 0 finds the 1st prime >= start,
/// if n > 0 finds the nth prime > start,
/// if n < 0 finds the nth prime < start (backwards). /// @pre start <= 2^64 - 2^32 * 11. /// uint64_t nth_prime(int64_t n, uint64_t start = 0); /// Find the nth prime in parallel. /// By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @param n if n = 0 finds the 1st prime >= start,
/// if n > 0 finds the nth prime > start,
/// if n < 0 finds the nth prime < start (backwards). /// @pre start <= 2^64 - 2^32 * 11. /// uint64_t parallel_nth_prime(int64_t n, uint64_t start = 0); /// Count the primes within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_primes(uint64_t start, uint64_t stop); /// Count the twin primes within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_twins(uint64_t start, uint64_t stop); /// Count the prime triplets within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_triplets(uint64_t start, uint64_t stop); /// Count the prime quadruplets within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_quadruplets(uint64_t start, uint64_t stop); /// Count the prime quintuplets within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_quintuplets(uint64_t start, uint64_t stop); /// Count the prime sextuplets within the interval [start, stop]. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t count_sextuplets(uint64_t start, uint64_t stop); /// Count the primes within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_primes(uint64_t start, uint64_t stop); /// Count the twin primes within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_twins(uint64_t start, uint64_t stop); /// Count the prime triplets within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_triplets(uint64_t start, uint64_t stop); /// Count the prime quadruplets within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_quadruplets(uint64_t start, uint64_t stop); /// Count the prime quintuplets within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_quintuplets(uint64_t start, uint64_t stop); /// Count the prime sextuplets within the interval [start, stop] in /// parallel. By default all CPU cores are used, use /// primesieve::set_num_threads(int) to change the number of /// threads. /// @pre stop <= 2^64 - 2^32 * 10. /// uint64_t parallel_count_sextuplets(uint64_t start, uint64_t stop); /// Print the primes within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_primes(uint64_t start, uint64_t stop); /// Print the twin primes within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_twins(uint64_t start, uint64_t stop); /// Print the prime triplets within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_triplets(uint64_t start, uint64_t stop); /// Print the prime quadruplets within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_quadruplets(uint64_t start, uint64_t stop); /// Print the prime quintuplets within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_quintuplets(uint64_t start, uint64_t stop); /// Print the prime sextuplets within the interval [start, stop] /// to the standard output. /// @pre stop <= 2^64 - 2^32 * 10. /// void print_sextuplets(uint64_t start, uint64_t stop); /// Call back the primes within the interval [start, stop]. /// @param callback A callback function. /// @pre stop <= 2^64 - 2^32 * 10. /// void callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime)); /// Call back the primes within the interval [start, stop]. /// @param callback An object derived from primesieve::Callback. /// @pre stop <= 2^64 - 2^32 * 10. /// void callback_primes(uint64_t start, uint64_t stop, primesieve::Callback* callback); /// Get the current set sieve size in kilobytes. int get_sieve_size(); /// Get the current set number of threads. /// @note By default MAX_THREADS (-1) is returned. /// int get_num_threads(); /// Returns the largest valid stop number for primesieve. /// @return (2^64-1) - (2^32-1) * 10. /// uint64_t get_max_stop(); /// Set the sieve size in kilobytes. /// The best sieving performance is achieved with a sieve size of /// your CPU's L1 data cache size (per core). For sieving >= 10^17 a /// sieve size of your CPU's L2 cache size sometimes performs /// better. /// @param sieve_size Sieve size in kilobytes. /// @pre sieve_size >= 1 && sieve_size <= 2048. /// void set_sieve_size(int sieve_size); /// Set the number of threads for use in subsequent /// primesieve::parallel_* function calls. Note that this only /// changes the number of threads for the current process. /// @param num_threads Number of threads for sieving /// or MAX_THREADS to use all CPU cores. /// void set_num_threads(int num_threads); /// Run extensive correctness tests. /// The tests last about one minute on a quad core CPU from /// 2013 and use up to 1 gigabyte of memory. /// @return true if success else false. /// bool primesieve_test(); /// Get the primesieve version number, in the form “i.j.kâ€. std::string primesieve_version(); } #endif primesieve-5.6.0/include/primesieve/000077500000000000000000000000001263266076300175005ustar00rootroot00000000000000primesieve-5.6.0/include/primesieve/Callback.hpp000066400000000000000000000012361263266076300217070ustar00rootroot00000000000000/// /// @file Callback.hpp /// @brief Callback interface classes. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef CALLBACK_PRIMESIEVE_HPP #define CALLBACK_PRIMESIEVE_HPP #include namespace primesieve { /// callback interface class. Objects derived from this class can be /// passed to the primesieve::generate_primes() functions. /// @param T must be uint64_t. /// template class Callback { public: virtual void callback(T prime) = 0; virtual ~Callback() { } }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/EratBig.hpp000066400000000000000000000023711263266076300215310ustar00rootroot00000000000000/// /// @file EratBig.hpp /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef ERATBIG_HPP #define ERATBIG_HPP #include "config.hpp" #include "WheelFactorization.hpp" #include #include namespace primesieve { /// EratBig is an implementation of the segmented sieve of /// Eratosthenes optimized for big sieving primes that have very few /// multiples per segment. /// class EratBig: public Modulo210Wheel_t { public: EratBig(uint64_t, uint_t, uint_t); ~EratBig(); void crossOff(byte_t*); private: const uint_t limit_; /// log2 of SieveOfEratosthenes::sieveSize_ const uint_t log2SieveSize_; const uint_t moduloSieveSize_; /// Vector of bucket lists, holds the sieving primes std::vector lists_; /// List of empty buckets Bucket* stock_; /// Pointers of the allocated buckets std::vector pointers_; void init(uint_t); static void moveBucket(Bucket&, Bucket*&); void pushBucket(uint_t); void storeSievingPrime(uint_t, uint_t, uint_t); void crossOff(byte_t*, SievingPrime*, SievingPrime*); DISALLOW_COPY_AND_ASSIGN(EratBig); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/EratMedium.hpp000066400000000000000000000020331263266076300222430ustar00rootroot00000000000000/// /// @file EratMedium.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef ERATMEDIUM_HPP #define ERATMEDIUM_HPP #include "config.hpp" #include "WheelFactorization.hpp" #include #include namespace primesieve { /// EratMedium is an implementation of the segmented sieve of /// Eratosthenes optimized for medium sieving primes that have a few /// multiples per segment. /// class EratMedium : public Modulo210Wheel_t { public: EratMedium(uint64_t, uint_t, uint_t); uint_t getLimit() const { return limit_; } void crossOff(byte_t*, uint_t); private: typedef std::list::iterator BucketIterator_t; const uint_t limit_; /// List of buckets, holds the sieving primes std::list buckets_; void storeSievingPrime(uint_t, uint_t, uint_t); static void crossOff(byte_t*, uint_t, Bucket&); DISALLOW_COPY_AND_ASSIGN(EratMedium); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/EratSmall.hpp000066400000000000000000000020231263266076300220720ustar00rootroot00000000000000/// /// @file EratSmall.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef ERATSMALL_HPP #define ERATSMALL_HPP #include "config.hpp" #include "WheelFactorization.hpp" #include #include namespace primesieve { /// EratSmall is an implementation of the segmented sieve of /// Eratosthenes optimized for small sieving primes that have many /// multiples per segment. /// class EratSmall : public Modulo30Wheel_t { public: EratSmall(uint64_t, uint_t, uint_t); uint_t getLimit() const { return limit_; } void crossOff(byte_t*, byte_t*); private: typedef std::list::iterator BucketIterator_t; const uint_t limit_; /// List of buckets, holds the sieving primes std::list buckets_; void storeSievingPrime(uint_t, uint_t, uint_t); static void crossOff(byte_t*, byte_t*, Bucket&); DISALLOW_COPY_AND_ASSIGN(EratSmall); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/ParallelPrimeSieve-lock.hpp000066400000000000000000000031701263266076300246650ustar00rootroot00000000000000/// /// @file ParallelPrimeSieve-lock.hpp /// @brief The OmpInitLock and OmpLockGuard classes are RAII-style /// wrappers for OpenMP locks. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PARALLELPRIMESIEVE_LOCK_HPP #define PARALLELPRIMESIEVE_LOCK_HPP #include namespace primesieve { /// RAII-style wrapper for OpenMP locks. /// Initialize lock -> destroy lock. /// class OmpInitLock { public: OmpInitLock(void**); ~OmpInitLock(); private: omp_lock_t lock_; }; /// @param lockAdress Allocate a new lock_ on the stack and /// store its address to lockAdress. /// OmpInitLock::OmpInitLock(void** lockAddress) { *lockAddress = static_cast(&lock_); omp_init_lock(&lock_); } OmpInitLock::~OmpInitLock() { omp_destroy_lock(&lock_); } /// RAII-style wrapper for OpenMP locks. /// Set lock -> unset lock. /// class OmpLockGuard { public: OmpLockGuard(omp_lock_t*, bool); ~OmpLockGuard(); bool isSet() const; private: omp_lock_t* lock_; bool isSet_; }; /// @param waitForLock If false do not block the current thread /// if the lock is not available. /// OmpLockGuard::OmpLockGuard(omp_lock_t* lock, bool waitForLock = true) : lock_(lock) { if (!waitForLock) isSet_ = (omp_test_lock(lock_) != 0); else { omp_set_lock(lock_); isSet_ = true; } } OmpLockGuard::~OmpLockGuard() { if (isSet()) omp_unset_lock(lock_); } bool OmpLockGuard::isSet() const { return isSet_; } } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/ParallelPrimeSieve.hpp000066400000000000000000000032011263266076300237320ustar00rootroot00000000000000/// /// @file ParallelPrimeSieve.hpp /// @brief The ParallelPrimeSieve class provides an easy API for /// multi-threaded prime sieving. /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PARALLELPRIMESIEVE_HPP #define PARALLELPRIMESIEVE_HPP #include "PrimeSieve.hpp" #include namespace primesieve { /// ParallelPrimeSieve sieves primes in parallel, it is /// derived from PrimeSieve so it has the same API. /// Please refer to doc/EXAMPLES for more information. /// class ParallelPrimeSieve : public PrimeSieve { public: /// Used for inter-process communication with the /// primesieve GUI application. struct SharedMemory { uint64_t start; uint64_t stop; uint64_t counts[6]; double status; double seconds; int flags; int sieveSize; int threads; }; ParallelPrimeSieve(); virtual ~ParallelPrimeSieve() { } void init(SharedMemory&); static int getMaxThreads(); int getNumThreads() const; void setNumThreads(int numThreads); using PrimeSieve::sieve; virtual void sieve(); private: enum { IDEAL_NUM_THREADS = -1 }; void* lock_; SharedMemory* shm_; int numThreads_; bool tooMany(int) const; int idealNumThreads() const; uint64_t getThreadInterval(int) const; uint64_t align(uint64_t) const; template T getLock() { return static_cast(lock_); } virtual double getWallTime() const; virtual void setLock(); virtual void unsetLock(); virtual bool updateStatus(uint64_t, bool); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PreSieve.hpp000066400000000000000000000034071263266076300217370ustar00rootroot00000000000000/// /// @file PreSieve.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRESIEVE_HPP #define PRESIEVE_HPP #include "config.hpp" #include namespace primesieve { /// @brief Pre-sieve multiples of small primes to speed up the sieve /// of Eratosthenes. /// /// PreSieve objects are used to pre-sieve multiples of small primes /// e.g. <= 19 to speed up SieveOfEratosthenes. The idea is to /// allocate an array (preSieved_) and remove the multiples of small /// primes from it at initialization. Then whilst sieving, the /// preSieved_ array is copied to the SieveOfEratosthenes array at the /// beginning of each new segment to pre-sieve the multiples of small /// primes <= limit_. Pre-sieving speeds up my sieve of Eratosthenes /// implementation by about 20 percent when sieving < 10^10. /// /// Memory Usage /// /// - PreSieve objects use: primeProduct(limit_) / 30 bytes of memory /// - PreSieve multiples of primes <= 11 uses 77 bytes /// - PreSieve multiples of primes <= 13 uses 1001 bytes /// - PreSieve multiples of primes <= 17 uses 16.62 kilobytes /// - PreSieve multiples of primes <= 19 uses 315.75 kilobytes /// - PreSieve multiples of primes <= 23 uses 7.09 megabytes /// class PreSieve { public: PreSieve(int); ~PreSieve(); uint_t getLimit() const { return limit_; } void doIt(byte_t*, uint_t, uint64_t) const; private: static const uint_t primes_[10]; /// Pre-sieve multiples of primes <= limit_ (>= 11 && <= 23) uint_t limit_; uint_t primeProduct_; byte_t* preSieved_; uint_t size_; void init(); DISALLOW_COPY_AND_ASSIGN(PreSieve); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PrimeFinder.hpp000066400000000000000000000023751263266076300224240ustar00rootroot00000000000000/// /// @file PrimeFinder.hpp /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMEFINDER_HPP #define PRIMEFINDER_HPP #include "config.hpp" #include "SieveOfEratosthenes.hpp" #include #include namespace primesieve { class PrimeSieve; /// PrimeFinder is a SieveOfEratosthenes class that is used to /// callback, print and count primes and prime k-tuplets /// (twin primes, prime triplets, ...). /// class PrimeFinder : public SieveOfEratosthenes { public: PrimeFinder(PrimeSieve&); private: enum { END = 0xff + 1 }; static const uint_t kBitmasks_[6][5]; /// Count lookup tables for prime k-tuplets std::vector kCounts_[6]; /// Reference to the associated PrimeSieve object PrimeSieve& ps_; void init_kCounts(); virtual void segmentFinished(const byte_t*, uint_t); void count(const byte_t*, uint_t); void print(const byte_t*, uint_t) const; template void callbackPrimes(T, const byte_t*, uint_t) const; void callbackPrimes(const byte_t*, uint_t) const; static void printPrime(uint64_t); DISALLOW_COPY_AND_ASSIGN(PrimeFinder); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PrimeGenerator.hpp000066400000000000000000000013201263266076300231300ustar00rootroot00000000000000/// /// @file PrimeGenerator.hpp /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMEGENERATOR_HPP #define PRIMEGENERATOR_HPP #include "config.hpp" #include "SieveOfEratosthenes.hpp" namespace primesieve { class PrimeFinder; class PrimeGenerator : public SieveOfEratosthenes { public: PrimeGenerator(PrimeFinder&); void doIt(); private: PrimeFinder& finder_; void segmentFinished(const byte_t*, uint_t); void generateSievingPrimes(const byte_t*, uint_t); void generateTinyPrimes(); DISALLOW_COPY_AND_ASSIGN(PrimeGenerator); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PrimeSieve-lock.hpp000066400000000000000000000012611263266076300232070ustar00rootroot00000000000000/// /// @file PrimeSieve-lock.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMESIEVE_LOCK_HPP #define PRIMESIEVE_LOCK_HPP #include "config.hpp" #include "PrimeSieve.hpp" namespace primesieve { /// Block the current PrimeSieve (or ParallelPrimeSieve) thread /// until it can set a lock, then continue execution. /// class LockGuard { public: LockGuard(PrimeSieve& ps) : ps_(ps) { ps_.setLock(); } ~LockGuard() { ps_.unsetLock(); } private: PrimeSieve& ps_; DISALLOW_COPY_AND_ASSIGN(LockGuard); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PrimeSieve.hpp000066400000000000000000000113711263266076300222640ustar00rootroot00000000000000/// /// @file PrimeSieve.hpp /// @brief The PrimeSieve class provides an easy API for prime /// sieving (single-threaded). /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMESIEVE_CLASS_HPP #define PRIMESIEVE_CLASS_HPP #include "Callback.hpp" #include #include #include namespace primesieve { /// PrimeSieve is a highly optimized C++ implementation of the /// segmented sieve of Eratosthenes that generates primes and prime /// k-tuplets (twin primes, prime triplets, ...) in order up to 2^64 /// maximum. The README file describes the algorithms used in more /// detail and doc/EXAMPLES contains source code examples. /// class PrimeSieve { friend class PrimeFinder; friend class LockGuard; public: /// Public flags for use with setFlags(int) /// @pre flag < (1 << 20) enum { COUNT_PRIMES = 1 << 0, COUNT_TWINS = 1 << 1, COUNT_TRIPLETS = 1 << 2, COUNT_QUADRUPLETS = 1 << 3, COUNT_QUINTUPLETS = 1 << 4, COUNT_SEXTUPLETS = 1 << 5, PRINT_PRIMES = 1 << 6, PRINT_TWINS = 1 << 7, PRINT_TRIPLETS = 1 << 8, PRINT_QUADRUPLETS = 1 << 9, PRINT_QUINTUPLETS = 1 << 10, PRINT_SEXTUPLETS = 1 << 11, PRINT_STATUS = 1 << 12, CALCULATE_STATUS = 1 << 13 }; PrimeSieve(); PrimeSieve(PrimeSieve&, int); virtual ~PrimeSieve(); // Getters uint64_t getStart() const; uint64_t getStop() const; int getSieveSize() const; int getFlags() const; double getStatus() const; double getSeconds() const; // Setters void setStart(uint64_t); void setStop(uint64_t); void setSieveSize(int); void setFlags(int); void addFlags(int); // Bool is* bool isFlag(int) const; bool isCallback() const; bool isCount() const; bool isCount(int) const; bool isPrint() const; bool isPrint(int) const; // Sieve virtual void sieve(); void sieve(uint64_t, uint64_t); void sieve(uint64_t, uint64_t, int); // Callback void callbackPrimes(uint64_t, uint64_t, void (*)(uint64_t)); void callbackPrimes(uint64_t, uint64_t, Callback*); void callbackPrimes_c(uint64_t, uint64_t, void (*)(uint64_t)); // nth prime uint64_t nthPrime(uint64_t); uint64_t nthPrime(int64_t, uint64_t); // Print void printPrimes(uint64_t, uint64_t); void printTwins(uint64_t, uint64_t); void printTriplets(uint64_t, uint64_t); void printQuadruplets(uint64_t, uint64_t); void printQuintuplets(uint64_t, uint64_t); void printSextuplets(uint64_t, uint64_t); // Count uint64_t countPrimes(uint64_t, uint64_t); uint64_t countTwins(uint64_t, uint64_t); uint64_t countTriplets(uint64_t, uint64_t); uint64_t countQuadruplets(uint64_t, uint64_t); uint64_t countQuintuplets(uint64_t, uint64_t); uint64_t countSextuplets(uint64_t, uint64_t); // Count getters uint64_t getPrimeCount() const; uint64_t getTwinCount() const; uint64_t getTripletCount() const; uint64_t getQuadrupletCount() const; uint64_t getQuintupletCount() const; uint64_t getSextupletCount() const; uint64_t getCount(int) const; protected: /// Sieve primes >= start_ uint64_t start_; /// Sieve primes <= stop_ uint64_t stop_; /// Prime number and prime k-tuplet counts std::vector counts_; /// Time elapsed of sieve() double seconds_; uint64_t getInterval() const; void reset(); virtual double getWallTime() const; virtual void setLock(); virtual void unsetLock(); virtual bool updateStatus(uint64_t, bool); private: struct SmallPrime { uint32_t firstPrime; uint32_t lastPrime; int index; std::string str; }; static const SmallPrime smallPrimes_[8]; /// Sum of all processed segments uint64_t processed_; /// Sum of processed segments that hasn't been updated yet uint64_t toUpdate_; /// Status of sieve() in percent double percent_; /// Sieve size in kilobytes int sieveSize_; /// Flags (settings) for PrimeSieve e.g. COUNT_PRIMES, PRINT_TWINS, ... int flags_; /// ParallelPrimeSieve thread number int threadNum_; /// Pointer to the parent ParallelPrimeSieve object PrimeSieve* parent_; /// Callbacks for use with *callbackPrimes() void (*callback_)(uint64_t); Callback* cb_; static void printStatus(double, double); bool isFlag(int, int) const; bool isValidFlags(int) const; bool isStatus() const; bool isParallelPrimeSieveChild() const; void doSmallPrime(const SmallPrime&); enum { INIT_STATUS = 0, FINISH_STATUS = 10 }; /// Private flags /// @pre flag >= (1 << 20) enum { CALLBACK_PRIMES = 1 << 20, CALLBACK_PRIMES_OBJ = 1 << 21, CALLBACK_PRIMES_C = 1 << 22 }; }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/PushBackPrimes.hpp000066400000000000000000000052201263266076300230700ustar00rootroot00000000000000/// /// @file PushBackPrimes.hpp /// @brief This file contains classes needed to store primes in /// std::vector objects. These classes derive from Callback /// and call PrimeSieve's callbackPrimes() method, the /// primes are then pushed back onto the vector inside the /// callback method. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PUSHBACKPRIMES_HPP #define PUSHBACKPRIMES_HPP #include "PrimeSieve.hpp" #include "Callback.hpp" #include "cancel_callback.hpp" #include #include namespace primesieve { /// approximate_prime_count(x) >= pi(x) inline uint64_t approximate_prime_count(uint64_t start, uint64_t stop) { if (start > stop) return 0; if (stop <= 10) return 4; // Dusard 2010: pi(x) <= x / (log(x) - 1.1) + 5 for x >= 4 double pix = (stop - start) / (std::log(static_cast(stop)) - 1.1) + 5; return static_cast(pix); } template class PushBackPrimes : public Callback { public: PushBackPrimes(T& primes) : primes_(primes) { } void callback(uint64_t prime) { typedef typename T::value_type V; primes_.push_back(static_cast(prime)); } void pushBackPrimes(uint64_t start, uint64_t stop) { if (start <= stop) { uint64_t prime_count = approximate_prime_count(start, stop); primes_.reserve(primes_.size() + static_cast(prime_count)); PrimeSieve ps; ps.callbackPrimes(start, stop, this); } } private: PushBackPrimes(const PushBackPrimes&); void operator=(const PushBackPrimes&); T& primes_; }; template class PushBack_N_Primes : public Callback { public: PushBack_N_Primes(T& primes) : primes_(primes) { } void callback(uint64_t prime) { typedef typename T::value_type V; primes_.push_back(static_cast(prime)); if (--n_ == 0) throw cancel_callback(); } void pushBack_N_Primes(uint64_t n, uint64_t start) { n_ = n; std::size_t newSize = primes_.size() + static_cast(n_); primes_.reserve(newSize); PrimeSieve ps; try { while (n_ > 0) { uint64_t logn = 50; // choose stop > nth prime uint64_t stop = start + n_ * logn + 10000; ps.callbackPrimes(start, stop, this); start = stop + 1; } } catch (cancel_callback&) { } } private: PushBack_N_Primes(const PushBack_N_Primes&); void operator=(const PushBack_N_Primes&); T& primes_; uint64_t n_; }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/SieveOfEratosthenes-inline.hpp000066400000000000000000000043541263266076300254200ustar00rootroot00000000000000/// /// @file SieveOfEratosthenes-inline.hpp /// @brief Inline methods of the SieveOfEratosthenes class. /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef SIEVEOFERATOSTHENES_INLINE_HPP #define SIEVEOFERATOSTHENES_INLINE_HPP #include "config.hpp" #include "SieveOfEratosthenes.hpp" #include "EratSmall.hpp" #include "EratMedium.hpp" #include "EratBig.hpp" #include "pmath.hpp" #include namespace primesieve { inline uint64_t SieveOfEratosthenes::getStart() const { return start_; } inline uint64_t SieveOfEratosthenes::getStop() const { return stop_; } inline uint64_t SieveOfEratosthenes::getSegmentLow() const { return segmentLow_; } inline uint_t SieveOfEratosthenes::getSieveSize() const { return sieveSize_; } /// Reconstruct the prime number corresponding to the first set /// bit of the `bits' parameter and unset that bit. /// inline uint64_t SieveOfEratosthenes::getNextPrime(uint64_t* bits, uint64_t base) { // calculate bitValues_[ bitScanForward(*bits) ] // using a custom De Bruijn bitscan uint64_t debruijn64 = UINT64_C(0x3F08A4C6ACB9DBD); uint64_t mask = *bits - 1; uint64_t bitValue = bruijnBitValues_[((*bits ^ mask) * debruijn64) >> 58]; uint64_t prime = base + bitValue; *bits &= mask; return prime; } /// This method must be called consecutively for all primes up to /// sqrt(stop) in order to sieve the primes within the /// interval [start, stop]. /// inline void SieveOfEratosthenes::addSievingPrime(uint_t prime) { uint64_t square = isquare(prime); // This loop is executed once all primes <= sqrt(segmentHigh_) // required to sieve the next segment have been // added to the erat* objects further down. while (segmentHigh_ < square) { sieveSegment(); segmentLow_ += sieveSize_ * NUMBERS_PER_BYTE; segmentHigh_ += sieveSize_ * NUMBERS_PER_BYTE; } if (prime > limitEratMedium_) eratBig_->addSievingPrime(prime, segmentLow_); else if (prime > limitEratSmall_) eratMedium_->addSievingPrime(prime, segmentLow_); else /* (prime > limitPreSieve) */ eratSmall_->addSievingPrime(prime, segmentLow_); } } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/SieveOfEratosthenes.hpp000066400000000000000000000050101263266076300241320ustar00rootroot00000000000000/// /// @file SieveOfEratosthenes.hpp /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef SIEVEOFERATOSTHENES_HPP #define SIEVEOFERATOSTHENES_HPP #include "config.hpp" #include #include namespace primesieve { class PreSieve; class EratSmall; class EratMedium; class EratBig; /// @brief The abstract SieveOfEratosthenes class sieves primes using /// the segmented sieve of Eratosthenes. /// /// SieveOfEratosthenes uses a bit array for sieving, the bit array /// uses 8 flags for 30 numbers. SieveOfEratosthenes uses three /// different sieve of Eratosthenes algorithms optimized for small, /// medium and big sieving primes to cross-off multiples. /// class SieveOfEratosthenes { public: static uint64_t getMaxStop(); static std::string getMaxStopString(); uint64_t getStart() const; uint64_t getStop() const; uint_t getSqrtStop() const; uint_t getSieveSize() const; uint_t getPreSieve() const; void addSievingPrime(uint_t); void sieve(); protected: SieveOfEratosthenes(uint64_t, uint64_t, uint_t); virtual ~SieveOfEratosthenes(); virtual void segmentFinished(const byte_t*, uint_t) = 0; static uint64_t getNextPrime(uint64_t*, uint64_t); uint64_t getSegmentLow() const; private: static const uint_t bitValues_[8]; static const uint_t bruijnBitValues_[64]; /// Lower bound of the current segment uint64_t segmentLow_; /// Upper bound of the current segment uint64_t segmentHigh_; /// Sieve primes >= start_ const uint64_t start_; /// Sieve primes <= stop_ const uint64_t stop_; /// sqrt(stop_) uint_t sqrtStop_; /// Copy of preSieve_->getLimit() uint_t limitPreSieve_; /// Copy of eratSmall_->getLimit() uint_t limitEratSmall_; /// Copy of eratMedium_->getLimit() uint_t limitEratMedium_; /// Size of sieve_ in bytes (power of 2) uint_t sieveSize_; /// Sieve of Eratosthenes array byte_t* sieve_; /// Pre-sieve multiples of tiny sieving primes PreSieve* preSieve_; /// Cross-off multiples of small sieving primes EratSmall* eratSmall_; /// cross-off multiples of medium sieving primes EratMedium* eratMedium_; /// cross-off multiples of big sieving primes EratBig* eratBig_; static uint64_t getByteRemainder(uint64_t); void init(); void cleanUp(); void preSieve(); void crossOffMultiples(); void sieveSegment(); DISALLOW_COPY_AND_ASSIGN(SieveOfEratosthenes); }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/WheelFactorization.hpp000066400000000000000000000177371263266076300240310ustar00rootroot00000000000000/// /// @file WheelFactorization.hpp /// @brief Classes and structs related to wheel factorization. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef WHEELFACTORIZATION_HPP #define WHEELFACTORIZATION_HPP #include "config.hpp" #include "toString.hpp" #include "pmath.hpp" #include "primesieve_error.hpp" #include #include #include #include #include namespace primesieve { /// The WheelInit data structure is used to calculate the first /// multiple >= start of each sieving prime. /// struct WheelInit { uint8_t nextMultipleFactor; uint8_t wheelIndex; }; extern const WheelInit wheel30Init[30]; extern const WheelInit wheel210Init[210]; /// The WheelElement data structure is used to skip multiples of /// small primes using wheel factorization. /// struct WheelElement { /// Bitmask used to unset the bit corresponding to the current /// multiple of a SievingPrime object. uint8_t unsetBit; /// Factor used to calculate the next multiple of a sieving prime /// that is not divisible by any of the wheel factors. uint8_t nextMultipleFactor; /// Overflow needed to correct the next multiple index /// (due to sievingPrime = prime / 30). uint8_t correct; /// Used to calculate the next wheel index: /// wheelIndex += next; int8_t next; }; extern const WheelElement wheel30[8*8]; extern const WheelElement wheel210[48*8]; /// Sieving primes are used to cross-off multiples (of itself). /// Each SievingPrime object contains a sieving prime and the position /// of its next multiple within the SieveOfEratosthenes array /// (i.e. multipleIndex) and a wheelIndex. /// class SievingPrime { public: enum { MAX_MULTIPLEINDEX = (1 << 23) - 1, MAX_WHEELINDEX = (1 << (32 - 23)) - 1 }; uint_t getSievingPrime() const { return sievingPrime_; } uint_t getMultipleIndex() const { return indexes_ & MAX_MULTIPLEINDEX; } uint_t getWheelIndex() const { return indexes_ >> 23; } void setMultipleIndex(uint_t multipleIndex) { assert(multipleIndex <= MAX_MULTIPLEINDEX); indexes_ = static_cast(indexes_ | multipleIndex); } void setWheelIndex(uint_t wheelIndex) { assert(wheelIndex <= MAX_WHEELINDEX); indexes_ = static_cast(wheelIndex << 23); } void set(uint_t multipleIndex, uint_t wheelIndex) { assert(multipleIndex <= MAX_MULTIPLEINDEX); assert(wheelIndex <= MAX_WHEELINDEX); indexes_ = static_cast(multipleIndex | (wheelIndex << 23)); } void set(uint_t sievingPrime, uint_t multipleIndex, uint_t wheelIndex) { set(multipleIndex, wheelIndex); sievingPrime_ = static_cast(sievingPrime); } private: /// multipleIndex = 23 least significant bits of indexes_. /// wheelIndex = 9 most significant bits of indexes_. uint32_t indexes_; uint32_t sievingPrime_; }; /// The Bucket data structure is used to store sieving primes. /// @see http://www.ieeta.pt/~tos/software/prime_sieve.html /// The Bucket class is designed as a singly linked list, once there /// is no more space in the current Bucket a new Bucket node is /// allocated. /// class Bucket { public: Bucket(const Bucket&) { reset(); } Bucket() { reset(); } SievingPrime* begin() { return &sievingPrimes_[0]; } SievingPrime* last() { return &sievingPrimes_[config::BUCKETSIZE - 1]; } SievingPrime* end() { return prime_; } Bucket* next() { return next_; } bool hasNext() const { return next_ != NULL; } bool empty() { return begin() == end(); } void reset() { prime_ = begin(); } void setNext(Bucket* next) { next_ = next; } /// Store a sieving prime in the bucket. /// @return false if the bucket is full else true. /// bool store(uint_t sievingPrime, uint_t multipleIndex, uint_t wheelIndex) { prime_->set(sievingPrime, multipleIndex, wheelIndex); return prime_++ != last(); } private: SievingPrime* prime_; Bucket* next_; SievingPrime sievingPrimes_[config::BUCKETSIZE]; }; /// The abstract WheelFactorization class is used skip multiples of /// small primes in the sieve of Eratosthenes. The EratSmall, /// EratMedium and EratBig classes are derived from /// WheelFactorization. /// template class WheelFactorization { public: /// Get the maximum upper bound for sieving static uint64_t getMaxStop() { const uint64_t MAX_UINT32 = std::numeric_limits::max(); const uint64_t MAX_UINT64 = std::numeric_limits::max(); return MAX_UINT64 - MAX_UINT32 * getMaxFactor(); } static std::string getMaxStopString() { return "2^64 - 2^32 * " + toString(getMaxFactor()); } /// @brief Add a new sieving prime. /// /// Calculate the first multiple > segmentLow of prime and the /// position within the SieveOfEratosthenes array of that multiple /// and its wheel index. When done store the sieving prime. /// void addSievingPrime(uint_t prime, uint64_t segmentLow) { segmentLow += 6; // calculate the first multiple (of prime) > segmentLow uint64_t quotient = segmentLow / prime + 1; uint64_t multiple = prime * quotient; // prime not needed for sieving if (multiple > stop_) return; // ensure multiple >= prime * prime if (quotient < prime) { multiple = isquare(prime); quotient = prime; } // calculate the next multiple of prime that is not // divisible by any of the wheel's factors uint64_t nextMultipleFactor = INIT[quotient % MODULO].nextMultipleFactor; multiple += prime * nextMultipleFactor; if (multiple > stop_) return; uint64_t lowOffset = multiple - segmentLow; uint_t multipleIndex = static_cast(lowOffset / NUMBERS_PER_BYTE); uint_t wheelIndex = wheelOffsets_[prime % NUMBERS_PER_BYTE] + INIT[quotient % MODULO].wheelIndex; storeSievingPrime(prime, multipleIndex, wheelIndex); } protected: /// @param stop Upper bound for sieving. /// @param sieveSize Sieve size in bytes. /// WheelFactorization(uint64_t stop, uint_t sieveSize) : stop_(stop) { const uint_t maxSieveSize = SievingPrime::MAX_MULTIPLEINDEX + 1; if (sieveSize > maxSieveSize) throw primesieve_error("WheelFactorization: sieveSize must be <= " + toString(maxSieveSize)); if (stop > getMaxStop()) throw primesieve_error("WheelFactorization: stop must be <= " + getMaxStopString()); } virtual ~WheelFactorization() { } virtual void storeSievingPrime(uint_t, uint_t, uint_t) = 0; static uint_t getMaxFactor() { return WHEEL[0].nextMultipleFactor; } /// Cross-off the current multiple (unset bit) of sievingPrime and /// calculate its next multiple i.e. multipleIndex. /// static void unsetBit(byte_t* sieve, uint_t sievingPrime, uint_t* multipleIndex, uint_t* wheelIndex) { sieve[*multipleIndex] &= WHEEL[*wheelIndex].unsetBit; *multipleIndex += WHEEL[*wheelIndex].nextMultipleFactor * sievingPrime; *multipleIndex += WHEEL[*wheelIndex].correct; *wheelIndex += WHEEL[*wheelIndex].next; } private: static const uint_t wheelOffsets_[30]; const uint64_t stop_; DISALLOW_COPY_AND_ASSIGN(WheelFactorization); }; template const uint_t WheelFactorization::wheelOffsets_[30] = { 0, SIZE * 7, 0, 0, 0, 0, 0, SIZE * 0, 0, 0, 0, SIZE * 1, 0, SIZE * 2, 0, 0, 0, SIZE * 3, 0, SIZE * 4, 0, 0, 0, SIZE * 5, 0, 0, 0, 0, 0, SIZE * 6 }; /// 3rd wheel, skips multiples of 2, 3 and 5 typedef WheelFactorization<30, 8, wheel30Init, wheel30> Modulo30Wheel_t; /// 4th wheel, skips multiples of 2, 3, 5 and 7 typedef WheelFactorization<210, 48, wheel210Init, wheel210> Modulo210Wheel_t; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/bits.hpp000066400000000000000000000010201263266076300211430ustar00rootroot00000000000000/// /// @file bits.hpp /// @brief Bitmasks to turn off single bits of a byte. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef BITS_HPP #define BITS_HPP enum { BIT0 = 0xfe, // 11111110 BIT1 = 0xfd, // 11111101 BIT2 = 0xfb, // 11111011 BIT3 = 0xf7, // 11110111 BIT4 = 0xef, // 11101111 BIT5 = 0xdf, // 11011111 BIT6 = 0xbf, // 10111111 BIT7 = 0x7f // 01111111 }; #endif primesieve-5.6.0/include/primesieve/callback_t.hpp000066400000000000000000000007201263266076300222670ustar00rootroot00000000000000/** * @file callback_t.hpp * @brief Callback types with C++ linkage and extern "C" linkage. * * Copyright (C) 2015 Kim Walisch, * * This file is distributed under the BSD License. See the COPYING * file in the top level directory. */ #ifndef CALLBACK_t_HPP #define CALLBACK_t_HPP #include // C++ linkage typedef void (*callback_t)(uint64_t); extern "C" { typedef void (*callback_c_t)(uint64_t); } #endif primesieve-5.6.0/include/primesieve/cancel_callback.hpp000066400000000000000000000006221263266076300232520ustar00rootroot00000000000000/// /// @file cancel_callback.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef CANCEL_CALLBACK_HPP #define CANCEL_CALLBACK_HPP #include namespace primesieve { class cancel_callback : public std::exception { }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/config.hpp000066400000000000000000000103001263266076300214500ustar00rootroot00000000000000/// /// @file config.hpp /// @brief Macros, typedefs and constants that set various limits /// and array sizes within primesieve. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef CONFIG_PRIMESIEVE_HPP #define CONFIG_PRIMESIEVE_HPP /// Include config.h generated by ./configure script #ifdef HAVE_CONFIG_H #include #endif /// Enable the UINT64_C() macro from #if !defined(__STDC_CONSTANT_MACROS) #define __STDC_CONSTANT_MACROS #endif #include /// Disable assert() macro #if !defined(DEBUG) && !defined(NDEBUG) #define NDEBUG #endif /// Disable the default copy constructor and assignment operator #ifndef DISALLOW_COPY_AND_ASSIGN #define DISALLOW_COPY_AND_ASSIGN(ClassName) \ ClassName(const ClassName&); \ void operator=(const ClassName&) #endif /// Default CPU L1 data cache size in kilobytes (per core) #ifndef L1_DCACHE_SIZE #define L1_DCACHE_SIZE 32 #endif #ifndef SIEVESIZE #define SIEVESIZE L1_DCACHE_SIZE #endif namespace primesieve { /// byte_t must be unsigned in primesieve typedef unsigned char byte_t; typedef unsigned int uint_t; enum { /// SieveOfEratosthenes objects use a bit array with 30 numbers per /// byte for sieving, the 8 bits of each byte correspond to the /// offsets { 7, 11, 13, 17, 19, 23, 29, 31 }. /// NUMBERS_PER_BYTE = 30 }; namespace config { enum { /// Default sieve size in kilobytes of the PrimeSieve class. Set /// PRIMESIEVE_SIEVESIZE to your CPUs L1 data cache size to get the /// best performance. /// @pre PRIMESIEVE_SIEVESIZE >= 1 && <= 2048 /// PRIMESIEVE_SIEVESIZE = SIEVESIZE, /// Sieve size in kilobytes of the PrimeGenerator class. /// @pre PRIMEGENERATOR_SIEVESIZE >= 1 && <= 2048 /// PRIMEGENERATOR_SIEVESIZE = L1_DCACHE_SIZE, /// Default pre-sieve limit. Multiples of primes up to this limit /// are pre-sieved to speed up the sieve of Eratosthenes. /// @pre PRESIEVE >= 13 && <= 23. /// PRESIEVE = 19, /// Pre-sieving is not used unless the sieving interval is >= /// PRESIEVE_THRESHOLD. (Pre-sieving is expensive to initialize.) /// PRESIEVE_THRESHOLD = 100000000, /// Number of sieving primes per Bucket in EratSmall, EratMedium and /// EratBig objects, affects performance by about 3%. /// /// - For x86-64 CPUs after 2010 use 1024 /// - For x86-64 CPUs before 2010 use 512 /// - For PowerPC G4 CPUs 2003 use 256 /// BUCKETSIZE = 1 << 10, /// EratBig allocates BYTES_PER_ALLOC of new memory each time /// it needs more buckets. Default = 8 megabytes. /// BYTES_PER_ALLOC = (1 << 20) * 8, /// primesieve::iterator caches at least ITERATOR_CACHE_SMALL /// bytes of primes. L3_CACHE_SIZE is a good value. /// ITERATOR_CACHE_SMALL = (1 << 20) * 8, /// primesieve::iterator maximum cache size in bytes, used if /// pi(sqrt(n)) * 8 bytes > ITERATOR_CACHE_MAX. /// ITERATOR_CACHE_MAX = (1 << 20) * 1024 }; /// Sieving primes <= (sieveSize in bytes * FACTOR_ERATSMALL) /// are processed in EratSmall objects, speed up ~ 5%. /// @pre FACTOR_ERATSMALL >= 0 && <= 3 /// /// - For x86-64 CPUs after 2010 use 0.5 /// - For x86-64 CPUs before 2010 use 0.8 /// - For PowerPC G4 CPUs 2003 use 1.0 /// const double FACTOR_ERATSMALL = 0.5; /// Sieving primes <= (sieveSize in bytes * FACTOR_ERATMEDIUM) /// (and > EratSmall see above) are processed in EratMedium objects. /// @pre FACTOR_ERATMEDIUM >= 0 && <= 9 /// /// Statistically ideal factor for 4th Wheel is: /// FACTOR_ERATMEDIUM * 2 + FACTOR_ERATMEDIUM * 10 = 30 /// FACTOR_ERATMEDIUM = 30 / 12 /// FACTOR_ERATMEDIUM = 2.5 /// const double FACTOR_ERATMEDIUM = 2.5; /// Each thread sieves at least an interval of size /// MIN_THREAD_INTERVAL to reduce the initialization overhead. /// @pre MIN_THREAD_INTERVAL >= 100 /// const uint64_t MIN_THREAD_INTERVAL = static_cast(1e7); /// Each thread sieves at most an interval of size /// MAX_THREAD_INTERVAL to prevent load imbalance near 99%. /// const uint64_t MAX_THREAD_INTERVAL = static_cast(2e10); } // namespace config } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/iterator.hpp000066400000000000000000000051401263266076300220420ustar00rootroot00000000000000/// /// @file iterator.hpp /// @brief The iterator class allows to easily iterate (forward and /// backward) over prime numbers. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMESIEVE_ITERATOR_HPP #define PRIMESIEVE_ITERATOR_HPP #include #include namespace primesieve { uint64_t get_max_stop(); /// primesieve::iterator allows to easily iterate over primes both /// forwards and backwards. Generating the first prime has a /// complexity of O(r log log r) operations with r = n^0.5, after that /// any additional prime is generated in amortized O(log n log log n) /// operations. The memory usage is about pi(n^0.5) * 16 bytes. /// primesieve::iterator objects are very convenient to use at the /// cost of being slightly slower than the callback_primes() /// functions. /// class iterator { public: /// Create a new iterator object. /// @param start Generate primes > start (or < start). /// @param stop_hint Stop number optimization hint, gives significant /// speed up if few primes are generated. E.g. if /// you want to generate the primes below 1000 use /// stop_hint = 1000. /// @pre start <= 2^64 - 2^32 * 10 /// iterator(uint64_t start = 0, uint64_t stop_hint = get_max_stop()); /// Reinitialize this iterator object to start. /// @param start Generate primes > start (or < start). /// @param stop_hint Stop number optimization hint, gives significant /// speed up if few primes are generated. E.g. if /// you want to generate the primes below 1000 use /// stop_hint = 1000. /// @pre start <= 2^64 - 2^32 * 10 /// void skipto(uint64_t start, uint64_t stop_hint = get_max_stop()); /// Advance the iterator by one position. /// @return The next prime. /// uint64_t next_prime() { if (i_++ == last_idx_) generate_next_primes(); return primes_[i_]; } /// Get the previous prime, /// or 0 if input <= 2 e.g. previous_prime(2) = 0. /// uint64_t previous_prime() { if (i_-- == 0) generate_previous_primes(); return primes_[i_]; } private: std::size_t i_; std::size_t last_idx_; std::vector primes_; uint64_t start_; uint64_t stop_; uint64_t stop_hint_; uint64_t tiny_cache_size_; uint64_t get_interval_size(uint64_t); void generate_next_primes(); void generate_previous_primes(); }; } // end namespace #endif primesieve-5.6.0/include/primesieve/littleendian_cast.hpp000066400000000000000000000026741263266076300237100ustar00rootroot00000000000000/// /// @file littleendian_cast.hpp /// @brief Cast bytes in ascending address order on both little and /// big endian CPUs. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef LITTLEENDIAN_CAST_HPP #define LITTLEENDIAN_CAST_HPP #include "config.hpp" namespace primesieve { /// http://c-faq.com/misc/endiantest.html inline bool is_littleendian() { union { int word; char c[sizeof(int)]; } x; x.word = 1; return (x.c[0] == 1); } /// Recursively sum bytes using template metaprogramming. /// e.g. littleendian_cast(array) = /// return (array[0] << 0) + /// (array[1] << 8) + /// (array[2] << 16) + /// (array[3] << 24); /// template struct littleendian_cast_helper { static T sum(const byte_t* array, T n) { n += static_cast(array[INDEX]) << (INDEX * 8); return littleendian_cast_helper::sum(array, n); } }; template struct littleendian_cast_helper { static T sum(const byte_t*, T n) { return n; } }; template inline T littleendian_cast(const byte_t* array) { if (is_littleendian()) return *reinterpret_cast(array); return littleendian_cast_helper::sum(array, 0); } } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/malloc_vector.hpp000066400000000000000000000032671263266076300230520ustar00rootroot00000000000000/// /// @file malloc_vector /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef MALLOC_VECTOR_HPP #define MALLOC_VECTOR_HPP #include #include #include #include namespace primesieve { /// malloc_vector is a dynamically growing array. /// It has the same API (though not complete) as std::vector but it /// uses malloc as its allocator. /// template class malloc_vector { public: malloc_vector() : array_(0), size_(0), capacity_(0), is_free_(true) { resize(16); } malloc_vector(std::size_t n) : array_(0), size_(0), capacity_(0), is_free_(true) { resize(n); } ~malloc_vector() { if (is_free_) free((void*) array_); } void push_back(const T& val) { array_[size_++] = val; if (size_ >= capacity_) resize(size_ * 2); } void reserve(std::size_t n) { if (n > capacity_) resize(n); } void resize(std::size_t n) { n = std::max(n, (std::size_t) 16); T* new_array = (T*) realloc((void*) array_, n * sizeof(T)); if (!new_array) throw std::bad_alloc(); array_ = new_array; capacity_ = n; size_ = std::min(size_, capacity_); } T& operator[] (T n) { return array_[n]; } T* data() { return array_; } std::size_t size() const { return size_; } void disable_free() { is_free_ = false; } public: typedef T value_type; private: T* array_; std::size_t size_; std::size_t capacity_; bool is_free_; }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/pmath.hpp000066400000000000000000000042731263266076300213300ustar00rootroot00000000000000/// /// @file pmath.hpp /// @brief Auxiliary math functions needed in primesieve. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PMATH_HPP #define PMATH_HPP #include namespace primesieve { template inline T numberOfBits(T) { return static_cast(sizeof(T) * 8); } template inline T isquare(T x) { return x * x; } /// @brief Check if an integer is a power of 2. /// @see Book "Hacker's Delight". /// template inline bool isPowerOf2(T x) { return (x != 0 && (x & (x - 1)) == 0); } /// @brief Round down to the next power of 2. /// @see Book "Hacker's Delight". /// template inline T floorPowerOf2(T x) { for (T i = 1; i < numberOfBits(x); i += i) x |= (x >> i); return x - (x >> 1); } /// @brief Fast and protable integer log2 function. /// @see Book "Hacker's Delight". /// template inline T ilog2(T x) { const T bits = numberOfBits(x); const T one = 1; T log2 = 0; for (T i = bits / 2; i != 0; i /= 2) { if (x >= (one << i)) { x >>= i; log2 += i; } } return log2; } /// @brief Integer square root, Newton's method. /// @see Book "Hacker's Delight". /// template inline T isqrt(T x) { if (x <= 1) return x; const T bits = numberOfBits(x); const T one = 1; // s = bits / 2 - nlz(x - 1) / 2 // nlz(x) = bits - 1 - ilog2(x) T s = bits / 2 - (bits - 1) / 2 + ilog2(x - 1) / 2; // first guess: least power of 2 >= sqrt(x) T g0 = one << s; T g1 = (g0 + (x >> s)) >> 1; while (g1 < g0) { g0 = g1; g1 = (g0 + (x / g0)) >> 1; } return g0; } template inline T getInBetween(T min, T value, T max) { if (value < min) return min; if (value > max) return max; return value; } /// @brief Get an approximation of the maximum prime gap near n. /// @return log(n)^2 /// inline uint64_t max_prime_gap(uint64_t n) { double logn = std::log(static_cast(n)); double prime_gap = logn * logn; return static_cast(prime_gap); } } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/primesieve_error.hpp000066400000000000000000000013621263266076300235740ustar00rootroot00000000000000/// /// @file primesieve_error.hpp /// @brief The primesieve_error class is used for all exceptions /// within primesieve. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef PRIMESIEVE_ERROR_HPP #define PRIMESIEVE_ERROR_HPP #include #include namespace primesieve { /// primesieve throws a primesieve_error exception /// if an error occurs that cannot be handled /// e.g. stop > primesieve::max_stop(). /// class primesieve_error : public std::runtime_error { public: primesieve_error(const std::string& msg) : std::runtime_error(msg) { } }; } // namespace primesieve #endif primesieve-5.6.0/include/primesieve/primesieve_iterator.h000066400000000000000000000055431263266076300237410ustar00rootroot00000000000000/** * @file primesieve_iterator.h * @brief primesieve_iterator allows to easily iterate over primes * both forwards and backwards. Generating the first prime * has a complexity of O(r log log r) operations with * r = n^0.5, after that any additional prime is generated in * amortized O(log n log log n) operations. The memory usage * is about pi(n^0.5) * 16 bytes. primesieve_iterator objects * are very convenient to use at the cost of being slightly * slower than the primesieve_callback_primes() functions. * * The @link primesieve_iterator.c primesieve_iterator.c * @endlink example shows how to use primesieve_iterator. If * any error occurs errno is set to EDOM and * primesieve_next_prime() and primesieve_previous_prime() * return PRIMESIEVE_ERROR. * * Copyright (C) 2015 Kim Walisch, * * This file is distributed under the BSD License. See the COPYING * file in the top level directory. */ #ifndef PRIMESIEVE_ITERATOR_H #define PRIMESIEVE_ITERATOR_H #include #include #ifdef __cplusplus extern "C" { #endif /** C prime iterator, please refer to @link primesieve_iterator.h * primesieve_iterator.h @endlink for more information. */ typedef struct { size_t i_; size_t last_idx_; uint64_t* primes_; uint64_t* primes_pimpl_; uint64_t start_; uint64_t stop_; uint64_t stop_hint_; uint64_t tiny_cache_size_; int is_error_; } primesieve_iterator; /** Initialize the primesieve iterator before first using it. */ void primesieve_init(primesieve_iterator* pi); /** Free all memory. */ void primesieve_free_iterator(primesieve_iterator* pi); /** Set the primesieve iterator to start. * @param start Generate primes > start (or < start). * @param stop_hint Stop number optimization hint. E.g. if you want * to generate the primes below 1000 use * stop_hint = 1000, if you don't know use * primesieve_get_max_stop(). * @pre start <= 2^64 - 2^32 * 10 */ void primesieve_skipto(primesieve_iterator* pi, uint64_t start, uint64_t stop_hint); /** Internal use. */ void primesieve_generate_next_primes(primesieve_iterator*); /** Internal use. */ void primesieve_generate_previous_primes(primesieve_iterator*); /** Get the next prime. */ static inline uint64_t primesieve_next_prime(primesieve_iterator* pi) { if (pi->i_++ == pi->last_idx_) primesieve_generate_next_primes(pi); return pi->primes_[pi->i_]; } /** Get the previous prime, * or 0 if input <= 2 e.g. previous_prime(2) = 0. */ static inline uint64_t primesieve_previous_prime(primesieve_iterator* pi) { if (pi->i_-- == 0) primesieve_generate_previous_primes(pi); return pi->primes_[pi->i_]; } #ifdef __cplusplus } /* extern "C" */ #endif #endif primesieve-5.6.0/include/primesieve/toString.hpp000066400000000000000000000007451263266076300220300ustar00rootroot00000000000000/// /// @file toString.hpp /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef TOSTRING_PRIMESIEVE_HPP #define TOSTRING_PRIMESIEVE_HPP #include #include namespace primesieve { template inline std::string toString(T t) { std::ostringstream oss; oss << t; return oss.str(); } } // namespace primesieve #endif primesieve-5.6.0/primesieve.pc.in000066400000000000000000000004151263266076300170060ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ bindir=@bindir@ libdir=@libdir@ includedir=@includedir@ Name: primesieve Description: Fast C/C++ prime number generator Version: @VERSION@ Libs: -L${libdir} -lprimesieve Libs.private: @OPENMP_CXXFLAGS@ Cflags: -I${includedir} primesieve-5.6.0/src/000077500000000000000000000000001263266076300144745ustar00rootroot00000000000000primesieve-5.6.0/src/apps/000077500000000000000000000000001263266076300154375ustar00rootroot00000000000000primesieve-5.6.0/src/apps/console/000077500000000000000000000000001263266076300171015ustar00rootroot00000000000000primesieve-5.6.0/src/apps/console/calculator.hpp000066400000000000000000000310311263266076300217410ustar00rootroot00000000000000/// /// @file calculator.hpp /// @brief calculator::eval(const std::string&) evaluates an integer /// arithmetic expression and returns the result. If an error /// occurs a calculator::error exception is thrown. /// /// @author Kim Walisch, /// @copyright Copyright (C) 2013 Kim Walisch /// @date November 30, 2013 /// @license BSD 2-Clause, http://opensource.org/licenses/BSD-2-Clause /// @version 1.0 patched: `^' is raise to power instead of XOR. /// /// == Supported operators == /// /// OPERATOR NAME ASSOCIATIVITY PRECEDENCE /// /// | Bitwise Inclusive OR Left 4 /// & Bitwise AND Left 6 /// << Shift Left Left 9 /// >> Shift Right Left 9 /// + Addition Left 10 /// - Subtraction Left 10 /// * Multiplication Left 20 /// / Division Left 20 /// % Modulo Left 20 /// ^, ** Raise to power Right 30 /// e, E Scientific notation Right 40 /// ~ Unary complement Left 99 /// /// The operator precedence has been set according to (uses the C and /// C++ operator precedence): http://en.wikipedia.org/wiki/Order_of_operations /// Operators with higher precedence are evaluated before operators /// with relatively lower precedence. Unary operators are set to have /// the highest precedence, this is not strictly correct for the power /// operator e.g. "-3**2" = 9 but a lot of software tools (Bash shell, /// Microsoft Excel, GNU bc, ...) use the same convention. /// /// == Examples of valid expressions == /// /// "65536 >> 15" = 2 /// "2**16" = 65536 /// "(0 + 0xDf234 - 1000)*3/2%999" = 828 /// "-(2**2**2**2)" = -65536 /// "(0 + ~(0xDF234 & 1000) *3) /-2" = 817 /// "(2**16) + (1 << 16) >> 0X5" = 4096 /// "5*-(2**(9+7))/3+5*(1 & 0xFf123)" = -109221 /// /// == About the algorithm used == /// /// calculator::eval(std::string&) relies on the ExpressionParser /// class which is a simple C++ operator precedence parser with infix /// notation for integer arithmetic expressions. /// ExpressionParser has its roots in a JavaScript parser published /// at: http://stackoverflow.com/questions/28256/equation-expression-parser-with-precedence/114961#114961 /// The same author has also published an article about his operator /// precedence algorithm at PerlMonks: /// http://www.perlmonks.org/?node_id=554516 /// #ifndef CALCULATOR_HPP #define CALCULATOR_HPP #include #include #include #include #include #include namespace calculator { /// calculator::eval() throws a calculator::error if it fails /// to evaluate the expression string. /// class error : public std::runtime_error { public: error(const std::string& expr, const std::string& message) : std::runtime_error(message), expr_(expr) { } #if __cplusplus >= 201103L ~error() { } #else ~error() throw() { } #endif std::string expression() const { return expr_; } private: std::string expr_; }; template class ExpressionParser { public: /// Evaluate an integer arithmetic expression and return its result. /// @throw error if parsing fails. /// T eval(const std::string& expr) { T result = 0; index_ = 0; expr_ = expr; try { result = parseExpr(); if (!isEnd()) unexpected(); } catch (const calculator::error&) { while(!stack_.empty()) stack_.pop(); throw; } return result; } /// Get the integer value of a character. T eval(char c) { std::string expr(1, c); return eval(expr); } private: enum { OPERATOR_NULL, OPERATOR_BITWISE_OR, /// | OPERATOR_BITWISE_XOR, /// ^ OPERATOR_BITWISE_AND, /// & OPERATOR_BITWISE_SHL, /// << OPERATOR_BITWISE_SHR, /// >> OPERATOR_ADDITION, /// + OPERATOR_SUBTRACTION, /// - OPERATOR_MULTIPLICATION, /// * OPERATOR_DIVISION, /// / OPERATOR_MODULO, /// % OPERATOR_POWER, /// ** OPERATOR_EXPONENT /// e, E }; struct Operator { /// Operator, one of the OPERATOR_* enum definitions int op; int precedence; /// 'L' = left or 'R' = right int associativity; Operator(int opr, int prec, int assoc) : op(opr), precedence(prec), associativity(assoc) { } }; struct OperatorValue { Operator op; T value; OperatorValue(const Operator& opr, T val) : op(opr), value(val) { } int getPrecedence() const { return op.precedence; } bool isNull() const { return op.op == OPERATOR_NULL; } }; /// Expression string std::string expr_; /// Current expression index, incremented whilst parsing std::size_t index_; /// The current operator and its left value /// are pushed onto the stack if the operator on /// top of the stack has lower precedence. std::stack stack_; /// Exponentiation by squaring, x^n. static T pow(T x, T n) { T res = 1; while (n != 0) { if (n % 2 != 0) { res *= x; n -= 1; } x *= x; n /= 2; } return res; } T checkZero(T value) const { if (value == 0) { std::string divOperators("/%"); std::size_t division = expr_.find_last_of(divOperators, index_ - 2); std::ostringstream msg; msg << "Parser error: division by 0"; if (division != std::string::npos) msg << " (error token is \"" << expr_.substr(division, expr_.size() - division) << "\")"; throw calculator::error(expr_, msg.str()); } return value; } T calculate(T v1, T v2, const Operator& op) const { switch (op.op) { case OPERATOR_BITWISE_OR: return v1 | v2; case OPERATOR_BITWISE_XOR: return v1 ^ v2; case OPERATOR_BITWISE_AND: return v1 & v2; case OPERATOR_BITWISE_SHL: return v1 << v2; case OPERATOR_BITWISE_SHR: return v1 >> v2; case OPERATOR_ADDITION: return v1 + v2; case OPERATOR_SUBTRACTION: return v1 - v2; case OPERATOR_MULTIPLICATION: return v1 * v2; case OPERATOR_DIVISION: return v1 / checkZero(v2); case OPERATOR_MODULO: return v1 % checkZero(v2); case OPERATOR_POWER: return pow(v1, v2); case OPERATOR_EXPONENT: return v1 * pow(10, v2); default: return 0; } } bool isEnd() const { return index_ >= expr_.size(); } /// Returns the character at the current expression index or /// 0 if the end of the expression is reached. /// char getCharacter() const { if (!isEnd()) return expr_[index_]; return 0; } /// Parse str at the current expression index. /// @throw error if parsing fails. /// void expect(const std::string& str) { if (expr_.compare(index_, str.size(), str) != 0) unexpected(); index_ += str.size(); } void unexpected() const { std::ostringstream msg; msg << "Syntax error: unexpected token \"" << expr_.substr(index_, expr_.size() - index_) << "\" at index " << index_; throw calculator::error(expr_, msg.str()); } /// Eat all white space characters at the /// current expression index. /// void eatSpaces() { while (std::isspace(getCharacter()) != 0) index_++; } /// Parse a binary operator at the current expression index. /// @return Operator with precedence and associativity. /// Operator parseOp() { eatSpaces(); switch (getCharacter()) { case '|': index_++; return Operator(OPERATOR_BITWISE_OR, 4, 'L'); case '&': index_++; return Operator(OPERATOR_BITWISE_AND, 6, 'L'); case '<': expect("<<"); return Operator(OPERATOR_BITWISE_SHL, 9, 'L'); case '>': expect(">>"); return Operator(OPERATOR_BITWISE_SHR, 9, 'L'); case '+': index_++; return Operator(OPERATOR_ADDITION, 10, 'L'); case '-': index_++; return Operator(OPERATOR_SUBTRACTION, 10, 'L'); case '/': index_++; return Operator(OPERATOR_DIVISION, 20, 'L'); case '%': index_++; return Operator(OPERATOR_MODULO, 20, 'L'); case '*': index_++; if (getCharacter() != '*') return Operator(OPERATOR_MULTIPLICATION, 20, 'L'); case '^': index_++; return Operator(OPERATOR_POWER, 30, 'R'); case 'e': index_++; return Operator(OPERATOR_EXPONENT, 40, 'R'); case 'E': index_++; return Operator(OPERATOR_EXPONENT, 40, 'R'); default : return Operator(OPERATOR_NULL, 0, 'L'); } } static T toInteger(char c) { if (c >= '0' && c <= '9') return c -'0'; if (c >= 'a' && c <= 'f') return c -'a' + 0xa; if (c >= 'A' && c <= 'F') return c -'A' + 0xa; T noDigit = 0xf + 1; return noDigit; } T getInteger() const { return toInteger(getCharacter()); } T parseDecimal() { T value = 0; for (T d; (d = getInteger()) <= 9; index_++) value = value * 10 + d; return value; } T parseHex() { index_ = index_ + 2; T value = 0; for (T h; (h = getInteger()) <= 0xf; index_++) value = value * 0x10 + h; return value; } bool isHex() const { if (index_ + 2 < expr_.size()) { char x = expr_[index_ + 1]; char h = expr_[index_ + 2]; return (std::tolower(x) == 'x' && toInteger(h) <= 0xf); } return false; } /// Parse an integer value at the current expression index. /// The unary `+', `-' and `~' operators and opening /// parentheses `(' cause recursion. /// T parseValue() { T val = 0; eatSpaces(); switch (getCharacter()) { case '0': if (isHex()) { val = parseHex(); break; } case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': val = parseDecimal(); break; case '(': index_++; val = parseExpr(); eatSpaces(); if (getCharacter() != ')') { if (!isEnd()) unexpected(); throw calculator::error(expr_, "Syntax error: `)' expected at end of expression"); } index_++; break; case '~': index_++; val = ~parseValue(); break; case '+': index_++; val = parseValue(); break; case '-': index_++; val = parseValue() * static_cast(-1); break; default : if (!isEnd()) unexpected(); throw calculator::error(expr_, "Syntax error: value expected at end of expression"); } return val; } /// Parse all operations of the current parenthesis /// level and the levels above, when done /// return the result (value). /// T parseExpr() { stack_.push(OperatorValue(Operator(OPERATOR_NULL, 0, 'L'), 0)); // first parse value on the left T value = parseValue(); while (!stack_.empty()) { // parse an operator (+, -, *, ...) Operator op(parseOp()); while (op.precedence < stack_.top().getPrecedence() || ( op.precedence == stack_.top().getPrecedence() && op.associativity == 'L')) { // end reached if (stack_.top().isNull()) { stack_.pop(); return value; } // do the calculation ("reduce"), producing a new value value = calculate(stack_.top().value, value, stack_.top().op); stack_.pop(); } // store on stack_ and continue parsing ("shift") stack_.push(OperatorValue(op, value)); // parse value on the right value = parseValue(); } return 0; } }; template inline T eval(const std::string& expression) { ExpressionParser parser; return parser.eval(expression); } template inline T eval(char c) { ExpressionParser parser; return parser.eval(c); } inline int eval(const std::string& expression) { return eval(expression); } inline int eval(char c) { return eval(c); } } // namespace calculator #endif primesieve-5.6.0/src/apps/console/cmdoptions.cpp000066400000000000000000000110741263266076300217670ustar00rootroot00000000000000/// /// @file cmdoptions.cpp /// @brief Parse command-line options for the primesieve console /// (terminal) application. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include "cmdoptions.hpp" #include "calculator.hpp" #include #include #include #include #include #include void help(); void version(); using namespace std; using namespace primesieve; namespace { /// e.g. id = "--threads", value = "4" struct Option { string id; string value; template T getValue() const { return calculator::eval(value); } }; enum OptionValues { OPTION_COUNT, OPTION_HELP, OPTION_NTHPRIME, OPTION_NUMBER, OPTION_DISTANCE, OPTION_PRINT, OPTION_QUIET, OPTION_SIZE, OPTION_TEST, OPTION_THREADS, OPTION_TIME, OPTION_VERSION }; /// Command-line options map optionMap; void initOptionMap() { optionMap["-c"] = OPTION_COUNT; optionMap["--count"] = OPTION_COUNT; optionMap["-h"] = OPTION_HELP; optionMap["--help"] = OPTION_HELP; optionMap["-n"] = OPTION_NTHPRIME; optionMap["--nthprime"] = OPTION_NTHPRIME; optionMap["--number"] = OPTION_NUMBER; optionMap["-d"] = OPTION_DISTANCE; optionMap["--dist"] = OPTION_DISTANCE; optionMap["-o"] = OPTION_DISTANCE; optionMap["--offset"] = OPTION_DISTANCE; optionMap["-p"] = OPTION_PRINT; optionMap["--print"] = OPTION_PRINT; optionMap["-q"] = OPTION_QUIET; optionMap["--quiet"] = OPTION_QUIET; optionMap["-s"] = OPTION_SIZE; optionMap["--size"] = OPTION_SIZE; optionMap["--test"] = OPTION_TEST; optionMap["-t"] = OPTION_THREADS; optionMap["--threads"] = OPTION_THREADS; optionMap["--time"] = OPTION_TIME; optionMap["-v"] = OPTION_VERSION; optionMap["--version"] = OPTION_VERSION; } void test() { bool ok = primesieve_test(); exit(ok ? 0 : 1); } int check(int primeType) { primeType--; if (primeType < 0 || primeType > 5) help(); return primeType; } int getCountFlags(int n) { int flags = 0; do { int primeType = check(n % 10); flags |= PrimeSieve::COUNT_PRIMES << primeType; n /= 10; } while (n > 0); return flags; } int getPrintFlags(int n) { return PrimeSieve::PRINT_PRIMES << check(n); } /// e.g. "--threads=8" -> (id = "--threads", value = "8") Option makeOption(const string& str) { Option option; size_t delimiter = str.find_first_of("=0123456789"); if (delimiter == string::npos) option.id = str; else { option.id = str.substr(0, delimiter); option.value = str.substr(delimiter + (str.at(delimiter) == '=' ? 1 : 0)); } if (option.id.empty() && !option.value.empty()) option.id = "--number"; if (optionMap.count(option.id) == 0) option.id = "--help"; return option; } } // end namespace PrimeSieveOptions parseOptions(int argc, char** argv) { initOptionMap(); PrimeSieveOptions pso; try { for (int i = 1; i < argc; i++) { Option option = makeOption(argv[i]); switch (optionMap[option.id]) { case OPTION_COUNT: if (option.value.empty()) option.value = "1"; pso.flags |= getCountFlags(option.getValue()); break; case OPTION_PRINT: if (option.value.empty()) option.value = "1"; pso.flags |= getPrintFlags(option.getValue()); pso.quiet = true; break; case OPTION_SIZE: pso.sieveSize = option.getValue(); break; case OPTION_THREADS: pso.threads = option.getValue(); break; case OPTION_QUIET: pso.quiet = true; break; case OPTION_NTHPRIME: pso.nthPrime = true; break; case OPTION_TIME: pso.time = true; break; case OPTION_NUMBER: pso.numbers.push_back(option.getValue()); break; case OPTION_DISTANCE: pso.numbers.push_back(option.getValue() + pso.numbers.front()); break; case OPTION_TEST: test(); break; case OPTION_VERSION: version(); break; case OPTION_HELP: help(); break; } } } catch (exception&) { help(); } if (pso.numbers.size() < 1 || pso.numbers.size() > 2) help(); if (!pso.quiet) pso.time = true; return pso; } primesieve-5.6.0/src/apps/console/cmdoptions.hpp000066400000000000000000000011701263266076300217700ustar00rootroot00000000000000/// /// @file cmdoptions.hpp /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #ifndef CMDOPTIONS_HPP #define CMDOPTIONS_HPP #include #include struct PrimeSieveOptions { std::deque numbers; int flags; int sieveSize; int threads; bool quiet; bool nthPrime; bool time; PrimeSieveOptions() : flags(0), sieveSize(0), threads(0), quiet(false), nthPrime(false), time(false) { } }; PrimeSieveOptions parseOptions(int, char**); #endif primesieve-5.6.0/src/apps/console/help.cpp000066400000000000000000000042521263266076300205400ustar00rootroot00000000000000/// /// @file help.cpp /// @brief help() and version() functions of the primesieve /// console application. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include using namespace std; namespace { const string helpMenu( "Usage: primesieve [START] STOP [OPTION]...\n" "Generate the primes and/or prime k-tuplets in the interval [START, STOP]\n" "(< 2^64) using the segmented sieve of Eratosthenes.\n" "\n" "Options:\n" "\n" " -c[N+], --count[=N+] Count primes and prime k-tuplets, 1 <= N <= 6\n" " N: 1 = primes, 2 = twins, 3 = triplets, ...\n" " -d, --dist= Sieve the interval [START, START + N]\n" " -h, --help Print this help menu\n" " -n, --nthprime Calculate the nth prime,\n" " e.g. 1 100 -n finds the 1st prime > 100\n" " -p[N], --print[=N] Print primes or prime k-tuplets, 1 <= N <= 6\n" " N: 1 = primes, 2 = twins, 3 = triplets, ...\n" " -q, --quiet Quiet mode, prints less output\n" " -s, --size= Set the sieve size in kilobytes, 1 <= N <= 2048\n" " --test Run various sieving tests and exit\n" " -t, --threads= Set the number of threads, 1 <= N <= CPU cores\n" " --time Print the time elapsed in seconds\n" " -v, --version Print version and license information\n" "\n" "Examples:\n" "\n" " Print the primes below 1000000\n" " $ primesieve 1e6 --print\n" "\n" " Count the twin primes inside [10^9, 10^9 + 2^32]\n" " $ primesieve 1e9 --dist=2**32 -c2" ); } // end namespace void help() { cout << helpMenu << endl; exit(1); } void version() { cout << "primesieve " << primesieve::primesieve_version(); cout << ", " << endl; cout << "Copyright (C) 2015 Kim Walisch" << endl; cout << "BSD 2-Clause License " << endl; exit(1); } primesieve-5.6.0/src/apps/console/main.cpp000066400000000000000000000064161263266076300205400ustar00rootroot00000000000000/// /// @file main.cpp /// @brief This file contains the main() function of the primesieve /// console (terminal) application. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include "cmdoptions.hpp" #include #include #include #include #include using namespace std; using namespace primesieve; namespace { void printResults(ParallelPrimeSieve& pps, PrimeSieveOptions& options) { cout << left; const string labels[] = { "Primes", "Twin primes", "Prime triplets", "Prime quadruplets", "Prime quintuplets", "Prime sextuplets" }; // largest label size, computed below int size = 0; for (int i = 0; i < 6; i++) { if (pps.isCount(i)) { int label_size = (int) labels[i].size(); size = max(size, label_size); } } if (options.time) { int label_size = (int) string("Seconds").size(); size = max(size, label_size); } // print results for (int i = 0; i < 6; i++) { if (pps.isCount(i)) cout << setw(size) << labels[i] << " : " << pps.getCount(i) << endl; } if (options.time) cout << setw(size) << "Seconds" << " : " << fixed << setprecision(3) << pps.getSeconds() << endl; } /// Used to count and print primes and prime k-tuplets void sieve(PrimeSieveOptions& options) { ParallelPrimeSieve pps; deque& numbers = options.numbers; if (options.flags != 0) pps.setFlags(options.flags); if (options.sieveSize != 0) pps.setSieveSize(options.sieveSize); if (options.threads != 0) pps.setNumThreads(options.threads); else if (pps.isPrint()) pps.setNumThreads(1); if (numbers.size() < 2) numbers.push_front(0); pps.setStart(numbers[0]); pps.setStop (numbers[1]); if (!options.quiet) { cout << "Sieve size = " << pps.getSieveSize() << " kilobytes" << endl; cout << "Threads = " << pps.getNumThreads() << endl; // enable printing status if (!pps.isPrint()) pps.addFlags(pps.PRINT_STATUS); } pps.sieve(); printResults(pps, options); } void nthPrime(PrimeSieveOptions& options) { ParallelPrimeSieve pps; deque& numbers = options.numbers; if (options.flags != 0) pps.setFlags(options.flags); if (options.sieveSize != 0) pps.setSieveSize(options.sieveSize); if (options.threads != 0) pps.setNumThreads(options.threads); if (numbers.size() < 2) numbers.push_back(0); uint64_t n = numbers[0]; uint64_t start = numbers[1]; uint64_t nthPrime = pps.nthPrime(n, start); cout << "Nth prime : " << nthPrime << endl; if (options.time) cout << "Seconds : " << fixed << setprecision(3) << pps.getSeconds() << endl; } } // namespace int main(int argc, char** argv) { PrimeSieveOptions options = parseOptions(argc, argv); bool isNthPrime = options.nthPrime; try { if (isNthPrime) nthPrime(options); else sieve(options); } catch (exception& e) { cerr << "Error: " << e.what() << "." << endl << "Try `primesieve --help' for more information." << endl; return 1; } return 0; } primesieve-5.6.0/src/apps/gui/000077500000000000000000000000001263266076300162235ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/AUTHORS000066400000000000000000000000451263266076300172720ustar00rootroot00000000000000Kim Walisch, primesieve-5.6.0/src/apps/gui/COPYING000066400000000000000000001045131263266076300172620ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . primesieve-5.6.0/src/apps/gui/INSTALL000066400000000000000000000017161263266076300172610ustar00rootroot00000000000000 ============================================= = Compilation instructions for primesieve = ============================================= 1. About ======== The primesieve GUI application has been developed with the Qt framework (http://qt-project.org). This file explains how to install Qt and build the primesieve GUI application. 2. Download and install Qt ========================== For Windows download and install the latest Qt 4 SDK: ftp://ftp.qt-project.org/qt/source/qt-win-opensource-4.8.1-mingw.exe For all other OSes download and install the latest Qt 5 SDK: http://qt-project.org/downloads PATH (variable) --------------- After the installation add /path-to-qt/bin to the PATH variable. 3. Build the primesieve GUI application ======================================= After having installed Qt, open a terminal and cd into the current directory then run the following commands: $ qmake && make primesieve-5.6.0/src/apps/gui/README000066400000000000000000000022121263266076300171000ustar00rootroot00000000000000 ================================ = primesieve GUI application = ================================ 1. About ======== This directory contains the primesieve GUI application developed with the Qt framework (http://qt-project.org). The INSTALL file in the current directory explains how to build the primesieve GUI application. 2. Project file =============== * primesieve.pro Project file for use with the Qt-Creator IDE. 3. Source files =============== * src/PrimeSieveGUI.cpp & .h Contains the graphical user interface code. * src/PrimeSieveGUI_menu.cpp Contains code related to the menu bar. * src/PrimeSieveProcess.cpp & .h Class that is used for prime sieving. PrimeSieveProcess launches a ParallelPrimeSieve instance in a new process, this approach allows to easily cancel sieving by killing the process. The inter-process communication between the GUI process (PrimeSieveGUI) and the ParallelPrimeSieve instance is realised via shared memory. * src/main.cpp Contains the ParallelPrimeSieve code launched by PrimeSieveProcess objects. primesieve-5.6.0/src/apps/gui/forms/000077500000000000000000000000001263266076300173515ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/forms/PrimeSieveGUI.ui000066400000000000000000000301651263266076300223320ustar00rootroot00000000000000 PrimeSieveGUI 0 0 526 454 true 0 0 6 10 16 10 0 Qt::Horizontal QSizePolicy::Fixed 8 20 Qt::Horizontal QSizePolicy::Fixed 8 20 false 0 0 16777215 16777215 Cancel 0 0 16777215 16777215 Sieve false 20 true 20 0 0 16777215 16777215 Lower bound 0 0 16777215 16777215 Upper bound 0 0 16777215 16777215 Sieve size 70 0 70 16777215 7 32 QComboBox::AdjustToContents Qt::Horizontal 40 20 0 0 16777215 16777215 Threads 70 0 70 16777215 7 32 Qt::Horizontal QSizePolicy::Fixed 10 0 Auto set true 0 0 16777215 16777215 Progress 1000 0 Qt::Horizontal QSizePolicy::Fixed 6 20 Qt::Horizontal QSizePolicy::Fixed 6 20 Qt::Vertical QSizePolicy::Fixed 20 10 false false 0 Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse 2048 0 0 526 21 false lowerBoundLineEdit upperBoundLineEdit sieveSizeComboBox threadsComboBox autoSetCheckBox sieveButton cancelButton primesieve-5.6.0/src/apps/gui/icons/000077500000000000000000000000001263266076300173365ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/icons/osx/000077500000000000000000000000001263266076300201475ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/icons/osx/primesieve.icns000066400000000000000000000745071263266076300232120ustar00rootroot00000000000000icnsyGic08y? jP ‡ ftypjp2 jp2 Ojp2hihdrcolr"cdefxÈjp2cÿOÿQ2ÿR ÿ\@@HHPHHPHHPHHPHHPÿd Axialisÿ xXÿS ÿ]@@HHPHHPHHPHHPHHPÿS ÿ]@@HHPHHPHHPHHPHHPÿS ÿ]@@HHPHHPHHPHHPHHPÿ“ßz0€Zà^c—Løp’Ý6­®:ÍñÎ<_Y}$†oŽ‘Bªâ°Ð‘I0~÷Àz5ö—¸'ºú»Û`Ǭ~]+È&Pu„ßz8Pp ¤6´$Þ&IVyÉjaL0B.weùvãÖ»Êä[÷òåeá§œ蚫qÅ0¹ÌCúùd”nGÑ/ïÄ}Ͻ}çñ÷Ÿ8£„G­mÜ9@¼“3x£ÀÁ¨ŠZ>•‹Æ‰!ñ»-›ÏEåŠç¢ïȨº5à÷ ƒÊ„äàé‡Ú`œÛ™}.P]ŸÝ!9Læ ÎÛóÛ^VçøÒ?YäU›­Âê[˜ÁL]#úZ»áx)#LÏ—D6³Ý–Ð'˜U˜ÝPÇ(·è¢âf• =Ó…èkã~øiø—i¶âf—åO äãëÃgÀš¯è`£ŸÆ]úœ‘‚—Jr9¶J¾÷¸—õp’8 ÇØuaÔ>à.G€T'QuJ¸~8½–(¤?²) j†LƒÐSíç¿ü9B&Ú«cÛ³ryRŸ'ج;BK::ú{DHm )ß©LW!9T¦••ÔVâ>~ÃËxKÓöBæ¬h~ÿF³Ñ?s±àªt¹©ôEjnß%:Lô¾è–s«ÝúÎT™]ÝÏ¡pÚbþv¡°ãì/õêÏã`r9 nd\‚É~ŽT)".Ñn ?ß‘•ùOÈ´7s¡„PN·ë Ë´ÊŒOëvX÷¡ñ¯œˆÎêƒ[´ÎÐÊd êQ›·üë6ÖsH­?çû·£­é²¶¢¾ÕQ„½QKŒé '}{)[e¬ý¤(ÁA=kûûѽƨ½Q¡¤Ø `É J‡tsz1Èó§ê SÂ0›•¸xC¦»·4{ED‡vÁ„ÇŒ™÷ÇÙVÇÙXGßYx´·”D'Î÷3¼9;YsŒèÔû%JÏŽÌѼ*`­U.ɧ.ÿÆs5´Èá·Æ7E©Q¸ðèÃ4´4=ðP Y.;ß¼[Îp‰b¯¤ÃÙŸ¼Ëœ_:®­úOýN¢-÷W!´’ œ[° ´j¿¶ýS*û8-í}òïeîA©’é‘ÁÍîÒ 'šRõÅJqÍ…B²øÆ×èª*Çí)>¸ö{í4zðàÿéáè·¸¨"/4Ö¥ã75Hù[ÐÚ&FB®qÛe¦Û4P`r°®XâLÕ&’‚Éõ [¸Ý~[òö Cïa7LG‡ºÿ`EÜHòåè°Dªdea¨ÛޏçŽ<|BLŒŸßÜŸŸYBVôŽÚ¸‹}·±§ËZY8êjM¤'q5,oéͤ‰½éPiJRN¸é'Q"M|.@[ËBUJºÑb¸n ¿|ˆõäHÃõdðy”+€ðÔHääãrèï%ª¸iË, Ÿ—$“#¿yøøX¢\•¾XYtI]/&fùÛ“GÄøÿ2ãÕq%²G¨œ1YÆh*„Ô’¢þý’,§µÏxߦçç¸12U¸/âOøý“Lz‹nx±óe#lj0ü­å*`ªÚ´ÃØñý©pcÕ‹ Òy—Ãá@óå›~SØÜÉø’t5³ð©D:Ûor:h£Ï¾¸Ÿ}w}t‹¿¡–yJµç1ÁCAG}wæê?r^ºÀß“âð£ÖqOëûúÉlÀ=”M8ëåw§óÚQY„”¥‚ôª­z…«bé.¶`·T~Ÿ!_(}V,>“œ ÇöÈö\ßò;ýý Wxi©^—Ã5(U¦œ OæE°ßí¾!°p|˜Çå>@»Ñ³uuÂú{–&~HìÌ€€Ò”½Çš [/sÉhY\¬á‹kÄÍ:é   ž]æ?¤£‰øYF¸>.’+!׃U­A¶¸–èÞLÍåõú Ÿå(EÑ) ƒŽ’tiü×çñƒˆ³éÊa9£$XþD2¾oì›ß¢³ÐI¥BÛ%Ço{žt[‹/ v->â(â§¥,ˆyO¼µ`ÐWPG»JááHð—ަ›Q%&hK›üŠ/T`yN3sHZv9GG¾/ÞÚE¤I¤·ß œvvìs{ÙóN7åý›Ÿ¸¿¢Ù› ö²wMϦ'Xž÷ßžIöà Ýù¹¬8›È½/zÅU4«óÜ®#'$ƒ3Þ¢ö]LE(*Íq+­LÇZ†½·ot’|λ.×§F¿"Së(û%Ó~îEŸ¥ §a®ƒeá"…0óŠ·`ÏŠwÒmghPÏUš>Hík´ Ø}÷ƒ’*œ Mlï†Þ’8Y•E |’îXŸ®¥]RÜõnkÄ-K8S¿ê‚"`·—.uð¼l—=.;ô/¬/ëÇÙRÇÙRÃì«xVÕ€bI3ïì|#5ìLüÖÜ&&g–²•@êÛÊ~{›HdÓ3ÚíŠtÅn`ú6 (Ì¿XÅc±cj²3Ç÷ž…²m°¿¸5‚5e¿‚)%oG=ø—I2Ͱ?øÕb¿5Cë1O7aì›wó;?äk µ§rÂ+ÑXl€¹’}zXfú7Ì #%z±0§¼¥—¡lº¯/¤ uðñô(õ—¬ÓÙsCùzó'åiø Ÿúœ‹"‰vº©<Söƒvo~ÌOHÉl未Y‘&Àœ-D&6ºª,²JÓ] öçâ^yXh®S®ž5†Y¿§Mg”írE¢Ó±ØùèÿBEí¸i6¥rÔÔ^Ò¡£ á•¿]1lþ`»à¢¥µ +οf°iY»òó ûÃÐzY~X·ûwIQSXØÑ@WŒOЦëCß$oC0›]þ—÷m=jJõsnÌ5X§™ålÞ~ýõ`z¨9ØlýgÖoÜî7~¹ºY°C_Å%£ä†¤œui”³R±ü¦"pM®öÜš±ÈS‰F&Ù£¢ìbhŸü–ä£Å™ŒJ€^§ëË:íˆÄ™šÄkìò l‡ÿ=ž—äM;®ÈûœuvдS‹UõùrOðkJ›ß• ~T$ü¨P‹±¦Õ·ažrÓí ÊÄøePu ™¶s>û¥¯>U82´ÉeÇ·»’b’Ó|Ú”›Iݧm©á±D”43¾¦äïWh´}LXŸx†U4‚ö·r¤iQû@};ä:±üÌ`EÃÜ6Þ-¿é©Ø”àÝR£óýÔ¤ ("gñtäIÊ Èz£ú#Iø\EÀ*!­žgÚwIÎQ3éÿ4^^Wå ‚ܱœ,ì”f¬£WË‚ÛUÌ¢‘T¤×8bnˆ†SÜÅʨ;$Ì1å¯ÐõZÑþÞ¬7UÎÈ$ÿ „5µnR´¯n¯É"×W³ ]ëcf¨x[·$¾²Þ1‰HÖ*ߤ{kËKÏêÚ›.´C² ‚ðM&vHáÀÅšÁ ÿÐÿXఌ逋çßÄ;õ„­`\Ja$,“S6{Çñ'ÅÞ<ÿDmŒÇ>åDŠm¸l¶®ÑgE|è3ÔeŽÒ%ÀAsv|4)²Lyj=HxŽâµçÇD‰™iá5(‡2GA)‹ÈÛÙ§ÏÃe§ß³Q÷ìÀ·gßH)º¥ª­:Ý è/9ã´12 ìß}Tþ¿ˆKr* ’íÀç³£¶q$°7Ý@ä—^¤ó« t¡Óø"ï`Û„¥|¹±¨R¤× ¤…/1äºÂ1"Aªål'®°Þ “Op[Ùk_v®qäXÏõpéK ¿õƒK@‡™3Ô{W»LŽÚû!ž¢!p½i'@TuÔ–¤¬vñ(ˆD1D÷ÌÊ+¸Ä|¢BPÅúvl8#G[¡Uºª¬|‹ðbhÖ`º¶PÒ*)ÆÒK„λ9…2ïw8˜1q_Þ ²$xnî©{ÙꂞiÆc',¡í¡k¹ F¾¦n¾<®.ÔÆESœx­ù²-¥£û.=˜Àú¸`½¤i. Vùî•Sô«"Éd»T·As`ºwC· €×Ú.N6K±qÁ8\B+7jJáè\šó6âTÜБ¸O™µÏA—›?bªÌ`úý&‡ÑøÈÔ3Å:xÝH9œ2fj/~8Է؈Ä ã˜[» ïÕN{ÚDdÐ «„¾yï•ÔlAú ²aAmÅ f:94rfm]¸,^Øu+][Ÿ£Öi,ÕÃé({×’/ö™Ã¯o{VEá2,ߦÊS¬±„¥D~½íÜ? ¤ _ÉÛkBpQkç_øç±ðÌJçðô<úC‹¿w.ì½5l¬J ŸúÀ°zg¥àL{ÅëÔ èqœÌ§\z˜ûSñŒ{Ù|öR—ïé7¯UŠXžQWžÄ;AhªØóì¦Iåèa‹sÃ4!@BËCŠ.WÜÑmnc‚6j)zG5NM˜—V.9+¤Œ£Y|ÜMѱ÷}ë5ôŠ´*™-Q©Íñ vß=e‹’‚C½÷ ÏÃj'áµ÷íHÌ{’¾¼ÑeËcÿL/»ÍF‹i„âõñb˔ȫãá4asyÂz»|32®¾ùv©Ô”P+éc5ãOz¢¡À˧¨83D·¨&ÚÖ›rD Ãg$’}Þ-.wìr¼Áy`•%Õ—X½e_ØéåkŽViÄ£4æOÞ¯BxÂyç¦ÉYaáG‘&ì=ɲy|„ÞðQëí«—!LÔµò^NüšÉ„…rB%L‹FX‡„¸Q•äÛÿƒnºñ”3ùÔR¥¾Rêβæím0×®´L.ÛÒU+ꕹC` ïÉa1:Í€À°ôŠ]~46™z•q×¾eªø"NˆWª™^‹Í5møJýº£‚I:_u9*¦Š1Q“už¡­Ù‹E}æÑüõ4œ8båù¾BAÌYm º~…SðDdcŠûBz-ߨ²wÀ¹WI?#%ă~»Ñ˜MˆØÔ6 ÝÁó@ àEl¥°™?âkÁd1‰2^™Ümr»cx´â†ÃF¶9E.%:åtùãðÏÓߊ`0®¾ò€Y´«2®S®qA®j@¦Ý¬{O PF?!ÜkÕXáÄš.H\d­ôÇ\¼‘$ê~—RUPÙÝÝ šÝ¦.J¨ÜsÝó ö‹RU‹êˆúú1jn„„\Ì™Ñåøk¿åF[[_ÿtSS‡[¹Ëéú@ƒ2iu¾ •à’J_@¬k(DB¨Õú놳5Yh{âzÎ/t¦ÛÿˆïpRT³6rH’ܯM}/ÀQœr²~¬ã(¼ *h”Oxyß0õ™í°Ü‘Î"¾n…k ‹³u>‚Ÿ©BZ–[¢D«zw{ÌpÖ];©ÞA§ö–ŠðÚ+°idÒeÝ /a×!t-Á˳¤^dA·r\©`Á{í!ïÑi%máeúÍÖ(êò ^Ðo'Ï@ +†]¦„`éR3!Ât}…þy±u9„Ñ»j¬&ìߊ›V+ƒ>ÈH•Çq2d.É`Þ[™Í3GL¶9âÊù”PŒÔ o>Œ˜<™¿ žJëÁÄsõ5{AÛÓÉÐâ\ÁáƒoqyùoNf¤_–T¶=ÿf‰ êyòùæ”ò [ÔÉ ÅÐjÎ>›îÔ!uŽrOØD“‚ì·/6§5szyÔýsï.RîNÊ^ÑÆÉÚ–|;¡`n!˜fäuq+´£z=þ6´TY °ÿµ¿üNã5’Õy¥ ã<½:)Þ£yØØ¸Å^ u0Â)¾‚E S¿ê0‹’$½ƒd î‹yÆBPÔK~|ÉùeGKÑïNXÖ†–O}ÜQ?,íZÀ N¦ºÿ\®õ¦¥o½O6w´AŠÊ¬d:¸iU,:2Ç‹¾°=èMlü{`¯3ÌW¸cjàж„Ù&G‚«a„±UNÔÕ‚DF´RŸ—,ÿkÆ<ÖÇ—ÙjÚÙlþøš3hŒÅdïæ[&Тwo~J¯ÃF^¨ÂiŽè¬Ó˜—¸¶s‰2s'´ˆ+²,Hõ+†.Ìùàk˜Þ–ü_«Ü¦8q±t…(¿ÄÖPxîÀÜ×G‚·¢_µº j'î lôÌ^Ž”Æ(¤eÁbcšòvnaW4#«œRÁQÇÛ¯1öëÌ>Ý„·eÓðfº¼V!t/Ái¿w ´8™mÉ'¯#´È\ÑÁµÜŸ^z† øÁuá[žï*¸z»÷y•,úBöBhLIYØáuÿXåô­áNJm·M¨$„©8«ïRö(±øÕQ˶w:•PRxtõ´~»½QZÒçE…º$©NQWô±PhZIk«ÿ;ø¯Š„ç]ùËð¾S œé5ê¨=æ³+ ~¬ °@j¬w»*XP!ß²i†AÕ•Ó7_÷8}×?¹24êSCý']o±nk×u‘òßvÛ·Ï•( Ö‚Í:Ž:°ðƒ2%ÀØõ918Á°âçSDÞ€¡­ÖzBå?¦ø)ç·¾¢Â©7$È?ÈÊ@Ú†¯AÉ¢f©„Q…ä–‘²û¢²ŠñÃÉò>¿Ö"ˆ©P+MRõ›\l%­g+™ë¶=FÃæOœe/OèÖä ™p —ìúM`“Tæ;4=(Ô™Fnb8‡…«nÙ*DORí=+V¬qüÀ±.#iÝåh°”ÁÕ\xÁ¶R¾³™ ×Ú±ð¸>³FHä¯eØ”ˆšËº¡ñFr•ÖC·v3>Œ¸-Pz|%IR{8oî{«Ê¾•‚%F…µÅm1¨~0c Ûˆƒ³„€Z†ÓÉü¯=Ÿyëë‹ÿH©—Ó±÷‡Æb{6â´°æáÙÓ•D¢¼D)¿5Ü.<Ÿ/º0HWæá½êfdèYÆ[÷a,cSna [K­¡ivºXScJr4#Bع1q(zrM&ÎïØ SÑä¡ç‹È‚2?›І Ž U.{AeÍm÷G/ž\ˆX]]Îhˆr(ž L¨o.y„÷!+ô‚aéùÂþ2­2¤ÕåK8>9±×ô÷¨üÑøÍ¶—&ƒ¶ç>ð0—¬×›þèðÖ*|¯%ó7œ7Ðå¡ò`ßsýÝXÑCÇ’§†)ùñ¨{š2Ó:yTðf‡L•Ø»”æ¥Q¡! aÕqÄœºŽ¨ëµx,-Öœ›º:ÌlùÓËo`bã=6þ–Ê3—ž~¢`ò‡éAUŽx8†îþ•T™Ãþ*>¯öóûƒY#OYQ0ÞÝ&1çé‰6 vBÒûXmö%¸£D6ì‘Å‚Hß7×KaÍNPŽ^*ËnŽ–¡®¦ÈLdû¯¯Ÿ%6áæNgcŽ4ÿYzAÑ£ ½ÉS©™M!;Çn>Ö¼C2~Pk¥ƒ¨ÐQ—\žl·Ñy÷¯„â9óHå¶ý5Ï¿Dçߢ³òÐàª]K¶¶¢ªôÔ“BåÏ€p{Ú¨EÔæ€_ÛüéIñÞ}‘»® –òv h#?EL½úÐ\0¨á ÖþŸS#Püè7 mé§—…uá†@^üqì¸Rš ;¶L§Ÿ}‹¦»e?ËóbuÊÑĽV·u´k&²y %^Þ_dîÍ_ösÈ*XôdD*ÿAÉß&|íù²¼Ö|"¨?7ߛӺûø‡ûäáðLo‚ üo2ŽÔê+ÿ`¡½ÿk]²~w„¬²ª:çn•LËÌÚ3{y0úGŸ¢Ê­ñ’$k‚Ð]Ú:—«ÆoðnȆ¼ÐsLMǸ?{8÷¡·A&*Œ€Òû¿îÕÄFcàA±^ ^ ËJ8Sé g mkO¢²çtO¹¢ ÛC®"AÙNrv&k¯^@y½A8ãÝÂ-0EzHgËžÓI¯áíÇ·Ó¶²7—À;Bdp0µÈOQ!lå·IªÄÕîËz¤2ÇÛÙt}½›Gߨ¨äªÛSÞ•ùå6$ó Sx)ê 8É}ã…ÇÍH† R‘n/­ì]h· ¦!såŸ[`dð% uþ>&«BiNlÌR_»ˆB®k"Ö—žMÓG¨Ó[^~#3Yˆà«pI0E©@gDR?Îa -àI¬Ö³ïýú÷òúŠ‹Âuõ‚AF<ÆÅëqìb/C€p·OœxßÏ#‡†bŸ–³{Jñâ¿(r†i= ;áñäõxûcLûzèöð&Øo/Ñ,°?È—@™òÔÈî´=íCß0Häèª5OALµxXQo"[ýåG8Òç&]rùgzS€Bm؈eZÑfŸV31le×`ù=*û]öiÇ0~ò‰„ Ð3øyÜùÄWňY¬:b“ïèl è*V*â-S‰ZÃ{ú²"†|²ã¶5ü$ÂDA¾oõdècɨ™dpÀðn¼˜|öÌÛ{ë”ÿ/¨žo–wš R˜­J7êì¤åà ’xʃ& ú"IÕ•LºDˆ‰Oý$I}ÒÈ¿aÓêVPÖiK$¯ü^R È÷{_‚veìl.ŒSi ѦœÎÆ2–¡\Ñ(R14¸)'‹¾Ø•Ò.f󣪹7ów—¸F§Ër¢ ±†±ÀµG%q›5¸¡¬q @|ê>y™*Z$hÒ¥¶[YëkX±n§ïÃ¬Ç (7%¨ö>Âf¢Ìš÷ÕúA+¶)ЯánØW›´‡#º &;vïÎ(·ô”“˜T“Ÿ¥BŠêOù%Q—¸š0ý)6LÎDá+½–YªÄ¸™³½¼Jé‚aDh’!Yתeåý šÍÈчƒU@åË\¯[&[´÷’R‘‹ÍvhÎé.†gÁåE­àïy^$¦41;‹¯à·¼¬(ÈÝ1- ô¼ÔK^ÇÞž*™QèåÁÕéŠfu´Jè*¿àåË(μà1áùE+•º7_Ñ<§‰ :ŠÅoˆÊ­ZõÎ_Od²ù°ºlÉQíø‚c°¡á(ÄÐM˜)XÿrLÊSÈÎø!SÔ¬Û€XÇEqJqf:½‚Ádû¨f¨° ž\;¾sçKC1þ3訴­„YçŒÛz”=@¯ÚMvç†Nò ùcڽ˧é–ÀÌ1¸0z¾R½l¦nøòW4ƒPÏÀ†QÈEµÙÔ ÊÖ68z.ÞŒÃìÉÁ¼øÜP0.KåcGyþG‡o™©‰BsTß:Ô j‰äÍóêý+æ L ò—1֛׆’(¹Ç`Ï>èš+oáWªÀv¸çÝÁËU†¦@tB¬ø:‡›ˆš¿úyb'iý”îɃäN?ðš§›éFp/ûï콦žœÐHÀFÿ “W% ìvó:1†@Ü>ì‹£|I+Pâ‹ß³Ý¥!¡#Cu6ótí"b¾}eý!ŠJ)“)Ë":Ùmú±Ü®<ÅseTíµBAå{’  µ6 Þ„ì›—n8|Ù}V{bî´È‹~}Üfý[„º÷úÎ,u¡¶XOT¤!ªm½ðg°—’ü¿–*òD߃qþÝé(k|ë|æèA\‹ùˆâ§9â¨ò¡I¿î´[2½«vs& 'ÞŽ1–Ƶ{ ¶!¬©â./"Jý?½'жã­Æ%2E»€**]13)D #Áœ^˜ÞNž Ñܵ‰þbˆ3SXžðھ׈äÍáÒ!DíZbo÷þ¤­{‡ÛÇwåò¶šV{“†ÁIl6aEÖò)9^ûDxû+,ꇘ{ ÷íj¶¬¬),?³ï¾3®ëv&9)H°ÒÌ$¬ØcY cw’G`êG\Á³ZG7gÉi³„š–‡t“5Òƒ-p ÕP2Q1_ø¹T_aÛë m^ÛI½ÊæÊ>,P«~]‰ŸNOÏöÈ$mXRe(¿4 È78áŒnçÿGðobŸRVhVÇG#Ü9‰ SuòÕŰLױł{wíÈ*~ióÖŠÃûqÊ)©Œÿä±Dr®ñ‘Ö™îÅ7¾Š#iwYˆzrŽÇÒÛ3o'´ Z­Zò( Û $>Bõíh)ÃŒZžwòK‘å º½S™?³H§ü(Tä)üÔxLëo§üÓqïŒM›Ž+Mî¹Ò8™vt›—g½§€—”½Í(Å©ÃÕlM×>L¬Y»“̆üo]ô« »Ïœ˜JÙ8# O~{‰* ºe´…_&Ò,¬Ü–}Ów’_“zöiîÿt{Ãϼƒüöƒ9ç„ú—£(›5F(Lø‡èìÏr±j!¼4°(-kA˦ùn”CÚ_ÀUuÍi EiS!e±÷< ̽ Tê› íÉIÌ–,Ì¢“~ËC‘ãÑUETºÖíÔòbl–[ÔúÃ&ÌVÆÓ]%JOñÒ³Á´dÌvD ümCŠ0,cÛaöíÉ&òÀ–F1Ó®·ØÖúÞx½¹+daªb¦ažÍ‡Q)8}ϩ̛_%í%þgð/|0/ÏøL ¢êÀŸ‹¾¤x´ÉJ_z~ Û0‡ ‰þ„åÛ’¦ÄVKCÞÛQ[‘¿qk7õݵqéÜfòØX,ߦ³½nmrl}›ã5‹'¢cÞeÔ”³mÅÀ9³ÖÖ“,^ ¯†c/žò&êêi²{%@/j·|X>H8iöSœ#ÌþxOÔT áW~ùYN5!0çW×5Á6ˤ$@f¿$¿ÃjãNdG E¤S»Dôq»ê¤"^‘ÃŽr9gë1ëðý×õW…Jýu(K4<š¡±Ëò/ª‘ÜMáH±°þC¹Üá=¢O¾4?·]Ö„¼þ_}Œø}”›Ÿpg4 å]XÌdt@*ñÑTÇ ¶ˆþüi:EFéq”ýÕ™*ÇÖx½¨SÕ 6)ˆQKAgο™›´Âã^Ë«yÐÙÒUR^ *  ôŒ›!ë$xh.,W1FoÿjhÞ.ñ‹ä’ËàÝÛ¼I¤ê[ËOüd¨®çTyæ½W@2tp;‡×ò ûËwÇÛÚ¼}¬Ãììðßæ 5ÄÞ¹î4\l³‚êNÄAÀ<¢ ø+¹¯‘®;qúè_kFáɆ9 Ò;'u©EиñK®çZ@M˜G.×3rÊJWqºHò’ÊÎE~ 膞Á2ÇíÊ”ÀÑc÷†9n .B°èEÖ2[Vˆû%Îdî·×‡Ñà÷¶ÂV%AØ$ áÚØz 0¿ˆâ­d^ê<ÿ®Ë’ÕÞ\.mŽi¨·1)$ÅQŠŠÌ)Þ +…z$¬ôR•ØÇ)“íGМ¡½ëƒben¡1-:LŒ÷¡›7÷ç:…SéɨgþZr_\ ôWöç6)8'†jc7`ÃOÔŽ¾>zÜûÈ} M6~r &°‚¡-Àù^<ÉË*‚­‚ÉD8²&gxª‡Îã'ìzk÷‰‘(ýŽ ÑŹ34dJȤ9:eùq™ùfTGWžóú’‚xŠ~}ÕY—’Ò€¾í²D—Ö™+¬@êŸñ#o¡IüÛøÝˆÔÐð…ÏKÊÝ ™:g³<ú«ù×Õæ“­‹r¬‹5â;‘f#™öw•nÏÓ‚ý+[õ2— °] þyÃD(mÁ6™ÓhÀ[Œ¦†Ç¦Šj­â†xaH¹AÈð5LuŠÍW*3¥ë ±CÅA²—ÀÓIσZ>5r[BWþ‹";92S-`8ÃÝ—ü?Îb†9v$DP|в.$üûÄ}W LYv§íóôÊ ç“}=S7”mFªÆéRÔ¦\9ËßÜK‚Þ#ªñ(Á¯¸®ùL±¸„jftÊ”ëÌÿ_1¯®wðåˆ+m`ÿ)”ÍšÙã¾È— .WœïÔ5Œ‡qvѱ×F=!+tÈf‡% ü¶4ÞëR…Yr-éj·b„˜¸]­míÝMÐ)³,JXp²¤å¨'ýò°ynº·Ú4v Îo:tö»àÚÉØ$fÏT ² faâ%–¿#UîäùÄ!dœ{Ò ÓØ–›î­—–üÀ_ƒ6’&•ÍÇõïÉcßWTå…§‡KaZªÓ¾ÉS·T|)rW~ÒEu–ü`-‹íF•êÆjác2úæ*V7kÁG›ÐÖ´)@‚w"É~ò öx®®×ÉÚΓg•ÎH«4ÚÀ÷sfÐÁªåE§%ÀŠ€VÒA m+N¦©uƒûC„š¨ˆ‘Å{;ħ"e'¯ý]²Æs±VG Žâ!yÕKF×t™¸8{ì9ÊöéÂ/Œ«5lšÆâ£E¥FæŒ~rî‘Ýiµ$ßv ìn3U|x[)¥úº±¯uDô¡õÿn€Æëü±e&Œ'¼9§Gé~}HATÕpã[bå í< «¾Ûz¼ÂQ~·itêÞ «É†[¹V¥LrC±(-’†QnE B ùK\²-,©ä†cÓl[x]ó¼Ýètë;×òU$<ÃŒ`Ù¾² ‡Ê«³ê¤þYèXDì,ÚfžBßMÀP¥‹;+ª7¤#F˜œ]Ÿn»7pæñtü̶ Á^FœÄiTq—á#25“‚/á÷ôR:íøÒ—*LÂóï袒è%ûÊD¼ŠÁ–oùàTeât‹}œe'ÈžsØUÜ 8…µÕµîÞ“o°K‘(Ÿ_6Ÿ?‡¹bEü)‡<*€¹W·!™+Ú«è3fïÉGK }W¡OÓ;á3”pý{Žÿq¤v1…f̵ç1Oê‡À!~{òkǪ7˲úŒƒ óU^d gÖÌ^MÐ 1×d³OFÀ-9¤PpD3™ ÉÛùe¢Û{„+*äšÝ餦8GRºN¯Ü‘Ç,B–ÈŸ4B•Èðµôc"Æìb}³ñ•ÞãÆLP”š¼çÜÊ5ð!ÿ%ÿK½ž“šØÅÖçP*uqéäXVüjSr~Mßrg+ƒ¤ ½8íL°˜Å+¦Ñwþ=ÐÔèmð9Ghy€KZzÂ,¯vüª¡Õ‰xŠŒSí ûvK~êäÐI¤3L\!dFšˆ‹°“³¾èÌÆ`] rM¬Xq¶ù×;/)²*¶;K)c+ CœžÓ· 6™šLtbÆÍ“×x§1…•:F;¦uOJyNT#ë…ìR.žws–²÷ „|Õü·EÙ…=¬8/¡–áÑÈ®=R-kæSaáñuuL{H/¡‰êœçŸâÏAŸëþ"b¶Á¨8e7K3©½›Â\|½JŠa”û8¸ ‰U‚Zó㕸‰¨ÑôÞ¬ƒÁBÕ"Œtz!Õ"mFA°ˆÔ•¶Úøâ@W÷"—`;Xbà ÔãÞË\ŠàƒÆŸ<À]f¸~„ös/Èi‰Ax7i«J¢z@Iòë °†Ï—Ü÷§éà$˜oÐoµÞ6Ñ |Æé0UÞÌQ[3KÈAÐa½˜†Ö|'ðUz/ƒ}D7œbÅÞp½³ܬ]›ø@”ª3€‚ 5LK~N…jž4H†cÃÛ=„àB¿é‰°7¡*æ…¬…ßûi\l€é^¹fØÆÓÑYQ­^ÇÀºìŠàгcÎFåÄå»n ¥ ”ÁNLÏTpzšpN‚eÈ;ܧÁn7Þ”`¨«Õåüž!-ݹ Òôšß;…rxÙ(µâ®õ,p*¢Jy,‹‘V0JTeÄlAäWÇÛ×ì}}CìëÐçý!íÁBNÌ­µmus‹úŒ"·TBX€û°›ÀE@Fÿ>V_ÂÅìLüQB-QÍ–z;ó.2ðÔ¡Ø_y°‘‡¸6ѱš<ñ~nk6††–É7·Œ 7Hv“FøY²\ ±3(¶VÑLu)b|É%ÆÓ¬{gÿ9KcJ|ˆ}(˜@œ¦LYO,Kæñ­_cÀ¯½ Ò Ù']©>³qdk#6ÄÄñ`³uèbh\ [üÂr#ÕâÂß±Vr2gN§Ãů„3R×ñ><$´eÅd©ìç³…­íÿ-Î÷Ðþ*U[”Õ ò!¯¥‚-.•¬œÃðx Ækû»Ó”|XVÂiÁ꡼e¡· ]€Ça¢›è2ãßljè‚6R9YžZâ=ÃoIÑä!c¾Æ#>äõ–È–åÉ3V×Ì Îà·š›%Ÿ£FNÕ2<Ƈ±ÏåÀæÿ!¼ð<˜å6`ãbæ½S)d·4Ãô'î­Y½äÕNºLN<8i(Ús€â©cÃÕÍüm¶”ö€Úb@MðE§o'ÚþRÊ÷ö²ÛÇ|Û‘7ö9T“Oç¾s^ëg´±­Ä¤§,/­[€°.=°7óý&9]û§~gð¦ÝP &ÊŽ¾Ø} ¸yë¡ÎÓcÀtLàƒy¯Mãû}Ö ‡#¸ÈnSKì³W~r9 3 ] çÜñÃîÛdöA,äH˜åͱKà†ørMYC”pZûd˜ÛäÖW‘#ù}ú`͗ǤXBX'éÅncÀ:8š>šÁ OFTgx>Ï÷yK8êtØÈ2܋ݫþ€Pi|ßR&'©ƒeò=ÇûùêöƒO5£Férß7®/:š›FÛâYcÊ…+,¢gÍâXe¢W†Œ¥µBžk5sŽÀ‰j>“Ò‡ˆÀ¯ŸÏUahrNtŽuëØ&B ž™æËIB¥Æñ÷O^BÑYp䡹Rui¾áÐÞ ëVòfÒe…øh^{/Ô n.UÏ£À®FÁ¿ °Àèv,jôhIª)x¾œÆølÿ-—žÑ«qSð½/«¡™+rÙœ¡MîOFy¸ÌfÊ2gÌ•Ÿ.k<‹bÈ‹|j´ƒõpð.Tr*íšk­²Ž„Û–™bw¨é@á{ßк¡_®„êÓã5™C0v@è¤@ft©¾áM[B—PÛ°Q¹3ÙûSIF|„æªmÆŒñjI¶`÷Cz2i‰ŠvZ!×¼¢¹×¥)Õ¾~rÁL‹cÙÁQ uéßž¡§·$SÈiGòT³uÄ^ÆZ1F›ÿs6 •Yæ? Ç·à-Fˆu¬¯#ßIÚ»näé(Bù#H`sG‡õ-G­à$…Æ=eZ¢;ãÓl ÐÜHõ‹îV S+Z¤A°CÇbñï}Èôõ¸NÕ˜V#l ¯’co›3WkNqæLbûø„y¦ÍÿÐÀYo–ÎZuDëÕ·|5 è¨ÜQŽG¥¤+ü:‰Xub £I·08ß÷MY6Âc„ñ¡oÜXeL©86"Ï#²5¸3ÿQTb»%‘UÊbVV´‚®yÃÞyª¦$óNjr"¨ãäÓFÓAÿPÜXš.ƒÝ˜f-CT»åÚÍÝ9¸Äo3ãK2€õsyt(ÖG%úÝ=ë0Åšp|¡vÀ…J…ŸËär¢P¶(í#^ç莽‚@Ð#þµ"$U y´+5MSžXÞÀÎ_*ù8$òä,`;SÍ3d…ajè·-ý*ɇÿyÐì³—F ™Ñ- ÆvQ4[ŽûÖèL¤¤«à®8oUG«ê'íë$#Äøðsl¡øÜt–¶+•îÍt-'Šc´[¾bz›RÇ" E¡Jp¿:d8‘ˆ€kÐõDgðôWxllm»7û³X¶#H¤InîØ×ÏÒ»~¦1™¤ïý}Œ—“à.dóë¾ØÓaÝjèõtt1Ô†_#[|°½üƪôÌÅSísz­µõôëec!òGÃÒÒtÂE$ãpf?”%6ìÀƒâ•±”õRrÚ‹ Œª•ɹ®_´ñ§háÔ›­t`±;Évµõ¬ýO‚1y¨{<‰Ù  ) áùë<ø†è;?•z,ΔM&¡u&Û‰ Lúk£&ãÔµœ¯5yã¹@‘ºæû¼ò#òcIU÷hN+Ç‹ZŒ,xÊ8µŸKb4¹˜r| «Ë¸k6Ùárº~&ù¯†Hý~M˜¹ˆÜ ú2•zzqÔÏïuFü\v“¬{ß+Ó› ¿|½*)4‚þkà çå+GF"[¿“sYæFx=ÐBƒµÚ{]+ ¥…µ]ùÂJ•D×U}Äøwˆ[I…Ï¿¡¹øtAA@ãå¹YÏM‰*0l…óÞ­#†X¤Â •àƒž¤6ƒdÕ“ª9¯æÕOZ&l´«íz$ÞIdúÿfúøjOŒ¨»-¡ãoï _¢<»vP€¹íVÚyðCE§ý€xeŽ æºß¹f†ý‹Ìq RbžâHpè¶EÛˆÊÈÒÂËX$ÏÍϱû–hî÷![D\#xÍvݪñWO®"…W! ª†"Æœ_dØÈÔå{è{†ùU4R…Lb}+ðÜ’Òׂä2@ ¯ã÷)q©+*³s"°ÊùÕv…Ϋ=Ëürby[éic¾MŒb´3+¿»|:6Ëñ¥HY3îô¶k[ðIZÒ ºy ñe"/ã êI$Jîæ´Õ@N ZoÌSÞ.S„ƒÿGâ§oaiéÌY¢ìƒã£x8¸’Y¢ -(áj./66‡EK€ìdÛÒ“Žßíÿ?ËúQ¡ÞƒÁÃá"ö˜Çâ7¾LȈÖãoÄy…h^W=i¶Vz¹õÙ8÷æ›.ˆlÝ&¼¤dSK˜uxš•È>ª*pˆœ¡îßú§PâVч3Yî”îR&|×^Tó¥uÃÆâ\rOÉoA‘ëb°9ÿ ×—±·I.ÑxÆgº7ÕÍrµseÞxP J…HÕ„?©xâ˧¦³µB„Щy,‡1ù¾æ"yR¼tSû-´UJJ‹è9vD@óR×–V3—ÿ!Y 2¨-ÚlÛ.Øß(D §ÜÒ©ýšøíP[pñõ£7D§ª¶žâ©^þ'úxÈ,Þv¡6ÚîóÁ•:?ïè¦Ô¡õ¶xJ‹åotqÎÑ­0s¥ &7>£NH’òvØ–]d’ÙýÃÖjLÄÉ’à/›`¥øìËÊCØ0ƒå]íå¶_xÊïÔûÊñ5EöA˜áŠäG½WïM‡&޼©É Æ`œ¬ †ßy HÔJ• á ñ-$q ÷žfkÞû¨½7±_UçÐ.§µ#󇯈ʸÅ`ã84ØMÆA8 vç ʼn*ùGeUO(†üøšú?‰>oÁ>ÍþCb²vl­R@f;óiSL£ï:GEuñW/“/’º×±™Üª¦ówmbšð²RÀ½ë*“. è„5'3Èþ8·E‘'ZßRi6Ëí–]ÎÎP¸:xƒl¾0û‘©E õãBäÓÇ¿yG ,è%¿…ë§¼ºÙ;Ês‘nð²Ps*&ýd5c'…¼â‚ÚO —«Úw)Ø™›CT 3¼÷úÑ:žÌ¯öfmê¼lGhZý’h¤z# è)b»üëöϾù'޼}ú¢ÅÓ-ýÇ‘Þöw)ÀXvÐ hæ©))˜î­óó³Y‰QÇy­%% ¶Dµ¼}“ø•pÊZ=è0úYÄU¶¦Ùˆàr¥|ö|¾ÆÈänwÍD#§ôßÓñCó#a„0éõŒóy¯Ó3SÓä1ɾgNQ$âsoÏXÐ.“ÉXê’bD.ójB€`h0Ä΢6I«õ”tX?6»îÍ`ü8u@-Ô^4 Bƒ 0¸:´O:PzñêîNzçÀ‡*>Äuh#{Ãî´1/A3¸Ô2>(”ŸÊx‘œYÆq¬ç–È<ÒÇ*½‘*\XzAR—°€m%hN ïNž EŸŒZø ÄGÜØ)ÏQçml½«Ïy»ÅŸãöìwìÚ?Ùª÷Ó²±û6KömwìÔOÙgáû4ÿ{5Ÿöh/ì¨ÀòëÆ§æ/Ç‘ã+¾¾cκ¶ÂŸkä}7&+%3ܘ¼lJö1«ü½4“âJ˜‘‚ä•np?n”ɺmØ¢÷îbxÌ#(Oš;ÚÒî“Ũ-±§ $?ªÑÄP¢ˆÍ`w†3>èú6…‚(/‰.-xuQ|ªiñ!Î`JµZí½ïU«€Ò¼¸#óÿç‹ôš¶¢dìüPËîRx%ÌD“ Ùãy8Ìz_w ”r‘Šp–«¾«k%õœ2:JX$RÜv…{>)ý§–iÚŠ"ΙP lmÜ¡KQƒª˜¶{CÑ*…Ÿ-hÙK.'€tÔk0=ÂY. Iâu2oPÀ(òßó´ã™ø`û?šÄÒx!\ÛûªÍ ÌÞG­»Íuoâ;Ù‘ÕýÒpË·–±qŸ6¼1“ße…Æy2¤PÿuÞÚbC¿3ˆ¶¡¤à?ÞMa('AÀ)Ò—¬ÜDwtlYt5Ñ# !-“e :q2Á„ ºÁ-ï©âÜßòëÆusEINÙÑÒO è¨<†èz…⸣íƒáaៈªñ¤¬Ì9òÎ’”ëå»AU hùú1cÝ;fÂ|sð»í~p ïâfdb’œVUXZqÏÀù¬÷œ¸®}ÍGÕœWè ø/)1nowŸú³=}`y#žÙ³«ÿ]tVýVã9.HF¾l>Ë‚©l$û¸¡½Ý]vMÒàÀ«QÒ¨Sf|}ü@‘Õ;%Iªø„T2Ý ¯…¯Øqä×¢ÐQ´(J*ñ`Tï„Õ± ~ßἓ cD¤6vO˰3̾Ôûtrôœì³ Ï÷5 [çY\¯z:7÷¬U¿âº½äÃyzŸp›¾7Ï–/J Âÿ~ìfªìH9Î4 —)›‘Y˜Òmà… >{¦ÂߺˆJÞ>:ìzÜ?:ç•YQPà4©¯öà¤2ëƒêÔP|ºóeÌ·®ðbF®ëAôÅq*#cMOƒ­WCKÉP€¢ëõùm4Ó‡¥¡©ݪÂ*tš^äzTöKmÊùþgÇ,ª3ý¢òF¡Cø»¹ä)6©wg$óòä³|öÒÙB^Öçåáù°Ø%Y¬ v’ìÀõMDéà–ÀòœÅ ³4…¿ØéÒ°»MêB g®°K†Âñ/eÏ´x\)À(ÈìWO½Q°x\EG·=¿ Vi4Ç-Øhò+ðPú3¬ ¤hTR;7šõ€sî¿I§’§Õ:N™‚Ö L0Œ€®n{`q–ð3&•b}··r’õº5 GbTÞà“‘;±dš«jx{à"ªaå®qùÌÈW™øPغ0ûdùS[bCø…–O%TºÑÇÝŒvÊDËý•Zÿ~–tÈ'ÊBy¯Rè¥Î(kÀKß-¨öÈŒ#¬9náÔú!/F¹·g…º|}ûðÓÚ¿t”ÕÜdVÑ åËØCÆ1Ñ|-úß¼5ò”Uã„,=}ëĬ—$êhïÔ6$ Š‘(ó û ËEÁ‰ñédèÞt°ûèZgXRÞZ‡ø#ˆÁÓˆ|TݪZVw§œFd©g6yê†Ntñj}]ûÕ²ÉTÛËlˆÔm`Ð`ô¿&a…€À0ú)Þ/¤¯ë3;¸rI—}Øh.}¸7¾yL÷e€‚­è[þßcy DÝ?ÙåÈzšßÊI¡&?m»ÊÓµÚYÊ>ƒ÷@LãJ†‰æÜ·¹×¬“K殺ºy)'§,@5‚µ¹°E4à“‹È*á÷w‰Æë©†pEt7p¡ü.êø+¹øjê[¡Z˜#œÛ7ÛÒü¹£@ߨƷ±;—#ӧ𸦀ôí¢ÏÌ|U¡§lÔ×Äâ ú`yÐã[?ÿTkë3ÃÙsq}¿]ÝXzNˆÚÕ„èÖ^¹µ‰Lj9ožÖ•ÎRCZïR¹2-Øä·*¼¸_Ôg¡soðm#Íyîz-Ãa3/?w ?E/a"—ÙEtÕÅúMÞ½«m̾uš!·!*p7{ZzGÞb»wñîQ<à,h•i£„kâAe]àç*X2(IEÉùPáåX3dåÄÍqƒV‹ 2‚“ƒWÜ\ž&­AõWMHÄ‚\©o\OŒEƥܨY[í€Ñ ¢7°§Z«ùT£`M{‹sgÄæzK¯”ËÎO1‰$ÀÄi!ÒjÔì=DÊË":OçŠWOÛ&Ä¢ðôùÆ)kÙóì'<–†Ö ŸÕndA’ÇTÊ}MÿJ¬EZSG*H6$zÖê’x~„õx)1ÐôœzÈ`x>C í´ë~óÞyŠH«5Ž1-B;‘hÌøyŽÛ˜…®é÷9 Êp¶1*Í.\Cn­â@¨q+95Áb¬Eø]ïy»@qbG/qî¢S$>U¡@#(KßãÈ !¢26D‰U1!Mß ð|¼µcIúz"ÆKŠ÷ëÆm„Á·Ûs8àòZó¸õ½¾ÁùÈ§Ž•#…ÝíÞe˜4×°Ÿ¢Ÿ}Éq›°ú©ô †öô}¬·ßâZ)½ïÂÞû̡ðÚ&0åû~œ³ ‚ækêgD{R…É’Ä¡G÷ç´±!iw Â1]ìGj[&  nãœË!bþ[ћ ›§ÓhÙd†Àq‚[à.¹qC-ñúZ¼m '=ünFm<´X·ÕÜ\õ4„¨: ¦jÌËÜñvýþùÀVS'­oÈ: ¥cÑíç´iêo½¾ŸÇôàœý>ŠÌk¢ÑS©½zþ-Ú8Rá„:ßs@úWåæ0r¨·4̇ÇØ“äš}^7¨ö¬!o¾ö{b ç¢j{ˆo ÉéFE^<öe[ufkŒ" #Ì(j±ùrÕJÓâóA@ê‰óŽ98”»È+ŸYª•C‚X½GFóEŸC®q<÷EãB¤MÔMGˆ,S^äãG`’BÇ&Çedgá} }PZv’=©8kX u’t¿Ø.· *ƒ—wZ/‹È ÞÒˆqjZí´Nt£Ñÿ ÚçÝ!)†| ïÝr$|€<‘&#MZnøÑÓŒiê÷ŸÆ™Kôd‰ßgmqYê½”‘TtŒìCÜIKÅ…rg½í|úF‘ì)»¿”¹é38t $Õ.`ÿÿ(:‚ ª‡ƒÏa˜¾ªˆ »«?pXÛ\/c+Mµ›~•—¿¡DÖc3tè7ôëòò™wV¼çãŒÖ:ñ )UØ[ÁÔìú‡ó“E]’t uóªÌÂó~|ëùIjJujØä÷`êQ‡õ³Î‡óâ1ÞSi½3I ´¨òìP o'Hˆ4uCÞþ$¾ÄªèömhØ;¬ÝéáB'¾Ì¿µù’¨Fæa%‚Õ¡IQó®y¬å“éÙ¥'or´/ÿZÍBƆ,D9…RzzþYX$²®³¤D—Ø/y™‘èŽòôË´¯%ãÆp®h›»¹é‘èÿCb{œÌ4m+Ó-;ŽìŶÃû_Ú‰>‡¦Õ»¬"&(œXí‘¶€*oÍ}€¹´¥„˦سžŒ…ÀA=©ßjo0Úñº+ªò0,#¡ÄåIg …ùÊ)¼Þc¸j¤ü¨ 2ªƒ“õ·'EÎ\Õ£îÁar|^ªáp«™U¸ÚȪ9š5F¬”€§–EoôS\Í»Ç")j\ç»Iúí-£¥åΓù<›®é”×.¬¹ŸË5ÌýßÅË¢ŒØà£ºÂe+ÂödY¯_Í µÎXë|æþ%’à„@‡ÎÙ Þ ©Îë6æ±Ë6Énºë4EÿxëCnë£Uv¥çAš, ±ôÒ#[Ê„bà=¤ÊÄ&ZÏÚE¼VF"Ê6/Iï)a«†Æ,pÿ5|ÔÿZukÅo›Û>ìì~¨Q"qÜó4õ¼Î°ßh\ǧÍöG°½Žäqð‡Ù’Bˆ&ngã•ÿq`±;Ø*Fý’w‹!ø÷˜€VÁŸ¿/ÑlrnâèÆæÑíŸ]> ÂOÏ =™±g`Së)ö‚ÆüBèÊ`ò˦¡GŒîóKHÜšŸ•û8ÓñhWønÅ0'ÀàŠAD1û_žò–-€&• B²šßš©ˆV‡QML$„‘g¬î³DÞ?«˜¦wç¤1^ìÉó]ù=­üHlÔÔN-.þj}¨Õç+›–“/zò2V,AÒŸ’ò(;ãöìßìÚÿlÖÙpãölÇìÛ¯Ùª²ßÃöjìÖ¯Ù ?²¨íeÃgR0­H©†ø6 •8‡«VUV7ãÍ[cª%ßBáAÛ:ñ{Ni††¡Ýù¦—Qsô|`È_nõŽóD–:`BúY@EOÒž‘¯1yËta©>h •ęӅy|ȵ|ÜE½E! ®+uVˆ’LÖÊØDÂàêÉ÷¡Ò­rùP¤oKèm÷ÿ#¶š›O9dÜxöMÓ7N똕ôñ¨ßÛ¥¦|P3·ô:ƒ{ÏU¼‚og+¥™ ða‘êîÿZdn^YS ;àæ…±È/ü³!þðí }%‚±Pð2uQo…ô`<Ø•WYHÒ/8‰áïBjõIï _ìõL§štÀE:"]„ÿCŽü¯÷g½oÛÑq2o¶ë¶sŒò»/+D¬«XqRõÀq)lòµ‘í´:&_ª-jß`ºcp N¤®3?ÿj0É,‡Mˆ.óâB·\•¯|zÊï‚&½…ËþÚÌÖe ügÈTÀ4»²Øoé‡×r©~´ð g‰ b&„[Ñçïš,ewsµâ{*ohŸÿ?©^ÔéówPnå°½H¤æ‘ã´Çà·W™ââæ}' ‚GÃÚç~Íòà;èsüÑ˒βX£>ùÄÀØq Œ6Ò’!tþ‰F´|EÏ$ ÷f´ ž—–מ|ÇÿYjtŒ%q–Ô›·Gòëöåq€éÍ…&.hº°¡‹ºO¹3NÚD˜~äh<ùtÃáŽ÷”S3çMÙãSÈ=Ôé›äì¶kÒøß-cýg<Ï(Èd,1A¬¾3ÒÌx¿ßšÚWök©µ=åtÓÐ"… {ü3 ˆÀÉ%« 5œ°…â.¼^©ÆTpöɨ¾Ö»ù É‹vüñŸA¶Ovó×ù$º´c £ÉÎ6®ºƒ†°ËF cÿ~”ŠC˜BàáCN+ÕEqfkÁ·þc!²5¿ü-ʪŽõUÉiþ8b~ô€ô š|"Wu‡ôpý¦9Íî€[}jc ÁüéÄf,Âv¤ÂK%Óž›W]±’Ÿ”²ËÿèEDbï9÷é xþr]½§]—èý°šKŸ¹à7QfyÇÅæÑ!nf;êEÞcå"Òë?j¤üþ >GâtÞ!( ~ F6åÛ¥Ÿ¢Wh“pVBLU3†l¯:$JJF"ìû`î°£uÔmd€ufIádžÈR.‘ü9‡gyD¨G Õ-›x/æs[ÖétKaì_Œ0´5.\1+ë^ú‘ …›ÿør[qJm€©ÚÌÉSøZ8ˆ{¿vDHÛx\‹ÊB¬ÄU_ÈÄŠÕÿFMËúã(•žä&”éòV‹äðÐ)ß*ç%ý•ŒÞ½2REÖ"*ÑWáÑ“Ö^,1òÂ,·hUœCö÷Ñ*M˜ùÄbææ9îŒBüâÒ?ÎÇ®¥™dûfA·Vø5°µòÑþUP6‡{{q{Iü wÔÝ«e«@lwì«Py§MØøûq?ª©öû˜ZŒú_¢è?i ‹ïžF?£y?Ó¬[ω"´Ç) 0/>‚…܈ñ§9å¬[„¥× «›\t² ^©ª?¥qŽZ@7äJ¹ÝJ~ü¸˜x²¡fËÁñwüDºÁÙög’±æT±_„ˆ¨pp(­·)9eõP:ÆuÓ¦t·r$Ë©™±éfò^ý•Âà©w9nQ»d&Ĉ^+gäVE¾iðzE¾¥Ï± G5Ä8¿Ü[')S¢„œŠJBד7_n!wBJÐ8ùqÿV`bB—Ë.¹•’Õ=}!„áBe©Í—o×Tô÷<¦µîѵdþhü\£yÅÉœé•àŠ;êÚ]?_ƒ˜šß ÏM»uÇŠÆf s_¤fö~ðõ±*»qà>^m¶ÔŽÎ»‹‹rµÅØ.hYòÏ8~¾“,PÆ(ƒ²¾½Ì‚ ÇKÒ¢?5UÂ+¥TçkclqpÃoŽèrú»n:­o–ø‹ÚØâ•Ûš¥8Ú°†…°mz‰Ê~bm§˜ägúà‘8d‡ªÀÑb“b=3O;ù²i+øù©Ö!Õ}‘¶˜Á‚ŒJÞ`¹“&H³ð×méóƒÊ•Q'Zÿ8¸ƒgÞ£¿˜¾p²êñÐEf_ýÀ¼ b¸âÔG½¨Q‘áüÙ²àרŸI:¥ ؇C¯dN¢™^å7¤ÒD¿C¾©§ˆ~P޾ñÙR QN¯µ#LñÄyð4}c¼“{ø¼^(ÏLJE“»²‘Ê,¹4eüPZ>wM*ÌÜ„hØL*W¥8íÇÒ¾½8Dàß(QûŸNw „«\ÿŸÉg0ë­ñÔ&k;Ü@é9¯Wá˜,¢ Á@P--2pÅx¿•sEõ?Zg"G¯F)ÅlŠfüy̦_öÁé}jg<”l/-ëJW‚½!ë'ÃåÜš3Óìà“©ªçð–gòK±-@–’ñÕµ´Î[Ô–ü£¿Ý¶ŒCG÷ä°Æ¥ÔW¨Æ¹„yz]E<31¯¸’G©–/ÊOÞ²’±§¿1jÎ`öégx|Ñ©v}d<6¬{ÄÞ'4†«pñAœ #ųEw”?î½QðaŠC¤‚âð†ª9Í ¦¥ºxµÖ-Ë(›ÛµJ´xau°vTð]%rìú\qQ-|YBè¯ôËv ?Û¬DÞHäyÎ z±Ñ¿O†„±dÀvQÇwHŒ7Óꦜ0G}!C­  ÃùªSäC®ßòˆzb¡ ¥(¥›ÿ,f·ƒÒT1‡7‹›qQ¼/„¨#Éóà\®[&%98©KBï«àÚšfùo|JòÔ|¹@TT$—±e'Oj'˜k Ðéyró·ÿOð×s a€–.‚¬:c4’¼$Y÷”Jªøÿñ‰hÛá³'²mÔäÓB÷Q€,óò?kºÆUÎz± ¶9=˜D-GJÏ}Báß™J´4Ôš/ß»‘8¼Ñ=ˆ0h¡‚ or›‹“{á<4¨½Fw¿,Á Úi;ôeŒââÿ r“¹$iÊ¿¢EÉ߉Þ)=|×µZ-¶hv4vZGÐùoè|Xä­òy´™j«Ž¦3Ä«ÏA+ž[Ü@T‹ù“‘¥Ÿ_­å}–ŒU8ïÄî@ìò3äã„/½¾‹Úÿ8G_Õ°ô¨”‰ÿ ’ß‚KOf¸ä±«32"ÝKÖ%òpãûÛrµ~©R^…@«¶_4Fé–„áìÔBžGoˆI±cÏuBƒ½ñ¡µ¢éMÆÍq¿:¶ÎäÙí+ú-kÅ™¹¤Gî8²UDH~Jå„DœÇ ²ÐC>/Lþpæ]û—(V$¨-Kìþá{£.®/‹1ÿ€¶2ÅÄÉȳGÐÿz°Û c$ª$¨­ä®7úé˜"¢Zl`п¢‘Âߢ°â,€n‰wÌþ Ú— ÿáÍ×Y,ož<ž”/’&9ºß±²@B9¤+ÐÿrÍ;† @mß6s© jÝàdx{rvˆeèçÔðÙ“ÖjBÃ×DŠŠõÅš(]]îšˆÜ¬ŽžãG-lÓ:Í‘éZ•ø‡ßwÚ°ƒC™Dنš¿—Þ“ÄüúÄ|@¬òÔ0Çš|>»vúh}¢£à³H™ú ¥¥xK+<‰]?pšØK;ŽØâ"H²žËÒÉß×£f ýA:M ¼‚ÕÐLÛ7m[êo³‚P=êP&±zµp£ ?’?ª0FwÀ¼ëw¸¿Ü£Nëlù(èÑ7×èdGft¯Md·¬G ;§…Ì$=U@)Üè (Èã K=‚·_8ÎWK(åæ¶{$#÷r¡Ê”Ùá.®«‰ÂÅæž@3jP%8VU!¤‡éÁ7UÊ«|@˜ú¾:tb ƒÙIgÛ®÷¡:`Kj±ænLQØàS§="Ē悜ßJíÔúÅìÌ!«¥5l¿SÐÕ ¸Â{»‘ õ»¶ÏÜ;éD}¾Ä"·6=‹KõíÙá)¿Kÿ5è—71ovµªa•GÖe*™7QiÑÀµæ!íÍWÿ6–w›EúUZÿl‰_n%ƒÓ•HýX—“Û¼q±eFk–cOñäs3N:Ø™Ð?ÙÀ¡a[樞»aácŠçÿÿÿ]ϪÁ%‹+ó:ÿô aoˆ¨7‘Ü>:Ç“Ãäɳ¥öù(“óh„غe6{P–,Û÷~ȇlß`Ío¾ß%_áúµ×ôöôõ7ôí ?V¼þžÍþž›~—‡ìÔ/Ùª³@?eHÆÛrì¾W×F}Ó ƒÖ¼ˆÕÉö<Äç‰XgÎ!BÆIÈvÔGI"Ï;’ƒmCõàãc´åׄ¼’fXpÉœûe2vLxy´&«…N-ĝ޵tîÝì¿ýƒžÖ9E Ðw]*4·–Ö‡ÉÉ$cf1öBß‚ÆÊ$zs…g̳ ©taùLQý¹-òÑ9‹ªM\nk7dÊ»ÄÛܲM/¨Š Ÿ|]·Šþ>†ê|[¥•¢ ®¬PB²‘é)OWÒHˆ ú÷1°Í]¡E5Éj¤œOæóåíYk:ªûsß’oª%xÒt‰@.³Tñ“!¾ÑHRgäø¦“mWø1ïÊÓ3Ìd±9¦p;K²‹CDjé ã1öªiV·6jÇGÍâ„óL(fÿfêœaÙ ýšxˆ€û#3ÞŽ.®RÏ$ò@Ú¼ÝÎ{GÚïì –oetªƒc¸ôz{ƒX$4—ßL¥ñcVÆ ¹.МÀ)2O˘w-y£Þ}¶€Ò´ªoÈD*Å1¥BqÉùþøg;ú×ÿ{ÕÜêÚ¹lUqj¸cq#Èá*²EΜlqE”jç°¹Ñ$Ë5!p]4“.©Hй¸ñBÎÌú%g œz÷¸…’¸¶YÇlïýTp!ó!nf;ìšîWênÆmó)æêx%ó*,jtC<ýä ÷À &+F¦aÉÕd3= …$¤êš#Õ¶oÝüOk,?)ÔºR'⺻(d<.ÔñÊpʱ¼ˆÆˆÜóÁçfY䪹_ó7Zž@î{o5òÕ3(Ñy¢½º”†~€úH(âx1ÞzïßA=µ*û&Îy£,ŽH,Z X¤u>„¯![g¸à”=¬38X[ݰ!L_éùT› ~ãçwiÇ÷òÉQ$bç®g×â6ºIÀ Ur¼àÄ™eà ãÿ8“J{üol·n?½Òcþ^¨ÖŽæ¿Ûs jÇé,=ÚLLÀ4TÛDµ|1ñ%/ŽEd^Ûý>x?'NA†d#ŽÓ=:‹¥ÒøL±’0¾†·ë}ÛÈÄdžuPþd#¡I›‡~Í$>ª?“é.&„Æ“tŸ¤¦ä͘zt‡òœ,œew8í àå‹n¼]àˆºãUÄOï;–oŠÓbï/5*nF˜‰L÷RÒ=8…a5ޤê|½ÉÜ@˜à¢‘Å*ì“|j‹A¥ÉÐÉy¤ ŸD˜2ükŸ–…œË6ëyþAfWê›íb ;úP›œ—ñø]%Þá±çÿv†N³%†Cï.¸Re yò{õw®“r½mÂV»³ý°e›Jyå’[ €<*aú·8Ikx9ŸÊ⤱£=ÝØöHŸ -î4xfâ#RK& ÁÁÕxx…þ\!ÿ@­öï¥mh¯—\Í_ͯtå+Kþo^šu¸ñ¾Î¤i+Úú‚»Í‰ç9Úwé7Æ¿xT<]Ã_ßÚW·S/9p_'œó%&æQ.]ðz[Aq.ÍFÎp˜ôˆ`ê];k0`¤/þ&h2h{B•KõU/»øî¹ÒÊßµJjÓßäHNi}„sžt´nM3AT1Yñ‡zùŸ‚ L‡Ph®Ää›CúJ!óËÙ±kê6“_17D,…x–]a vF|Û-gŸö©íA;äû#}ÿ]ÿXV…Ž3XƒÌ±Nžåh w²¹6Y¤°»[…ÅA‚\ruÔn‘ÏfW§ÓT’†~•¼`S‘ªf4õ+>» pà¼Ì¯-ïÃr [o‰y§ôk0…ƒ|䓨Ý·MUìFg#'¡:@­Pù ¼+ṵ̂\“À~°jJÎSWÑah.|˜ÅráDË W3Þ‹ªNmÂ^´«¢Ðê$Wrg0U nûÿvÍɼJm1åºÍ<¿>c2gJ¹k98Ëzo§iªæ›F~œh†ÿ})x¿‰ã‡aÍñGãÌÛ¬ò¡×²oªÍûÕySÅåŒå—Ðæeªðwñ]WSƒl3zâ™Ñ«A0jŒ—è=ÂÃWj[szo–üÉhÀ;‡F÷2ÕI/TPª£N~c³r77q”6.ÍÖ] ¾ =‰ ß©¶Žh¾Ä:¤nyýÍÃ'Y.Aà3€!8OþY¬xe”»»õFtŸû‰þÑY¡dö ñ4ðæ •ÆëRÁÌQÉ]‹ÀlN×mFž dâPÞ^½õ<œ¶ ÉU)TÿETâÓ¯mÑ®V } Ì ËwG¹ëT¡uÍ[îÒ91Àÿ!Á¢Ÿn(;HïlUô„¹´?”׌ã[-vØË8*FÔÓã7%¶X½ ¹3„1FGp`=yU Æïl.Úãù(çuo¬_?ú¶µú,û!ôo«ÇTw|’C´Y¤}ÔËy׿ö îÛW}Œä-Ç¡lbµ H¤Ûmݺ8Ù¥(hbmO%Pi‹Ö³eª‹ å1¹¡~öT ¼cè–µÆQ¬Jût$îuAmd <ª7ˆC¿n’bòAð=~‹QÖJˆ·vÝö*Ÿ5AÂ1A»ƒ¡.» IÎsÃÁ·wÝ\yxbxg¢¸ÃAáÑ“šs)Áª›–Ài`hrlÀÿdgZ“šªÿ„eïÞ¨‘j®éh–~²€ bS€ùG,¶‡ÜÞ„w~»w ¸–sŒ_K¢Ÿ_HAø÷ õB¤MÔMGˆÝ£%W¿O¹aûAœv×Êf¹šÈ"P»BkÊI#ElÉÖYøõé_s 8J[òÛ‡®öÁÎÏÉxSéõ]Z" ‰˜ê7W¡¥=„?á“380W ‡l §rK²B4™è?î ­u Êd£îű l *ÛmGpw éfxÜ;¢S¶¸…^6“„вÙe檑o„®®¥©=úÚÖ2“|SÔÿzXbý`Á(§¤B§ ˜ýµlÆ’Æ`ÙT¾äAËô¶´ìS¤¿ ±î.!\[C0‚¬Q ¤ä¹F›²…݆ÄðØ#Ó“’¨øò¦Ö±AÓ„Gó8¦ ûksn|*]ìÖzËCfvr=@>"gGäiîØß·¡òª¬ZÈìyJGgdªÒçý÷?ïºs÷Ý_¾éý÷Oï¹qûìŸßaþû÷Øóœ¤©`Y¶Q¦ø+ç÷{@]ƒ(©3»/9VsÃã¹DþÖ>iû2ùpn–$,É®J%±á‰v¾["HIãÝÿ‰sâç=rždÍܧؽit®¿¿KßA ü:Ù^*öbN±8X=[â1£²®³«x“-99 ›Ýî¡Ö0s†< Z í­:Âõ:ý§y|üŸGž`:jf„÷ÚÓì놲XZ«´|q¹@wؑٷ£beW³GòO®Ç+ ½B“ܧ}e5é‰ÿ.¸“…WÓܾÐ1â ¢€ØÆz'ïÞˆæz=`ç^Ä£” ôtê÷…Í 'õÅäÅñzâ]>Õ¾æq ®ðo W–ÃÔh¡Â(°m ¨¼foj^šŸd{¹ §SØ »×ŽË¦_êªi28ÀÕ!=¢’𽨭tÎÅ äqü Ö*nAº†ˆê híÊœ#VíÕÛ×SºQšœ B0´4#bZfÆáذß;%ÛÍ­xnND¿q æ&Ši©è êŽ*²jy [ûJU¨íAúF$+øz÷t¹ °Ôsk•ùïÀl¨2vÈ„dˆ[M”ÏÛN…‚ ¢Ñ€,f؉xe"l"©qÈ]‚_;ÄðãR͈b¹¹†%æSeHHÅo¼·_Kåº9ÒÇÂûnh²}»‰µg€î9 ×Pç¢N´’/œPÝpñhÁÐŽöÔµÚ£Ëè‚•@ôT–ÈÙ¬ØB,;uŽ÷ŒOb*CTYÄn)–©”ªÇŽ2èè@OÑ|]"›¨1¹·Ü®0’Ó/X–a¦í[uãya´ÒL¬è°÷ŸÔ¯«#?7ÉÉ9‡Õ²ú::ùüˆÆËdh±å&؃Mú[é®ÕÔSB*Ý¿3Æóá]…ÑžÙ…Tê|D€Ü˘[Òr¡T f”=âß/)÷ùàGø+%oèë´G(Ø$…§ª9ÔÛnP,_ §–éýUx¶•é[Qe ãvOa".€¯‚‰¬ZRwõ[’3ûfr&ˆ'ûÌ+Úq‹¾¤ÜŸŠ]Ú,0Ø è7%ÉE~¡Ïí‚nüÀ…ïW_%<ÔuI9ž9Õ¢ @FL@•Ù˜&ð¼¹}#ᘈ7í@ðY”«Ú?dûÑ ÂnD|×òÀ|ðmä)\µF”u:PgÇ}ì1·“´ÿjÕ-ê½æÚ2Ÿ€%ßz~ñx~‡G–PÏ Å϶×ã’Ù±§õýR‚D7ÔÿA]õóLÙÏNðìöDHCëÞ0k¤”yÛW*BCEŠ:µ¬slÁäŸ2‘áâbìÏ-JÏ¿é'³û1ç®4 õyÅí7Ú/Ûô$£þéV+•§YÙ‹<ÕçÙræ'¦WI£ø5=ŸO÷£!BÕ-•¼\ÔZ³¾_n˜_´¹âa3Nœ~Rr6 /}žÃ@!+Uª±‹ÞUÉew¤ó(»7áã»ÕØÕư\–nGOîc2׈þK¤êqÚã%Ç Üàhß ä˜ì«ïsŸHÚù¥Žê½…¿¤Kðìo`ÿr•ø'õ,!g`®6%ÛÐhÿÉFg‚Ù`dy7þ ­¶M$`e˾3–3ÙWò^Ï6N r ªÁ†púa1ä¸pÿCuND‚)þÎú• ¿º ¦ê7<ü\ëYöJøûêÈñÐR8ÉŠ=ø,›÷UF^¨#Ú°”î"fX:¬ÚÊë[=e«1šlÓj¬:N>nÏyÓ%u¹-‰+ßG¡Å·‰­Å肤ҹwo-ªû†oRp-^y”¤Û¸y¢+ÆÉÙºXŸIuÙ†¼ßgŸ<tm—{²#ù™¬¯K4KE†oO£ô&Nú:ýKÕ‹Ì5Žtdrü•Jc…Ò<’•jß¿"¹j*¦hgIÕoŽÁ²„Åi”.š4ížxf)É ðe’ÔÑ–©j“{9/~ñáýê%k9îvõœuçQ°‡ŽëÅ3Ã+hX1§ÕŒHRX¼Qá2vÈZØ›YI\o¹k­§Óˆ€{ûEáN%lo‹Øõ°ßb6¼|/zøFÁJzRpæËÄF%<ù%ï··­›Šrk–$ñ¾]Þ w,çî^Ë‘,°Ôˆ÷vë²Á½+£ÉŠå%Òýÿ;HžýNdÆš|]!y‡Â{uØwÄýöRç@oIbÕ§Ä*)3^½šÿCPkbþÎUÃ^"—᪵÷$ì-I‰ájÔtÁˆŠ&ÊÈn¿qá½áz†¡9c ÕW'r}%>Ïñ$fkà„ÜÐI0$«¨Oë¿$1TãeëÚͦ®¹{­6¹Gâ("[kM%·Ú^âl…”HùÚî÷dz|™ÁóÉd@‘ŽA^RÒÏåöüÏyîPrèùÅÜefƒÓ!¥Hnžd„I´ð‰U¿âÀ¥_/̨ݛإvÑ :ÙHëI™\,ÌBäç'ÀÔÙ–ú°ˆõ•£®Ï¶‘LÕ(­,·g¿ðFÐñïgÏ8•pøÖ®…QZ_²ÅZu§Ù9Ĩ\¸ôzg*ªc• ¸¥=èÈ¥*aØ—ºšŽ†~£`¬ˆ€ä–iÕ:wàë(&£Õæ¾å…Ó’(íâ]:š–Z¦©úBÔç8µÊY¶?ðî7û$‰£7(ª¸Ò²ì…Ô"d¥l¯ÑïÂ`!’¹Ð {9”¨SJŽYà…+‡GWÄkEM/Úsˆ³ýîËÄT%bw ºÓÚ¼ ôq–VÁG“ÎvCªT¼t{ȼ7ðø`àQ¥U|’º´ªµ•îX\š˜­N°­ã8Ì7Œɨ–ë*áKh9›™K!p _€¶Žˆ£îϲovE Ld âƒò‘ô©Ï3s¸Eª¹¡ŒVDkÄ;®z%WutøR¿¶íá’MTü|„ØToÖ'>q·ü¿3‘0>ÖÖJ]÷Îu8Dx“Ÿý;$zjtŠ?×WÀv»ûðgˆ:—d•á#É8äžJür6#uÝ%ý¢ú›m@èïü´cÿÙprimesieve-5.6.0/src/apps/gui/icons/win/000077500000000000000000000000001263266076300201335ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/icons/win/primesieve.ico000066400000000000000000005470531263266076300230150ustar00rootroot00000000000000 è(î00¨ ¨¾hf }Î!€€ (K5`` ¨”s=HH ˆTÒ@@ (B£&00 ¨%Ëh(( hsŽ  ¨Û¨ ˆ ƒ¹ ¸ à hÃÉ( @€€€€€€€€€€€€€ÀÀÀÿÿÿÿÿÿÿÿÿÿÿÿs227#"2222p###"2#"3€s"####"2#'"23"#"222#pr22ƒ"2#"22'#"2ÿ‚222#"22€"2#ÿƒ"2###"20r223ÿ‚###"###'22##ÿƒ"2##"2"2#"2'ÿ‚#"2##"22"223ÿó####"22#p#"2'ÿÿ‡2#"22## 22#"ÿÿÿˆ##"22# 2###ÿ‡ÿ‡##"220#"2#ò7ÿ‚22#"02#"2ó"3ø2"2# 2222÷2"8ÿó2220#"2"?ø"22ø"#"p"2228ø222(ÿs"222"ˆÿ#""3ÿƒ##r22ÿÿˆˆxˆÿr#'"27ÿÿÿÿÿÿø"202#"3xˆøøˆ222pr222######"7"2##"22#"2pr22##"22272##"2#"#p2#"22#ps227ÿÿÿÿÿðÿÿ€ÿþü?øðààÀÀÀ€€€€€€€€ÀÀÀààðøü?þÿ€ÿÿðÿÿÿÿÿ( À€€€€€€€€€€€€ÀÀÀÿÿÿÿÿÿÿÿÿÿÿÿ€r2#'##"2028r22#"?r2#"p#?r"220"?‡222 r2?ˆ‡""7‚28ƒˆƒ2'2(‚#ˆ"02xó2r0"øˆˆ2p237ws#"#"20s##'pþðàÀ€€€€€€Ààðþ(0`€ ‹2Œ2Œ4Ž58 8 9 ’=“@”@”B–D—E˜G˜H˜I ™J šL$O&Q(žS)ŸT- V/¡X0¡X4£\6¤]9¦`<¨c@©fBªhE¬jG¬lJ¬lL¯pO°rP°sR±tT±tV³xY´y]¶}a¸€eºƒf¹„hº…j¼ˆm½Šo¾Œr¾t¿ŽsÀtÀŽvÀzÔ|Ä–~Ř„ȋˣŒÌ£”Ϫ–Ы›Ò¯ Õ³¢Öµ¦×¸ªÙ»ªÙ¼®Ú¾±ÜÁµÞĺàÈÄåÐÈæÓÉçÔËèÕÍé×ÎéØÑêÚÕìÝÙîáÝðäàòçâòèåóêæôëçôìêõîí÷ñïøóðøóòùõõú÷öûøùüúûýüþþþ"P0p=L°YÏgðxÿŠÿ1œÿQ®ÿqÀÿ‘Òÿ±äÿÑÿÿÿ&/@PZptް©ÏÂðÑÿØÿ1ÞÿQãÿqéÿ‘ïÿ±öÿÑÿÿÿ/&PAp[t°ŽÏ©ðÃÿÒÿØ1ÿÝQÿäqÿê‘ÿð±ÿöÑÿÿÿ/P"p0>°MÏ[ðiÿyÿŠ1ÿQÿ¯qÿÁ‘ÿÒ±ÿåÑÿÿÿ/Pp ° Ï ðÿ ÿ>1ÿ\Qÿzqÿ—‘ÿ¶±ÿÔÑÿÿÿ/Pp!+°6Ï@ðIÿZÿ1pÿQ†ÿqœÿ‘²ÿ±ÈÿÑßÿÿÿ/ P6pLb°xÏŽð¤ÿ³ÿ1¾ÿQÇÿqÑÿ‘Üÿ±åÿÑðÿÿÿ,/KPip‡¥°ÄÏáððÿò1ÿôQÿöqÿ÷‘ÿù±ÿûÑÿÿÿÿ/-P?pRc°vψð™ÿ¦1ÿ´QÿÂqÿÏ‘ÿܱÿëÑÿÿÿÿ/Pp!°&Ï,ð>ÿX1ÿqQÿŒqÿ¦‘ÿ¿±ÿÚÑÿÿÿÿ6)'')6##..5  5  545 2R\F  BooZ Qoo\5[ooZ4 &_ooX .+aooS/1aooQ1aooO "1aooK "1aooP+`ooaXG,$_ooooo`P93[ooooooo`R<5)Too`Q\ooooaR9)' Noo]'$BWaooo`L(''Goo`)YoooY43!^ooI%Naoo]9SooVFaoo[*Hoo`/FaooM"9aooCOoo_+" 24 XooP/`ooD0`aYLZooM"\ooJ -,`ooooooWD<1)#!"#*7AQaooE- E_ooooooooa`_^^_`aooooV! 2 ,GT^ooooooooooooooo_K$2$9BIRX]_```^[TLA+ &'(&"  3232  2  2--""6)'')6ÿÿÿÿÿÿÿÿøÿÿÿÿ€ÿÿÿü?ÿÿðÿÿàÿÿÀÿÿÿþþü?øððàààÀÀÀÀ€€€€€€ÀÀÀÀàààððøü?þþÿÿÿÀÿÿàÿÿðÿÿü?ÿÿÿ€ÿÿÿÿøÿÿÿÿÿÿÿÿ( @€Œ2458 :’=“?”?”@•C—E–E˜G˜H™I"›N"œN&žQ*ŸT,ŸT- U1¢Y3£\7¥^:§aA¨eCªhE«jF¬kJ­nN®pP¯qO°qP°rS±uU³wW´y]µ|h»…i¼‡k½‰uÁz”|Õ{Ä•|Ä—~Ř€Æ™„ȉʠŒË£‘ΦӱžÔ± Ô³¥×·§Ø¹¨Ø¹«Ú¼¯Û¿´Ý÷ߎáÊ¿âÌÀãÍÆåÑÊçÔËèÕÌèÖÑëÛÓëÜÔìÝØîàÝðäæôëéõîíöðïøòñùôõúööûøùüúûýüþþþ ° Ïð ÿ=ÿ1[ÿQyÿq˜ÿ‘µÿ±ÔÿÑÿÿÿ/"P0p=L°YÏgðxÿŠÿ1œÿQ®ÿqÀÿ‘Òÿ±äÿÑÿÿÿ&/@PZptް©ÏÂðÑÿØÿ1ÞÿQãÿqéÿ‘ïÿ±öÿÑÿÿÿ/&PAp[t°ŽÏ©ðÃÿÒÿØ1ÿÝQÿäqÿê‘ÿð±ÿöÑÿÿÿ/P"p0>°MÏ[ðiÿyÿŠ1ÿQÿ¯qÿÁ‘ÿÒ±ÿåÑÿÿÿ/Pp ° Ï ðÿ ÿ>1ÿ\Qÿzqÿ—‘ÿ¶±ÿÔÑÿÿÿ/Pp!+°6Ï@ðIÿZÿ1pÿQ†ÿqœÿ‘²ÿ±ÈÿÑßÿÿÿ/ P6pLb°xÏŽð¤ÿ³ÿ1¾ÿQÇÿqÑÿ‘Üÿ±åÿÑðÿÿÿ,/KPip‡¥°ÄÏáððÿò1ÿôQÿöqÿ÷‘ÿù±ÿûÑÿÿÿÿ/-P?pRc°vψð™ÿ¦1ÿ´QÿÂqÿÏ‘ÿܱÿëÑÿÿÿÿ/Pp!°&Ï,ð>ÿX1ÿqQÿŒqÿ¦‘ÿ¿±ÿÚÑÿÿÿÿ"   &  &,  ,    1L4 , H_?, N_> &Q_;& !R_6 "R_4 !R_A  P__PB) L_TS_SG* I_F.BQ_SC%A_F $=P_O5 7_K#ASTE *_Q 1N_J PT2(N_A  H_B 2TQ# -I¨dCªhN¯qR±tV²vW³xX³xX´y^·~`·j¼‡o¾‹vÀ|Ä–‚Ç›ƒÇœ›Ò¯¥×·§Ø¸ªÙ»¬Ú½·ßŹàÇ»àÈÀãÍÃäÏÆåÑÊçÔÍè×ÒëÛÖìÞÛïâßñæäóêæôëêöîí÷ðQÿÈqÿÓ‘ÿܱÿåÑÿðÿÿÿ/Pp",°6Ï@ðJÿ[1ÿqQÿ‡qÿ‘ÿ²±ÿÉÑÿßÿÿÿ/Pp ° Ïð ÿ=ÿ1[ÿQyÿq˜ÿ‘µÿ±ÔÿÑÿÿÿ/"P0p=L°YÏgðxÿŠÿ1œÿQ®ÿqÀÿ‘Òÿ±äÿÑÿÿÿ&/@PZptް©ÏÂðÑÿØÿ1ÞÿQãÿqéÿ‘ïÿ±öÿÑÿÿÿ/&PAp[t°ŽÏ©ðÃÿÒÿØ1ÿÝQÿäqÿê‘ÿð±ÿöÑÿÿÿ/P"p0>°MÏ[ðiÿyÿŠ1ÿQÿ¯qÿÁ‘ÿÒ±ÿåÑÿÿÿ/Pp ° Ï ðÿ ÿ>1ÿ\Qÿzqÿ—‘ÿ¶±ÿÔÑÿÿÿ/Pp!+°6Ï@ðIÿZÿ1pÿQ†ÿqœÿ‘²ÿ±ÈÿÑßÿÿÿ/ P6pLb°xÏŽð¤ÿ³ÿ1¾ÿQÇÿqÑÿ‘Üÿ±åÿÑðÿÿÿ,/KPip‡¥°ÄÏáððÿò1ÿôQÿöqÿ÷‘ÿù±ÿûÑÿÿÿÿ/-P?pRc°vψð™ÿ¦1ÿ´QÿÂqÿÏ‘ÿܱÿëÑÿÿÿÿ/Pp!°&Ï,ð>ÿX1ÿqQÿŒqÿ¦‘ÿ¿±ÿÚÑÿÿÿÿ!!   * 788,! 523-!!0$#3% !&).('36"490,+1/      !!þðàÀ€€€€€€Ààðþ‰PNG  IHDR\r¨fDIDATxÚíÝ]ŒUÕð50H#4>T;µ©Q_”V!õ¡:ÆÁÖ@(•ôÒJƒ¢¤6ÄaªIň>(CC+¤V0V´ )aF})©Al‘j­M…ŠÃÌíYÜár™¹÷|ìµ?Öþÿ^tæÜs†»ÿ{ïµ÷9·‰ ZM®OÜAD 1@ÄCD  Äôš™ücNHÿ^©Ð6“Çoj¢CÇ&:ÖÝFû\_3”‡È”õtÅEchmº—•Ľ´÷ÐZúÀõù@6Oq^é§×“†5Úõ¹”‘U_Ó(º#?!<Á >[¯M¾œçú\„íHÞuë~@82ØÃ?•ôðS\Ÿ‹c‡Íè ù¾ÍÝ}õ„m´ÝõyÄ lph¿×õy©‰fad  €«õcšéhòå(×ç¢DÕó†p£oM»0§—•L¡é£93%aˆï¦¥! BÃ÷‚ 0@NÓÚém óýÄÓƒž5t½ëó  #4üp ²C4€†.Ac€ áë  Æ´ ôhòKYåú<À¼ Ñc=«é^×çáÀ ÁÍ;Ç\ŸÈë=C°à,a¸#L Ί:°–±ï!ˆ20܇ÑÞk]Lo§ÍÉU/q}à¡ uv¯¡¥®Oæ¨`ú.Ô×½:žvÅ…bÈyŲR >0ä‡Â"˜¨ ôú`ŠæÑ€ÊÀn>0Më.Bu0}½@ú­ nìè^Mwº> “Tªü`ƒ¦U‚ù>ئ¥.| ñƒ+B è@ã×B`•~ðFÀû‚ lîïÁ?x+À*Ðø!Aí&°Æ! e¯@'‰žÄHÀû@ã‡`Pð:Ðø!xž‡€·€u~PÃãð2°Ã´ñuÇ w€ÆZù^?hç[x6×ú“:•\üÅ®¯âãÓoN} &¾„€'ÇxA„¼Ø(ä<°Ü±òáA£NE?ˆë¢ ÓÀ¼Àm=ÀÙ cÞ0ÄY=ÀI`Þoßä–©Ôòå _ßrÝüóþßìk½ÝÝrÁ;|ô úèä?¾~ý½—ètßi׿o¸ªXÌûe´^sÇÀŸ×MœI-ãÎ6ôé——ZÆOp}j ¥aqâä1z÷è¾hÃÁE=Àz`Þ_\Ú‹_6îë4yâwþ›Dïí‹4^}w;øï1:|â-×§$Îv=Àê‹aÞŸÍØÑcéæ«nêÍCéÉmxçøÚb½zx»Ö@°Z°ú/íÕy^~åøoФËou}JAáQºŽ¼èúTŒ±9°Iïß—ü1ÊÖëù¨ºgÿvËL4vÞ}ëZFýÉ(`´²±VýÇ6‰¾7iéÀ|Ãx{xšðHW[ÐA`kUÀJÄTøãj<÷ð³¯YŒïXèA`£ (þÓÚéí¦&š"ý:.-¼a9Í™´CzOqüøwß§ÏNÿÇõ©ä%^ Í…?.Þ-¼é>ÕËpÚ´¿²‚~{p“ëÓÈEº (‡þÜÛ/™ù †÷âUƒõ\Ôh@r* v`m…?žÛ·µnDÃWàÄgÇhÁ³S‚ É‚ Xhéýǽ„ž¸ëyÌï• -¤F"ÕRøC¯¯[H!P©Ð¡ž5t½é㊀†ÞŸçúkn{Òõi€09›®t}™HŒŒPCïÏ=ÿ#óvº> °„wþªëA×§ÑÄ(Àx„ÞûóœÿO÷|êú4À²¥¿žĆ!Ó££ÓÐûïZþ>æü e*`z`4BïýysÏæ»{\Ÿ8rÿ޹AÜUhr`ì@zÿ‡ævF³³·Ç¾ÿÙ߇þηÔV;üáÞ¤Wü¸ôë´Œ¿”&mÖyÿÍ×§ñ&¡u;ýÿ4z“£czïÏ´ CxHÛ}üµ¯ÓÆíûSu¸øš>íÈU0ÌèpþQ™˜9Èôš™4ÿ½n%å„8ü¯}– a›Gzw%lŒÎB™$-wVwí+4ôþ!-ýñð}ÉÖV×§áÿ;-½q•ØÎÌ`€ÌŒJ@CïÏB ÊÚµ©¯Pê ŒÊ€‚ÞŸ…lΦˌêB%Q´ *¨ü( Ôkºß?Ĉ}€(ÿ¼€R a鯚ä*¿±¸X·lêÆŽs-€!”zjP©Ð2üO™|Cñ2Üî#[hãžuÔ_©?~*”e+ `”šþAMÃÿje¶§þñ=R¥æ½ÉsÕçÆÏ`Vl +üîÑúœÿÑM£è™¼œy™©^£¯&u{q¬ õû¼ý‰¯Ð¿þ÷‰ëËË«ðç” UÃÿZõžý—µÑW“ºÉ(ÖÀïó|E§…~HËÚVé'ï~|òCzûøþÜÉ'µË0Ö" Ôï3Äùÿ‚{Š€òÞß´•­­þ§b]ì\Ô%²0¤]€Ã)2 @X µ¼ÊC,L’¼g#ÔáÊJÌè ùɼw›ë‹ …ä³CÃ!5÷zø?¨©‰h£í¹~&ï‹ ÷ÏGj¸ªá ›—äóBþ§òŽ‚¤Öþ™–7lV’[µCyX¢[õ¿,É7mLÃ~ªÐ3?ì{@Hˆ›F”s5 _l ’?æ¹¾ÆPH Yc[þ“šF¥f>zõö÷º¾LSrÝ70üÏAª`¥ªÇj@ú9—RóLB$—«by€Ôþ‰jný­K$0ÿÏGjùOSÁªÏgP;•ÊQȘÿç"5tÕ8d­eëá,{ÿA™ëyÃÿ°û¯[_mï?(ë4 @êM¬}øoó±lŠ{ÿFóÿ|póO~6¿æßãŒu€L0mõ&ߨìúšB!µn­uøo£ÚŸÒ>ŠJ%ÃõS=«i\£ïË6Àð?‰ù¿Æ7.ïð[yë/­~£ö¡µ,Ó€axXE6ÒÛ{‡Ûý¤æ²šÞ¼ü;jkÝhµñG1ï¯a$´>ýWŠÔú¿–Ý6çû)m£§¬²<-¸aà ùHC¿û‡üísŸ½©g8\;™÷ôÕšnöÉ,ËB†áÃ*.äbÈÏbnüÌH`þŸT0Ôù«‹**öÆŸjT@„àù¿ ½>Cã?` €n{}ÆÓ¥Ÿ½¸tèóc‡°H*B)Öû4%B¯•H(¸ ‰`w­qíã‘;w:kø,Ô:‰¸÷Ô ¬äÛ €ëá~*ĉ-V†H}|þ7ü7Ýk}CO-.ö-îœÍÞþ"–IJ ùIGypãŸûôUt¦¿Ïõ©x­T ˜ö×¾j>O‹|T¯ˆ0Dë €O Ÿù6" Àm+¾5|òßñô7©¯¿ßõ©`–^Ò»¿µÃúM;õ`‰¯€0 +| Ko\åUÃç^¿£ë'ò—„ò €oCý¶ôšƒ&õ ©€tö5‹½køèõÍC e€ç÷·Lžï|ÏHÐëË@“ú`Sàca¯vôÉBóuÀ×ù}5Tøå!5†öÝû…ñã _öé7Â{~úü|úôsôúÒ‚¤Vò€ïÃüj>Þà¤@ë%À†ù)îõ—ýæ6ù,C’Z¨¾Wókq‘¯sßÃèõA²>îÖkK{î!I-¦ÀE½[®¾+˜a~Š{ýE›§¢Èç€ ‰%@ƾð¦ûœ?n+/ ÷ýƒ"µ*^Ó߸g†ûžA‘Z ªû~C‰=¸á¯úý|ú[x½V8ðPÐú¤V|‡;ö§ Š-Pà @P碮 Öä‹BÃW¹Ç‚ã£Áê’Zô¾e>Œ¡82­€†¯>XÈWÇ]J»W|äú4Œâªþæ¿<†âž"!š–qo¾^!€oÔÙðÒ*4|ÅJV†ò ¶ìÆ¡Ñ ÀÀ÷4:`x!~\ŒÀ”õtŘf:æúb|J¤ýçnÂ\.2½gh¡µôA½ïÉôÜiÔ.ä{`)Íÿ  _÷païÑ—Wáû€äS`˜Ã1Ó6ÐÉä/v}A>ñ!ÐÛÃH’w穞Õ4®Ñ÷eàž€ ¸ Þ´³ëmèí¡¾÷œû¶Œ0 8Çö& âï>²KxY–á?C`#ÒF¿õÍ ñ!7‰x!ùcžë ódð¼¾#™×ÿŠÛ‘ÀY¾1{ 0D2²~$Àˆ2ÎÿÏ~k˜œ…Ÿeþ3@ð™d @ðZæù?˨ .®Û¹Äõ%B¨rÌÿÏ~{N˜ À_y†ÿ P|%x@ü”å üL‘Š}€åíý øÈ^D¾€ïä¬þŸû±‚bHß4gÓ•®/S¤÷g…`Z;ij¢Ñ®/Üé»gtþgU*Ô׳†š‹üláwZÌO F€O²<ýw$¥Þi±Nà“¢ÃV6¢¼7ɵ÷¿V©wZ¬Óø¢ÌðŸ•~§Å8 €m½‘ßïú2!e†ÿ¬|D¸'@:pK0dRpíÿüCÛ(`rËTÚ|wØñEÙÞŸ™ €G’Ÿ €€† ôþgcHl£¸d¢÷g& ª%AÉÀýÐ@©¥¿jF×›b ÀS½?3ÑŒ:uѤËo96ê0Öû3ã;Nb<4·“f_»X䨉ÉÞŸI@£8`´÷g"{NcHž Ã1Ýû3©P? Àý`™ñÞŸ‰½Ë´`“DïÏä@ùî@éíÀbh×ßð‡¤} ¹)©ÞŸ‰¾Ë´?/ÒÊÞï߈ø»LsAPr%à[I¨>A"…¿jVº­SÉXñÜÍ´ÿƒ7\_"8$9ôOÙ ¥AÉ•Ü9ÁÂßù/cI2 èKþeëõl\ @D­?éý­|憵ÐZ”*"â%]ø«fµÔ¬± (U@DK¼ðWÍúZ“¶‚à–Ӛ۞4~\@œlþªYmS©: >6‡þ)'»M´­ ìZþ>µŒŸ`ô˜€ÈXªú_ø²Žhª¬l}˜–M}Àè1Q±:ï¯æt¿©–z€Ä4ÛóþjN@S=Àô3qp1ï¯æüŽ-õÓ«¸(Žæý矂´ÔLß9¾‡–lmu}9 ËÙ¼¿šÀ4ÔLÝ0ûÉËèŸ'?v}9 È弿š'‘Òewâ‰ÀúùÒø™7'´‹NÐøõs]ô«åU0 !0~ì%´mÙ¡\!ÐþÊ úíÁM®OùÖø™wÀ4„k´2ÀÏÿß}d =õÚÏétßi×§ ‚|lüÌË`Z–kýùo Þþ^×§6T¨³{ -u}Ãñ6ØôvÚœœ!&Å.?ó:B‚åyãgÞC@€¼ØèÓHÀ’èOÎ6˜ó…¸ù´Ö_O'™ÂHDÏŸ *B¼Àœ¿VpÀL„@…èTrñ»¾P"ÀÆÏ‚ ¦iŸ΃Ûz‹ŸzÀ´ì„pùºÃ/« €!À•Ð? >BlÓÐø™ŠHixžø/”5þ,Ô\HJËãÅÀKA­ñg¡.VÀ¸€+ýõ/K)ÔÀ-óýᨠ€vBanîÉC}0Œ /ͽ~µ( …UÈBS•¿‘h.4…)Œ(‚!­è€ N Ž&_Žr}.à…þdÈ?1†!­( …åBк¼—ýò›‡â¤nSO€AX)ˆG,þ,50-P,òáþp#À´@ ÷G€hA44ü!‚‚†Ÿ '×ÐðsB„b¡GPÜ+ P‚À!4üÒ† î#xœ0=¶£÷ ݃u|38 š›é½ä—Ûìú\T¨ÐéÞ>ºÞ<€0LJÀ_À¢4¿R¡m®ÏÃgMM´à@mw}±@8282XK¨ìHÞ…ëÑÓ»ðDD€ï€§8’éBWèŸ`<ð)ÌMÔŠï'@@xuá¢14‹¿ö­–Àswþó‹^Ú‹j}8Jðˆ!ùÇœþÝt@¤ |àØDÇУ뀈 b€ˆ!"†ˆ b€ˆýÆß—˜9sKIEND®B`‚(€ ªU”? Œ4Š2#281HŒ3x‹1€‹1€‹1€‹1€‹1€‹1€‹1€‹1€Œ3x1H28Š2#Œ4”? ªUÿˆ3‹.!Ž2VŒ22‡Œ2¥‹1׌2àŒ1çŒ1ìŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2üŒ1ìŒ1çŒ2à‹1׌2¥2‡Œ2Ž2V‹.!ˆ3ÿ?/ ‹1M2~Œ2¬Œ1ÜŒ1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ñŒ1ÜŒ2¬2~‹1M/ ?™3‹1‹1X‹2˜Œ1ØŒ2î‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2îŒ1Ø‹2˜‹1X‹1™3ÿŒ31HŒ1ŒŒ2ÕŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ2ÔŒ1Œ1HŒ3ÿªU/2Z‹1¸‹1í‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1í‹1¸2Z/ªUªU‹.!‹1q‹1ÉŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1É‹1q‹.!ªUÿ/‹1q‹2ËŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹2Ë‹1q/ÿ‘63U‹1ºŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹1º3U‘6™3Š/0‹1›‹1íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í‹1›Š/0™3Š5Œ1v‹2Û‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2ÛŒ1vŠ5UU4'‹2¨‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1÷‹2¨4'UU?‹1XŒ2Ë‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŒ2Ë‹1X?Š5Š0}Œ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1çŠ0}Š5‹.!‹2¨Œ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹2¨‹.!ÿ1$‹1®‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1®1$ÿUUŽ2=‹1¸‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1¸Ž2=UU?Ž2FŒ1Í‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1Î1H?UUŠ2FŒ2Ú‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1Ü1HUUÿŽ2=Œ1Í‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ ‘:ÿ 9ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹2΋2BUU1$‹1¸‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ5¤^ÿ‡É ÿœÓ²ÿ™Ò¯ÿzÄ”ÿ<¨cÿ :ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1Lj1)‹6!‹1®‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿP±rÿ×îßÿýþýÿÿÿÿÿÿÿÿÿüþüÿâóèÿ€Æšÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1®‹6!”5‹2¨‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ-¡WÿÌé×ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòúõÿqÀŽÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2¨”5Œ0}Œ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿ‹Ë£ÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÌéØÿ™JÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ0}ªUŒ0YŒ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ(ŸSÿÓìÞÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèõíÿ9¦bÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1çŒ0YªU2-‹2ÏŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿcºƒÿõû÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ=¨eÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ï2-‰1Œ2­‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿ›Ò°ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ=¨eÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŒ2­‰1*Œ3xŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ™IÿÌéÖÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ=¨eÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ3x*Š/0‹2ÛŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦bÿèõíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ<¨dÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ÛŠ/06Š1œ‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ]¸~ÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãóéÿ, WÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŠ1œ6ÿ3U‹1íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ~Řÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßñåÿ šLÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í3Uÿ/2ºŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿ•Ьÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßñåÿ šLÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ2º/ªU‹1qŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”?ÿ¬Û¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ×íßÿ™JÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹1qªU‹.!Œ2ËŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Cÿ½äËÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¿äÌÿ–DÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ë‹.!ªU‹1qŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜IÿÑìÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¼ãÊÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹1qªU/‹2ÉŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ šLÿßñåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¬Û¾ÿ”?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2É/ÿŒ2[Œ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ*ŸUÿãóèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿœÓ²ÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ2[ÿŒ3‹1¸Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ<§dÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ•Ьÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¸Œ3‹0I‹1íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‚Ç›ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í‹0I*Œ1Œ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€Æ™ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1Œ*‹1Œ2ÕŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿxÂ’ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Õ‹1‹1XŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôû÷ÿ`¹ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1XŸ?‹2˜Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿ]¸}ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2˜Ÿ?/ Œ2ØŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿ]¸}ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ø/ ‹1MŒ2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿM°qÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2î‹1MÿŒ2‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ=¨eÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2ÿˆ3Œ2­Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿðøóÿcº„ÿ–DÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2­ˆ3’.!Œ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦bÿèõíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿêöïÿ¿ãÌÿ~Æ™ÿ=¨cÿ”Aÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ü’.!‹2V‹1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ$œOÿàòæÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþüÿæôìÿ´ÞÆÿl¾Šÿ&žRÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ñ‹2V‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšKÿÛïâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷üùÿ×íàÿ”ϪÿE¬jÿ•Cÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€ªUŒ2ˆŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ—DÿÀåÍÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿêöïÿ¸àÇÿ_·ÿ™Hÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ˆªU‰' 1¤Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ•Bÿ¸áÇÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúõÿÄåÐÿi½‡ÿšKÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1¤‰' •41׌2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿÔ³ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿÉèÔÿuÂ’ÿ%Qÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1ו4Š2#Œ2àŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ†ÉŸÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿÑëÜÿˆÊ¡ÿ5¤^ÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2àŠ2#28Œ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿrÁÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÜðäÿÌ¥ÿ5¤^ÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ç28Š5H‹2íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿZ·{ÿòúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÜðäÿŒÌ¤ÿ/¡YÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2íŠ5HŒ3xŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ>¨eÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÒëÝÿv“ÿ›Lÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2üŒ3x‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ$œPÿßñæÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúõÿ½âËÿäóêÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿÄæÐÿ`¸€ÿ•CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜FÿÉèÕÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿH­nÿ:§cÿˆÊ¡ÿÒìÝÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñùôÿ«Ù¼ÿ@ªfÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”?ÿ¬Û¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿêöïÿAªhÿŒ2ÿ8ÿ'žSÿi½ˆÿºáÉÿí÷ñÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿàñæÿ„ÈžÿšKÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿŽÍ¦ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòùõÿY¶zÿŒ2ÿŒ2ÿŒ2ÿ3ÿ–DÿN°sÿžÕ³ÿâòèÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿ¾âÌÿL¯qÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿxÂ’ÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿo¿‹ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’;ÿ7¥_ÿ„ÈžÿÐëÜÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿçõìÿΦÿ%Pÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿX¶yÿòúõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ†ÉŸÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ'žRÿnÀŒÿÁäÎÿñùôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿÉèÔÿ]·~ÿ“?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ<¨dÿéõîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¡Õ¶ÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ˜Gÿ]·~ÿ°ÝÂÿë÷ðÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿí÷ñÿ—Ѭÿ, Vÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ"›NÿÜðãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÁåÐÿ–EÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ•BÿQ²vÿ¸àÈÿñùôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÈèÓÿO°rÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€Œ3xŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Cÿ¼ãÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞñåÿ%QÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ—Fÿ^·ÿºáÈÿòúõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæôëÿ}Å—ÿ—DÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2üŒ3xŠ5H‹2íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘:ÿÓ²ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëöïÿBªiÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ—Fÿg»‡ÿÇçÒÿ÷üùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿŸÔ²ÿ!›Nÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2íŠ5H28Œ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿÆ™ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõûøÿbºƒÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ!œNÿyÄ”ÿÚïâÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿ¹àÈÿ:¨aÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ç28Š2#Œ2àŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ]¸~ÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿƒÈÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ6¥^ÿ›Ó°ÿí÷ñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿÌé×ÿE¬jÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2àŠ2#•41׌2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦bÿèõíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥Ø¹ÿ ’=ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿ`¸ÿÍéØÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿÚïáÿS²uÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1ו4‰' 1¤Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšKÿÒìÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍê×ÿ˜HÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ.¢YÿŸÕ´ÿòúõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝðäÿP°sÿ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1¤‰' ªUŒ2ˆŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿ¬Û¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæôìÿ5¥_ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–CÿwÓÿâóéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÏëÙÿ:¨bÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ˆªU‹1€Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ‡É ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöüøÿi¼‡ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿU´xÿÐëÚÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿ¹àÈÿ!›MÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1€Œ1WŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ]¸ÿôú÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¢×µÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ:¨bÿ¼áÊÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿΦÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ñ‹2V’.!Œ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ0¢YÿáòçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚïâÿ* UÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ.¡Xÿ¹àÉÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçõíÿH­nÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ü’.!ˆ3Œ2­Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”Aÿ³ÞÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿbº‚ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ.¡Xÿ¼áËÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿ¦Øºÿ“>ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2­ˆ3ÿŒ2‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿƒÈœÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ˜Ñ¯ÿ :ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ:¨bÿÍêØÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçõíÿAªgÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2ÿ‹1MŒ2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿM°qÿîøòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐëÛÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿM°rÿáòèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿ“Ϫÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2î‹1M/ Œ2ØŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšLÿÐëÛÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿN°qÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿ|Å—ÿõû÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚïâÿ/¢YÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ø/ Ÿ?‹2˜Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿ‘Ψÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿ‰Ê¡ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜Fÿ²ÝÂÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿn¿‹ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2˜Ÿ?‹1XŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ•Bÿ.¡Xÿ6¥_ÿšKÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿE­kÿêöïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»âÊÿ•CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿO±tÿí÷ñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­Û¾ÿ“?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1X‹1Œ2ÕŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿF­mÿ·ßÆÿãóéÿæôìÿÖíÞÿ›Ó¯ÿ_¸~ÿ#Nÿ ‘:ÿŒ2ÿ–Dÿ»áÉÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜðãÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿºàÉÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝðäÿ&RÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Õ‹1*2Œ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=©dÿØîàÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿØîßÿ›Ó¯ÿ_¸~ÿ'žRÿ~ƘÿùüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜðãÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ€ÆšÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿN°rÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1Œ*Ž1MŒ2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿŠË¢ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿÝðäÿÌê×ÿøüùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¹âÉÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿaºÿõû÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿ]¸}ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í‹0IŒ3‹1¸Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘:ÿœÓ²ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòúõÿk¾‰ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ–CÿˆË¡ÿùýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòùõÿY¶zÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¸Œ3ÿŒ2[Œ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿ•Ьÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèõîÿ‚È›ÿU´wÿ<¨dÿ#œNÿ˜Fÿ“?ÿ8ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ7ÿ”@ÿ!›LÿE¬kÿqÀÿ²ÝÄÿðøôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿ=¨eÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ2[ÿ‘-‹1ÎŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿk½‰ÿ÷üùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿñùôÿèõíÿßñåÿÊèÕÿ­Û¾ÿ•ЫÿÆ™ÿe»…ÿY¶zÿAªhÿ:§cÿ&žRÿ šLÿ šLÿ šLÿ šLÿ šLÿ šLÿ šLÿ!›Mÿ1£[ÿ=¨eÿI®nÿ^¸~ÿwÂ’ÿͦÿ³ÞÃÿØîàÿì÷ðÿùýúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËéÖÿ™JÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1Α-ªU1wŒ2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ)ŸTÿÔìÝÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿöüøÿòúõÿêöïÿèõíÿáòèÿßñåÿßñåÿßñåÿßñåÿßñåÿßñåÿßñåÿàñæÿåôëÿéõîÿí÷ñÿôûöÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿ„Èžÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ù1wªU1$‹2ÐŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿeº„ÿìöðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆçÒÿ(žSÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ð1$ªU1wŒ2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’=ÿq¿ÿàòçÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞñäÿO°rÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ù1wªU‹6!Œ1ÇŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿH®nÿµÞÅÿñùôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿÛïâÿV³wÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ç‹6!Š2ZŒ2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ—Eÿ\¶}ÿ¨Ùºÿâòéÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿ½âËÿD¬jÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1íŒ0Yˆ3‹1¤Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ“>ÿ6¥^ÿsÁÿ¨Ùºÿ×îßÿïøóÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùüûÿÑëÝÿ{Ä—ÿ ›Lÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŠ1 6‰2=‹2ߌ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ “=ÿ#œNÿP±sÿ|Ä–ÿ¦Ø¹ÿÑëÜÿèõíÿõû÷ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿîøòÿÅæÑÿzÄ–ÿ)ŸUÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2߉2=*Œ3xŒ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ ’=ÿšJÿ9¦aÿa¹‚ÿÇ›ÿ¥Ø¸ÿÈèÓÿáòçÿëöïÿôûöÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿîøòÿàñçÿ»âÊÿˆÊ ÿN°qÿ™HÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ3x*‰1‹2±Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ ’<ÿ—Fÿ*ŸUÿC«jÿ^¸ÿƘÿ›Ó±ÿ´ßÄÿÊèÕÿÞñåÿæôìÿîøòÿóúöÿùýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿõû÷ÿóúöÿïøóÿèõíÿáñçÿÎêØÿ´ßÄÿ’Ψÿo¿‹ÿK¯pÿ)ŸTÿ–CÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹2±‰1Œ0:Œ1ÓŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ :ÿ•@ÿ˜Fÿ"›Nÿ5¥^ÿM°qÿ]¸}ÿn¿‹ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ€Æ™ÿ{Ä•ÿaºÿ]¸}ÿP±tÿ;§cÿ$Pÿ˜Gÿ•@ÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÓŒ0:ªUŠ2Z‹1ëŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ëŠ2ZªU”? 2‰Œ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷2‰”? ”5‹2¨‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2¨”5‹6!‹1®‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1®‹6!Œ3(Œ2Ä‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1Lj1)2AŒ1Í‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹2΋2BUUUUŽ2FŒ2Ú‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1Ü1HUU?Ž2FŒ1Í‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1Î1H?UU2AŒ2Ä‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1Ç‹2BUUŒ3(‹1®‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1®ˆ1)UU‹.!‹2¨Œ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹2¨‹.!Š5‹2‰‹1ëŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ë‹2‰Š5”? Œ3YŒ2Ë‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŒ2ËŒ3Y”? UU4'‹2¨‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1÷‹2¨4'UUŠ5Œ1v‹2Û‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2ÛŒ1vŠ5™3Š/0Œ3 Œ2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2îŒ3 Š/0™3ˆ3Š2Z‹1ÇŒ2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ù‹1ÇŠ2Zˆ3/ ‹1w‹2ÐŒ2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ù‹2Ћ1w/ ªU†1$‹1w‹1ÎŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1΋1w†1$ªUªU‘-2Z‹1¸Œ2îŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2î‹1¸2Z‘-ªUÿŒ3‹1M2Œ2ÕŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ2Õ2‹1MŒ3ÿ™3‹1‹1X‹2˜Œ1ØŒ1ðŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2îŒ1Ø‹2˜‹1X‹1™3?/ 2Q‹1€Œ2¬Œ1ÜŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ1ÜŒ2¬2~‹1M/ ?ÿˆ3‹.!Œ1W‹1€2‡Œ2¥‹1׌2àŒ1çŒ1ìŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2üŒ1ìŒ1çŒ2à‹1׌2¥2‡‹1€Œ1W‹.!ˆ3ÿªU”? Œ4Š2#281HŒ3x‹1€‹1€‹1€‹1€‹1€‹1€‹1€‹1€Œ3x1H28Š2#Œ4”? ªUÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿÿÿÀÿÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿàÿÿÿÿÿÿÿÿ€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿü?ÿÿÿÿÿÿøÿÿÿÿÿÿàÿÿÿÿÿÿÀÿÿÿÿÿÿ€ÿÿÿÿÿþÿÿÿÿü?ÿÿÿÿøÿÿÿÿðÿÿÿÿàÿÿÿÿÀÿÿÿÿ€ÿÿÿÿ€ÿÿÿÿÿÿÿþÿÿü?ÿÿøÿÿøÿÿðÿÿðÿÿàÿÿÀÿÿÀÿÿ€ÿÿ€ÿÿÿÿÿþþþü?ü?ü?øøøðððððààààààààààààààààààààààðððððøøøü?ü?ü?þþþÿÿÿÿÿ€ÿÿ€ÿÿÀÿÿÀÿÿàÿÿðÿÿðÿÿøÿÿøÿÿü?ÿÿþÿÿÿÿÿÿÿ€ÿÿÿÿ€ÿÿÿÿÀÿÿÿÿàÿÿÿÿðÿÿÿÿøÿÿÿÿü?ÿÿÿÿþÿÿÿÿÿ€ÿÿÿÿÿÿÀÿÿÿÿÿÿàÿÿÿÿÿÿøÿÿÿÿÿÿü?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿÿÿÿÿÿÿàÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÀÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(`À €”?‰1‘2#Ž14‹3TŒ2`Œ2`Œ2`Œ2`Œ2`Œ2`4S‰14‘2#Ž2?‘$‹.Œ0:Œ1m‹2›1ª‹1ÒŒ2à‹2èŒ1÷Œ2ýŒ2ýŒ2ýŒ2ýŒ2ýŒ2ýŒ1÷‹1èŒ2àŒ2Ñ‹1ª‹1›‹1lŠ19‘0ª*‘$‰0%Œ2`Œ1œ‹1ÍŒ1ì‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹1ì‹1Í‹1›‹2_‰0%‘$‰11SŒ2¡‹2Û‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹2ÛŒ1 ‹1R‰1?Œ.&Œ2o‹2Ë‹1õŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ôŒ1É‹2nŒ.&?ªU4'Œ2‹1׋1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ùŒ2Ö‹2~‰4'ªU7Œ1mŒ2ÕŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ûŒ2ÓŒ2k‹.3 ‹0IŒ1¹‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ2·Œ2G8 „2‹1‹1ëŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1ë‹2Š*ªŽ/;Œ2¶‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ1´19U3 Œ0dŒ2ÚŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹2ÙŒ1b8 * Š1{Œ1ðŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ïŒ0x‹. ‹.‹1‡Œ2òŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ñ2„‘0ˆ-‹1Ÿ‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ2ž/‹.‹1Ÿ‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ4ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2ž‹.* ‹1‡‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ&Pÿk¼‰ÿyÕÿb¸ÿ)ŸSÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹3”* 3 Œ1{Œ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1£ZÿÈçÓÿûýüÿýþþÿúýûÿÖíßÿYµ{ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1òŒ0x8 ªUŒ2dŒ1ðŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“>ÿ¨ØºÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖíßÿ(žSÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ï1aªUŒ3<Œ2ÚŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿC«jÿì÷ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøûùÿX´zÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ÙŒ0:Œ+2ºŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿŒÌ¤ÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùüúÿ`¸ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1¸/3 Œ2“Œ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ•BÿÂäÏÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùüúÿ`¸ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹18 ‰0JŒ1ìŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ.¡Xÿåóêÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùüúÿ_¸€ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ëŒ2G7‹1ºŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿO°rÿôú÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøûùÿO°rÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2·‹.ªU‹0n‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿl½Šÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷ûøÿF¬jÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ2kªˆ1)‹2ÖŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ‡Ê ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿBªgÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ2Ó‰4'?Œ1Œ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿžÕ²ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèöíÿ5¥\ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û‹2~?4'Œ1ØŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿ´ÝÄÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿäôêÿ0¢YÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ö0%‹1q‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’<ÿ½áËÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚîâÿ"œOÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ù‹0n/Œ2ÌŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–CÿÈçÓÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÔìÝÿ˜IÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ɉ13UŒ1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÌèÖÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ô‹1R‘H‹1¤Œ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆæÒÿ“?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1¡‘$‰-'‹2ÝŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²ÞÂÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Û‰0%Œ1b‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¯ÝÀÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹2_‘HŒ2žŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥Ø¸ÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1›ª*…7‹1ÏŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ—Ñ®ÿŽ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ì‘0Œ3<‹2íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒëÛÿm¾Šÿ.¢Xÿ ‘;ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ì19Œ2oŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’<ÿ¾áËÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿâòèÿªÙ¼ÿ]·~ÿšKÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹1l‹1ŸŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿ°ÜÀÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöûøÿÑëÛÿˆÊ ÿ:¦aÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2› Œ2­Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿšÓ®ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿèõíÿ£Ö¶ÿH­lÿ ’=ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹3ª/‹2ÔŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿƒÈœÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿí÷ðÿ­Û½ÿP±tÿ•Bÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÑŽ2‰0%‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿg»†ÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿñùôÿ»áÊÿc¹‚ÿ—Fÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2àŠ2#36‹2êŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿQ²uÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿÂäÎÿc¹‚ÿ–EÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2èŽ14Ž2V‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿëöïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõú÷ÿ¹àÉÿP±tÿ ’=ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹0T0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ"›NÿÞðåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿ´ÞÄÿËè×ÿõû÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿïøóÿ¥×·ÿ<§cÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿÈçÓÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùüúÿcº„ÿ™Iÿ^·ÿ±ÝÁÿëöïÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿâòèÿÇ›ÿšLÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ :ÿ­Ú¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿt‘ÿ3ÿŒ3ÿ“>ÿ@ªgÿ”ЫÿÜðãÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿÂäÐÿM¯qÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ“ϨÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿΦÿ3ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ+ UÿvÂ’ÿÊèÕÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿëöïÿ‘Χÿ&Pÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿo¿Œÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ©Ø»ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ5ÿ™Iÿa¹ÿºàÉÿðùóÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÍé×ÿ[µ|ÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`0cŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿN¯qÿ÷üøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆæÒÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ•BÿP±uÿ·ßÇÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿ“Ï©ÿ›KÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2`Œ1W‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3¤[ÿçõìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßñæÿ&QÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ–Cÿ[µ|ÿ½áÊÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÀãÍÿ@©eÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷‹3T‹27‹2êŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜HÿÔìÝÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿAªgÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ—Eÿg¼†ÿÌé×ÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿÚîáÿX´zÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2èŽ14Œ.&‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’=ÿ·àÆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿ`¸€ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ#œOÿ…ÉžÿäóêÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéöîÿqÀŽÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2à1$/‹2ÔŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ‘ΨÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿˆË ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿE¬jÿ»áÉÿùüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿðùóÿÇšÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ÒŽ2 ‹1®Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿh¼ˆÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ´ÞÄÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ™Jÿ‹Ì£ÿîøòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúõÿwÃ’ÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2«Ÿ‹1ŸŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ?©fÿïøóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿØîàÿ$œOÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿcº„ÿßñæÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéöîÿX´zÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŠ2œ‹1qŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ›MÿÖíßÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿV³wÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿF­kÿÑêÚÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÓìÜÿ,¡VÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ1mŒ3<‹2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘:ÿ©Ùºÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿ™Ò®ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ?¨eÿÑêÚÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿΧÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ìŒ4:7Œ1ÏŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿo¿ÿüýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑëÛÿ™IÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿF¬kÿÝðäÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞñæÿ.¡XÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Í‹.‘H‹1ŸŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ:§bÿêöïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñùôÿG­mÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ_¸€ÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýüÿÅ™ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŠ2œ‘$‹0c‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ•CÿÂäÏÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿˆÊ ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’<ÿ”Ï©ÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÌé×ÿ™HÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2øŒ2`4'Œ2ÝŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ“?ÿ*ŸUÿ&Qÿ“=ÿ3ÿŒ2ÿ4ÿvÂ’ÿûýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¾ãÍÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ)ŸUÿØîáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòùõÿM¯qÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ÛŒ.&?‹1¥Œ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ4¤\ÿ²ÜÂÿãòéÿßñæÿ¶ßÅÿsÁŽÿ3¤[ÿ“>ÿ1¢ZÿáòçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜïãÿšJÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿͦÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿ…Éžÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2¢‘$Œ0Y‹2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿ´ÞÃÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿûýûÿæôëÿ·ßÅÿ‚È›ÿÏëÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒëÜÿ˜GÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿXµzÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ«Û¼ÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1õ1SŒ+Œ1ÍŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ"›NÿÚïâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿûþüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿ“Ъÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ :ÿk½‰ÿ÷üøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¬Û¾ÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ê“1‹0sŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ™IÿÔìÝÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿ®Û¾ÿqÀŽÿS²vÿ<¨cÿ'žSÿ—Eÿ ’=ÿ :ÿŽ7ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ7ÿ ‘;ÿ”@ÿ$œOÿAªgÿn¿‹ÿ¦Ø¸ÿçôíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿΧÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŠ2pˆ/+‹1ÝŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ 9ÿ¡Õ´ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿûýüÿøüùÿïøòÿÞðåÿÐêÚÿºáÉÿ¨Ùºÿ•Ьÿ†ÉŸÿ~Å—ÿ~Å—ÿ~Å—ÿ~Å—ÿ~Å—ÿ~ŘÿŽÍ¦ÿ™Ò®ÿ®Ü¿ÿÇæÒÿÛïâÿðùóÿúýûÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿU³wÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ûˆ1)f3Š2ˆ‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ=¨cÿÜïãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿ²ÝÂÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2„?2-‹2ÛŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿN°rÿÎéÙÿüýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿÎéØÿ5¤]ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ÚŽ/+¿?2yŒ2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ)ŸTÿ‹Ë£ÿØîàÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýûÿÀãÍÿ:§aÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2øŒ1v?‰1‹1ÂŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ%Qÿf»†ÿ¨ØºÿÖíÞÿñùôÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿÝðåÿ‡Ê ÿ!›Mÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹2¼,ÿ1S‹2îŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ9ÿšLÿH­mÿtÁÿ¦Ø¹ÿËèÖÿæôëÿóúöÿüþüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿïøòÿÊèÕÿ‚È›ÿ0¢Zÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ìŒ3P‹. Œ1•Œ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ8ÿ—Eÿ.¡WÿM¯qÿtÁÿ”Ϫÿ±ÜÁÿÏéØÿàòçÿí÷ñÿ÷üùÿúýûÿüþýÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿüþýÿúýûÿøüùÿîøñÿÞñåÿÄåÐÿŸÕ³ÿvÂ’ÿB«hÿ—FÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ûŠ2“™3 Š2#Œ1ÂŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ ‘;ÿ–Dÿ* Tÿ;§bÿN¯qÿg»†ÿ~Ƙÿ“Ï©ÿŸÔ²ÿŸÔ²ÿŸÔ²ÿŸÔ²ÿŸÔ²ÿŸÔ²ÿžÓ±ÿ‰Ë ÿ~ǘÿk½‰ÿQ±tÿ<¨cÿ'žRÿ”@ÿ8ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2À‹.!ÿ3@Œ2àŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ3ÿ4ÿ4ÿ4ÿ4ÿ4ÿ4ÿ4ÿ4ÿ3ÿ3ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ß‹1>ÿ™3‹2j‹1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ð1g™33 ‹2~Œ2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2òŠ1{8 ‰: Œ2“Œ2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹2’‰' ”5‹2¡Œ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ûŒ1 7Œ+‹2¡‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2øŒ1 ‘-Š5Œ2“Œ2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2òŒ2“Š5‰: ‹0~‹1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ðŠ1{‰' 3 ‹2j‹1áŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ß‹1h8 ™3‹/@‹1¸‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2·‹1>™3‰1‹2’‹1íŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1ì‹1Ž2™3 ‹2KŒ1¿‹2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2øŒ1½3J3 ‰1‹2y‹2Û‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹2Û‹1wŽ2?2-Œ2ˆ‹1Ý‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹1ÜŠ1†‹4,?™3ˆ/+‹0sŒ1Í‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1öŒ2Ì‹1q‹0*?‘6Œ0Y‹1¥‹1Ý‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹1Ý‹1¤‹1Xˆ-?‰4'‹3cŒ2¡‹2Ћ2íŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û‹1íŒ2ÏŒ2žŒ1b‰-'??Š5Œ3<‹1q‹1Ÿ‹1®‹2Ô‹1â‹2ê‹2øŒ2ýŒ2ýŒ2ýŒ2ýŒ2ýŒ2ý‹2øŒ2é‹1â‹2ÔŒ2­‹1ŸŠ2pŒ3<7‘$ÿ8 /Œ.&‹27Œ1W0c0c0c0c0c0cŒ1W360%/8 ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿü?ÿÿÿÿÿÿÿÿàÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿàÿÿÿÿÿÿ€ÿÿÿÿÿþÿÿÿÿÿü?ÿÿÿÿðÿÿÿÿàÿÿÿÿÀÿÿÿÿ€ÿÿÿÿÿÿÿþÿÿü?ÿÿøÿÿðÿÿàÿÿÀÿÿÀÿÿ€ÿÿ€ÿÿÿþþü?ü?øøøðððàààÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀàààðððøøøü?ü?þþÿÿÿÿÿ€ÿÿÀÿÿÀÿÿàÿÿðÿÿøÿÿü?ÿÿþÿÿÿÿÿÿÿ€ÿÿÿÿÀÿÿÿÿàÿÿÿÿðÿÿÿÿü?ÿÿÿÿþÿÿÿÿÿ€ÿÿÿÿÿÿàÿÿÿÿÿÿøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàÿÿÿÿÿÿÿÿü?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(H `TU/‹1Š2#Š2#Š2#Š2#‹1ˆ3‘$ˆ-Ž2B‹1q1‹‹1³‹1Ë2Û‹1â‹1â‹1â‹1â‹2ÛŒ1ÂŒ2²‹1‹‹1q‹2Bˆ-‘$Œ3(Œ2fŒ1©‹2ÖŒ1ñ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1ñŒ2Õ‹2¨Š2eŒ3(‘$‡-Œ2LŒ2£Œ2à‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2ߌ2¢‹2K/*Œ3Y2º‹1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ðŒ1¹‹1X‡-‘$ˆ0EŒ1´‹1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ô‹1³Œ1C‘$‹6!‹1Œ2éŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2èŒ2Ž/ ?Š0D‹1Ë1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŒ2Á‹2B?™3 ‹2n‹2äŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1â‹1l3 ™3Œ2‹2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1|ˆ3‘0Œ1•‹1öŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1õ‹1”‘0/Œ3•Œ2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ”@ÿ ’<ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ùŒ1•–-™3 Œ2Œ1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿƒÇœÿÆåÒÿ¼áÉÿo¾Œÿ“>ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1÷‹1€3 ?Œ0o‹2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ5ÿv‘ÿ÷üùÿÿÿÿÿÿÿÿÿõû÷ÿn¾Œÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹1l?Œ3E‹2äŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšKÿÒëÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ³ÝÃÿ :ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŒ1CŠ2#Œ2ÆŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿP°sÿõû÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¸ßÇÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ć4"‘$‹2’Œ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ†ÉŸÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ·ßÆÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ü‹1‘$Œ3EŒ2éŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ 9ÿ°ÜÀÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­Ú½ÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2èŒ1C8Œ1µŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ•BÿÉçÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¨×¹ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1³‡-Œ2[Œ1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšKÿÙîáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ—Ñ«ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ô‹1X‡<‹2¼Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ(žRÿåóëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‰Ë¡ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1º/Œ2LŒ1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3£\ÿëöðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿxÔÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ð‹2K‹1¤Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿj»‡ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2¢Œ3(Œ2àŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýüÿ`¸ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ߌ3(Œ2f‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷üùÿS³uÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2d‹1ªŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõûøÿN°qÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2¨‘$‘6‹2ÖŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦aÿî÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿP±sÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Õˆ6Œ1CŒ2òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4¤\ÿìöðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿÖíßÿ“Ï©ÿH­mÿ•Cÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ñ‹2B‹0s‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ'žQÿäóéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿòùõÿÄåÐÿuÁ‘ÿ+ UÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1qUU‹2Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ™JÿØíßÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÞðåÿ‘Χÿ4¤\ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1‹?Œ1´Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿÇæÒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿåóêÿ›Ó°ÿBªhÿ ‘<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1³‘$/Œ2ÄŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ 9ÿ±ÝÁÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿìöðÿ¨Ø¹ÿE«jÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ã/”1Œ2ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ”ϪÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿùýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿìöðÿœÓ±ÿ5¤]ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Û‹11$Œ2ãŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿvÁ‘ÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÇæÓÿo¾Œÿ¼áÊÿðùóÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿáòçÿÇšÿšKÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŠ2#1$Œ2ãŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿU³wÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÁäÎÿ”?ÿ”@ÿH­lÿžÔ²ÿãóéÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿÇæÓÿP±sÿ :ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŠ2#1$Œ2ãŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ;¦aÿïøòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕìÞÿ˜GÿŒ2ÿŒ2ÿ8ÿ0¢Yÿ‚ÈœÿÓìÝÿùýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿí÷ñÿ•Ъÿ'žQÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŠ2#1$Œ2ãŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ$œOÿßñåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæôëÿ- WÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ!›Mÿm¾‹ÿÈçÔÿùüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿÐêÙÿYµzÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŠ2#/ Œ2ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”AÿÇæÒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿH­mÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ™Iÿq¿ÿÐêÙÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿ‹Ë¢ÿ—EÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Û‹1/Œ2ÄŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ©Ùºÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþüÿl½ŠÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ!›Mÿ~Ƙÿßñåÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿ­Ú¾ÿ(žSÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ã/?Œ1´Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ‚Ç›ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ’ϨÿŽ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ4¤]ÿ§Ø¹ÿôúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿÃåÏÿ4¤\ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1³‘$UU‹2Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿW´yÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»áÉÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿl¾ŠÿâòèÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿÉçÔÿ.¡WÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŠ1Œ‹0s‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3£\ÿêöîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßñæÿ'žRÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿE¬kÿÌéÖÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿ³ÞÃÿ—FÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹1qŠ0DŒ2òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–DÿËèÖÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿ^·~ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ/¢XÿÁãÎÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿzÄ•ÿ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ò‹2BŒ4‹1׌2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ—Ьÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¢Öµÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ/¡XÿÊèÕÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖíßÿ#œOÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Öˆ6Œ1«Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿZµ|ÿøüùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖíßÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿC«iÿãóéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿo¿Œÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1©1g‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ ‘;ÿ :ÿ3ÿŒ2ÿ#œOÿÙîáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿL¯pÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿzÄ•ÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¾âÌÿ“@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2f1)‹1áŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ]¶~ÿ¶ÞÅÿ²ÝÁÿuÁÿ4¤\ÿ•Bÿ—ЬÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿwÂ’ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ$œOÿÚîáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõíÿ3£[ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2àŒ3(Ÿ?Œ2§Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4¤\ÿåôêÿÿÿÿÿÿÿÿÿüþýÿèõíÿ»áÉÿ¶ßÅÿûþüÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿj½ˆÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ :ÿ³ÝÂÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöûøÿP±sÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2£Œ1NŒ2òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿG­kÿôúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿéõîÿWµyÿ!›Mÿ”Aÿ9ÿ4ÿ3ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ3ÿŽ5ÿ“?ÿ'žRÿ\¶}ÿÚïâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôúöÿI®mÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ñŒ2L8Œ2ÀŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ)ŸSÿßñæÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿëöïÿÜïãÿÈçÓÿ°ÜÀÿ—ѬÿÇšÿn¾Œÿa¸€ÿ`·ÿ`·ÿ`·ÿc¹‚ÿsÀÿ†Êžÿ¢ÕµÿÂäÎÿàòçÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛïâÿ%PÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¾8Œ2`‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿ{Ä–ÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿýþþÿýþýÿýþýÿýþýÿýþýÿýþýÿýþþÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüùÿ~ŘÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹1]…02¼Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’=ÿk½‰ÿÕìÞÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöûøÿ—Ьÿ•AÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1¹Œ33J‹2íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ$œOÿi¼‡ÿ±ÜÁÿÝðäÿõû÷ÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿÕíÞÿo¾Œÿ“?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ëŽ2F8 Š2—Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ ‘:ÿ$œOÿL¯oÿ|Å—ÿ©Ù»ÿÌèÖÿäóêÿóùõÿûýüÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿõû÷ÿãóéÿ»áÉÿrÀŽÿ$Pÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ü‹1”?0%Œ2ÌŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ8ÿ•Bÿ*ŸTÿD«iÿa¸ÿ‚ÈœÿŸÔ²ÿ¶ÞÄÿÈçÓÿ×íßÿÜïãÿÜïãÿÜïãÿÜïãÿÛïâÿÏêØÿÅæÑÿ³ÝÂÿ™Ò­ÿsÁÿM¯qÿ+ Uÿ“>ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2É1$ÿ3JŒ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿŽ5ÿ :ÿ•Aÿ˜Gÿ™Iÿ™Iÿ™Iÿ™Iÿ™Iÿ–Dÿ”@ÿ9ÿŽ5ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1æ1Hÿ*‹0sŒ2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2òŠ2p™3‹. ‹2„Œ1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1÷‹1‚™3 8‹1™‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2—8‹.‹1™Œ2÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2÷Œ2—‹.8‹2„‹2óŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ó2‚8‹. ‹0sŒ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1æ‹1q™3 *Š1H‹2ÅŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2üŒ1ÄŠ2F™3Š2#Œ2“‹1ëŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2êŒ2‘Ž-"?‰0J‹2¼‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1öŒ2»1H…0Œ2`‹2ÀŒ1òŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ñŒ1¿0^Œ3†5Ž3OŠ1©‹1âŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ1áŒ2§Œ1N88 ˆ/+Š2i‹1®‹1Ù‹2ó‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1ò‹1׌1«‹1h‹0*Ÿ?8 3Œ3E‹2uŒ1Œ2¶‹2ÅŒ1Ý‹2ä‹2ä‹2ä‹2ä‹1Ý‹2ÅŒ2µŒ2Ž‹2uŒ0EŒ4?ªU8 ‡-‹.!‰0%‰0%‰0%‰0%/ ‡-Ÿ?ªUÿÿÿÿÿÿÿÿÿÿÿÿü?ÿÿÿÿÿÿÀÿÿÿÿÿþÿÿÿÿðÿÿÿÿàÿÿÿÿ€ÿÿÿþÿÿÿü?ÿÿøÿÿðÿÿàÿÿÀÿÿ€ÿÿÿþþü?ü?øðððààÀÀÀÀÀ€€€€€€€€€€€€ÀÀÀÀÀààðððøøü?þþÿÿÿ€ÿÿÀÿÿàÿÿðÿÿøÿÿü?ÿÿþÿÿÿ€ÿÿÿÿÀÿÿÿÿðÿÿÿÿþÿÿÿÿÿ€ÿÿÿÿÿÿü?ÿÿÿÿÿÿÿÿÿÿÿÿ(@€ BUU8 7Œ.&Œ0:Š1HŠ1HŠ1HŠ1HŒ0:Œ.&78 UU™3 ˆ1)3UŒ2Ž‹1¸Œ2Ñ‹1ã‹2ïŒ1÷Œ1÷Œ1÷Œ1÷‹2ï‹1ãŒ2Ñ‹1¸Œ2Ž3Uˆ1)™3 ?1$2e‹2±‹1â‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹1â‹2±Š2e1$?*Ž22Œ1ŠŒ2Ú‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2ÚŒ1ŠŽ22*Œ5&Œ2ŒŒ2ãŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2ãŒ2ŒŒ5&ˆ3Š1gŒ2ÓŒ2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2üŒ2ÓŠ1gˆ3ÿ‰0%‹1Ÿ‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹1Ÿ‰0%ÿ‰1CŒ1ÊŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ1ʉ1C™3Œ3PŒ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÜŠ2Q™3™3‹1a‹1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1æŒ1b™3Š2Q‹1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ—FÿP°sÿM¯pÿ™IÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ç‹2VÿŒ1CŒ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Eÿ¯Û¿ÿ÷ûøÿöûøÿÄåÐÿ,¡VÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÜŒ1CÿŒ.&Œ2ÊŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿf»…ÿøüúÿÿÿÿÿÿÿÿÿþþþÿÅ™ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÊŒ.&/Œ2¢Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿ³ÝÂÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿͧÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2¢/1g‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ#œOÿÞðåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿͦÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö1gŒ.&Œ1ÓŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ@©fÿòùõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ„ÈœÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÓŒ.&*‹2Œ1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ[µ|ÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿ|Ä–ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ü‹2*Ž22Œ1ãŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿrÀŽÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿl¾ŠÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ãŽ22?Œ1ŠŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿƒÇœÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýüÿ^¶~ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ1Š?1$Œ2ÚŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿͦÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿO°rÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ú1$Œ2f‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿͧÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõúøÿE«jÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2f™3 ‹2±Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿͧÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿïøóÿ:§aÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2±™3 1)‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿͧÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿì÷ðÿ5¥]ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1â1)3U‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿͧÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëöðÿD«iÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø3UUUŒ1Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿˆÊ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿÝðäÿ¡Ö´ÿT²vÿ—Fÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1UU8 ‹1¸Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿv‘ÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõû÷ÿÍè×ÿŘÿ- VÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¸8 ,Œ2ÑŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ`¸€ÿúýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿßñæÿÍ¥ÿ5¤]ÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ñ,Œ.&2âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿG¬lÿõûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿåôëÿŸÔ²ÿ>¨eÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ2âŒ.&Œ0:‹2ïŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ2£[ÿêöïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿêöîÿœÓ°ÿ3£\ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ïŒ0:Š1HŒ1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšJÿÛïâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»áÊÿ¤Ö¶ÿäóêÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿáòçÿƒÈœÿšKÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1÷Š1HŠ1HŒ1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿÄåÐÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿšÒ¯ÿ ’<ÿ2£Zÿ‚ÇœÿÒëÛÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿÉçÔÿT²vÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1÷Š1HŠ1HŒ1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ©Ùºÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ³ÞÃÿ9ÿŒ2ÿ4ÿšJÿeº„ÿ¾âÌÿóùõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿïøòÿ™Ñ­ÿ)ŸSÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1÷Š1HŠ1HŒ1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ‡ÉŸÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÌé×ÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ•AÿQ±tÿ³ÝÃÿóúõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿÒëÛÿYµzÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1÷Š1HŒ0:‹2ïŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿc¹‚ÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿãóéÿ(žSÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿU²wÿ¼âÊÿöûøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîøòÿ‡É ÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ïŒ0:Œ.&2âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿAªfÿòùõÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿC«iÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ–Cÿh¼†ÿÔìÝÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿ¦Ø¸ÿ ›LÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ2âŒ.&,Œ2ÑŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ$Pÿßñæÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿj¼ˆÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ*ŸTÿŸÔ³ÿôúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþüÿ¶ÞÄÿ"›MÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ñ,8 ‹1¸Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿÁäÎÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ›Ò¯ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“>ÿqÀÿçõìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿ§Ø¹ÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¸8 UUŒ1Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ”ϪÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑëÛÿ˜HÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿT²vÿßñæÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüùÿsÁÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1UU3U‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿY´zÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿóúöÿI®nÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ5ÿS²vÿæôìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕìÞÿ"›NÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø3U1)‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ)ŸSÿáòçÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿ‰Ê¡ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿp¿ÿõûøÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿl½‰ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1â1)™3 ‹2±Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ’=ÿ&Qÿ—EÿŽ5ÿ 9ÿ¨ÙºÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÄåÐÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿ³ÝÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿºàÈÿ’=ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2±™3 Œ2f‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜Gÿ§Ø¹ÿâòèÿÎéØÿͦÿJ®nÿrÀŽÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÜðãÿ™KÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ\¶|ÿùüúÿÿÿÿÿÿÿÿÿÿÿÿÿäóéÿ*ŸTÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2f‰0%‹2ÛŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿQ±tÿ÷üùÿÿÿÿÿÿÿÿÿþÿþÿóúöÿãóèÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿ½âÊÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿR²tÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿí÷ñÿ7¦_ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Ú1$?1‹‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿH­mÿôú÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿØîàÿ—ѬÿzÄ”ÿ[¶|ÿC«hÿ3£[ÿ'žRÿ šLÿ šLÿ šLÿ!›Lÿ)ŸTÿ6¥^ÿK®oÿrÀŽÿ¢Ö´ÿÝðäÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÝðäÿ$œOÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ1‹?‹05Œ2åŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Dÿ»áÉÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿþÿúýûÿóúöÿêöïÿãóéÿßñåÿßñåÿßñåÿàñæÿåóêÿì÷ðÿöûøÿýþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿ•Ъÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2å‹05*‹2’Œ1ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ- Vÿ­Ú¾ÿòùõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþüÿ¶ÞÅÿ!›MÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ý‹2’*ˆ1)Œ2ÖŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“?ÿM¯pÿœÓ°ÿÒëÛÿðøóÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿåôëÿͦÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÕŒ3(2j‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ˜Gÿ=¨dÿk½‰ÿšÒ®ÿ¿ãÌÿÛïâÿìöðÿ÷üùÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿõû÷ÿåóêÿÄåÐÿ†Éžÿ6¥^ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹2j/‹2¦Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ ’=ÿšKÿ5¤]ÿP°sÿl¾Šÿ†ÉžÿžÔ²ÿ²ÜÁÿ·ßÅÿ·ßÅÿ·ßÅÿ·ßÅÿ­Û½ÿŸÔ²ÿ‰Ê¡ÿm¾ŠÿJ®nÿ+ Uÿ”@ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹2¦/Œ3(Œ1ÍŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿŽ6ÿ8ÿ8ÿ8ÿ8ÿ8ÿ7ÿŽ6ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÍŒ3(ÿŒ1CŒ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ÜŒ1Cÿ3UŒ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ç‹2V™3‹1aŒ1çŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1çŒ1b™3™3Š3UŒ1ÜŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ü‹2V™3Œ1CŒ1ÍŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ1ÍŒ1Cÿ‰4'‹1Ÿ‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹1Ÿ‰4'ÿˆ3Š1gŒ2ÔŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2ÔŠ1gˆ3Œ3(‹0’Œ2å‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2å‹0’Œ3(*‹05‹1‹‹2Û‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2Û‹1‹‹05*?‰0%Œ2f‹2±‹1ã‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹1â‹2±Œ2f‰0%?™3 ‹0*‹2VŒ1‹1¸Œ2Ñ‹1ã‹2ïŒ1÷Œ1÷Œ1÷Œ1÷‹2ï‹1ãŒ2Ñ‹1¸Œ13Uˆ1)™3 UU8 7Œ.&Œ0:Š1HŠ1HŠ1HŠ1HŒ0:Œ.&78 UUÿÿÿÿÿÿÿÿÿÿÿ€ÿÿÿÿÿü?ÿÿÿÿàÿÿÿÿ€ÿÿÿþÿÿü?ÿÿðÿÿàÿÿÀÿÿ€ÿÿÿþþü?øøððàààÀÀÀ€€€€€€€€€€€€€€ÀÀÀàààððøøü?þþÿÿÿ€ÿÿÀÿÿàÿÿðÿÿü?ÿÿþÿÿÿ€ÿÿÿÿàÿÿÿÿü?ÿÿÿÿÿ€ÿÿÿÿÿÿÿÿÿÿÿ(0` €%ÿ????ÿ™3 Š2#3J‹2j‹2‰Œ1¥Œ1«Œ1«Œ1¥‹2‰‹2j3JŠ2#™3 ™3‹0*Œ1mŒ1´‹2ß‹1öŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1ö‹2ߌ1´Œ1m‹0*™3*28‹1–Œ2à‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1üŒ2à‹1–28*ÿŽ4"‹1‹Œ1æ‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ1æ‹1‹Ž4"ÿ*Œ1N‹1΋1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1ÎŒ1N*‹. 1w‹1ëŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ë1w‹. /Œ1ŠŒ2ôŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ô‹1‹‡-‹. ‹1‹‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ/¡Xÿ@©fÿ–DÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹2”? *‹1wŒ2ôŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿCªhÿÞðåÿòùõÿ²ÝÂÿ–DÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1õ1w*ÿŠ3O‹1ëŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿ¦×¸ÿÿÿÿÿÿÿÿÿïøóÿ9¦`ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ëŠ3OÿŠ2#Œ2ÏŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿšKÿÚîáÿÿÿÿÿÿÿÿÿñùôÿ;§bÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÏŠ2#*1‹‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ:¦aÿðøóÿÿÿÿÿÿÿÿÿî÷òÿ4£\ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü1‹*ˆ28Œ1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿQ±tÿøüúÿÿÿÿÿÿÿÿÿéõíÿ- VÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1æˆ28™31–‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿc¸ÿýþýÿÿÿÿÿÿÿÿÿàòçÿ$OÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ1–™3‹0*‹1áŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿn¾‹ÿþþþÿÿÿÿÿÿÿÿÿÙîáÿ˜HÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1á‹0*Œ1m‹2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿo¾ŒÿþþþÿÿÿÿÿÿÿÿÿÐêÚÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2üŒ1m3 Œ1´Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿo¾ŒÿþþþÿÿÿÿÿÿÿÿÿÉçÔÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1´3 Š2#‹1ߌ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿn¾‹ÿþþþÿÿÿÿÿÿÿÿÿÔìÝÿ<¨cÿ ’<ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ߊ2#3J‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿb¸€ÿüþýÿÿÿÿÿÿÿÿÿýþþÿêöîÿ¶ßÅÿeºƒÿ šLÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö3JŠ2kŒ1ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿO°rÿøüùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýûÿÕìÝÿ}Å—ÿ(žSÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ýŠ2kÿŠ1ŠŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9¦`ÿðøóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿÝðäÿ‹Ë£ÿ- WÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŠ1ŠÿªUŒ1¥Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ%PÿâòèÿÿÿÿÿÿÿÿÿûýüÿÚïâÿóúöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþþÿÞðåÿ~ŘÿšJÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1¥ªU?Œ1«Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ•CÿÏêØÿÿÿÿÿÿÿÿÿóúöÿT²vÿO°rÿ§×¹ÿèõìÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿûýüÿËèÕÿV³xÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1«??Œ1«Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ 9ÿµÞÄÿÿÿÿÿÿÿÿÿúýûÿW³yÿŒ2ÿ 9ÿ5¤]ÿŒÌ£ÿÛïãÿüþýÿÿÿÿÿÿÿÿÿÿÿÿÿðùôÿ›Ò¯ÿ(ŸSÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1«?ªUŒ1¥Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ”ϪÿÿÿÿÿÿÿÿÿþÿþÿzÔÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ'žRÿ„ÈÿÞðåÿýþþÿÿÿÿÿÿÿÿÿýþþÿÒëÛÿR±uÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1¥ªUÿŠ1ŠŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿm¾Šÿýþþÿÿÿÿÿÿÿÿÿ Õ³ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ-¡Wÿ–Ыÿí÷ñÿÿÿÿÿÿÿÿÿÿÿÿÿëöïÿsÀÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŠ1ŠÿŠ2kŒ1ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿG¬lÿõú÷ÿÿÿÿÿÿÿÿÿÄåÐÿ“>ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ9ÿP°sÿÎéØÿýþþÿÿÿÿÿÿÿÿÿóúöÿƘÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ýŠ2k3J‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ&Qÿáòçÿÿÿÿÿÿÿÿÿæôëÿ-¡WÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ*ŸTÿ²ÝÁÿüþýÿÿÿÿÿÿÿÿÿñøóÿ^·~ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö3JŠ2#‹1ߌ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’<ÿºàÈÿÿÿÿÿÿÿÿÿûýüÿh»†ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ™Jÿ±ÜÁÿýþþÿÿÿÿÿÿÿÿÿÍé×ÿ˜HÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ߊ2#3 Œ1´Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ}Å—ÿýþþÿÿÿÿÿÿÿÿÿªÙ»ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ)ŸTÿÑëÛÿÿÿÿÿÿÿÿÿøüúÿ`¸€ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1´3 Œ1m‹2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Eÿq¿ÿsÀÿ7¥^ÿE¬jÿëöïÿÿÿÿÿÿÿÿÿÖíßÿ˜GÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿj¼ˆÿúýûÿÿÿÿÿÿÿÿÿªÙ¼ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2üŒ1m‹0*‹1áŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿl½‰ÿûýüÿýþýÿëöïÿÊçÔÿïøóÿÿÿÿÿÿÿÿÿÍé×ÿ˜Gÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿI­mÿñùôÿÿÿÿÿÿÿÿÿÈæÓÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1á‹0*™3‹2˜Œ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿeº„ÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçôìÿ«Ú¼ÿŒÌ£ÿo¾‹ÿY´zÿK®nÿH¬lÿH¬lÿL¯pÿ\¶|ÿwÂ’ÿ£ÖµÿØîàÿýþþÿÿÿÿÿÿÿÿÿ­Ú½ÿ9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹2˜™3Œ0:‹1èŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜Hÿ¯Û¿ÿøüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿúýûÿøüùÿ÷ûùÿ÷ûùÿøüùÿûýüÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåóêÿH­lÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1èŒ0:*Œ2ŽŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Dÿfº„ÿ¶ÞÅÿâòèÿ÷ûùÿþÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøüúÿÉçÔÿO°rÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý2*1$‹2ÐŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ ‘;ÿ'žRÿO°rÿ|Ä–ÿ¦×¸ÿÄåÐÿÛïãÿêöîÿóúöÿùýûÿûýûÿûýûÿúýûÿöûøÿðøóÿãóéÿËèÕÿ¢Öµÿ^·~ÿ˜GÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ð1$ÿ‹1RŒ1ìŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿ“>ÿšKÿ/¢XÿBªhÿQ±sÿT²vÿT²vÿS²uÿI®mÿ:¦aÿ'žQÿ•AÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ì‹1Rÿ*Œ3xŒ2ôŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1õŒ3x*”* Œ2Œ‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ø‹2”? /Œ2ŒŒ2ôŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ô‹2‡-”* Œ3x‹1ìŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ìŒ3x”* ª*Œ1N‹1΋2üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ü‹1ÎŒ1Nª*ÿŠ2#2‹1èŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1è2Š2#ÿ‘$Œ0:‹2˜‹1á‹1üŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ü‹1á‹2˜Œ0:‘$™3ˆ/+Œ1m‹1µ‹2ß‹1öŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1ö‹2ߌ1´Œ1mˆ/+™3™3 Š2#3J‹2j‹2‰Œ1¥Œ1«Œ1«Œ1¥‹2‰‹2j3JŠ2#™3 ÿ?™3™3?ÿÿÿøÿÿÿÿÿÿÿü?ÿÿðÿÿÀÿÿ€ÿÿÿþü?øððààÀÀÀ€€€€€€€€ÀÀÀààððøü?þÿÿÿ€ÿÿÀÿÿðÿÿü?ÿÿÿÿÿÿÿøÿÿ((P @?‡-‘0‘0‡-?* 0/‹1a‹1”‹1³Œ2Ê‹1Ò‹1ÒŒ2Ê‹1³‹1”‹1a0/* ÿŽ21aŒ2¶‹1èŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û‹1èŒ2¶1aŽ2ÿˆ3‹1aŒ2Ê‹2øŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2øŒ2Ê‹1aˆ3ÿ4,Œ1«Œ1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1õŒ1«4,ÿªU1HŒ2Ó‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2Ó1HªUªU‹2VŒ1áŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1áŒ1WªUÿ1HŒ1áŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿi»†ÿ¥×·ÿS²uÿ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1â‹0Iÿ2-Œ1ÓŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6¥^ÿèõíÿÿÿÿÿÑëÛÿ—FÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ó2-ˆ3‹2¬‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿuÁ‘ÿýþþÿÿÿÿÿÜðäÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þ‹2¬ˆ3ÿ‹1aŒ1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ¢ÕµÿÿÿÿÿÿÿÿÿØíàÿ—GÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1õ‹1aÿŽ2Œ2ÊŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘:ÿºàÈÿÿÿÿÿÿÿÿÿÏêØÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÊŽ2Œ1b‹2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ“>ÿÇæÒÿÿÿÿÿÿÿÿÿÄäÐÿ“=ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ùŒ1b‹. Œ2¶Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿÊçÕÿÿÿÿÿÿÿÿÿºàÇÿ 9ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2¶‹. 0/‹1èŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”@ÿÊçÕÿÿÿÿÿÿÿÿÿ°Ü¿ÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1è0/1aŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ”?ÿÉçÔÿÿÿÿÿÿÿÿÿÉçÔÿAªfÿ“?ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û1aŒ2“Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿ¾âËÿÿÿÿÿÿÿÿÿþÿþÿïøòÿ¿âËÿk¼‰ÿšKÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2“?1³Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ6ÿªÙ»ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúýûÿÓëÜÿ{Ä–ÿ&Qÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1³?–-Œ2ÉŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿŽÍ¥ÿÿÿÿÿÿÿÿÿúýûÿðøóÿþÿþÿÿÿÿÿÿÿÿÿüþýÿÚîáÿ{Ä•ÿ™JÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2É–-‘0‹1ÒŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿm½ŠÿýþþÿÿÿÿÿãóéÿX´yÿ̤ÿÙîáÿûýüÿÿÿÿÿÿÿÿÿûýüÿÊçÕÿW³xÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1Ò‘0‘0‹1ÒŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿM¯pÿ÷üùÿÿÿÿÿëöïÿ1¢YÿŽ5ÿ#œOÿp¿ÿÉçÔÿùüúÿÿÿÿÿÿÿÿÿñùôÿœÓ°ÿ(žRÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1Ò‘0–-Œ2ÉŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1£Zÿëöïÿÿÿÿÿ÷üùÿM¯pÿŒ2ÿŒ2ÿ3ÿ—Fÿj¼ˆÿÏêÙÿûýüÿÿÿÿÿýþþÿÑêÚÿL¯oÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2É–-?1³Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜GÿÖíßÿÿÿÿÿþÿþÿrÀŽÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ ›LÿˆÉ ÿëöïÿÿÿÿÿÿÿÿÿæôëÿb¹ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ1³?‹1”Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ :ÿµÞÄÿÿÿÿÿÿÿÿÿ¤Ö¶ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿR±tÿ×íßÿÿÿÿÿÿÿÿÿéõîÿQ±sÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2“1aŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ€Æ™ÿþÿþÿÿÿÿÿØîàÿšKÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ=¨cÿ×íßÿÿÿÿÿÿÿÿÿÈæÓÿ—FÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û1a0/‹1èŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿ9ÿ4ÿCªhÿñùôÿÿÿÿÿöûøÿN¯qÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿS²uÿïøòÿÿÿÿÿ÷üùÿZµ{ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1è0/‹. Œ2¶Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿBªgÿ±ÜÁÿ’Ψÿ^·~ÿÖíßÿÿÿÿÿþÿþÿvÂ’ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿµÞÄÿÿÿÿÿÿÿÿÿžÔ±ÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2¶‹. Œ1b‹2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿˆÊ ÿÿÿÿÿÿÿÿÿöûøÿøüúÿÿÿÿÿûýüÿŠË¡ÿ9¦`ÿ%Pÿ—Fÿ”Aÿ”@ÿ•Aÿ˜Gÿ+ŸUÿP±sÿÊçÕÿÿÿÿÿÿÿÿÿ§Ø¸ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ùŒ1b‰1Œ2ÌŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿF¬kÿãóéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùýúÿðøóÿãòèÿÕìÞÿÎéØÿÍé×ÿÏéØÿ×íßÿçôëÿ÷ûøÿþÿÿÿÿÿÿÿñùôÿ\µ|ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2̉1ÿŒ2d‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ?©eÿ Ô³ÿÙîàÿóúõÿýþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþýÿÝðäÿp¿Œÿ :ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹3cÿ/Œ2­‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿšJÿBªhÿm½Šÿ–Ыÿ·ßÅÿÏêÙÿßñåÿèõíÿêöîÿêöîÿæôëÿÜïãÿÉçÔÿ§Ø¸ÿo¿Œÿ)ŸTÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2­/0/Œ2ÕŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ 9ÿ•Bÿ!›Mÿ+ Uÿ- Vÿ- Vÿ)žSÿšKÿ”@ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2Õ0/ÿ‹0I‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1â‹0IÿªUŽ2V‹1âŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1âŒ1WªUªU‹0IŒ2Ô‹2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2þŒ2Ô‹0IªUÿ2-Œ1«‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1öŒ1«2-ÿˆ3‹0cŒ2Ì‹2ùŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ùŒ2Ì‹0cˆ3ÿ‰1Œ1bŒ2¶‹1èŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û‹1èŒ2¶Œ1b‰1ÿ* Š/01a‹1”‹1³Œ2Ê‹1Ò‹1ÒŒ2Ê‹1³‹1”‹1a0/* ?‡-‘0‘0‡-?ÿÿÿÿÿøÿÿÀÿÿ€ÿþü?øððàÀÀÀ€€€€€€ÀÀÀàððøü?þÿ€ÿÿÀÿÿøÿÿÿÿÿ( @ €…,‰4'Œ41Œ41‰4'…,Š/0Œ3r‹1¯Œ1Ó‹2å‹1í‹1í‹2åŒ1Ó‹1¯Œ3rŠ/0™3Œ0:‹2¡‹1æŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1æ‹2¡Œ0:™3‘0‹1‚Œ1æŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ1æ‹1‚‘01$‹1¯‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹1¯1$1$Œ1½Œ2ýŒ2ÿŒ2ÿŒ2ÿ“>ÿ1¢Yÿ”@ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1¾‰0%‘0‹1¯Œ2ýŒ2ÿŒ2ÿŒ2ÿŽ5ÿ„ÈœÿêöïÿͦÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1¯‘0™3Œ2ƒ‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜GÿÔìÝÿÿÿÿÿ½âÊÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1úŒ2ƒ™3Œ4:‹1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3£\ÿí÷ñÿÿÿÿÿ·ßÅÿ8ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1æŒ4:‹1¡Œ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿF«jÿöûøÿÿÿÿÿ«Ú¼ÿ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹1¡Š/0‹1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿO°qÿùüúÿÿÿÿÿžÔ±ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1æŠ/0‹0sŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿP°rÿùüúÿÿÿÿÿ’ϧÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹0s?‹1¯Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿN¯pÿøüúÿÿÿÿÿÀãÍÿI­mÿ•BÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¯?,Œ1ÒŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ@©eÿóúöÿÿÿÿÿÿÿÿÿóúõÿÅåÐÿk½‰ÿ™Jÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ò,4'Œ2åŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ- VÿéõíÿÿÿÿÿüþýÿüþýÿÿÿÿÿúýûÿÒëÛÿuÁÿ™HÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2å4'‰22‹1íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜HÿØîàÿÿÿÿÿÒëÛÿ|Ä—ÿÇæÒÿöû÷ÿÿÿÿÿúýûÿÊçÔÿW´yÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í‰22‰22‹1íŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ’<ÿÀãÍÿÿÿÿÿÑëÛÿ—Eÿ–CÿU³wÿ´ÝÃÿóúõÿÿÿÿÿñùôÿÓ±ÿ&žQÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1í‰224'Œ2åŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŽ5ÿ Õ³ÿÿÿÿÿæôëÿ*ŸTÿŒ2ÿŒ2ÿ’=ÿS±uÿÁãÍÿúýûÿýþþÿÍé×ÿCªhÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2å4',Œ1ÒŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿvÁ‘ÿþÿþÿöûøÿK®oÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ—Eÿ„ÈÿïøòÿÿÿÿÿÝðäÿBªgÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1Ò,?‹1¯Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿE«jÿôúöÿþÿþÿ‰Ê ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿi¼‡ÿïøòÿÿÿÿÿÁãÎÿ–CÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1¯?‹0sŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ ‘;ÿ™Iÿ"œNÿÓëÜÿÿÿÿÿÆåÑÿ”?ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ8ÿŠÊ¡ÿüþýÿöûøÿS²uÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹0s/0Œ1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ{Ä•ÿÙîáÿ¯Û¿ÿÔìÝÿÿÿÿÿØîàÿ"›Nÿ5ÿŒ3ÿŒ2ÿŒ2ÿŒ3ÿŽ6ÿF¬kÿðùôÿÿÿÿÿ‰Ê ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿ‹1æŠ/0Œ2¢Œ2þŒ2ÿŒ2ÿŒ2ÿ3ÿ~Řÿúýûÿÿÿÿÿÿÿÿÿÿÿÿÿñùôÿ½áÊÿ Ô³ÿ‰Ê¡ÿ€Æ™ÿ€Æ™ÿŒË£ÿ¨Ø¹ÿÔìÝÿüþýÿùüúÿh»…ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2¢Œ3<‹1èŒ2ÿŒ2ÿŒ2ÿŒ2ÿ–Cÿ}Å—ÿÌè×ÿî÷ñÿûýüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿìöðÿ’Χÿ”AÿŒ2ÿŒ2ÿŒ2ÿŒ1çŒ3<™3‹2„‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ–Cÿ7¥^ÿ^·~ÿ†Éžÿ§Ø¹ÿ¾âËÿÌèÖÿÍé×ÿËèÕÿ¿âÌÿ¥×·ÿyÔÿ:§aÿ 9ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2„™3‹.‹2°Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ3ÿŽ6ÿ ‘;ÿ”@ÿ”@ÿ”@ÿ ‘;ÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹2°‹.1$‹1¾Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1¾‰0%1$‹1°‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹1°‰0%‹.‹1‚Œ1çŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ1ç‹1‚‹.™3Œ3<Œ2¢Œ1æŒ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ1æŒ2¢Œ3<™3/0‹2s‹1°Œ1Ó‹2å‹1í‹1í‹2åŒ1Ó‹1¯Œ3r/0…,‰4'Œ41Œ41‰4'…,ÿðÿÿ€ÿþü?øðàÀÀ€€€€€€ÀÀàðøü?þÿ€ÿÿðÿ(0 ` ”* ˆ1)Œ3EŒ1WŒ1WŽ0DŒ3(”* ÿ‘-Œ2kŒ2»Œ2åŒ1õŒ1ûŒ1ûŒ1õ‹2ä‹1º‹2jˆ-Œ1WŒ2Ì‹1úŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2Ë3U‘$‰' Œ2Œ2ïŒ2ÿŒ2ÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ïŠ2}”* ?Œ2‹1öŒ2ÿŒ2ÿ™Iÿ„Èœÿ;§aÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1õŒ2}‘$ÿŒ0YŒ1ðŒ2ÿŒ2ÿŒ2ÿk½‰ÿüýüÿÍ¥ÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2ï‹2Vÿ‘6Œ1ÍŒ2ÿŒ2ÿŒ2ÿ4ÿ›Ò¯ÿÿÿÿÿ‹Ë¢ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Ë8‹1lŒ1ûŒ2ÿŒ2ÿŒ2ÿ6ÿ®Û¾ÿÿÿÿÿ}Ä–ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2j‰: Œ2»Œ2ÿŒ2ÿŒ2ÿŒ2ÿ7ÿ²ÜÁÿþÿþÿo¾ŒÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2º”* 1)Œ2åŒ2ÿŒ2ÿŒ2ÿŒ2ÿ6ÿ®Û¾ÿþÿÿÿ¹àÇÿO°rÿ•BÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2äŒ3(Š2F‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ›Ò¯ÿÿÿÿÿþÿÿÿõû÷ÿÄåÐÿgº…ÿ—EÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1õŽ4DŒ0YŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ}Å—ÿÿÿÿÿÊçÕÿ´ÝÃÿî÷ñÿøüúÿÆåÑÿU³wÿ ‘:ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ûŒ1WŒ3YŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ[µ{ÿûýüÿ«Ù¼ÿ”@ÿ?©eÿžÔ±ÿëöïÿñùôÿ›Ò¯ÿ"›MÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ûŒ1WŠ2F‹1öŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ;§aÿðùóÿÊçÕÿ”@ÿŒ2ÿ8ÿBªgÿºàÈÿùüúÿÄäÏÿ/¡XÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1öŒ3E‹0*‹1æŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ™IÿØîàÿéõîÿ2¢ZÿŒ2ÿŒ2ÿŒ2ÿ—FÿœÓ°ÿúýûÿ¶ßÅÿ”@ÿŒ2ÿŒ2ÿŒ2ÿ‹2åˆ1)‰: 2¼Œ2ÿŒ2ÿŒ2ÿŒ3ÿ)žSÿ:¦aÿ°ÜÀÿüþýÿfº„ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ˜GÿÆåÑÿôúöÿI­mÿŒ2ÿŒ2ÿŒ2ÿŒ2»”* Œ1mŒ1ûŒ2ÿŒ2ÿŽ6ÿ¢Õ´ÿëöïÿéõíÿþÿþÿŸÔ²ÿF¬jÿ5¤]ÿ1¢Yÿ6¥^ÿP°rÿÄäÐÿûýüÿ`·ÿŒ2ÿŒ2ÿ‹1ûŒ2kˆ3‹2ÐŒ2ÿŒ2ÿŒ3ÿBªgÿºàÈÿèõìÿùüúÿüþüÿöûøÿîøòÿì÷ðÿïøòÿ÷üùÿôúöÿ±ÜÀÿšJÿŒ2ÿŒ2ÿŒ1ÍŒ4ÿŠ1\‹1ñŒ2ÿŒ2ÿŒ2ÿ’=ÿ-¡WÿR±tÿvÁ‘ÿ”Ï©ÿ¤Ö¶ÿ¥Ö·ÿšÒ®ÿ{Ä•ÿJ­mÿ”AÿŒ2ÿŒ2ÿŒ1ðŒ0Yÿ8 Œ2ƒ‹1÷Œ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ3ÿ5ÿ5ÿ4ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ö‹1€‘6Œ0ƒ‹1ñŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ð‹1€‰: 8 2ZŒ2ÏŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1û‹1Î1X?ÿ‹1Œ2o‹1¾Œ1ç‹1ö‹1ü‹1ü‹1ö‹1æŒ1½‹0nˆ3ÿ‘6Ž/+Š1H2Z2ZŒ2Gˆ/+‰: þøðàÀ€€€€Ààðøþ(( ‰' 50‹2V2n‹2n‹2VŠ/0”* ‰' Œ1W‹1¸Œ2é‹1úŒ2þŒ2þ‹1úŒ2é‹2·‹2V”* / ‹2¡Œ2ôŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ó‹1Ÿ‹1/ ‹1¹Œ2ýŒ2ÿ#œNÿ?¨eÿŽ6ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ1ü‹2·‹1‰: Œ2¢Œ2ýŒ2ÿŽ6ÿÓ°ÿÓìÜÿ˜GÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ý‹1Ÿ”* Œ0YŒ2ôŒ2ÿŒ2ÿ”@ÿÊçÔÿØîàÿ˜GÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ó‹2V‰: Œ1¹Œ2ÿŒ2ÿŒ2ÿ—EÿÖìÞÿÏêÙÿ•BÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2¶”* Ž22Œ2êŒ2ÿŒ2ÿŒ2ÿ—FÿÖíÞÿÔìÜÿ, UÿŽ5ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2éŠ/0Œ0YŒ1ûŒ2ÿŒ2ÿŒ2ÿ”AÿÍè×ÿûýüÿÛïâÿͦÿ4¤\ÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ú‹2VŒ1rŒ2ÿŒ2ÿŒ2ÿŒ2ÿ 9ÿ¸ßÆÿðøóÿºàÈÿçôìÿåóêÿͦÿ%Pÿ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ0nŒ1rŒ2ÿŒ2ÿŒ2ÿŒ2ÿ4ÿ˜Ñ­ÿéõíÿ5¤]ÿ5¤]ÿ‘ΧÿäóêÿÒëÛÿW³xÿ7ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ0nŒ0YŒ1ûŒ2ÿŒ2ÿŒ2ÿŒ2ÿo¾ŒÿöûøÿM¯pÿŒ2ÿŽ6ÿ<§bÿ¼áÉÿêöïÿi»†ÿŽ5ÿŒ2ÿŒ2ÿŒ1úŽ2VŒ23‹1ëŒ2ÿŒ2ÿŒ2ÿ :ÿE«jÿðøóÿŠÊ¡ÿ3ÿŒ2ÿŒ2ÿ šLÿ¾âËÿÞðåÿ(žSÿŒ2ÿŒ2ÿŒ2é50‘6Œ2»Œ2ÿŒ2ÿ7ÿ̤ÿºàÇÿïøòÿ»àÈÿ*ŸTÿ˜Gÿ—Eÿ!›Lÿ…Èÿ÷üùÿR±tÿŒ2ÿŒ2ÿ‹1¸‰: Š1\Œ1õŒ2ÿ4ÿ`·€ÿÐêÙÿðøóÿôúöÿäóéÿØíàÿÖíÞÿÞðåÿìöðÿ¾âËÿ$œOÿŒ2ÿŒ2ô1X‘6Œ1¥Œ2ýŒ2ÿ4ÿ—Eÿ9¦`ÿ\¶|ÿ{Ä•ÿŒË¢ÿŠÊ¡ÿv‘ÿN¯qÿ—EÿŒ2ÿŒ2ýŒ2¢‰' Ž4"‹2¼Œ2ýŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ1¹‹.!Ž4"‹1¤‹1õŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ôŒ2¢‹.!‘6Œ2[Œ2»‹1ëŒ1ûŒ2þŒ2þŒ1û‹1ë‹1ºŠ2Z‰: ‘6Œ23Š2ZŒ1rŒ1rŒ0YŽ226üðððàpÀ0€€€€À0àpððüð(  @3 ‹05Œ2i‹2‰‹2‰Œ2i‹053 ‰14Œ2§‹1ëŒ2ýŒ2ÿŒ2ÿŒ2ý‹1ëŒ2§‰14‰2LŒ2ÚŒ3þ˜Gÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2ÚŒ2L‰14Œ2ÚŒ2ÿ•Bÿ·ßÅÿU²vÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2Û‰143 Œ2§Œ2þŒ2ÿ, Vÿæôëÿ^·~ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þŒ2§3 ‹05‹1ëŒ2ÿŒ2ÿ5¤]ÿêöîÿU²vÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹1ë‹05Œ2iŒ2ýŒ2ÿŒ2ÿ1¢Yÿêöïÿ»àÈÿX´yÿ•BÿŒ3ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ýŒ2i‹2‰Œ2ÿŒ2ÿŒ2ÿ!›MÿßñæÿÒëÛÿ×íßÿÀãÍÿW³xÿ ‘;ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿ‹2‰‹2‰Œ2ÿŒ2ÿŒ2ÿ”@ÿÊçÔÿƒÇœÿ*ŸTÿ‚Ç›ÿÔìÝÿ›Ò¯ÿšJÿŒ2ÿŒ2ÿŒ2ÿ‹2‰Œ2iŒ2ýŒ2ÿŒ2ÿŽ6ÿ¥×·ÿ¬Ú½ÿ8ÿ5ÿ8¥_ÿÃäÏÿªÙ»ÿ“?ÿŒ2ÿŒ2ýŒ2i‹05‹1ëŒ2ÿŽ6ÿX´yÿ§Ø¸ÿ×íßÿ&Qÿ 9ÿ :ÿR±tÿäóêÿ>¨dÿŒ2ÿ‹1ë‹053 ‹2¨Œ2þŽ6ÿ|Ä–ÿÛïâÿí÷ðÿÊçÕÿ¹àÇÿ¹àÇÿÍè×ÿÆåÑÿ(žRÿŒ2þ‹2¨3 Ž14‹2ÛŒ2ÿ7ÿ"›MÿCªhÿ`·ÿo¾‹ÿj¼‡ÿN¯qÿ™JÿŒ3ÿ‹2ÛŽ14Œ2L‹2ÛŒ2þŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2ÿŒ2þ‹2ÛŒ2LŽ14‹2¨‹1ëŒ2ýŒ2ÿŒ2ÿŒ2ý‹1ë‹2¨Ž14™3 ‹05Œ2i‹2‰‹2‰Œ2i‹05™3 ðÀ€€€€Àðprimesieve-5.6.0/src/apps/gui/icons/win/primesieve.rc000066400000000000000000000001011263266076300226210ustar00rootroot00000000000000IDI_ICON1 ICON DISCARDABLE "primesieve.ico" primesieve-5.6.0/src/apps/gui/primesieve.pro000066400000000000000000000043521263266076300211210ustar00rootroot00000000000000# --------------------------------------------------------- # primesieve GUI project settings # --------------------------------------------------------- TARGET = primesieve TEMPLATE = app FORMS += forms/PrimeSieveGUI.ui # --------------------------------------------------------- # Qt modules: core, gui and widgets (Qt > 4) # --------------------------------------------------------- QT_VER = $$QT_VERSION QT_VER = $$split(QT_VER, ".") QT_MAJ = $$member(QT_VER, 0) !contains(QT_MAJ, 4) { QT += core gui widgets } # --------------------------------------------------------- # primesieve GUI application sources # --------------------------------------------------------- SOURCES += \ src/main.cpp \ src/l1d_cache_size.cpp \ src/PrimeSieveGUI.cpp \ src/PrimeSieveGUI_menu.cpp \ src/PrimeSieveProcess.cpp HEADERS += \ src/calculator.hpp \ src/PrimeSieveGUI.hpp \ src/PrimeSieveGUI_const.hpp \ src/PrimeSieveProcess.hpp # --------------------------------------------------------- # Sieve of Eratosthenes sources (src/primesieve) # --------------------------------------------------------- INCLUDEPATH += ../../../include SOURCES += \ ../../primesieve/EratBig.cpp \ ../../primesieve/EratMedium.cpp \ ../../primesieve/EratSmall.cpp \ ../../primesieve/ParallelPrimeSieve.cpp \ ../../primesieve/popcount.cpp \ ../../primesieve/PreSieve.cpp \ ../../primesieve/PrimeFinder.cpp \ ../../primesieve/PrimeGenerator.cpp \ ../../primesieve/PrimeSieve.cpp \ ../../primesieve/SieveOfEratosthenes.cpp \ ../../primesieve/WheelFactorization.cpp # --------------------------------------------------------- # primesieve icon file # --------------------------------------------------------- win* { RC_FILE = icons/win/primesieve.rc } macx { RC_FILE = icons/osx/primesieve.icns } # --------------------------------------------------------- # Add OpenMP compiler flag # --------------------------------------------------------- *msvc* { QMAKE_CXXFLAGS += /openmp /EHsc } *g++* { QMAKE_CXXFLAGS += -fopenmp QMAKE_LFLAGS += -fopenmp } *clang* { QMAKE_CXXFLAGS += -fopenmp QMAKE_LFLAGS += -fopenmp } *icc* { win* { QMAKE_CXXFLAGS += /Qopenmp /EHsc } unix { QMAKE_CXXFLAGS += -openmp QMAKE_LFLAGS += -openmp } } primesieve-5.6.0/src/apps/gui/src/000077500000000000000000000000001263266076300170125ustar00rootroot00000000000000primesieve-5.6.0/src/apps/gui/src/PrimeSieveGUI.cpp000066400000000000000000000324371263266076300221440ustar00rootroot00000000000000/* * PrimeSieveGUI.cpp -- This file is part of primesieve * * Copyright (C) 2015 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #include "PrimeSieveGUI.hpp" #include "ui_PrimeSieveGUI.h" #include "PrimeSieveProcess.hpp" #include "calculator.hpp" #include #include #include #if QT_VERSION >= 0x050000 #include #include #include #include #include #include #include #include #include #else #include #include #include #include #include #include #include #include #include #endif int get_l1d_cache_size(); using namespace primesieve; PrimeSieveGUI::PrimeSieveGUI(QWidget *parent) : QMainWindow(parent), ui(new Ui::PrimeSieveGUI), validator_(0), primeSieveProcess_(0), saveAct_(0), quitAct_(0), aboutAct_(0), alignmentGroup_(0) { ui->setupUi(this); primeText_.push_back("Prime numbers"); primeText_.push_back("Twin primes"); primeText_.push_back("Prime triplets"); primeText_.push_back("Prime quadruplets"); primeText_.push_back("Prime quintuplets"); primeText_.push_back("Prime sextuplets"); this->initGUI(); this->initConnections(); } PrimeSieveGUI::~PrimeSieveGUI() { this->cleanUp(); delete validator_; delete saveAct_; delete quitAct_; delete aboutAct_; delete alignmentGroup_; for (; !countAct_.isEmpty(); countAct_.pop_back()) delete countAct_.back(); for (; !printAct_.isEmpty(); printAct_.pop_back()) delete printAct_.back(); // Qt code delete ui; } void PrimeSieveGUI::changeEvent(QEvent *e) { QMainWindow::changeEvent(e); switch (e->type()) { case QEvent::LanguageChange: ui->retranslateUi(this); break; default: break; } } void PrimeSieveGUI::initGUI() { this->setWindowTitle(APPLICATION_NAME + " " + PRIMESIEVE_VERSION); this->createMenu(primeText_); // fill the sieveSizeComboBox with power of 2 values <= "2048 KB" for (int i = MINIMUM_SIEVE_SIZE; i <= MAXIMUM_SIEVE_SIZE; i *= 2) ui->sieveSizeComboBox->addItem(QString::number(i) + " KB"); int l1dCacheSize = get_l1d_cache_size(); if (l1dCacheSize < 16 || l1dCacheSize > 1024) l1dCacheSize = DEFAULT_L1D_CACHE_SIZE; int defaultSieveSize = floorPowerOf2(l1dCacheSize); // default sieve size = CPU L1 data cache size this->setTo(ui->sieveSizeComboBox, QString::number(defaultSieveSize) + " KB"); // fill the threadsComboBox with power of 2 values <= maxThreads_ maxThreads_ = ParallelPrimeSieve::getMaxThreads(); for (int i = 1; i < maxThreads_; i *= 2) ui->threadsComboBox->addItem(QString::number(i)); ui->threadsComboBox->addItem(QString::number(maxThreads_)); this->setTo(ui->threadsComboBox, "1"); // set an ideal ComboBox width int width = ui->sieveSizeComboBox->minimumSizeHint().width(); ui->sieveSizeComboBox->setFixedWidth(width); ui->threadsComboBox->setFixedWidth(width); // set a nice GUI size QSize size = this->sizeHint(); size.setWidth(this->minimumSizeHint().width()); #if defined(Q_OS_WIN) size.setHeight(size.height() - size.height() / 10); #endif this->resize(size); // limit input for arithmetic expressions QRegExp rx("[0-9\\+\\-\\*\\/\\%\\^\\(\\)\\e\\E]*"); validator_ = new QRegExpValidator(rx, this); ui->lowerBoundLineEdit->setValidator(validator_); ui->upperBoundLineEdit->setValidator(validator_); } void PrimeSieveGUI::initConnections() { connect(&progressBarTimer_, SIGNAL(timeout()), this, SLOT(advanceProgressBar())); connect(ui->lowerBoundLineEdit, SIGNAL(textChanged(const QString &)), this, SLOT(autoSetThreads())); connect(ui->upperBoundLineEdit, SIGNAL(textChanged(const QString &)), this, SLOT(autoSetThreads())); connect(ui->autoSetCheckBox, SIGNAL(toggled(bool)), this, SLOT(autoSetThreads())); connect(saveAct_, SIGNAL(triggered()), this, SLOT(saveToFile())); connect(quitAct_, SIGNAL(triggered()), qApp, SLOT(closeAllWindows())); connect(alignmentGroup_, SIGNAL(triggered(QAction*)), this, SLOT(printMenuClicked(QAction*))); connect(aboutAct_, SIGNAL(triggered()), this, SLOT(showAboutDialog())); } /** * Get the sieve size in kilobytes from the sieveSizeComboBox. * @post sieveSize >= 1 && sieveSize <= 2048. */ int PrimeSieveGUI::getSieveSize() { QString sieveSize(ui->sieveSizeComboBox->currentText()); // remove " KB" sieveSize.chop(3); return sieveSize.toInt(); } /** * Get the number of threads from the threadsComboBox. */ int PrimeSieveGUI::getThreads() { return ui->threadsComboBox->currentText().toInt(); } quint64 PrimeSieveGUI::getNumber(const QString& str) { if (str.isEmpty()) throw std::invalid_argument("Please enter a lower and upper bound for prime sieving."); quint64 result = 0; try { result = calculator::eval(str.toLatin1().data()); } catch (calculator::error& e) { throw std::invalid_argument(e.what()); } int digits = str.count(QRegExp("[0-9]")); if (result >= UPPER_BOUND_LIMIT || ( digits == str.size() && ( digits > UPPER_BOUND_STR.size() || ( digits == UPPER_BOUND_STR.size() && str >= UPPER_BOUND_STR)))) throw std::invalid_argument("Please use positive integers < 2^64 - 2^32*10."); return result; } void PrimeSieveGUI::setTo(QComboBox* comboBox, const QString& text) { comboBox->setCurrentIndex(comboBox->findText(text)); } /** * If "Auto set" is enabled set an ideal number of threads for the * current lower bound, upper bound in the threadsComboBox. */ void PrimeSieveGUI::autoSetThreads() { if (ui->autoSetCheckBox->isEnabled() && ui->autoSetCheckBox->isChecked()) { try { quint64 lowerBound = this->getNumber(ui->lowerBoundLineEdit->text()); quint64 upperBound = this->getNumber(ui->upperBoundLineEdit->text()); ParallelPrimeSieve pps; pps.setStart(lowerBound); pps.setStop(upperBound); int idealNumThreads = pps.getNumThreads(); if (idealNumThreads < maxThreads_) { // floor to the next power of 2 value int p = 1; for (; p <= idealNumThreads; p *= 2) ; idealNumThreads = p / 2; } this->setTo(ui->threadsComboBox, QString::number(idealNumThreads)); } catch (...) { this->setTo(ui->threadsComboBox, "1"); } } } /** * The user has chosen a custom number of threads, disable "Auto set". */ void PrimeSieveGUI::on_threadsComboBox_activated() { ui->autoSetCheckBox->setChecked(false); } /** * Start sieving primes. */ void PrimeSieveGUI::on_sieveButton_clicked() { // invert buttons, reset upon cleanUp() ui->sieveButton->setDisabled(true); ui->cancelButton->setEnabled(true); try { flags_ = this->getMenuSettings() | CALCULATE_STATUS; if ((flags_ & (COUNT_FLAGS | PRINT_FLAGS)) == 0) throw std::invalid_argument("Nothing to do, no count or print options selected."); quint64 lowerBound = this->getNumber(ui->lowerBoundLineEdit->text()); quint64 upperBound = this->getNumber(ui->upperBoundLineEdit->text()); if (lowerBound > upperBound) throw std::invalid_argument("The lower bound must not be greater than the upper bound."); // reset the GUI widgets ui->progressBar->setValue(ui->progressBar->minimum()); ui->textEdit->clear(); progressBarTimer_.start(25); // start a new process for sieving (avoids cancel // trouble with multiple threads) primeSieveProcess_ = new PrimeSieveProcess(this); if (flags_ & PRINT_FLAGS) connect(primeSieveProcess_, SIGNAL(readyReadStandardOutput()), this, SLOT(printProcessOutput())); connect(primeSieveProcess_, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(processFinished(int, QProcess::ExitStatus))); primeSieveProcess_->start(lowerBound, upperBound, this->getSieveSize(), flags_, this->getThreads()); } catch (std::invalid_argument& ex) { this->cleanUp(); QMessageBox::warning(this, APPLICATION_NAME, ex.what()); } catch (std::exception& ex) { this->cleanUp(); QMessageBox::critical(this, APPLICATION_NAME, ex.what()); } } void PrimeSieveGUI::advanceProgressBar() { int permil = static_cast(primeSieveProcess_->getStatus() * 10.0); ui->progressBar->setValue(permil); } /** * Redirects the standard output (prime numbers or prime k-tuplets) of * the primeSieveProcess_ to the TextEdit. */ void PrimeSieveGUI::printProcessOutput() { QByteArray buffer; buffer.reserve(PRINT_BUFFER_SIZE + 256); while (ui->cancelButton->isEnabled() && primeSieveProcess_->canReadLine()) { buffer.clear(); while (primeSieveProcess_->canReadLine() && buffer.size() < PRINT_BUFFER_SIZE) buffer.append(primeSieveProcess_->readLine(256)); // remove "\r\n" or '\n', '\r' at the back while (buffer.endsWith('\n') || buffer.endsWith('\r')) buffer.chop(1); if (!buffer.isEmpty()) ui->textEdit->appendPlainText(buffer); /// @brief Keep the GUI responsive. /// @bug processEvents() crashes on Windows with MSVC 2010 and Qt 5 beta. /// @warning QApplication::processEvents() must not be used on /// operating systems that use signal recursion (like Linux /// X11) otherwise the stack will explode! #if defined(Q_OS_WIN) || defined(Q_OS_MAC) || defined(Q_OS_IOS) QApplication::processEvents(); #else ui->textEdit->repaint(); #endif } } /** * Is executed when the primeSieveProcess_ finishes, checks for * process errors and calls this->printResults(). */ void PrimeSieveGUI::processFinished(int exitCode, QProcess::ExitStatus exitStatus) { // the process did not exit normally, i.e. threw and exception if (exitCode != 0) { // Qt uses '/' internally, even for Windows QString path = QCoreApplication::applicationDirPath() + "/" + APPLICATION_NAME + "_error.txt"; QFile error_log(path); if (error_log.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) { QTextStream out(&error_log); out << primeSieveProcess_->readAllStandardError(); error_log.close(); } this->cleanUp(); QMessageBox::critical(this, APPLICATION_NAME, "The PrimeSieveProcess reported an error (see primesieve_error.txt), sieving has been aborted."); } // the PrimeSieveProcess has been interrupted by a signal (SIGTERM, // SIGKILL, ...) or a segmentation fault else if (exitStatus == QProcess::CrashExit) { this->cleanUp(); QMessageBox::critical(this, APPLICATION_NAME, "The PrimeSieveProcess crashed, sieving has been aborted."); } // the PrimeSieveProcess has finished correctly else { ui->progressBar->setValue(ui->progressBar->maximum()); // print results if not canceled lately if (ui->cancelButton->isEnabled()) this->printResults(); this->cleanUp(); } } /** * Print the sieving results. */ void PrimeSieveGUI::printResults() { if (!ui->textEdit->toPlainText().isEmpty()) ui->textEdit->appendPlainText(""); // hack to get the count results aligned using tabs QString maxSizeText; for (int i = 0; i < primeText_.size(); i++) { if ((flags_ & (COUNT_PRIMES << i)) && maxSizeText.size() < primeText_[i].size()) maxSizeText = primeText_[i]; } ui->textEdit->insertPlainText(maxSizeText + ": "); int maxWidth = ui->textEdit->cursorRect().left(); ui->textEdit->moveCursor(QTextCursor::StartOfLine, QTextCursor::KeepAnchor); ui->textEdit->textCursor().removeSelectedText(); ui->textEdit->setTabStopWidth(maxWidth); // print prime counts & time elapsed for (int i = 0; i < primeText_.size(); i++) { if (flags_ & (COUNT_PRIMES << i)) ui->textEdit->appendPlainText(primeText_[i] + ":\t" + QString::number(primeSieveProcess_->getCount(i))); } if (flags_ & COUNT_KTUPLETS) ui->textEdit->appendPlainText(""); QString time("Elapsed time:\t" + QString::number(primeSieveProcess_->getSeconds(), 'f', 2) + " sec"); ui->textEdit->appendPlainText(time); } /** * Cancel sieving. */ void PrimeSieveGUI::on_cancelButton_clicked() { ui->cancelButton->setDisabled(true); ui->progressBar->setValue(0); // too late to abort if ((flags_ & PRINT_FLAGS) && primeSieveProcess_->isFinished()) return; this->cleanUp(); } /** * Clean up after sieving is finished or canceled (abort the * PrimeSieveProcess if still running). */ void PrimeSieveGUI::cleanUp() { progressBarTimer_.stop(); if (primeSieveProcess_ != 0) delete primeSieveProcess_; primeSieveProcess_ = 0; // invert buttons ui->cancelButton->setDisabled(true); ui->sieveButton->setEnabled(true); // force repainting widgets this->repaint(); } primesieve-5.6.0/src/apps/gui/src/PrimeSieveGUI.hpp000066400000000000000000000077141263266076300221510ustar00rootroot00000000000000/* * PrimeSieveGUI.hpp -- This file is part of primesieve * * Copyright (C) 2012 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #ifndef PRIMESIEVEGUI_HPP #define PRIMESIEVEGUI_HPP #include "PrimeSieveGUI_const.hpp" #include #if QT_VERSION >= 0x050000 #include #include #include #include #include #include #include #include #include #include #include #else #include #include #include #include #include #include #include #include #include #include #include #endif namespace Ui { class PrimeSieveGUI; } class PrimeSieveProcess; /** * PrimeSieveGUI is a graphical user interface for primeSieve (highly * optimized sieve of Eratosthenes implementation). */ class PrimeSieveGUI : public QMainWindow { Q_OBJECT public: PrimeSieveGUI(QWidget* parent = 0); ~PrimeSieveGUI(); protected: void changeEvent(QEvent* e); private slots: void autoSetThreads(); void on_threadsComboBox_activated(); void on_sieveButton_clicked(); void on_cancelButton_clicked(); void advanceProgressBar(); void printProcessOutput(); void processFinished(int, QProcess::ExitStatus); /// PrimeSieveGUI_menu.cpp void printMenuClicked(QAction*); void saveToFile(); void showAboutDialog(); private: /// Qt GUI object Ui::PrimeSieveGUI* ui; enum { COUNT_PRIMES = primesieve::ParallelPrimeSieve::COUNT_PRIMES, COUNT_KTUPLETS = primesieve::ParallelPrimeSieve::COUNT_SEXTUPLETS * 2 - primesieve::ParallelPrimeSieve::COUNT_TWINS, COUNT_FLAGS = primesieve::ParallelPrimeSieve::COUNT_SEXTUPLETS * 2 - primesieve::ParallelPrimeSieve::COUNT_PRIMES, PRINT_FLAGS = primesieve::ParallelPrimeSieve::PRINT_SEXTUPLETS * 2 - primesieve::ParallelPrimeSieve::PRINT_PRIMES, PRINT_PRIMES = primesieve::ParallelPrimeSieve::PRINT_PRIMES, CALCULATE_STATUS = primesieve::ParallelPrimeSieve::CALCULATE_STATUS }; void initGUI(); void initConnections(); int getSieveSize(); int getThreads(); quint64 getNumber(const QString&); void setTo(QComboBox*, const QString&); void printResults(); void cleanUp(); QVector primeText_; /// Validates the input of the lower and upperBoundLineEdit. QValidator* validator_; int maxThreads_; /// Settings (bit flags) for PrimeSieveProcess. int flags_; /// Timer for the progressBar. QTimer progressBarTimer_; /// Separate process used for sieving PrimeSieveProcess* primeSieveProcess_; /** * PrimeSieveGUI_menu.cpp & menu bar objects. */ void createMenuActions(QVector&); void createMenu(QVector&); int getMenuSettings(); QMenu* fileMenu_; QMenu* printMenu_; QMenu* countMenu_; QMenu* helpMenu_; /// Save textEdit content to file. QAction* saveAct_; /// Quit application. QAction* quitAct_; /// Show about dialog. QAction* aboutAct_; /// Use radio button like behaviour. QActionGroup* alignmentGroup_; /// Count settings for PrimeSieveProcess. QVector countAct_; /// Print settings for PrimeSieveProcess. QVector printAct_; }; #endif // PRIMESIEVEGUI_H primesieve-5.6.0/src/apps/gui/src/PrimeSieveGUI_const.hpp000066400000000000000000000054571263266076300233610ustar00rootroot00000000000000/* * PrimeSieveGUI_const.hpp -- This file is part of primesieve * * Copyright (C) 2015 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ /** * @file PrimeSieveGUI_const.hpp * @brief Various constants used in PrimeSieveGUI. * The values are optimized for CPUs with 32 to 64 kilobytes of * L1 Data Cache (set in 2010). */ #ifndef PRIMESIEVEGUI_CONST_HPP #define PRIMESIEVEGUI_CONST_HPP #include #include /** * @def __STDC_LIMIT_MACROS * Enable the UINT64_MAX, UINT32_MAX macros from . */ #if !defined(__STDC_LIMIT_MACROS) #define __STDC_LIMIT_MACROS #endif #include const QString APPLICATION_NAME("primesieve"); const QString APPLICATION_HOMEPAGE("http://primesieve.org"); const QString APPLICATION_ABOUT( "

Copyright © 2015 Kim Walisch

" "

primesieve generates prime numbers and prime k-tuplets using a highly " "optimized implementation of the sieve of Eratosthenes. By the date " "of release this is the fastest publicly available prime generation software." "

" "This is free software: you can redistribute it and/or modify " "it under the terms of the GNU General Public License as published by " "the Free Software Foundation; either version 3 of the License, or " "(at your option) any later version.

"); /** * Minimum sieve size in kilobytes. * For performance reasons the minimum sieve size should not be much * smaller than the system's CPU L1 cache size. * @pre MINIMUM_SIEVE_SIZE >= 1 * @see PrimeSieve.cpp */ const int MINIMUM_SIEVE_SIZE = 16; /** * @pre MAXIMUM_SIEVE_SIZE <= 2048 * @see PrimeSieve.cpp */ const int MAXIMUM_SIEVE_SIZE = 2048; /** * @pre DEFAULT_L1D_CACHE_SIZE >= MINIMUM_SIEVE_SIZE && * DEFAULT_L1D_CACHE_SIZE <= MAXIMUM_SIEVE_SIZE */ const int DEFAULT_L1D_CACHE_SIZE = 32; /** * PrimeSieve allows numbers up to < (2^64-1)-(2^32-1)*10. * @see PrimeSieve.cpp */ const quint64 UPPER_BOUND_LIMIT = UINT64_MAX - UINT32_MAX * Q_UINT64_C(10); const QString UPPER_BOUND_STR = QString::number(UPPER_BOUND_LIMIT); /** * Print chunks of PRINT_BUFFER_SIZE bytes to the TextEdit. */ const int PRINT_BUFFER_SIZE = 1024; #endif // PRIMESIEVEGUI_CONST_H primesieve-5.6.0/src/apps/gui/src/PrimeSieveGUI_menu.cpp000066400000000000000000000111031263266076300231530ustar00rootroot00000000000000/* * PrimeSieveGUI_menu.cpp -- This file is part of primesieve * * Copyright (C) 2013 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #include "PrimeSieveGUI.hpp" #include "ui_PrimeSieveGUI.h" #include #include #if QT_VERSION >= 0x050000 #include #include #include #include #include #include #else #include #include #include #include #include #endif /** * Initialize the menu items. */ void PrimeSieveGUI::createMenuActions(QVector& primeText) { // file actions saveAct_ = new QAction("&Save", this); saveAct_->setShortcut(tr("Ctrl+S")); quitAct_ = new QAction("&Quit", this); quitAct_->setShortcut(tr("Ctrl+Q")); // count actions countAct_.push_back(new QAction(primeText[0], this)); countAct_.back()->setCheckable(true); countAct_.push_back(new QAction("Prime k-tuplets", this)); countAct_.back()->setCheckable(true); // default count prime numbers countAct_.front()->setChecked(true); // radio button like behaviour for print actions alignmentGroup_ = new QActionGroup(this); alignmentGroup_->setExclusive(false); // print actions for (int i = 0; i < primeText.size(); i++) { printAct_.push_back(new QAction(primeText[i], this)); printAct_.back()->setCheckable(true); alignmentGroup_->addAction(printAct_.back()); } // about action aboutAct_ = new QAction("About", this); } /** * Create the menu bar with 'File', 'Count', 'Print' and 'Help' * menu options. */ void PrimeSieveGUI::createMenu(QVector& primeText) { this->createMenuActions(primeText); fileMenu_ = menuBar()->addMenu("&File"); fileMenu_->addAction(saveAct_); fileMenu_->addAction(quitAct_); countMenu_ = menuBar()->addMenu("&Count"); for (int i = 0; i < countAct_.size(); i++) countMenu_->addAction(countAct_[i]); printMenu_ = menuBar()->addMenu("&Print"); for (int i = 0; i < printAct_.size(); i++) printMenu_->addAction(printAct_[i]); helpMenu_ = menuBar()->addMenu("&Help"); helpMenu_->addAction(aboutAct_); } /** * Return the count and print menu settings as bit flags. */ int PrimeSieveGUI::getMenuSettings() { int flags = 0; // get count settings if (countAct_[0]->isChecked()) flags |= COUNT_PRIMES; if (countAct_[1]->isChecked()) flags |= COUNT_KTUPLETS; // get print settings for (int i = 0; i < printAct_.size(); i++) if (printAct_[i]->isChecked()) flags |= PRINT_PRIMES << i; return flags; } /** * Disable the "Threads" ComboBox and the "Auto set" CheckBox and * set to 1 Threads for printing (else invert). */ void PrimeSieveGUI::printMenuClicked(QAction* qAct) { // disable other print options for (int i = 0; i < printAct_.size(); i++) { if (printAct_[i] != qAct) printAct_[i]->setChecked(false); } ui->autoSetCheckBox->setDisabled(qAct->isChecked()); if (qAct->isChecked()) { ui->autoSetCheckBox->setChecked(true); ui->threadsComboBox->setCurrentIndex(0); } ui->threadsComboBox->setDisabled(qAct->isChecked()); this->autoSetThreads(); } /** * Save the content of the textEdit to a file. */ void PrimeSieveGUI::saveToFile() { // Qt uses '/' internally, also for Windows QString currentPath = QDir::currentPath() + "/Unsaved Document 1"; QString fileName = QFileDialog::getSaveFileName(this, "Save As...", currentPath, "All Files (*)"); QFile file(fileName); if (file.open(QFile::WriteOnly | QFile::Text)) { QTextStream textStream(&file); textStream << ui->textEdit->toPlainText(); } } void PrimeSieveGUI::showAboutDialog() { QString title = "About " + APPLICATION_NAME; QString message = "

" + APPLICATION_NAME + " " + PRIMESIEVE_VERSION + "

" + APPLICATION_ABOUT + + "" + APPLICATION_HOMEPAGE + ""; QMessageBox::about(this, title, message); } primesieve-5.6.0/src/apps/gui/src/PrimeSieveProcess.cpp000066400000000000000000000071301263266076300231260ustar00rootroot00000000000000/* * PrimeSieveProcess.cpp -- This file is part of primesieve * * Copyright (C) 2012 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #include "PrimeSieveProcess.hpp" #include #include #include #include #include #if defined(Q_OS_WIN) #include #else #include #endif PrimeSieveProcess::PrimeSieveProcess(QObject* parent) : QProcess(parent) { sharedMemory_.setParent(parent); sharedMemory_.setKey(QString::number(this->getProcessId())); } PrimeSieveProcess::~PrimeSieveProcess() { // disconnect all signals, must be used to avoid zombie processes this->disconnect(); // kill() and terminate() = trouble, close() works fine this->close(); sharedMemory_.detach(); } /** * Get the process ID of the current process. I tried to use * QProcess::pid() but got a lot of trouble on Windows and Mac OS X, * also it is not portable. */ int PrimeSieveProcess::getProcessId() { #if defined(Q_OS_WIN) return static_cast(GetCurrentProcessId()); #else return static_cast(getpid()); #endif } /** * Create a shared memory segement for communication with the * ParallelPrimeSieve process. */ void PrimeSieveProcess::createSharedMemory() { // attach the shared memory if (!sharedMemory_.isAttached() && !sharedMemory_.create(sizeof(shm_))) { throw std::runtime_error( "Interprocess communication error, could not allocate shared memory."); } // map the attached shared memory to the shm_ segment shm_ = static_cast(sharedMemory_.data()); } /** * Start a new ParallelPrimeSieve process that sieves * the primes within [start, stop]. */ void PrimeSieveProcess::start(quint64 start, quint64 stop, int sieveSize, int flags, int threads) { this->createSharedMemory(); // initialize the shared memory segment shm_->start = start; shm_->stop = stop; shm_->sieveSize = sieveSize; shm_->flags = flags; shm_->threads = threads; shm_->status = 0.0; shm_->seconds = 0.0; for (int i = 0; i < 6; i++) shm_->counts[i] = 0; // path + file name of the aplication QString path = QCoreApplication::applicationFilePath(); // process arguments, see main.cpp QStringList args; args << "PrimeSieveProcess" << sharedMemory_.key(); /// start a new ParallelPrimeSieve process /// @see main.cpp QProcess::start(path, args, QIODevice::ReadOnly); } bool PrimeSieveProcess::isFinished() { return (static_cast(shm_->status) == 100); } /** * @return The count of primes/k-tuplets within [start, stop]. * @pre index < 6 */ quint64 PrimeSieveProcess::getCount(unsigned int index) const { return shm_->counts[index]; } /** * @return The sieving status in percent. */ double PrimeSieveProcess::getStatus() const { return shm_->status; } /** * @return The time elapsed in seconds (if sieving is finished). */ double PrimeSieveProcess::getSeconds() const { return shm_->seconds; } primesieve-5.6.0/src/apps/gui/src/PrimeSieveProcess.hpp000066400000000000000000000034461263266076300231410ustar00rootroot00000000000000/* * PrimeSieveProcess.hpp -- This file is part of primesieve * * Copyright (C) 2012 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #ifndef PRIMESIEVEPROCESS_HPP #define PRIMESIEVEPROCESS_HPP #include #include #include #include #include #include /** * QProcess class used for prime sieving, using a separate process * for sieving allows to easily cancel a multi-threaded * ParallelPrimeSieve instance. */ class PrimeSieveProcess : public QProcess { public: PrimeSieveProcess(QObject*); ~PrimeSieveProcess(); void start(quint64, quint64, int, int, int); bool isFinished(); quint64 getCount(unsigned int) const; double getStatus() const; double getSeconds() const; private: /// Shared memory for interprocess communication between the /// Qt GUI process and the ParallelPrimeSieve process. QSharedMemory sharedMemory_; /// Contains the settings (start, stop, sieveSize, ...) /// for sieving, will be mapped to sharedMemory_ primesieve::ParallelPrimeSieve::SharedMemory* shm_; void createSharedMemory(); int getProcessId(); }; #endif // PRIMESIEVEPROCESS_H primesieve-5.6.0/src/apps/gui/src/calculator.hpp000066400000000000000000000310311263266076300216520ustar00rootroot00000000000000/// /// @file calculator.hpp /// @brief calculator::eval(const std::string&) evaluates an integer /// arithmetic expression and returns the result. If an error /// occurs a calculator::error exception is thrown. /// /// @author Kim Walisch, /// @copyright Copyright (C) 2013 Kim Walisch /// @date November 30, 2013 /// @license BSD 2-Clause, http://opensource.org/licenses/BSD-2-Clause /// @version 1.0 patched: `^' is raise to power instead of XOR. /// /// == Supported operators == /// /// OPERATOR NAME ASSOCIATIVITY PRECEDENCE /// /// | Bitwise Inclusive OR Left 4 /// & Bitwise AND Left 6 /// << Shift Left Left 9 /// >> Shift Right Left 9 /// + Addition Left 10 /// - Subtraction Left 10 /// * Multiplication Left 20 /// / Division Left 20 /// % Modulo Left 20 /// ^, ** Raise to power Right 30 /// e, E Scientific notation Right 40 /// ~ Unary complement Left 99 /// /// The operator precedence has been set according to (uses the C and /// C++ operator precedence): http://en.wikipedia.org/wiki/Order_of_operations /// Operators with higher precedence are evaluated before operators /// with relatively lower precedence. Unary operators are set to have /// the highest precedence, this is not strictly correct for the power /// operator e.g. "-3**2" = 9 but a lot of software tools (Bash shell, /// Microsoft Excel, GNU bc, ...) use the same convention. /// /// == Examples of valid expressions == /// /// "65536 >> 15" = 2 /// "2**16" = 65536 /// "(0 + 0xDf234 - 1000)*3/2%999" = 828 /// "-(2**2**2**2)" = -65536 /// "(0 + ~(0xDF234 & 1000) *3) /-2" = 817 /// "(2**16) + (1 << 16) >> 0X5" = 4096 /// "5*-(2**(9+7))/3+5*(1 & 0xFf123)" = -109221 /// /// == About the algorithm used == /// /// calculator::eval(std::string&) relies on the ExpressionParser /// class which is a simple C++ operator precedence parser with infix /// notation for integer arithmetic expressions. /// ExpressionParser has its roots in a JavaScript parser published /// at: http://stackoverflow.com/questions/28256/equation-expression-parser-with-precedence/114961#114961 /// The same author has also published an article about his operator /// precedence algorithm at PerlMonks: /// http://www.perlmonks.org/?node_id=554516 /// #ifndef CALCULATOR_HPP #define CALCULATOR_HPP #include #include #include #include #include #include namespace calculator { /// calculator::eval() throws a calculator::error if it fails /// to evaluate the expression string. /// class error : public std::runtime_error { public: error(const std::string& expr, const std::string& message) : std::runtime_error(message), expr_(expr) { } #if __cplusplus >= 201103L ~error() { } #else ~error() throw() { } #endif std::string expression() const { return expr_; } private: std::string expr_; }; template class ExpressionParser { public: /// Evaluate an integer arithmetic expression and return its result. /// @throw error if parsing fails. /// T eval(const std::string& expr) { T result = 0; index_ = 0; expr_ = expr; try { result = parseExpr(); if (!isEnd()) unexpected(); } catch (const calculator::error&) { while(!stack_.empty()) stack_.pop(); throw; } return result; } /// Get the integer value of a character. T eval(char c) { std::string expr(1, c); return eval(expr); } private: enum { OPERATOR_NULL, OPERATOR_BITWISE_OR, /// | OPERATOR_BITWISE_XOR, /// ^ OPERATOR_BITWISE_AND, /// & OPERATOR_BITWISE_SHL, /// << OPERATOR_BITWISE_SHR, /// >> OPERATOR_ADDITION, /// + OPERATOR_SUBTRACTION, /// - OPERATOR_MULTIPLICATION, /// * OPERATOR_DIVISION, /// / OPERATOR_MODULO, /// % OPERATOR_POWER, /// ** OPERATOR_EXPONENT /// e, E }; struct Operator { /// Operator, one of the OPERATOR_* enum definitions int op; int precedence; /// 'L' = left or 'R' = right int associativity; Operator(int opr, int prec, int assoc) : op(opr), precedence(prec), associativity(assoc) { } }; struct OperatorValue { Operator op; T value; OperatorValue(const Operator& opr, T val) : op(opr), value(val) { } int getPrecedence() const { return op.precedence; } bool isNull() const { return op.op == OPERATOR_NULL; } }; /// Expression string std::string expr_; /// Current expression index, incremented whilst parsing std::size_t index_; /// The current operator and its left value /// are pushed onto the stack if the operator on /// top of the stack has lower precedence. std::stack stack_; /// Exponentiation by squaring, x^n. static T pow(T x, T n) { T res = 1; while (n != 0) { if (n % 2 != 0) { res *= x; n -= 1; } x *= x; n /= 2; } return res; } T checkZero(T value) const { if (value == 0) { std::string divOperators("/%"); std::size_t division = expr_.find_last_of(divOperators, index_ - 2); std::ostringstream msg; msg << "Parser error: division by 0"; if (division != std::string::npos) msg << " (error token is \"" << expr_.substr(division, expr_.size() - division) << "\")"; throw calculator::error(expr_, msg.str()); } return value; } T calculate(T v1, T v2, const Operator& op) const { switch (op.op) { case OPERATOR_BITWISE_OR: return v1 | v2; case OPERATOR_BITWISE_XOR: return v1 ^ v2; case OPERATOR_BITWISE_AND: return v1 & v2; case OPERATOR_BITWISE_SHL: return v1 << v2; case OPERATOR_BITWISE_SHR: return v1 >> v2; case OPERATOR_ADDITION: return v1 + v2; case OPERATOR_SUBTRACTION: return v1 - v2; case OPERATOR_MULTIPLICATION: return v1 * v2; case OPERATOR_DIVISION: return v1 / checkZero(v2); case OPERATOR_MODULO: return v1 % checkZero(v2); case OPERATOR_POWER: return pow(v1, v2); case OPERATOR_EXPONENT: return v1 * pow(10, v2); default: return 0; } } bool isEnd() const { return index_ >= expr_.size(); } /// Returns the character at the current expression index or /// 0 if the end of the expression is reached. /// char getCharacter() const { if (!isEnd()) return expr_[index_]; return 0; } /// Parse str at the current expression index. /// @throw error if parsing fails. /// void expect(const std::string& str) { if (expr_.compare(index_, str.size(), str) != 0) unexpected(); index_ += str.size(); } void unexpected() const { std::ostringstream msg; msg << "Syntax error: unexpected token \"" << expr_.substr(index_, expr_.size() - index_) << "\" at index " << index_; throw calculator::error(expr_, msg.str()); } /// Eat all white space characters at the /// current expression index. /// void eatSpaces() { while (std::isspace(getCharacter()) != 0) index_++; } /// Parse a binary operator at the current expression index. /// @return Operator with precedence and associativity. /// Operator parseOp() { eatSpaces(); switch (getCharacter()) { case '|': index_++; return Operator(OPERATOR_BITWISE_OR, 4, 'L'); case '&': index_++; return Operator(OPERATOR_BITWISE_AND, 6, 'L'); case '<': expect("<<"); return Operator(OPERATOR_BITWISE_SHL, 9, 'L'); case '>': expect(">>"); return Operator(OPERATOR_BITWISE_SHR, 9, 'L'); case '+': index_++; return Operator(OPERATOR_ADDITION, 10, 'L'); case '-': index_++; return Operator(OPERATOR_SUBTRACTION, 10, 'L'); case '/': index_++; return Operator(OPERATOR_DIVISION, 20, 'L'); case '%': index_++; return Operator(OPERATOR_MODULO, 20, 'L'); case '*': index_++; if (getCharacter() != '*') return Operator(OPERATOR_MULTIPLICATION, 20, 'L'); case '^': index_++; return Operator(OPERATOR_POWER, 30, 'R'); case 'e': index_++; return Operator(OPERATOR_EXPONENT, 40, 'R'); case 'E': index_++; return Operator(OPERATOR_EXPONENT, 40, 'R'); default : return Operator(OPERATOR_NULL, 0, 'L'); } } static T toInteger(char c) { if (c >= '0' && c <= '9') return c -'0'; if (c >= 'a' && c <= 'f') return c -'a' + 0xa; if (c >= 'A' && c <= 'F') return c -'A' + 0xa; T noDigit = 0xf + 1; return noDigit; } T getInteger() const { return toInteger(getCharacter()); } T parseDecimal() { T value = 0; for (T d; (d = getInteger()) <= 9; index_++) value = value * 10 + d; return value; } T parseHex() { index_ = index_ + 2; T value = 0; for (T h; (h = getInteger()) <= 0xf; index_++) value = value * 0x10 + h; return value; } bool isHex() const { if (index_ + 2 < expr_.size()) { char x = expr_[index_ + 1]; char h = expr_[index_ + 2]; return (std::tolower(x) == 'x' && toInteger(h) <= 0xf); } return false; } /// Parse an integer value at the current expression index. /// The unary `+', `-' and `~' operators and opening /// parentheses `(' cause recursion. /// T parseValue() { T val = 0; eatSpaces(); switch (getCharacter()) { case '0': if (isHex()) { val = parseHex(); break; } case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': val = parseDecimal(); break; case '(': index_++; val = parseExpr(); eatSpaces(); if (getCharacter() != ')') { if (!isEnd()) unexpected(); throw calculator::error(expr_, "Syntax error: `)' expected at end of expression"); } index_++; break; case '~': index_++; val = ~parseValue(); break; case '+': index_++; val = parseValue(); break; case '-': index_++; val = parseValue() * static_cast(-1); break; default : if (!isEnd()) unexpected(); throw calculator::error(expr_, "Syntax error: value expected at end of expression"); } return val; } /// Parse all operations of the current parenthesis /// level and the levels above, when done /// return the result (value). /// T parseExpr() { stack_.push(OperatorValue(Operator(OPERATOR_NULL, 0, 'L'), 0)); // first parse value on the left T value = parseValue(); while (!stack_.empty()) { // parse an operator (+, -, *, ...) Operator op(parseOp()); while (op.precedence < stack_.top().getPrecedence() || ( op.precedence == stack_.top().getPrecedence() && op.associativity == 'L')) { // end reached if (stack_.top().isNull()) { stack_.pop(); return value; } // do the calculation ("reduce"), producing a new value value = calculate(stack_.top().value, value, stack_.top().op); stack_.pop(); } // store on stack_ and continue parsing ("shift") stack_.push(OperatorValue(op, value)); // parse value on the right value = parseValue(); } return 0; } }; template inline T eval(const std::string& expression) { ExpressionParser parser; return parser.eval(expression); } template inline T eval(char c) { ExpressionParser parser; return parser.eval(c); } inline int eval(const std::string& expression) { return eval(expression); } inline int eval(char c) { return eval(c); } } // namespace calculator #endif primesieve-5.6.0/src/apps/gui/src/l1d_cache_size.cpp000066400000000000000000000201331263266076300223520ustar00rootroot00000000000000/// /// @file l1d_cache_size.cpp /// @brief Get the L1 cache size in kilobytes on Windows /// and most Unix-like operating systems. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. /// #include #if defined(_WIN32) || defined(_WIN64) #include typedef BOOL (WINAPI *LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD); /// Get the CPU's L1 data cache size (per core) in kilobytes. /// Successfully tested on Windows x64. /// @return L1 data cache size in kilobytes or -1 if an error occurred. /// int get_l1d_cache_size() { LPFN_GLPI glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")), "GetLogicalProcessorInformation"); // GetLogicalProcessorInformation not supported if (glpi == NULL) return -1; DWORD buffer_bytes = 0; int cache_size = 0; glpi(0, &buffer_bytes); std::size_t size = buffer_bytes / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); SYSTEM_LOGICAL_PROCESSOR_INFORMATION* buffer = new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[size]; glpi(buffer, &buffer_bytes); for (std::size_t i = 0; i < size; i++) { if (buffer[i].Relationship == RelationCache && buffer[i].Cache.Level == 1) { cache_size = (int) buffer[i].Cache.Size; break; } } delete buffer; return cache_size / 1024; } #else /// Get the CPU's L1 data cache size (per core) in kilobytes. /// Successfully tested on Linux and Mac OS X. /// @return L1 data cache size in kilobytes or -1 if an error occurred. /// int get_l1d_cache_size() { // Posix shell script for UNIX like OSes, // Returns log2 of L1_DCACHE_SIZE in kilobytes. // The script tries to get the L1 cache size using 3 different approaches: // 1) getconf LEVEL1_DCACHE_SIZE // 2) cat /sys/devices/system/cpu/cpu0/cache/index0/size // 3) sysctl hw.l1dcachesize const char* shell_script = "command -v getconf >/dev/null 2>/dev/null; \n" "if [ $? -eq 0 ]; \n" "then \n" " # Returns L1 cache size in bytes \n" " L1_DCACHE_BYTES=$(getconf LEVEL1_DCACHE_SIZE 2>/dev/null); \n" "fi; \n" " \n" "if test \"x$L1_DCACHE_BYTES\" = \"x\" || test \"$L1_DCACHE_BYTES\" = \"0\"; \n" "then \n" " # Returns L1 cache size like e.g. 32K, 1M \n" " L1_DCACHE_BYTES=$(cat /sys/devices/system/cpu/cpu0/cache/index0/size 2>/dev/null); \n" " \n" " if test \"x$L1_DCACHE_BYTES\" != \"x\"; \n" " then \n" " is_kilobytes=$(echo $L1_DCACHE_BYTES | grep K); \n" " if test \"x$is_kilobytes\" != \"x\"; \n" " then \n" " L1_DCACHE_BYTES=$(expr $(echo $L1_DCACHE_BYTES | sed -e s'/K$//') '*' 1024); \n" " fi; \n" " is_megabytes=$(echo $L1_DCACHE_BYTES | grep M); \n" " if test \"x$is_megabytes\" != \"x\"; \n" " then \n" " L1_DCACHE_BYTES=$(expr $(echo $L1_DCACHE_BYTES | sed -e s'/M$//') '*' 1024 '*' 1024); \n" " fi; \n" " else \n" " # This method works on OS X \n" " command -v sysctl >/dev/null 2>/dev/null; \n" " if [ $? -eq 0 ]; \n" " then \n" " # Returns L1 cache size in bytes \n" " L1_DCACHE_BYTES=$(sysctl hw.l1dcachesize 2>/dev/null | sed -e 's/^.* //'); \n" " fi; \n" " fi; \n" "fi; \n" " \n" "if test \"x$L1_DCACHE_BYTES\" != \"x\"; \n" "then \n" " if [ $L1_DCACHE_BYTES -ge 1024 2>/dev/null ]; \n" " then \n" " # Convert to kilobytes \n" " L1_DCACHE_SIZE=$(expr $L1_DCACHE_BYTES '/' 1024); \n" " fi; \n" "fi; \n" " \n" "if test \"x$L1_DCACHE_SIZE\" = \"x\"; \n" "then \n" " exit 1; \n" "fi; \n" " \n" "LOG2_L1_DCACHE_SIZE=0; \n" "while [ $L1_DCACHE_SIZE -ge 2 ]; \n" "do \n" " L1_DCACHE_SIZE=$(expr $L1_DCACHE_SIZE '/' 2); \n" " LOG2_L1_DCACHE_SIZE=$(expr $LOG2_L1_DCACHE_SIZE '+' 1); \n" "done; \n" " \n" "exit $LOG2_L1_DCACHE_SIZE; \n"; int exit_code = std::system(shell_script); exit_code = WEXITSTATUS(exit_code); // check if shell script executed without any errors if (exit_code <= 2) return -1; int l1d_cache_size = 1 << exit_code; return l1d_cache_size; } #endif primesieve-5.6.0/src/apps/gui/src/main.cpp000066400000000000000000000052651263266076300204520ustar00rootroot00000000000000/* * main.cpp -- This file is part of primesieve * * Copyright (C) 2012 Kim Walisch, * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see */ #include "PrimeSieveGUI.hpp" #include #if QT_VERSION >= 0x050000 #include #else #include #endif #include #include #include #include /** * The primesieve GUI is launched if the user starts the application * by mouse click or without arguments, a PrimeSieveProcess is * launched if process and a shared memory identifiers are provided as * arguments. * @param argv[1] [process identifier] * @param argv[2] [Shared memory identifier] * @see PrimeSieveProcess.cpp */ int main(int argc, char *argv[]) { if (argc == 3) { QString psp("PrimeSieveProcess"); QString parent(argv[1]); if (parent.compare(psp) == 0) { // open an existing and initialized shared memory QString id(argv[2]); QSharedMemory sharedMemory(id); if (!sharedMemory.attach()) { std::cerr << "Unable to attach shared memory " << argv[2] << std::endl; exit(EXIT_FAILURE); } // map the attached shared memory to the shm segment primesieve::ParallelPrimeSieve::SharedMemory* shm = static_cast(sharedMemory.data()); try { // initialize the ParallelPrimeSieve object with // values from the shared memory segment provided by // the primesieve GUI and start sieving if (!shm) throw std::runtime_error("sharedMemory.data() must not be NULL"); primesieve::ParallelPrimeSieve pps; pps.init(*shm); pps.sieve(); } catch (std::exception& e) { sharedMemory.detach(); std::cerr << "ParallelPrimeSieve error: " << e.what() << std::endl; exit(EXIT_FAILURE); } sharedMemory.detach(); return 0; } } // Qt GUI interface QApplication a(argc, argv); PrimeSieveGUI w; w.show(); return a.exec(); } primesieve-5.6.0/src/msvc_compat/000077500000000000000000000000001263266076300170075ustar00rootroot00000000000000primesieve-5.6.0/src/msvc_compat/has_openmp.cpp000066400000000000000000000007561263266076300216540ustar00rootroot00000000000000/// /// @file has_openmp.cpp /// @brief Used to check OpenMP support in compilers. /// /// Copyright (C) 2012 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include int main() { std::cout << "OpenMP version (yyyymm) : " << _OPENMP << std::endl << "Number of CPU cores : " << omp_get_max_threads() << std::endl; return 0; } primesieve-5.6.0/src/msvc_compat/stdint.h000066400000000000000000000655361263266076300205040ustar00rootroot00000000000000/* A portable stdint.h **************************************************************************** * BSD License: **************************************************************************** * * Copyright (c) 2005-2007 Paul Hsieh * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. * **************************************************************************** * * Version 0.1.11 * * The ANSI C standard committee, for the C99 standard, specified the * inclusion of a new standard include file called stdint.h. This is * a very useful and long desired include file which contains several * very precise definitions for integer scalar types that is * critically important for making portable several classes of * applications including cryptography, hashing, variable length * integer libraries and so on. But for most developers its likely * useful just for programming sanity. * * The problem is that most compiler vendors have decided not to * implement the C99 standard, and the next C++ language standard * (which has a lot more mindshare these days) will be a long time in * coming and its unknown whether or not it will include stdint.h or * how much adoption it will have. Either way, it will be a long time * before all compilers come with a stdint.h and it also does nothing * for the extremely large number of compilers available today which * do not include this file, or anything comparable to it. * * So that's what this file is all about. Its an attempt to build a * single universal include file that works on as many platforms as * possible to deliver what stdint.h is supposed to. A few things * that should be noted about this file: * * 1) It is not guaranteed to be portable and/or present an identical * interface on all platforms. The extreme variability of the * ANSI C standard makes this an impossibility right from the * very get go. Its really only meant to be useful for the vast * majority of platforms that possess the capability of * implementing usefully and precisely defined, standard sized * integer scalars. Systems which are not intrinsically 2s * complement may produce invalid constants. * * 2) There is an unavoidable use of non-reserved symbols. * * 3) Other standard include files are invoked. * * 4) This file may come in conflict with future platforms that do * include stdint.h. The hope is that one or the other can be * used with no real difference. * * 5) In the current verison, if your platform can't represent * int32_t, int16_t and int8_t, it just dumps out with a compiler * error. * * 6) 64 bit integers may or may not be defined. Test for their * presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX. * Note that this is different from the C99 specification which * requires the existence of 64 bit support in the compiler. If * this is not defined for your platform, yet it is capable of * dealing with 64 bits then it is because this file has not yet * been extended to cover all of your system's capabilities. * * 7) (u)intptr_t may or may not be defined. Test for its presence * with the test: #ifdef PTRDIFF_MAX. If this is not defined * for your platform, then it is because this file has not yet * been extended to cover all of your system's capabilities, not * because its optional. * * 8) The following might not been defined even if your platform is * capable of defining it: * * WCHAR_MIN * WCHAR_MAX * (u)int64_t * PTRDIFF_MIN * PTRDIFF_MAX * (u)intptr_t * * 9) The following have not been defined: * * WINT_MIN * WINT_MAX * * 10) The criteria for defining (u)int_least(*)_t isn't clear, * except for systems which don't have a type that precisely * defined 8, 16, or 32 bit types (which this include file does * not support anyways). Default definitions have been given. * * 11) The criteria for defining (u)int_fast(*)_t isn't something I * would trust to any particular compiler vendor or the ANSI C * committee. It is well known that "compatible systems" are * commonly created that have very different performance * characteristics from the systems they are compatible with, * especially those whose vendors make both the compiler and the * system. Default definitions have been given, but its strongly * recommended that users never use these definitions for any * reason (they do *NOT* deliver any serious guarantee of * improved performance -- not in this file, nor any vendor's * stdint.h). * * 12) The following macros: * * PRINTF_INTMAX_MODIFIER * PRINTF_INT64_MODIFIER * PRINTF_INT32_MODIFIER * PRINTF_INT16_MODIFIER * PRINTF_LEAST64_MODIFIER * PRINTF_LEAST32_MODIFIER * PRINTF_LEAST16_MODIFIER * PRINTF_INTPTR_MODIFIER * * are strings which have been defined as the modifiers required * for the "d", "u" and "x" printf formats to correctly output * (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t, * (u)least32_t, (u)least16_t and (u)intptr_t types respectively. * PRINTF_INTPTR_MODIFIER is not defined for some systems which * provide their own stdint.h. PRINTF_INT64_MODIFIER is not * defined if INT64_MAX is not defined. These are an extension * beyond what C99 specifies must be in stdint.h. * * In addition, the following macros are defined: * * PRINTF_INTMAX_HEX_WIDTH * PRINTF_INT64_HEX_WIDTH * PRINTF_INT32_HEX_WIDTH * PRINTF_INT16_HEX_WIDTH * PRINTF_INT8_HEX_WIDTH * PRINTF_INTMAX_DEC_WIDTH * PRINTF_INT64_DEC_WIDTH * PRINTF_INT32_DEC_WIDTH * PRINTF_INT16_DEC_WIDTH * PRINTF_INT8_DEC_WIDTH * * Which specifies the maximum number of characters required to * print the number of that type in either hexadecimal or decimal. * These are an extension beyond what C99 specifies must be in * stdint.h. * * Compilers tested (all with 0 warnings at their highest respective * settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32 * bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio * .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3 * * This file should be considered a work in progress. Suggestions for * improvements, especially those which increase coverage are strongly * encouraged. * * Acknowledgements * * The following people have made significant contributions to the * development and testing of this file: * * Chris Howie * John Steele Scott * Dave Thorup * */ #include #include #include /* * For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and * do nothing else. On the Mac OS X version of gcc this is _STDINT_H_. */ #if ((defined(__STDC__) && __STDC__ && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (defined(_STDINT_H) || defined(_STDINT_H_)) )) && !defined (_PSTDINT_H_INCLUDED) #include #define _PSTDINT_H_INCLUDED # ifndef PRINTF_INT64_MODIFIER # define PRINTF_INT64_MODIFIER "ll" # endif # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "l" # endif # ifndef PRINTF_INT16_MODIFIER # define PRINTF_INT16_MODIFIER "h" # endif # ifndef PRINTF_INTMAX_MODIFIER # define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER # endif # ifndef PRINTF_INT64_HEX_WIDTH # define PRINTF_INT64_HEX_WIDTH "16" # endif # ifndef PRINTF_INT32_HEX_WIDTH # define PRINTF_INT32_HEX_WIDTH "8" # endif # ifndef PRINTF_INT16_HEX_WIDTH # define PRINTF_INT16_HEX_WIDTH "4" # endif # ifndef PRINTF_INT8_HEX_WIDTH # define PRINTF_INT8_HEX_WIDTH "2" # endif # ifndef PRINTF_INT64_DEC_WIDTH # define PRINTF_INT64_DEC_WIDTH "20" # endif # ifndef PRINTF_INT32_DEC_WIDTH # define PRINTF_INT32_DEC_WIDTH "10" # endif # ifndef PRINTF_INT16_DEC_WIDTH # define PRINTF_INT16_DEC_WIDTH "5" # endif # ifndef PRINTF_INT8_DEC_WIDTH # define PRINTF_INT8_DEC_WIDTH "3" # endif # ifndef PRINTF_INTMAX_HEX_WIDTH # define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH # endif # ifndef PRINTF_INTMAX_DEC_WIDTH # define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH # endif /* * Something really weird is going on with Open Watcom. Just pull some of * these duplicated definitions from Open Watcom's stdint.h file for now. */ # if defined (__WATCOMC__) && __WATCOMC__ >= 1250 # if !defined (INT64_C) # define INT64_C(x) (x + (INT64_MAX - INT64_MAX)) # endif # if !defined (UINT64_C) # define UINT64_C(x) (x + (UINT64_MAX - UINT64_MAX)) # endif # if !defined (INT32_C) # define INT32_C(x) (x + (INT32_MAX - INT32_MAX)) # endif # if !defined (UINT32_C) # define UINT32_C(x) (x + (UINT32_MAX - UINT32_MAX)) # endif # if !defined (INT16_C) # define INT16_C(x) (x) # endif # if !defined (UINT16_C) # define UINT16_C(x) (x) # endif # if !defined (INT8_C) # define INT8_C(x) (x) # endif # if !defined (UINT8_C) # define UINT8_C(x) (x) # endif # if !defined (UINT64_MAX) # define UINT64_MAX 18446744073709551615ULL # endif # if !defined (INT64_MAX) # define INT64_MAX 9223372036854775807LL # endif # if !defined (UINT32_MAX) # define UINT32_MAX 4294967295UL # endif # if !defined (INT32_MAX) # define INT32_MAX 2147483647L # endif # if !defined (INTMAX_MAX) # define INTMAX_MAX INT64_MAX # endif # if !defined (INTMAX_MIN) # define INTMAX_MIN INT64_MIN # endif # endif #endif #ifndef _PSTDINT_H_INCLUDED #define _PSTDINT_H_INCLUDED #ifndef SIZE_MAX # define SIZE_MAX (~(size_t)0) #endif /* * Deduce the type assignments from limits.h under the assumption that * integer sizes in bits are powers of 2, and follow the ANSI * definitions. */ #ifndef UINT8_MAX # define UINT8_MAX 0xff #endif #ifndef uint8_t # if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S) typedef unsigned char uint8_t; # define UINT8_C(v) ((uint8_t) v) # else # error "Platform not supported" # endif #endif #ifndef INT8_MAX # define INT8_MAX 0x7f #endif #ifndef INT8_MIN # define INT8_MIN INT8_C(0x80) #endif #ifndef int8_t # if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S) typedef signed char int8_t; # define INT8_C(v) ((int8_t) v) # else # error "Platform not supported" # endif #endif #ifndef UINT16_MAX # define UINT16_MAX 0xffff #endif #ifndef uint16_t #if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S) typedef unsigned int uint16_t; # ifndef PRINTF_INT16_MODIFIER # define PRINTF_INT16_MODIFIER "" # endif # define UINT16_C(v) ((uint16_t) (v)) #elif (USHRT_MAX == UINT16_MAX) typedef unsigned short uint16_t; # define UINT16_C(v) ((uint16_t) (v)) # ifndef PRINTF_INT16_MODIFIER # define PRINTF_INT16_MODIFIER "h" # endif #else #error "Platform not supported" #endif #endif #ifndef INT16_MAX # define INT16_MAX 0x7fff #endif #ifndef INT16_MIN # define INT16_MIN INT16_C(0x8000) #endif #ifndef int16_t #if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S) typedef signed int int16_t; # define INT16_C(v) ((int16_t) (v)) # ifndef PRINTF_INT16_MODIFIER # define PRINTF_INT16_MODIFIER "" # endif #elif (SHRT_MAX == INT16_MAX) typedef signed short int16_t; # define INT16_C(v) ((int16_t) (v)) # ifndef PRINTF_INT16_MODIFIER # define PRINTF_INT16_MODIFIER "h" # endif #else #error "Platform not supported" #endif #endif /* * Author: Kim Walisch, * I reversed the order of 'unsigned int' and 'unsigned long' to prevent * the following bug in my software when compiling with MSVC 2010: * "... cannot convert parameter 3 from 'void (__cdecl *)(unsigned int)' * to 'void (__cdecl *)(uint32_t)' ..." */ #ifndef UINT32_MAX # define UINT32_MAX (0xffffffffUL) #endif #ifndef uint32_t #if (UINT_MAX == UINT32_MAX) && !defined (S_SPLINT_S) typedef unsigned int uint32_t; # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "" # endif # define UINT32_C(v) v ## U #elif (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S) typedef unsigned long uint32_t; # define UINT32_C(v) v ## UL # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "l" # endif #elif (USHRT_MAX == UINT32_MAX) typedef unsigned short uint32_t; # define UINT32_C(v) ((unsigned short) (v)) # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "" # endif #else #error "Platform not supported" #endif #endif #ifndef INT32_MAX # define INT32_MAX (0x7fffffffL) #endif #ifndef INT32_MIN # define INT32_MIN INT32_C(0x80000000) #endif #ifndef int32_t #if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S) typedef signed long int32_t; # define INT32_C(v) v ## L # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "l" # endif #elif (INT_MAX == INT32_MAX) typedef signed int int32_t; # define INT32_C(v) v # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "" # endif #elif (SHRT_MAX == INT32_MAX) typedef signed short int32_t; # define INT32_C(v) ((short) (v)) # ifndef PRINTF_INT32_MODIFIER # define PRINTF_INT32_MODIFIER "" # endif #else #error "Platform not supported" #endif #endif /* * The macro stdint_int64_defined is temporarily used to record * whether or not 64 integer support is available. It must be * defined for any 64 integer extensions for new platforms that are * added. */ #undef stdint_int64_defined #if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S) # if (__STDC__ && __STDC_VERSION >= 199901L) || defined (S_SPLINT_S) # define stdint_int64_defined typedef long long int64_t; typedef unsigned long long uint64_t; # define UINT64_C(v) v ## ULL # define INT64_C(v) v ## LL # ifndef PRINTF_INT64_MODIFIER # define PRINTF_INT64_MODIFIER "ll" # endif # endif #endif #if !defined (stdint_int64_defined) # if defined(__GNUC__) # define stdint_int64_defined __extension__ typedef long long int64_t; __extension__ typedef unsigned long long uint64_t; # define UINT64_C(v) v ## ULL # define INT64_C(v) v ## LL # ifndef PRINTF_INT64_MODIFIER # define PRINTF_INT64_MODIFIER "ll" # endif # elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S) # define stdint_int64_defined typedef long long int64_t; typedef unsigned long long uint64_t; # define UINT64_C(v) v ## ULL # define INT64_C(v) v ## LL # ifndef PRINTF_INT64_MODIFIER # define PRINTF_INT64_MODIFIER "ll" # endif # elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC) # define stdint_int64_defined typedef __int64 int64_t; typedef unsigned __int64 uint64_t; # define UINT64_C(v) v ## UI64 # define INT64_C(v) v ## I64 # ifndef PRINTF_INT64_MODIFIER # define PRINTF_INT64_MODIFIER "I64" # endif # endif #endif #if !defined (LONG_LONG_MAX) && defined (INT64_C) # define LONG_LONG_MAX INT64_C (9223372036854775807) #endif #ifndef ULONG_LONG_MAX # define ULONG_LONG_MAX UINT64_C (18446744073709551615) #endif #if !defined (INT64_MAX) && defined (INT64_C) # define INT64_MAX INT64_C (9223372036854775807) #endif #if !defined (INT64_MIN) && defined (INT64_C) # define INT64_MIN INT64_C (-9223372036854775808) #endif #if !defined (UINT64_MAX) && defined (INT64_C) # define UINT64_MAX UINT64_C (18446744073709551615) #endif /* * Width of hexadecimal for number field. */ #ifndef PRINTF_INT64_HEX_WIDTH # define PRINTF_INT64_HEX_WIDTH "16" #endif #ifndef PRINTF_INT32_HEX_WIDTH # define PRINTF_INT32_HEX_WIDTH "8" #endif #ifndef PRINTF_INT16_HEX_WIDTH # define PRINTF_INT16_HEX_WIDTH "4" #endif #ifndef PRINTF_INT8_HEX_WIDTH # define PRINTF_INT8_HEX_WIDTH "2" #endif #ifndef PRINTF_INT64_DEC_WIDTH # define PRINTF_INT64_DEC_WIDTH "20" #endif #ifndef PRINTF_INT32_DEC_WIDTH # define PRINTF_INT32_DEC_WIDTH "10" #endif #ifndef PRINTF_INT16_DEC_WIDTH # define PRINTF_INT16_DEC_WIDTH "5" #endif #ifndef PRINTF_INT8_DEC_WIDTH # define PRINTF_INT8_DEC_WIDTH "3" #endif /* * Ok, lets not worry about 128 bit integers for now. Moore's law says * we don't need to worry about that until about 2040 at which point * we'll have bigger things to worry about. */ #ifdef stdint_int64_defined typedef int64_t intmax_t; typedef uint64_t uintmax_t; # define INTMAX_MAX INT64_MAX # define INTMAX_MIN INT64_MIN # define UINTMAX_MAX UINT64_MAX # define UINTMAX_C(v) UINT64_C(v) # define INTMAX_C(v) INT64_C(v) # ifndef PRINTF_INTMAX_MODIFIER # define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER # endif # ifndef PRINTF_INTMAX_HEX_WIDTH # define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH # endif # ifndef PRINTF_INTMAX_DEC_WIDTH # define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH # endif #else typedef int32_t intmax_t; typedef uint32_t uintmax_t; # define INTMAX_MAX INT32_MAX # define UINTMAX_MAX UINT32_MAX # define UINTMAX_C(v) UINT32_C(v) # define INTMAX_C(v) INT32_C(v) # ifndef PRINTF_INTMAX_MODIFIER # define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER # endif # ifndef PRINTF_INTMAX_HEX_WIDTH # define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH # endif # ifndef PRINTF_INTMAX_DEC_WIDTH # define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH # endif #endif /* * Because this file currently only supports platforms which have * precise powers of 2 as bit sizes for the default integers, the * least definitions are all trivial. Its possible that a future * version of this file could have different definitions. */ #ifndef stdint_least_defined typedef int8_t int_least8_t; typedef uint8_t uint_least8_t; typedef int16_t int_least16_t; typedef uint16_t uint_least16_t; typedef int32_t int_least32_t; typedef uint32_t uint_least32_t; # define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER # define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER # define UINT_LEAST8_MAX UINT8_MAX # define INT_LEAST8_MAX INT8_MAX # define UINT_LEAST16_MAX UINT16_MAX # define INT_LEAST16_MAX INT16_MAX # define UINT_LEAST32_MAX UINT32_MAX # define INT_LEAST32_MAX INT32_MAX # define INT_LEAST8_MIN INT8_MIN # define INT_LEAST16_MIN INT16_MIN # define INT_LEAST32_MIN INT32_MIN # ifdef stdint_int64_defined typedef int64_t int_least64_t; typedef uint64_t uint_least64_t; # define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER # define UINT_LEAST64_MAX UINT64_MAX # define INT_LEAST64_MAX INT64_MAX # define INT_LEAST64_MIN INT64_MIN # endif #endif #undef stdint_least_defined /* * The ANSI C committee pretending to know or specify anything about * performance is the epitome of misguided arrogance. The mandate of * this file is to *ONLY* ever support that absolute minimum * definition of the fast integer types, for compatibility purposes. * No extensions, and no attempt to suggest what may or may not be a * faster integer type will ever be made in this file. Developers are * warned to stay away from these types when using this or any other * stdint.h. */ typedef int_least8_t int_fast8_t; typedef uint_least8_t uint_fast8_t; typedef int_least16_t int_fast16_t; typedef uint_least16_t uint_fast16_t; typedef int_least32_t int_fast32_t; typedef uint_least32_t uint_fast32_t; #define UINT_FAST8_MAX UINT_LEAST8_MAX #define INT_FAST8_MAX INT_LEAST8_MAX #define UINT_FAST16_MAX UINT_LEAST16_MAX #define INT_FAST16_MAX INT_LEAST16_MAX #define UINT_FAST32_MAX UINT_LEAST32_MAX #define INT_FAST32_MAX INT_LEAST32_MAX #define INT_FAST8_MIN INT_LEAST8_MIN #define INT_FAST16_MIN INT_LEAST16_MIN #define INT_FAST32_MIN INT_LEAST32_MIN #ifdef stdint_int64_defined typedef int_least64_t int_fast64_t; typedef uint_least64_t uint_fast64_t; # define UINT_FAST64_MAX UINT_LEAST64_MAX # define INT_FAST64_MAX INT_LEAST64_MAX # define INT_FAST64_MIN INT_LEAST64_MIN #endif #undef stdint_int64_defined /* * Whatever piecemeal, per compiler thing we can do about the wchar_t * type limits. */ #if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__) # include # ifndef WCHAR_MIN # define WCHAR_MIN 0 # endif # ifndef WCHAR_MAX # define WCHAR_MAX ((wchar_t)-1) # endif #endif /* * Whatever piecemeal, per compiler/platform thing we can do about the * (u)intptr_t types and limits. */ #if defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED) # define STDINT_H_UINTPTR_T_DEFINED #endif #ifndef STDINT_H_UINTPTR_T_DEFINED # if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64) # define stdint_intptr_bits 64 # elif defined (__WATCOMC__) || defined (__TURBOC__) # if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__) # define stdint_intptr_bits 16 # else # define stdint_intptr_bits 32 # endif # elif defined (__i386__) || defined (_WIN32) || defined (WIN32) # define stdint_intptr_bits 32 # elif defined (__INTEL_COMPILER) /* TODO -- what will Intel do about x86-64? */ # endif # ifdef stdint_intptr_bits # define stdint_intptr_glue3_i(a,b,c) a##b##c # define stdint_intptr_glue3(a,b,c) stdint_intptr_glue3_i(a,b,c) # ifndef PRINTF_INTPTR_MODIFIER # define PRINTF_INTPTR_MODIFIER stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER) # endif # ifndef PTRDIFF_MAX # define PTRDIFF_MAX stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX) # endif # ifndef PTRDIFF_MIN # define PTRDIFF_MIN stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN) # endif # ifndef UINTPTR_MAX # define UINTPTR_MAX stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX) # endif # ifndef INTPTR_MAX # define INTPTR_MAX stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX) # endif # ifndef INTPTR_MIN # define INTPTR_MIN stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN) # endif # ifndef INTPTR_C # define INTPTR_C(x) stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x) # endif # ifndef UINTPTR_C # define UINTPTR_C(x) stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x) # endif typedef stdint_intptr_glue3(uint,stdint_intptr_bits,_t) uintptr_t; typedef stdint_intptr_glue3( int,stdint_intptr_bits,_t) intptr_t; # else /* TODO -- This following is likely wrong for some platforms, and does nothing for the definition of uintptr_t. */ typedef ptrdiff_t intptr_t; # endif # define STDINT_H_UINTPTR_T_DEFINED #endif /* * Assumes sig_atomic_t is signed and we have a 2s complement machine. */ #ifndef SIG_ATOMIC_MAX # define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1) #endif #endif #if defined (__TEST_PSTDINT_FOR_CORRECTNESS) /* * Please compile with the maximum warning settings to make sure macros are not * defined more than once. */ #include #include #include #define glue3_aux(x,y,z) x ## y ## z #define glue3(x,y,z) glue3_aux(x,y,z) #define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,=) glue3(UINT,bits,_C) (0); #define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,=) glue3(INT,bits,_C) (0); #define DECL(us,bits) glue3(DECL,us,) (bits) #define TESTUMAX(bits) glue3(u,bits,=) glue3(~,u,bits); if (glue3(UINT,bits,_MAX) glue3(!=,u,bits)) printf ("Something wrong with UINT%d_MAX\n", bits) int main () { DECL(I,8) DECL(U,8) DECL(I,16) DECL(U,16) DECL(I,32) DECL(U,32) #ifdef INT64_MAX DECL(I,64) DECL(U,64) #endif intmax_t imax = INTMAX_C(0); uintmax_t umax = UINTMAX_C(0); char str0[256], str1[256]; sprintf (str0, "%d %x\n", 0, ~0); sprintf (str1, "%d %x\n", i8, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with i8 : %s\n", str1); sprintf (str1, "%u %x\n", u8, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with u8 : %s\n", str1); sprintf (str1, "%d %x\n", i16, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with i16 : %s\n", str1); sprintf (str1, "%u %x\n", u16, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with u16 : %s\n", str1); sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n", i32, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with i32 : %s\n", str1); sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n", u32, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with u32 : %s\n", str1); #ifdef INT64_MAX sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n", i64, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with i64 : %s\n", str1); #endif sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n", imax, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with imax : %s\n", str1); sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n", umax, ~0); if (0 != strcmp (str0, str1)) printf ("Something wrong with umax : %s\n", str1); TESTUMAX(8); TESTUMAX(16); TESTUMAX(32); #ifdef INT64_MAX TESTUMAX(64); #endif return EXIT_SUCCESS; } #endif primesieve-5.6.0/src/primesieve/000077500000000000000000000000001263266076300166445ustar00rootroot00000000000000primesieve-5.6.0/src/primesieve/EratBig.cpp000066400000000000000000000136171263266076300206750ustar00rootroot00000000000000/// /// @file EratBig.cpp /// @brief Segmented sieve of Eratosthenes optimized for big sieving /// primes. This is an optimized implementation of Tomas /// Oliveira e Silva's cache-friendly bucket sieve algorithm: /// http://www.ieeta.pt/~tos/software/prime_sieve.html /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #include namespace primesieve { /// @param stop Upper bound for sieving. /// @param sieveSize Sieve size in bytes. /// @param limit Sieving primes in EratBig must be <= limit, /// usually limit = sqrt(stop). /// EratBig::EratBig(uint64_t stop, uint_t sieveSize, uint_t limit) : Modulo210Wheel_t(stop, sieveSize), limit_(limit), log2SieveSize_(ilog2(sieveSize)), moduloSieveSize_(sieveSize - 1), stock_(NULL) { // '>> log2SieveSize' requires a power of 2 sieveSize if (!isPowerOf2(sieveSize)) throw primesieve_error("EratBig: sieveSize must be a power of 2"); init(sieveSize); } EratBig::~EratBig() { for (std::size_t i = 0; i < pointers_.size(); i++) delete[] pointers_[i]; } void EratBig::init(uint_t sieveSize) { uint_t maxSievingPrime = limit_ / NUMBERS_PER_BYTE; uint_t maxNextMultiple = maxSievingPrime * getMaxFactor() + getMaxFactor(); uint_t maxMultipleIndex = sieveSize - 1 + maxNextMultiple; uint_t maxSegmentCount = maxMultipleIndex >> log2SieveSize_; uint_t size = maxSegmentCount + 1; // EratBig uses up to 1.6 gigabytes of memory near 2^64 pointers_.reserve(((1u << 30) * 2) / config::BYTES_PER_ALLOC); lists_.resize(size, NULL); for (uint_t i = 0; i < size; i++) pushBucket(i); } /// Add a new sieving prime to EratBig void EratBig::storeSievingPrime(uint_t prime, uint_t multipleIndex, uint_t wheelIndex) { assert(prime <= limit_); uint_t sievingPrime = prime / NUMBERS_PER_BYTE; uint_t segment = multipleIndex >> log2SieveSize_; multipleIndex &= moduloSieveSize_; if (!lists_[segment]->store(sievingPrime, multipleIndex, wheelIndex)) pushBucket(segment); } /// Add an empty bucket to the front of lists_[segment]. void EratBig::pushBucket(uint_t segment) { // if the stock_ is empty allocate new buckets if (!stock_) { const int N = config::BYTES_PER_ALLOC / sizeof(Bucket); Bucket* buckets = new Bucket[N]; for (int i = 0; i < N-1; i++) buckets[i].setNext(&buckets[i + 1]); buckets[N-1].setNext(NULL); pointers_.push_back(buckets); stock_ = buckets; } Bucket* emptyBucket = stock_; stock_ = stock_->next(); moveBucket(*emptyBucket, lists_[segment]); } void EratBig::moveBucket(Bucket& src, Bucket*& dest) { src.setNext(dest); dest = &src; } /// Cross-off the multiples of big sieving primes /// from the sieve array. /// void EratBig::crossOff(byte_t* sieve) { // process the buckets in lists_[0] which hold the sieving primes // that have multiple(s) in the current segment while (lists_[0]->hasNext() || !lists_[0]->empty()) { Bucket* bucket = lists_[0]; lists_[0] = NULL; pushBucket(0); do { crossOff(sieve, bucket->begin(), bucket->end()); Bucket* processed = bucket; bucket = bucket->next(); processed->reset(); moveBucket(*processed, stock_); } while (bucket); } // move the list corresponding to the next segment // i.e. lists_[1] to lists_[0] ... std::rotate(lists_.begin(), lists_.begin() + 1, lists_.end()); } /// Cross-off the next multiple of each sieving prime within the /// current bucket. This is an implementation of the segmented sieve /// of Eratosthenes with wheel factorization optimized for big sieving /// primes that have very few multiples per segment. This algorithm /// uses a modulo 210 wheel that skips multiples of 2, 3, 5 and 7. /// void EratBig::crossOff(byte_t* sieve, SievingPrime* sPrime, SievingPrime* sEnd) { Bucket** lists = &lists_[0]; uint_t moduloSieveSize = moduloSieveSize_; uint_t log2SieveSize = log2SieveSize_; // 2 sieving primes are processed per loop iteration // to increase instruction level parallelism for (; sPrime + 2 <= sEnd; sPrime += 2) { uint_t multipleIndex0 = sPrime[0].getMultipleIndex(); uint_t wheelIndex0 = sPrime[0].getWheelIndex(); uint_t sievingPrime0 = sPrime[0].getSievingPrime(); uint_t multipleIndex1 = sPrime[1].getMultipleIndex(); uint_t wheelIndex1 = sPrime[1].getWheelIndex(); uint_t sievingPrime1 = sPrime[1].getSievingPrime(); // cross-off the current multiple (unset bit) // and calculate the next multiple unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0); unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1); uint_t segment0 = multipleIndex0 >> log2SieveSize; uint_t segment1 = multipleIndex1 >> log2SieveSize; multipleIndex0 &= moduloSieveSize; multipleIndex1 &= moduloSieveSize; // move the 2 sieving primes to the list related // to their next multiple if (!lists[segment0]->store(sievingPrime0, multipleIndex0, wheelIndex0)) pushBucket(segment0); if (!lists[segment1]->store(sievingPrime1, multipleIndex1, wheelIndex1)) pushBucket(segment1); } if (sPrime != sEnd) { uint_t multipleIndex = sPrime->getMultipleIndex(); uint_t wheelIndex = sPrime->getWheelIndex(); uint_t sievingPrime = sPrime->getSievingPrime(); unsetBit(sieve, sievingPrime, &multipleIndex, &wheelIndex); uint_t segment = multipleIndex >> log2SieveSize; multipleIndex &= moduloSieveSize; if (!lists[segment]->store(sievingPrime, multipleIndex, wheelIndex)) pushBucket(segment); } } } // namespace primesieve primesieve-5.6.0/src/primesieve/EratMedium.cpp000066400000000000000000000103551263266076300214100ustar00rootroot00000000000000/// /// @file EratMedium.cpp /// @brief Segmented sieve of Eratosthenes optimized for medium /// sieving primes. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include namespace primesieve { /// @param stop Upper bound for sieving. /// @param sieveSize Sieve size in bytes. /// @param limit Sieving primes in EratMedium must be <= limit. /// EratMedium::EratMedium(uint64_t stop, uint_t sieveSize, uint_t limit) : Modulo210Wheel_t(stop, sieveSize), limit_(limit) { // ensure multipleIndex < 2^23 in crossOff() if (sieveSize > (1u << 21)) throw primesieve_error("EratMedium: sieveSize must be <= 2^21, 2048 kilobytes"); if (limit > sieveSize * 9) throw primesieve_error("EratMedium: limit must be <= sieveSize * 9"); buckets_.push_back(Bucket()); } /// Add a new sieving prime to EratMedium void EratMedium::storeSievingPrime(uint_t prime, uint_t multipleIndex, uint_t wheelIndex) { assert(prime <= limit_); uint_t sievingPrime = prime / NUMBERS_PER_BYTE; if (!buckets_.back().store(sievingPrime, multipleIndex, wheelIndex)) buckets_.push_back(Bucket()); } /// Cross-off the multiples of medium sieving /// primes from the sieve array. /// void EratMedium::crossOff(byte_t* sieve, uint_t sieveSize) { for (BucketIterator_t iter = buckets_.begin(); iter != buckets_.end(); ++iter) crossOff(sieve, sieveSize, *iter); } /// Cross-off the multiples of the sieving primes within the current /// bucket. This is an implementation of the segmented sieve of /// Eratosthenes with wheel factorization optimized for medium sieving /// primes that have a few multiples per segment. This algorithm uses /// a modulo 210 wheel that skips multiples of 2, 3, 5 and 7. /// void EratMedium::crossOff(byte_t* sieve, uint_t sieveSize, Bucket& bucket) { SievingPrime* sPrime = bucket.begin(); SievingPrime* sEnd = bucket.end(); // process 3 sieving primes per loop iteration to // increase instruction level parallelism for (; sPrime + 3 <= sEnd; sPrime += 3) { uint_t multipleIndex0 = sPrime[0].getMultipleIndex(); uint_t wheelIndex0 = sPrime[0].getWheelIndex(); uint_t sievingPrime0 = sPrime[0].getSievingPrime(); uint_t multipleIndex1 = sPrime[1].getMultipleIndex(); uint_t wheelIndex1 = sPrime[1].getWheelIndex(); uint_t sievingPrime1 = sPrime[1].getSievingPrime(); uint_t multipleIndex2 = sPrime[2].getMultipleIndex(); uint_t wheelIndex2 = sPrime[2].getWheelIndex(); uint_t sievingPrime2 = sPrime[2].getSievingPrime(); // cross-off the multiples (unset bits) of sievingPrime // @see unsetBit() in WheelFactorization.hpp while (multipleIndex0 < sieveSize) { unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0); if (multipleIndex1 >= sieveSize) break; unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1); if (multipleIndex2 >= sieveSize) break; unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2); } while (multipleIndex0 < sieveSize) unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0); while (multipleIndex1 < sieveSize) unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1); while (multipleIndex2 < sieveSize) unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2); multipleIndex0 -= sieveSize; multipleIndex1 -= sieveSize; multipleIndex2 -= sieveSize; sPrime[0].set(multipleIndex0, wheelIndex0); sPrime[1].set(multipleIndex1, wheelIndex1); sPrime[2].set(multipleIndex2, wheelIndex2); } // process remaining sieving primes for (; sPrime != sEnd; sPrime++) { uint_t multipleIndex = sPrime->getMultipleIndex(); uint_t wheelIndex = sPrime->getWheelIndex(); uint_t sievingPrime = sPrime->getSievingPrime(); while (multipleIndex < sieveSize) unsetBit(sieve, sievingPrime, &multipleIndex, &wheelIndex); multipleIndex -= sieveSize; sPrime->set(multipleIndex, wheelIndex); } } } // namespace primesieve primesieve-5.6.0/src/primesieve/EratSmall.cpp000066400000000000000000000371661263266076300212510ustar00rootroot00000000000000/// /// @file EratSmall.cpp /// @brief Segmented sieve of Eratosthenes optimized for small /// sieving primes. /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include namespace primesieve { /// @param stop Upper bound for sieving. /// @param sieveSize Sieve size in bytes. /// @param limit Sieving primes in EratSmall must be <= limit. /// EratSmall::EratSmall(uint64_t stop, uint_t sieveSize, uint_t limit) : Modulo30Wheel_t(stop, sieveSize), limit_(limit) { if (limit > sieveSize * 3) throw primesieve_error("EratSmall: limit must be <= sieveSize * 3"); buckets_.push_back(Bucket()); } /// Add a new sieving prime to EratSmall void EratSmall::storeSievingPrime(uint_t prime, uint_t multipleIndex, uint_t wheelIndex) { assert(prime <= limit_); uint_t sievingPrime = prime / NUMBERS_PER_BYTE; if (!buckets_.back().store(sievingPrime, multipleIndex, wheelIndex)) buckets_.push_back(Bucket()); } /// Cross-off the multiples of small sieving /// primes from the sieve array. /// void EratSmall::crossOff(byte_t* sieve, byte_t* sieveLimit) { for (BucketIterator_t iter = buckets_.begin(); iter != buckets_.end(); ++iter) crossOff(sieve, sieveLimit, *iter); } /// Cross-off the multiples of the sieving primes within the current /// bucket. This is an implementation of the segmented sieve of /// Eratosthenes with wheel factorization optimized for small sieving /// primes that have many multiples per segment. This algorithm uses a /// hardcoded modulo 30 wheel that skips multiples of 2, 3 and 5. /// void EratSmall::crossOff(byte_t* sieve, byte_t* sieveLimit, Bucket& bucket) { SievingPrime* sPrime = bucket.begin(); SievingPrime* sEnd = bucket.end(); for (; sPrime != sEnd; sPrime++) { uint_t sievingPrime = sPrime->getSievingPrime(); uint_t multipleIndex = sPrime->getMultipleIndex(); uint_t wheelIndex = sPrime->getWheelIndex(); // pointer to the byte containing the first multiple // of sievingPrime within the current segment byte_t* p = &sieve[multipleIndex]; byte_t* loopLimit = sieveLimit - (sievingPrime * 28 + 27); if (loopLimit > sieveLimit) loopLimit = p; switch (wheelIndex) { for (;;) // i*30 + 7 { case 0: // each iteration removes the next 8 multiples // of the current sievingPrime for (; p < loopLimit; p += sievingPrime * 30 + 7) { p[sievingPrime * 0 + 0] &= BIT0; p[sievingPrime * 6 + 1] &= BIT4; p[sievingPrime * 10 + 2] &= BIT3; p[sievingPrime * 12 + 2] &= BIT7; p[sievingPrime * 16 + 3] &= BIT6; p[sievingPrime * 18 + 4] &= BIT2; p[sievingPrime * 22 + 5] &= BIT1; p[sievingPrime * 28 + 6] &= BIT5; } if (p >= sieveLimit) { sPrime->setWheelIndex(0); break; } *p &= BIT0; p += sievingPrime * 6 + 1; case 1: if (p >= sieveLimit) { sPrime->setWheelIndex(1); break; } *p &= BIT4; p += sievingPrime * 4 + 1; case 2: if (p >= sieveLimit) { sPrime->setWheelIndex(2); break; } *p &= BIT3; p += sievingPrime * 2 + 0; case 3: if (p >= sieveLimit) { sPrime->setWheelIndex(3); break; } *p &= BIT7; p += sievingPrime * 4 + 1; case 4: if (p >= sieveLimit) { sPrime->setWheelIndex(4); break; } *p &= BIT6; p += sievingPrime * 2 + 1; case 5: if (p >= sieveLimit) { sPrime->setWheelIndex(5); break; } *p &= BIT2; p += sievingPrime * 4 + 1; case 6: if (p >= sieveLimit) { sPrime->setWheelIndex(6); break; } *p &= BIT1; p += sievingPrime * 6 + 1; case 7: if (p >= sieveLimit) { sPrime->setWheelIndex(7); break; } *p &= BIT5; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 11 { case 8: for (; p < loopLimit; p += sievingPrime * 30 + 11) { p[sievingPrime * 0 + 0] &= BIT1; p[sievingPrime * 6 + 2] &= BIT3; p[sievingPrime * 10 + 3] &= BIT7; p[sievingPrime * 12 + 4] &= BIT5; p[sievingPrime * 16 + 6] &= BIT0; p[sievingPrime * 18 + 6] &= BIT6; p[sievingPrime * 22 + 8] &= BIT2; p[sievingPrime * 28 + 10] &= BIT4; } if (p >= sieveLimit) { sPrime->setWheelIndex(8); break; } *p &= BIT1; p += sievingPrime * 6 + 2; case 9: if (p >= sieveLimit) { sPrime->setWheelIndex(9); break; } *p &= BIT3; p += sievingPrime * 4 + 1; case 10: if (p >= sieveLimit) { sPrime->setWheelIndex(10); break; } *p &= BIT7; p += sievingPrime * 2 + 1; case 11: if (p >= sieveLimit) { sPrime->setWheelIndex(11); break; } *p &= BIT5; p += sievingPrime * 4 + 2; case 12: if (p >= sieveLimit) { sPrime->setWheelIndex(12); break; } *p &= BIT0; p += sievingPrime * 2 + 0; case 13: if (p >= sieveLimit) { sPrime->setWheelIndex(13); break; } *p &= BIT6; p += sievingPrime * 4 + 2; case 14: if (p >= sieveLimit) { sPrime->setWheelIndex(14); break; } *p &= BIT2; p += sievingPrime * 6 + 2; case 15: if (p >= sieveLimit) { sPrime->setWheelIndex(15); break; } *p &= BIT4; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 13 { case 16: for (; p < loopLimit; p += sievingPrime * 30 + 13) { p[sievingPrime * 0 + 0] &= BIT2; p[sievingPrime * 6 + 2] &= BIT7; p[sievingPrime * 10 + 4] &= BIT5; p[sievingPrime * 12 + 5] &= BIT4; p[sievingPrime * 16 + 7] &= BIT1; p[sievingPrime * 18 + 8] &= BIT0; p[sievingPrime * 22 + 9] &= BIT6; p[sievingPrime * 28 + 12] &= BIT3; } if (p >= sieveLimit) { sPrime->setWheelIndex(16); break; } *p &= BIT2; p += sievingPrime * 6 + 2; case 17: if (p >= sieveLimit) { sPrime->setWheelIndex(17); break; } *p &= BIT7; p += sievingPrime * 4 + 2; case 18: if (p >= sieveLimit) { sPrime->setWheelIndex(18); break; } *p &= BIT5; p += sievingPrime * 2 + 1; case 19: if (p >= sieveLimit) { sPrime->setWheelIndex(19); break; } *p &= BIT4; p += sievingPrime * 4 + 2; case 20: if (p >= sieveLimit) { sPrime->setWheelIndex(20); break; } *p &= BIT1; p += sievingPrime * 2 + 1; case 21: if (p >= sieveLimit) { sPrime->setWheelIndex(21); break; } *p &= BIT0; p += sievingPrime * 4 + 1; case 22: if (p >= sieveLimit) { sPrime->setWheelIndex(22); break; } *p &= BIT6; p += sievingPrime * 6 + 3; case 23: if (p >= sieveLimit) { sPrime->setWheelIndex(23); break; } *p &= BIT3; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 17 { case 24: for (; p < loopLimit; p += sievingPrime * 30 + 17) { p[sievingPrime * 0 + 0] &= BIT3; p[sievingPrime * 6 + 3] &= BIT6; p[sievingPrime * 10 + 6] &= BIT0; p[sievingPrime * 12 + 7] &= BIT1; p[sievingPrime * 16 + 9] &= BIT4; p[sievingPrime * 18 + 10] &= BIT5; p[sievingPrime * 22 + 12] &= BIT7; p[sievingPrime * 28 + 16] &= BIT2; } if (p >= sieveLimit) { sPrime->setWheelIndex(24); break; } *p &= BIT3; p += sievingPrime * 6 + 3; case 25: if (p >= sieveLimit) { sPrime->setWheelIndex(25); break; } *p &= BIT6; p += sievingPrime * 4 + 3; case 26: if (p >= sieveLimit) { sPrime->setWheelIndex(26); break; } *p &= BIT0; p += sievingPrime * 2 + 1; case 27: if (p >= sieveLimit) { sPrime->setWheelIndex(27); break; } *p &= BIT1; p += sievingPrime * 4 + 2; case 28: if (p >= sieveLimit) { sPrime->setWheelIndex(28); break; } *p &= BIT4; p += sievingPrime * 2 + 1; case 29: if (p >= sieveLimit) { sPrime->setWheelIndex(29); break; } *p &= BIT5; p += sievingPrime * 4 + 2; case 30: if (p >= sieveLimit) { sPrime->setWheelIndex(30); break; } *p &= BIT7; p += sievingPrime * 6 + 4; case 31: if (p >= sieveLimit) { sPrime->setWheelIndex(31); break; } *p &= BIT2; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 19 { case 32: for (; p < loopLimit; p += sievingPrime * 30 + 19) { p[sievingPrime * 0 + 0] &= BIT4; p[sievingPrime * 6 + 4] &= BIT2; p[sievingPrime * 10 + 6] &= BIT6; p[sievingPrime * 12 + 8] &= BIT0; p[sievingPrime * 16 + 10] &= BIT5; p[sievingPrime * 18 + 11] &= BIT7; p[sievingPrime * 22 + 14] &= BIT3; p[sievingPrime * 28 + 18] &= BIT1; } if (p >= sieveLimit) { sPrime->setWheelIndex(32); break; } *p &= BIT4; p += sievingPrime * 6 + 4; case 33: if (p >= sieveLimit) { sPrime->setWheelIndex(33); break; } *p &= BIT2; p += sievingPrime * 4 + 2; case 34: if (p >= sieveLimit) { sPrime->setWheelIndex(34); break; } *p &= BIT6; p += sievingPrime * 2 + 2; case 35: if (p >= sieveLimit) { sPrime->setWheelIndex(35); break; } *p &= BIT0; p += sievingPrime * 4 + 2; case 36: if (p >= sieveLimit) { sPrime->setWheelIndex(36); break; } *p &= BIT5; p += sievingPrime * 2 + 1; case 37: if (p >= sieveLimit) { sPrime->setWheelIndex(37); break; } *p &= BIT7; p += sievingPrime * 4 + 3; case 38: if (p >= sieveLimit) { sPrime->setWheelIndex(38); break; } *p &= BIT3; p += sievingPrime * 6 + 4; case 39: if (p >= sieveLimit) { sPrime->setWheelIndex(39); break; } *p &= BIT1; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 23 { case 40: for (; p < loopLimit; p += sievingPrime * 30 + 23) { p[sievingPrime * 0 + 0] &= BIT5; p[sievingPrime * 6 + 5] &= BIT1; p[sievingPrime * 10 + 8] &= BIT2; p[sievingPrime * 12 + 9] &= BIT6; p[sievingPrime * 16 + 12] &= BIT7; p[sievingPrime * 18 + 14] &= BIT3; p[sievingPrime * 22 + 17] &= BIT4; p[sievingPrime * 28 + 22] &= BIT0; } if (p >= sieveLimit) { sPrime->setWheelIndex(40); break; } *p &= BIT5; p += sievingPrime * 6 + 5; case 41: if (p >= sieveLimit) { sPrime->setWheelIndex(41); break; } *p &= BIT1; p += sievingPrime * 4 + 3; case 42: if (p >= sieveLimit) { sPrime->setWheelIndex(42); break; } *p &= BIT2; p += sievingPrime * 2 + 1; case 43: if (p >= sieveLimit) { sPrime->setWheelIndex(43); break; } *p &= BIT6; p += sievingPrime * 4 + 3; case 44: if (p >= sieveLimit) { sPrime->setWheelIndex(44); break; } *p &= BIT7; p += sievingPrime * 2 + 2; case 45: if (p >= sieveLimit) { sPrime->setWheelIndex(45); break; } *p &= BIT3; p += sievingPrime * 4 + 3; case 46: if (p >= sieveLimit) { sPrime->setWheelIndex(46); break; } *p &= BIT4; p += sievingPrime * 6 + 5; case 47: if (p >= sieveLimit) { sPrime->setWheelIndex(47); break; } *p &= BIT0; p += sievingPrime * 2 + 1; } break; for (;;) // i*30 + 29 { case 48: for (; p < loopLimit; p += sievingPrime * 30 + 29) { p[sievingPrime * 0 + 0] &= BIT6; p[sievingPrime * 6 + 6] &= BIT5; p[sievingPrime * 10 + 10] &= BIT4; p[sievingPrime * 12 + 12] &= BIT3; p[sievingPrime * 16 + 16] &= BIT2; p[sievingPrime * 18 + 18] &= BIT1; p[sievingPrime * 22 + 22] &= BIT0; p[sievingPrime * 28 + 27] &= BIT7; } if (p >= sieveLimit) { sPrime->setWheelIndex(48); break; } *p &= BIT6; p += sievingPrime * 6 + 6; case 49: if (p >= sieveLimit) { sPrime->setWheelIndex(49); break; } *p &= BIT5; p += sievingPrime * 4 + 4; case 50: if (p >= sieveLimit) { sPrime->setWheelIndex(50); break; } *p &= BIT4; p += sievingPrime * 2 + 2; case 51: if (p >= sieveLimit) { sPrime->setWheelIndex(51); break; } *p &= BIT3; p += sievingPrime * 4 + 4; case 52: if (p >= sieveLimit) { sPrime->setWheelIndex(52); break; } *p &= BIT2; p += sievingPrime * 2 + 2; case 53: if (p >= sieveLimit) { sPrime->setWheelIndex(53); break; } *p &= BIT1; p += sievingPrime * 4 + 4; case 54: if (p >= sieveLimit) { sPrime->setWheelIndex(54); break; } *p &= BIT0; p += sievingPrime * 6 + 5; case 55: if (p >= sieveLimit) { sPrime->setWheelIndex(55); break; } *p &= BIT7; p += sievingPrime * 2 + 2; } break; for (;;) // i*30 + 31 { case 56: for (; p < loopLimit; p += sievingPrime * 30 + 1) { p[sievingPrime * 0 + 0] &= BIT7; p[sievingPrime * 6 + 1] &= BIT0; p[sievingPrime * 10 + 1] &= BIT1; p[sievingPrime * 12 + 1] &= BIT2; p[sievingPrime * 16 + 1] &= BIT3; p[sievingPrime * 18 + 1] &= BIT4; p[sievingPrime * 22 + 1] &= BIT5; p[sievingPrime * 28 + 1] &= BIT6; } if (p >= sieveLimit) { sPrime->setWheelIndex(56); break; } *p &= BIT7; p += sievingPrime * 6 + 1; case 57: if (p >= sieveLimit) { sPrime->setWheelIndex(57); break; } *p &= BIT0; p += sievingPrime * 4 + 0; case 58: if (p >= sieveLimit) { sPrime->setWheelIndex(58); break; } *p &= BIT1; p += sievingPrime * 2 + 0; case 59: if (p >= sieveLimit) { sPrime->setWheelIndex(59); break; } *p &= BIT2; p += sievingPrime * 4 + 0; case 60: if (p >= sieveLimit) { sPrime->setWheelIndex(60); break; } *p &= BIT3; p += sievingPrime * 2 + 0; case 61: if (p >= sieveLimit) { sPrime->setWheelIndex(61); break; } *p &= BIT4; p += sievingPrime * 4 + 0; case 62: if (p >= sieveLimit) { sPrime->setWheelIndex(62); break; } *p &= BIT5; p += sievingPrime * 6 + 0; case 63: if (p >= sieveLimit) { sPrime->setWheelIndex(63); break; } *p &= BIT6; p += sievingPrime * 2 + 0; } break; } // set multipleIndex for the next segment sPrime->setMultipleIndex(static_cast(p - sieveLimit)); } } } // namespace primesieve primesieve-5.6.0/src/primesieve/ParallelPrimeSieve.cpp000066400000000000000000000151171263266076300231020ustar00rootroot00000000000000/// /// @file ParallelPrimeSieve.cpp /// @brief ParallelPrimeSieve sieves primes in parallel using /// OpenMP 2.0 (2002) or later. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #ifdef _OPENMP #include #include #endif namespace primesieve { ParallelPrimeSieve::ParallelPrimeSieve() : lock_(NULL), shm_(NULL), numThreads_(IDEAL_NUM_THREADS) { } void ParallelPrimeSieve::init(SharedMemory& shm) { setStart(shm.start); setStop(shm.stop); setSieveSize(shm.sieveSize); setFlags(shm.flags); setNumThreads(shm.threads); shm_ = &shm; } int ParallelPrimeSieve::getNumThreads() const { if (numThreads_ == IDEAL_NUM_THREADS) return idealNumThreads(); return numThreads_; } void ParallelPrimeSieve::setNumThreads(int threads) { numThreads_ = threads; if (numThreads_ != IDEAL_NUM_THREADS) numThreads_ = getInBetween(1, numThreads_, getMaxThreads()); } /// Get an ideal number of threads for the current /// set start_ and stop_ numbers. /// int ParallelPrimeSieve::idealNumThreads() const { if (start_ > stop_) return 1; uint64_t threshold = std::max(config::MIN_THREAD_INTERVAL, isqrt(stop_) / 5); uint64_t threads = getInterval() / threshold; threads = getInBetween(1, threads, getMaxThreads()); return static_cast(threads); } /// Get an interval size that ensures a good load balance /// when multiple threads are used. /// uint64_t ParallelPrimeSieve::getThreadInterval(int threads) const { assert(threads > 0); uint64_t unbalanced = getInterval() / threads; uint64_t balanced = isqrt(stop_) * 1000; uint64_t fastest = std::min(balanced, unbalanced); uint64_t threadInterval = getInBetween(config::MIN_THREAD_INTERVAL, fastest, config::MAX_THREAD_INTERVAL); uint64_t chunks = getInterval() / threadInterval; if (chunks < threads * 5u) threadInterval = std::max(config::MIN_THREAD_INTERVAL, unbalanced); threadInterval += 30 - threadInterval % 30; return threadInterval; } /// Align n to modulo 30 + 2 to prevent prime k-tuplet /// (twin primes, prime triplets, ...) gaps. /// uint64_t ParallelPrimeSieve::align(uint64_t n) const { if (n == start_) return start_; n = std::min(n + 32 - n % 30, stop_); return n; } bool ParallelPrimeSieve::tooMany(int threads) const { return (threads > 1 && getInterval() / threads < config::MIN_THREAD_INTERVAL); } #ifdef _OPENMP int ParallelPrimeSieve::getMaxThreads() { return omp_get_max_threads(); } double ParallelPrimeSieve::getWallTime() const { return omp_get_wtime(); } /// Sieve the primes and prime k-tuplets within [start_, stop_] /// in parallel using OpenMP multi-threading. /// void ParallelPrimeSieve::sieve() { reset(); if (start_ > stop_) return; OmpInitLock ompInit(&lock_); int threads = getNumThreads(); if (tooMany(threads)) threads = idealNumThreads(); if (threads == 1) PrimeSieve::sieve(); else { uint64_t threadInterval = getThreadInterval(threads); uint64_t count0 = 0, count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0; double t1 = getWallTime(); #if _OPENMP >= 200800 /* OpenMP >= 3.0 (2008) */ #pragma omp parallel for schedule(dynamic) num_threads(threads) \ reduction(+: count0, count1, count2, count3, count4, count5) for (uint64_t n = start_; n < stop_; n += threadInterval) { PrimeSieve ps(*this, omp_get_thread_num()); uint64_t threadStart = align(n); uint64_t threadStop = align(n + threadInterval); ps.sieve(threadStart, threadStop); count0 += ps.getCount(0); count1 += ps.getCount(1); count2 += ps.getCount(2); count3 += ps.getCount(3); count4 += ps.getCount(4); count5 += ps.getCount(5); } #else /* OpenMP 2.x */ int64_t iters = 1 + (getInterval() - 1) / threadInterval; #pragma omp parallel for schedule(dynamic) num_threads(threads) \ reduction(+: count0, count1, count2, count3, count4, count5) for (int64_t i = 0; i < iters; i++) { PrimeSieve ps(*this, omp_get_thread_num()); uint64_t n = start_ + i * threadInterval; uint64_t threadStart = align(n); uint64_t threadStop = align(n + threadInterval); ps.sieve(threadStart, threadStop); count0 += ps.getCount(0); count1 += ps.getCount(1); count2 += ps.getCount(2); count3 += ps.getCount(3); count4 += ps.getCount(4); count5 += ps.getCount(5); } #endif seconds_ = getWallTime() - t1; counts_[0] = count0; counts_[1] = count1; counts_[2] = count2; counts_[3] = count3; counts_[4] = count4; counts_[5] = count5; } // communicate the sieving results to the // primesieve GUI application if (shm_) { std::copy(counts_.begin(), counts_.end(), shm_->counts); shm_->seconds = seconds_; } } /// Calculate the sieving status. /// @param processed Sum of recently processed segments. /// bool ParallelPrimeSieve::updateStatus(uint64_t processed, bool waitForLock) { OmpLockGuard lock(getLock(), waitForLock); if (lock.isSet()) { PrimeSieve::updateStatus(processed, false); if (shm_) shm_->status = getStatus(); } return lock.isSet(); } /// Used to synchronize threads for prime number generation void ParallelPrimeSieve::setLock() { omp_lock_t* lock = getLock(); omp_set_lock(lock); } void ParallelPrimeSieve::unsetLock() { omp_lock_t* lock = getLock(); omp_unset_lock(lock); } #endif /* _OPENMP */ /// If OpenMP is disabled then ParallelPrimeSieve behaves like /// the single threaded PrimeSieve. /// #if !defined(_OPENMP) int ParallelPrimeSieve::getMaxThreads() { return 1; } void ParallelPrimeSieve::sieve() { PrimeSieve::sieve(); // communicate the sieving results to the // primesieve GUI application if (shm_) { std::copy(counts_.begin(), counts_.end(), shm_->counts); shm_->seconds = seconds_; } } double ParallelPrimeSieve::getWallTime() const { return PrimeSieve::getWallTime(); } bool ParallelPrimeSieve::updateStatus(uint64_t processed, bool waitForLock) { bool isUpdate = PrimeSieve::updateStatus(processed, waitForLock); if (shm_) shm_->status = getStatus(); return isUpdate; } void ParallelPrimeSieve::setLock() { } void ParallelPrimeSieve::unsetLock() { } #endif } // namespace primesieve primesieve-5.6.0/src/primesieve/PreSieve.cpp000066400000000000000000000046571263266076300211060ustar00rootroot00000000000000/// /// @file PreSieve.cpp /// @brief Pre-sieve multiples of small primes to speed up the /// sieve of Eratosthenes. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include using std::memcpy; using std::memset; namespace primesieve { const uint_t PreSieve::primes_[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 }; /// PreSieve multiples of small primes <= limit. /// @pre limit >= 11 && <= 23 /// PreSieve::PreSieve(int limit) : limit_(limit), preSieved_(NULL) { // limit_ <= 23 prevents 32-bit overflows if (limit_ < 11 || limit_ > 23) throw primesieve_error("PreSieve: limit must be >= 11 && <= 23"); init(); } PreSieve::~PreSieve() { delete[] preSieved_; } /// Cross-off the multiples of small primes <= limit_ /// in the preSieved_ array. /// void PreSieve::init() { primeProduct_ = 1; for (int i = 0; primes_[i] <= limit_; i++) primeProduct_ *= primes_[i]; size_ = primeProduct_ / NUMBERS_PER_BYTE; preSieved_ = new byte_t[size_]; memset(preSieved_, 0xff, size_); uint_t stop = primeProduct_ * 2; EratSmall eratSmall(stop, size_, limit_); for (int i = 3; primes_[i] <= limit_; i++) eratSmall.addSievingPrime(primes_[i], primeProduct_); // sieve [primeProduct_, primeProduct_ * 2] eratSmall.crossOff(preSieved_, &preSieved_[size_]); } /// Pre-sieve the multiples of small primes <= limit_ /// in the sieve array. /// void PreSieve::doIt(byte_t* sieve, uint_t sieveSize, uint64_t segmentLow) const { // map segmentLow to the preSieved_ array uint_t remainder = static_cast(segmentLow % primeProduct_); uint_t index = remainder / NUMBERS_PER_BYTE; uint_t sizeLeft = size_ - index; if (sieveSize <= sizeLeft) memcpy(sieve, &preSieved_[index], sieveSize); else { // copy the last remaining bytes at the end of preSieved_ // to the beginning of the sieve array memcpy(sieve, &preSieved_[index], sizeLeft); // restart copying at the beginning of preSieved_ for (index = sizeLeft; index + size_ < sieveSize; index += size_) memcpy(&sieve[index], preSieved_, size_); memcpy(&sieve[index], preSieved_, sieveSize - index); } } } // namespace primesieve primesieve-5.6.0/src/primesieve/PrimeFinder.cpp000066400000000000000000000137031263266076300215600ustar00rootroot00000000000000/// /// @file PrimeFinder.cpp /// @brief Callback, print and count primes and prime k-tuplets /// (twin primes, prime triplets, ...). /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace primesieve { /// forward declaration uint64_t popcount(const uint64_t* array, uint64_t size); const uint_t PrimeFinder::kBitmasks_[6][5] = { { END }, { 0x06, 0x18, 0xc0, END }, // Twin prime bitmasks, i.e. b00000110, b00011000, b11000000 { 0x07, 0x0e, 0x1c, 0x38, END }, // Prime triplet bitmasks, i.e. b00000111, b00001110, ... { 0x1e, END }, // Prime quadruplet bitmasks { 0x1f, 0x3e, END }, // Prime quintuplet bitmasks { 0x3f, END } // Prime sextuplet bitmasks }; PrimeFinder::PrimeFinder(PrimeSieve& ps) : SieveOfEratosthenes(std::max(7, ps.getStart()), ps.getStop(), ps.getSieveSize()), ps_(ps) { if (ps_.isFlag(ps_.COUNT_TWINS, ps_.COUNT_SEXTUPLETS)) init_kCounts(); } /// Calculate the number of twins, triplets, ... (bitmask matches) /// for each possible byte value 0 - 255. /// void PrimeFinder::init_kCounts() { for (uint_t i = 1; i < ps_.counts_.size(); i++) { if (ps_.isCount(i)) { kCounts_[i].resize(256); for (uint_t j = 0; j < kCounts_[i].size(); j++) { uint_t bitmaskCount = 0; for (const uint_t* b = kBitmasks_[i]; *b <= j; b++) { if ((j & *b) == *b) bitmaskCount++; } kCounts_[i][j] = bitmaskCount; } } } } /// Executed after each sieved segment. /// @see sieveSegment() in SieveOfEratosthenes.cpp /// void PrimeFinder::segmentFinished(const byte_t* sieve, uint_t sieveSize) { if (ps_.isCallback()) callbackPrimes(sieve, sieveSize); if (ps_.isCount()) count(sieve, sieveSize); if (ps_.isPrint()) print(sieve, sieveSize); if (ps_.isStatus()) ps_.updateStatus(sieveSize * NUMBERS_PER_BYTE, /* waitForLock = */ false); } /// Reconstruct prime numbers from 1 bits of the sieve array and /// call a callback function for each prime. /// template inline void PrimeFinder::callbackPrimes(T callback, const byte_t* sieve, uint_t sieveSize) const { uint64_t base = getSegmentLow(); for (uint_t i = 0; i < sieveSize; i += 8, base += NUMBERS_PER_BYTE * 8) { uint64_t bits = littleendian_cast(&sieve[i]); while (bits != 0) { uint64_t prime = getNextPrime(&bits, base); callback(prime); } } } template <> inline void PrimeFinder::callbackPrimes(Callback* cb, const byte_t* sieve, uint_t sieveSize) const { uint64_t base = getSegmentLow(); for (uint_t i = 0; i < sieveSize; i += 8, base += NUMBERS_PER_BYTE * 8) { uint64_t bits = littleendian_cast(&sieve[i]); while (bits != 0) { uint64_t prime = getNextPrime(&bits, base); cb->callback(prime); } } } /// Callback the primes within the current segment. /// @note primes < 7 are handled in PrimeSieve::doSmallPrime() /// void PrimeFinder::callbackPrimes(const byte_t* sieve, uint_t sieveSize) const { if (ps_.isFlag(ps_.CALLBACK_PRIMES_OBJ)) callbackPrimes(ps_.cb_, sieve, sieveSize); if (ps_.isFlag(ps_.CALLBACK_PRIMES)) callbackPrimes(ps_.callback_, sieve, sieveSize); if (ps_.isFlag(ps_.CALLBACK_PRIMES_C)) callbackPrimes(reinterpret_cast(ps_.callback_), sieve, sieveSize); } /// Count the primes and prime k-tuplets within /// the current segment. /// void PrimeFinder::count(const byte_t* sieve, uint_t sieveSize) { // count prime numbers (1 bits), see popcount.cpp if (ps_.isFlag(ps_.COUNT_PRIMES)) ps_.counts_[0] += popcount(reinterpret_cast(sieve), (sieveSize + 7) / 8); // count prime k-tuplets (i = 1 twins, i = 2 triplets, ...) for (uint_t i = 1; i < ps_.counts_.size(); i++) { if (ps_.isCount(i)) { uint_t sum0 = 0; uint_t sum1 = 0; uint_t sum2 = 0; uint_t sum3 = 0; for (uint_t j = 0; j < sieveSize; j += 4) { sum0 += kCounts_[i][sieve[j+0]]; sum1 += kCounts_[i][sieve[j+1]]; sum2 += kCounts_[i][sieve[j+2]]; sum3 += kCounts_[i][sieve[j+3]]; } ps_.counts_[i] += (sum0 + sum1) + (sum2 + sum3); } } } void PrimeFinder::printPrime(uint64_t prime) { std::cout << prime << '\n'; } /// Print primes and prime k-tuplets to cout. /// @note primes < 7 are handled in PrimeSieve::doSmallPrime() /// void PrimeFinder::print(const byte_t* sieve, uint_t sieveSize) const { if (ps_.isFlag(ps_.PRINT_PRIMES)) { LockGuard lock(ps_); callbackPrimes(printPrime, sieve, sieveSize); } // print prime k-tuplets if (ps_.isFlag(ps_.PRINT_TWINS, ps_.PRINT_SEXTUPLETS)) { uint_t i = 1; // i = 1 twins, i = 2 triplets, ... uint64_t base = getSegmentLow(); for (; !ps_.isPrint(i); i++); for (uint_t j = 0; j < sieveSize; j++, base += NUMBERS_PER_BYTE) { for (const uint_t* bitmask = kBitmasks_[i]; *bitmask <= sieve[j]; bitmask++) { if ((sieve[j] & *bitmask) == *bitmask) { std::ostringstream kTuplet; kTuplet << "("; uint64_t bits = *bitmask; while (bits != 0) { kTuplet << getNextPrime(&bits, base); kTuplet << ((bits != 0) ? ", " : ")\n"); } std::cout << kTuplet.str(); } } } } } } // namespace primesieve primesieve-5.6.0/src/primesieve/PrimeGenerator.cpp000066400000000000000000000041141263266076300222730ustar00rootroot00000000000000/// /// @file PrimeGenerator.cpp /// Generates the sieving primes up to sqrt(stop) and adds /// them to PrimeFinder. /// /// Copyright (C) 2014 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include namespace primesieve { PrimeGenerator::PrimeGenerator(PrimeFinder& finder) : SieveOfEratosthenes(finder.getPreSieve() + 1, finder.getSqrtStop(), config::PRIMEGENERATOR_SIEVESIZE), finder_(finder) { } /// Generate the primes up to finder.stop_^0.25 using /// the sieve of Eratosthenes. /// void PrimeGenerator::generateTinyPrimes() { uint_t P = getPreSieve() + 1; uint_t N = getSqrtStop(); std::vector isPrime(N + 1, true); for (uint_t i = 3; i * i <= N; i += 2) if (isPrime[i]) for (uint_t j = i * i; j <= N; j += i * 2) isPrime[j] = false; assert(P > 5); for (uint_t i = P + (~P & 1); i <= N; i += 2) if (isPrime[i]) addSievingPrime(i); } void PrimeGenerator::doIt() { generateTinyPrimes(); // calls segmentFinished() after each sieved segment sieve(); } void PrimeGenerator::segmentFinished(const byte_t* sieve, uint_t sieveSize) { generateSievingPrimes(sieve, sieveSize); } /// Reconstruct primes from 1 bits of the sieve array /// and use them for sieving in finder_. /// void PrimeGenerator::generateSievingPrimes(const byte_t* sieve, uint_t sieveSize) { uint64_t base = getSegmentLow(); for (uint_t i = 0; i < sieveSize; i += 8) { uint64_t bits = littleendian_cast(&sieve[i]); while (bits != 0) { uint_t prime = static_cast(getNextPrime(&bits, base)); finder_.addSievingPrime(prime); } base += NUMBERS_PER_BYTE * 8; } } } // namespace primesieve primesieve-5.6.0/src/primesieve/PrimeSieve-nthPrime.cpp000066400000000000000000000106521263266076300232100ustar00rootroot00000000000000/// /// @file PrimeSieve-nthPrime.cpp /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include using namespace std; using namespace primesieve; namespace { void checkLimit(uint64_t start, uint64_t dist) { if (dist > get_max_stop() - start) throw primesieve_error("nth prime is too large > 2^64 - 2^32 * 11"); } void checkLowerLimit(uint64_t stop) { if (stop == 0) throw primesieve_error("nth prime < 2 is impossible, negative n is too small"); } void checkLowerLimit(uint64_t start, double dist) { double s = static_cast(start); s = max(1E4, s); if (s / dist < 0.9) throw primesieve_error("nth prime < 2 is impossible, negative n is too small"); } int64_t pix(int64_t n) { double x = static_cast(n); double logx = log(max(4.0, x)); double pix = x / logx; return static_cast(pix); } bool sieveBackwards(int64_t n, int64_t count, uint64_t stop) { return (count >= n) && !(count == n && stop < 2); } uint64_t nthPrimeDistance(int64_t n, int64_t count, uint64_t start, bool bruteForce = false) { double x = static_cast(n - count); double s = static_cast(start); x = abs(x); x = max(4.0, x); s = max(4.0, s); double logx = log(x); double loglogx = log(logx); double pix = x * (logx + loglogx - 1); // Correct start if sieving backwards if (count >= n) s -= pix; // Approximate the nth prime using // start + n * log(start + pi(n) / log log n)) double logStartPix = log(max(4.0, s + pix / loglogx)); double dist = max(pix, x * logStartPix); double maxPrimeGap = logStartPix * logStartPix; double safetyFactor = (count >= n || bruteForce) ? 2 : -2; // Make sure start + dist <= nth prime dist += sqrt(dist) * log(logStartPix) * safetyFactor; dist = max(dist, maxPrimeGap); if (count >= n) checkLowerLimit(start, dist); return static_cast(dist); } /// This class is used to generate n primes and /// then stop by throwing an exception. /// class NthPrime : public Callback { public: NthPrime() : n_(0), nthPrime_(0) { } void findNthPrime(uint64_t, uint64_t, uint64_t); void callback(uint64_t); uint64_t getNthPrime() const; private: uint64_t n_; uint64_t nthPrime_; }; void NthPrime::findNthPrime(uint64_t n, uint64_t start, uint64_t stop) { n_ = n; PrimeSieve ps; try { ps.callbackPrimes(start, stop, this); ps.callbackPrimes(stop + 1, get_max_stop(), this); throw primesieve_error("nth prime is too large > 2^64 - 2^32 * 11"); } catch (cancel_callback&) { } } uint64_t NthPrime::getNthPrime() const { return nthPrime_; } void NthPrime::callback(uint64_t prime) { if (--n_ == 0) { nthPrime_ = prime; throw cancel_callback(); } } } // namespace namespace primesieve { uint64_t PrimeSieve::nthPrime(uint64_t n) { return nthPrime(0, n); } uint64_t PrimeSieve::nthPrime(int64_t n, uint64_t start) { setStart(start); double t1 = getWallTime(); if (n != 0) // Find nth prime > start (or < start) start += (n > 0) ? 1 : ((start > 0) ? -1 : 0); else // Mathematica convention n = 1; uint64_t stop = start; uint64_t dist = nthPrimeDistance(n, 0, start); uint64_t nthPrimeGuess = start + dist; int64_t pixSqrtNthPrime = pix(isqrt(nthPrimeGuess)); int64_t bruteForceMin = 10000; int64_t bruteForceThreshold = max(bruteForceMin, pixSqrtNthPrime); int64_t count = 0; while (sieveBackwards(n, count, stop) || (n - count) > bruteForceThreshold) { if (count < n) { dist = nthPrimeDistance(n, count, start); checkLimit(start, dist); stop = start + dist; count += countPrimes(start, stop); start = stop + 1; } if (sieveBackwards(n, count, stop)) { checkLowerLimit(stop); dist = nthPrimeDistance(n, count, stop); start = (start > dist) ? start - dist : 1; count -= countPrimes(start, stop); stop = start - 1; } } if (n < 0) count--; dist = nthPrimeDistance(n, count, start, true) * 2; checkLimit(start, dist); stop = start + dist; NthPrime np; np.findNthPrime(n - count, start, stop); seconds_ = getWallTime() - t1; return np.getNthPrime(); } } // namespace primesieve primesieve-5.6.0/src/primesieve/PrimeSieve.cpp000066400000000000000000000245761263266076300214360ustar00rootroot00000000000000/// /// @file PrimeSieve.cpp /// @brief The PrimeSieve class provides an easy API for prime /// sieving (single-threaded). /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace primesieve { const PrimeSieve::SmallPrime PrimeSieve::smallPrimes_[8] = { { 2, 2, 0, "2" }, { 3, 3, 0, "3" }, { 5, 5, 0, "5" }, { 3, 5, 1, "(3, 5)" }, { 5, 7, 1, "(5, 7)" }, { 5, 11, 2, "(5, 7, 11)" }, { 5, 13, 3, "(5, 7, 11, 13)" }, { 5, 17, 4, "(5, 7, 11, 13, 17)" } }; PrimeSieve::PrimeSieve() : start_(0), stop_(0), counts_(6), flags_(COUNT_PRIMES), threadNum_(0), parent_(NULL) { setSieveSize(config::PRIMESIEVE_SIEVESIZE); reset(); } /// ParallelPrimeSieve creates one PrimeSieve /// child object for each thread. /// PrimeSieve::PrimeSieve(PrimeSieve& parent, int threadNum) : counts_(6), sieveSize_(parent.sieveSize_), flags_(parent.flags_), threadNum_(threadNum), parent_(&parent), callback_(parent.callback_), cb_(parent.cb_) { } PrimeSieve::~PrimeSieve() { } uint64_t PrimeSieve::getStart() const { return start_; } uint64_t PrimeSieve::getStop() const { return stop_; } uint64_t PrimeSieve::getInterval() const { return stop_ - start_; } uint64_t PrimeSieve::getPrimeCount() const { return counts_[0]; } uint64_t PrimeSieve::getTwinCount() const { return counts_[1]; } uint64_t PrimeSieve::getTripletCount() const { return counts_[2]; } uint64_t PrimeSieve::getQuadrupletCount() const { return counts_[3]; } uint64_t PrimeSieve::getQuintupletCount() const { return counts_[4]; } uint64_t PrimeSieve::getSextupletCount() const { return counts_[5]; } uint64_t PrimeSieve::getCount(int index) const { return counts_.at(index); } double PrimeSieve::getStatus() const { return percent_; } double PrimeSieve::getSeconds() const { return seconds_; } int PrimeSieve::getSieveSize() const { return sieveSize_; } int PrimeSieve::getFlags() const { return (flags_ & ((1 << 20) - 1)); } bool PrimeSieve::isValidFlags(int flags) const { return (flags >= 0 && flags < (1 << 20)); } bool PrimeSieve::isFlag(int flag) const { return (flags_ & flag) == flag; } bool PrimeSieve::isFlag(int first, int last) const { return (flags_ & (last * 2 - first)) != 0; } bool PrimeSieve::isCount(int index) const { return isFlag(COUNT_PRIMES << index); } bool PrimeSieve::isPrint(int index) const { return isFlag(PRINT_PRIMES << index); } bool PrimeSieve::isCallback() const { return isFlag(CALLBACK_PRIMES, CALLBACK_PRIMES_C); } bool PrimeSieve::isCount() const { return isFlag(COUNT_PRIMES, COUNT_SEXTUPLETS); } bool PrimeSieve::isPrint() const { return isFlag(PRINT_PRIMES, PRINT_SEXTUPLETS); } bool PrimeSieve::isStatus() const { return isFlag(PRINT_STATUS, CALCULATE_STATUS); } bool PrimeSieve::isParallelPrimeSieveChild() const { return parent_ != NULL; } /// Set a start number (lower bound) for sieving. /// @pre start <= 2^64 - 2^32 * 10 /// void PrimeSieve::setStart(uint64_t start) { uint64_t maxStop = PrimeFinder::getMaxStop(); if (start > maxStop) throw primesieve_error("start must be <= " + PrimeFinder::getMaxStopString()); start_ = start; } /// Set a stop number (upper bound) for sieving. /// @pre stop <= 2^64 - 2^32 * 10 /// void PrimeSieve::setStop(uint64_t stop) { uint64_t maxStop = PrimeFinder::getMaxStop(); if (stop > maxStop) throw primesieve_error("stop must be <= " + PrimeFinder::getMaxStopString()); stop_ = stop; } /// Set the size of the sieve of Eratosthenes array in kilobytes /// (default = 32). The best sieving performance is achieved with a /// sieve size of the CPU's L1 data cache size per core. /// @pre sieveSize >= 1 && <= 2048 /// void PrimeSieve::setSieveSize(int sieveSize) { sieveSize_ = getInBetween(1, floorPowerOf2(sieveSize), 2048); } void PrimeSieve::setFlags(int flags) { if (isValidFlags(flags)) flags_ = flags; } void PrimeSieve::addFlags(int flags) { if (isValidFlags(flags)) flags_ |= flags; } void PrimeSieve::reset() { std::fill(counts_.begin(), counts_.end(), 0); seconds_ = 0.0; toUpdate_ = 0; processed_ = 0; percent_ = -1.0; } double PrimeSieve::getWallTime() const { return static_cast(std::clock()) / CLOCKS_PER_SEC; } void PrimeSieve::setLock() { if (isParallelPrimeSieveChild()) parent_->setLock(); } void PrimeSieve::unsetLock() { if (isParallelPrimeSieveChild()) parent_->unsetLock(); } /// Calculate the sieving status. /// @param processed Sum of recently processed segments. /// bool PrimeSieve::updateStatus(uint64_t processed, bool waitForLock) { if (isParallelPrimeSieveChild()) { toUpdate_ += processed; if (parent_->updateStatus(toUpdate_, waitForLock)) toUpdate_ = 0; } else { processed_ += processed; double percent = processed_ * 100.0 / (getInterval() + 1); double old = percent_; percent_ = std::min(percent, 100.0); if (isFlag(PRINT_STATUS)) printStatus(old, percent_); } return true; } void PrimeSieve::printStatus(double old, double current) { int percent = static_cast(current); if (percent > static_cast(old)) { std::cout << '\r' << percent << '%' << std::flush; if (percent == 100) std::cout << std::endl; } } void PrimeSieve::doSmallPrime(const SmallPrime& sp) { if (sp.firstPrime >= start_ && sp.lastPrime <= stop_) { // callback prime numbers if (sp.index == 0) { if (isFlag(CALLBACK_PRIMES_OBJ)) cb_->callback(sp.firstPrime); if (isFlag(CALLBACK_PRIMES)) callback_(sp.firstPrime); if (isFlag(CALLBACK_PRIMES_C)) reinterpret_cast(callback_)(sp.firstPrime); } if (isCount(sp.index)) counts_[sp.index]++; if (isPrint(sp.index)) std::cout << sp.str << '\n'; } } /// Sieve the primes and prime k-tuplets (twin primes, prime /// triplets, ...) within the interval [start, stop]. /// void PrimeSieve::sieve() { reset(); if (start_ > stop_) return; double t1 = getWallTime(); if (isStatus()) updateStatus(INIT_STATUS, false); // Small primes and k-tuplets (first prime <= 5) // are checked manually if (start_ <= 5) { LockGuard lock(*this); for (int i = 0; i < 8; i++) doSmallPrime(smallPrimes_[i]); } if (stop_ >= 7) { PrimeFinder finder(*this); // First generate the sieving primes up to // sqrt(stop) and add them to finder if (finder.getSqrtStop() > finder.getPreSieve()) { PrimeGenerator generator(finder); generator.doIt(); } // sieve the primes within [start, stop] finder.sieve(); } seconds_ = getWallTime() - t1; if (isStatus()) updateStatus(FINISH_STATUS, true); } void PrimeSieve::sieve(uint64_t start, uint64_t stop) { setStart(start); setStop(stop); sieve(); } void PrimeSieve::sieve(uint64_t start, uint64_t stop, int flags) { setStart(start); setStop(stop); setFlags(flags); sieve(); } /// Generate the primes within the interval [start, stop] and call /// a callback function for each prime. /// void PrimeSieve::callbackPrimes(uint64_t start, uint64_t stop, void (*callback)(uint64_t)) { if (!callback) throw primesieve_error("callback is NULL"); callback_ = callback; flags_ = CALLBACK_PRIMES; sieve(start, stop); } /// Generate the primes within the interval [start, stop] and call /// the callback method of the cb object. /// void PrimeSieve::callbackPrimes(uint64_t start, uint64_t stop, Callback* cb) { if (!cb) throw primesieve_error("Callback pointer is NULL"); cb_ = cb; flags_ = CALLBACK_PRIMES_OBJ; sieve(start, stop); } /// Generate the primes within the interval [start, stop] and call a /// callback function with extern "C" linkage for each prime. /// void PrimeSieve::callbackPrimes_c(uint64_t start, uint64_t stop, void (*callback)(uint64_t)) { if (!callback) throw primesieve_error("callback is NULL"); callback_ = callback; flags_ = CALLBACK_PRIMES_C; sieve(start, stop); } // Print member functions void PrimeSieve::printPrimes(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_PRIMES); } void PrimeSieve::printTwins(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_TWINS); } void PrimeSieve::printTriplets(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_TRIPLETS); } void PrimeSieve::printQuadruplets(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_QUADRUPLETS); } void PrimeSieve::printQuintuplets(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_QUINTUPLETS); } void PrimeSieve::printSextuplets(uint64_t start, uint64_t stop) { sieve(start, stop, PRINT_SEXTUPLETS); } // Count member functions uint64_t PrimeSieve::countPrimes(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_PRIMES); return getPrimeCount(); } uint64_t PrimeSieve::countTwins(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_TWINS); return getTwinCount(); } uint64_t PrimeSieve::countTriplets(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_TRIPLETS); return getTripletCount(); } uint64_t PrimeSieve::countQuadruplets(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_QUADRUPLETS); return getQuadrupletCount(); } uint64_t PrimeSieve::countQuintuplets(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_QUINTUPLETS); return getQuintupletCount(); } uint64_t PrimeSieve::countSextuplets(uint64_t start, uint64_t stop) { sieve(start, stop, COUNT_SEXTUPLETS); return getSextupletCount(); } } // namespace primesieve primesieve-5.6.0/src/primesieve/README000066400000000000000000000136411263266076300175310ustar00rootroot00000000000000About ===== This directory (src/primesieve) contains primesieve's sieve of Eratosthenes implementation. Most files that start with a capital letter contain a class of the same name. The header files of these classes are stored in include/primesive. Below is a short explanation of the most important classes and files. C++ classes ----------- * PrimeSieve PrimeSieve objects provide an easy API for prime sieving, PrimeSieve::sieve(start, stop) sieves the primes within the interval [start, stop]. The classes below are all used directly or indirectly for sieving. * ParallelPrimeSieve (derived from PrimeSieve) ParallelPrimeSieve provides an easy API for multi-threaded prime sieving using OpenMP, it scales well even with 100 CPU cores! In ParallelPrimeSieve each OpenMP thread sieves primes using a thread private PrimeSieve object. * SieveOfEratosthenes (abstract class) Implementation of the segmented sieve of Eratosthenes using a bit array with 30 numbers per byte, each byte of the sieve array holds the 8 offsets k = { 7, 11, 13, 17, 19, 23, 29, 31 }. Its main methods are addSievingPrime(uint_t) which must be called consecutively for all primes <= sqrt(n) in order to sieve the primes up to n and sieve(). SieveOfEratosthenes uses the EratSmall, EratMedium and EratBig classes to cross-off multiples. * PrimeFinder (derived from SieveOfEratosthenes) Main SieveOfEratosthenes class: PrimeFinder is used to callback, print and count the primes and prime k-tuplets within the interval [start_, stop_] of the associated PrimeSieve object. * PrimeGenerator (derived from SieveOfEratosthenes) Generates the primes up to sqrt(n) needed for sieving by the PrimeFinder class. * PreSieve PreSieve objects are used to pre-sieve multiples of small primes e.g. <= 19 to speed up the sieve of Eratosthenes. * WheelFactorization (abstract class) Wheel factorization is used to skip multiples of small primes e.g. <= 7 to speed up the sieve of Eratosthenes. The abstract WheelFactorization class is used to initialize sieving primes i.e. addSievingPrime() calculates the first multiple >= start of each sieving prime and the position within the SieveOfEratosthenes array of that multiple (multipleIndex). The unsetBit() method is used to cross-off a multiple (unset a bit) and to calculate the sieving prime's next multiple. * EratSmall (derived from WheelFactorization) Segmented sieve of Eratosthenes algorithm with a hard-coded modulo 30 wheel that skips multiples of 2, 3 and 5. This algorithm is optimized for small sieving primes that have many multiples in each segment. EratSmall is a further optimized implementation of Achim Flammenkamp's algorithm.[9] * EratMedium (derived from WheelFactorization) Segmented sieve of Eratosthenes algorithm with a fixed modulo 210 wheel that skips multiples of 2, 3, 5 and 7. The wheel is implemented using a precomputed lookup table (wheel210 array from WheelFactorization.cpp). This algorithm is optimized for medium sieving primes with a few multiples per segment. * EratBig (derived from WheelFactorization) Segmented sieve of Eratosthenes algorithm with Tomás Oliveira's improvement for big sieving primes [11] and a fixed modulo 210 wheel that skips multiples of 2, 3, 5 and 7. The wheel is implemented using a precomputed lookup table (wheel210 array from WheelFactorization.cpp). EratBig is optimized for big sieving primes that have less than one multiple per segment. * iterator The iterator class has been introduced in primesieve-5.0 and allows to easily iterate over primes. It provides next_prime() and previous_prime() methods. Other files ----------- * include/primesieve.hpp This header contains primesieve's new API first released in primesieve-5.0. It is mostly a wrapper around the methods of the PrimeSieve and ParallelPrimeSieve classes. * primesieve-api.cpp This file contains the implementations of the functions declared in include/primesieve.hpp. * include/primesieve/config.hpp Contains compile time constants that set the size of various arrays and limits within primesieve. You can set these constants according to your CPU type to get the best performance. References ========== [1] Richard C. Singleton, "An efficient prime number generator", Communications of the ACM 12, 563-564, 1969. [2] R. P. Brent, "The first occurrence of large gaps between successive primes", Mathematics of Computation, 27:959-963, 1973. [3] C. Bays and R. Hudson, "The segmented sieve of Eratosthenes and primes in arithmetic progressions to 10^12", BIT 17:121 127, 1977. [4] Paul Pritchard, "Fast compact prime number sieves (among others)", Journal of Algorithms 4 (1983), 332-344. [5] J. Sorenson, "An Introduction To Prime Number Sieves", Computer Science Technical Report Vol. 909, January 1990. http://research.cs.wisc.edu/techreports/1990/TR909.pdf [6] J. Sorenson, "An analysis of two prime number sieves", Computer Science Technical Report Vol. 1028, June 1991. http://research.cs.wisc.edu/techreports/1991/TR1028.pdf [7] J. Sorenson and I. Parberry, "Two Fast Parallel Prime Number Sieves", Information and Computation, Vol. 114, No. 1, 1994. http://larc.unt.edu/ian/pubs/sieve.pdf [8] J. Sorenson, "Trading Time for Space in Prime Number Sieves", Lecture Notes in Computer Science, Vol. 1423 (1998), 179-194. [9] Achim Flammenkamp, "The Art of Prime Sieving", 1998. http://wwwhomes.uni-bielefeld.de/achim/prime_sieve.html [10] Jörg Richstein, "Segmentierung und Optimierung von Algorithmen zu Problemen aus der Zahlentheorie", Gießen, Univ., Diss., 1999. [11] Tomás Oliveira e Silva, "Fast implementation of the segmented sieve of Eratosthenes", 2002. http://www.ieeta.pt/~tos/software/prime_sieve.html [12] A. Járai and E. Vatai, "Cache optimized linear sieve", Acta Univ. Sapientiae, Informatica, 3, 2 (2011) 205-223. http://www.acta.sapientia.ro/acta-info/C3-2/info32-5.pdf primesieve-5.6.0/src/primesieve/SieveOfEratosthenes.cpp000066400000000000000000000127131263266076300233010ustar00rootroot00000000000000/// /// @file SieveOfEratosthenes.cpp /// @brief Implementation of the segmented sieve of Eratosthenes. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #include #include #include namespace primesieve { const uint_t SieveOfEratosthenes::bitValues_[8] = { 7, 11, 13, 17, 19, 23, 29, 31 }; /// De Bruijn bitscan table const uint_t SieveOfEratosthenes::bruijnBitValues_[64] = { 7, 47, 11, 49, 67, 113, 13, 53, 89, 71, 161, 101, 119, 187, 17, 233, 59, 79, 91, 73, 133, 139, 163, 103, 149, 121, 203, 169, 191, 217, 19, 239, 43, 61, 109, 83, 157, 97, 181, 229, 77, 131, 137, 143, 199, 167, 211, 41, 107, 151, 179, 227, 127, 197, 209, 37, 173, 223, 193, 31, 221, 29, 23, 241 }; /// @param start Sieve primes >= start. /// @param stop Sieve primes <= stop. /// @param sieveSize A sieve size in kilobytes. /// @pre start >= 7 /// @pre stop <= 2^64 - 2^32 * 10 /// @pre sieveSize >= 1 && <= 2048 /// SieveOfEratosthenes::SieveOfEratosthenes(uint64_t start, uint64_t stop, uint_t sieveSize) : start_(start), stop_(stop), sieve_(NULL), preSieve_(NULL), eratSmall_(NULL), eratMedium_(NULL), eratBig_(NULL) { if (start_ < 7) throw primesieve_error("SieveOfEratosthenes: start must be >= 7"); if (start_ > stop_) throw primesieve_error("SieveOfEratosthenes: start must be <= stop"); // choose fastest pre-sieve setting limitPreSieve_ = 11; if ((stop_ - start_) >= (7 * 11 * 13) * NUMBERS_PER_BYTE) limitPreSieve_ = 13; if ((stop_ - start_) >= config::PRESIEVE_THRESHOLD) limitPreSieve_ = config::PRESIEVE; sqrtStop_ = static_cast(isqrt(stop_)); // sieveSize_ must be a power of 2 sieveSize_ = getInBetween(1u, floorPowerOf2(sieveSize), 2048u); sieveSize_ *= 1024; // convert to bytes segmentLow_ = start_ - getByteRemainder(start_); segmentHigh_ = segmentLow_ + sieveSize_ * NUMBERS_PER_BYTE + 1; // allocate sieve of Eratosthenes array sieve_ = new byte_t[sieveSize_]; init(); } SieveOfEratosthenes::~SieveOfEratosthenes() { cleanUp(); } void SieveOfEratosthenes::cleanUp() { delete[] sieve_; delete preSieve_; delete eratSmall_; delete eratMedium_; delete eratBig_; } void SieveOfEratosthenes::init() { limitEratSmall_ = static_cast(sieveSize_ * config::FACTOR_ERATSMALL); limitEratMedium_ = static_cast(sieveSize_ * config::FACTOR_ERATMEDIUM); try { preSieve_ = new PreSieve(limitPreSieve_); if (sqrtStop_ > limitPreSieve_) eratSmall_ = new EratSmall (stop_, sieveSize_, limitEratSmall_); if (sqrtStop_ > limitEratSmall_) eratMedium_ = new EratMedium(stop_, sieveSize_, limitEratMedium_); if (sqrtStop_ > limitEratMedium_) eratBig_ = new EratBig (stop_, sieveSize_, sqrtStop_); } catch (const std::exception&) { cleanUp(); throw; } } uint_t SieveOfEratosthenes::getSqrtStop() const { return sqrtStop_; } uint_t SieveOfEratosthenes::getPreSieve() const { return limitPreSieve_; } std::string SieveOfEratosthenes::getMaxStopString() { return EratBig::getMaxStopString(); } uint64_t SieveOfEratosthenes::getMaxStop() { return EratBig::getMaxStop(); } uint64_t SieveOfEratosthenes::getByteRemainder(uint64_t n) { uint64_t r = n % NUMBERS_PER_BYTE; if (r <= 1) r += NUMBERS_PER_BYTE; return r; } void SieveOfEratosthenes::sieveSegment() { preSieve(); crossOffMultiples(); segmentFinished(sieve_, sieveSize_); } void SieveOfEratosthenes::crossOffMultiples() { if (eratSmall_) eratSmall_->crossOff(sieve_, &sieve_[sieveSize_]); if (eratMedium_) eratMedium_->crossOff(sieve_, sieveSize_); if (eratBig_) eratBig_->crossOff(sieve_); } /// Pre-sieve multiples of small primes e.g. <= 19 /// to speed up the sieve of Eratosthenes. /// void SieveOfEratosthenes::preSieve() { preSieve_->doIt(sieve_, sieveSize_, segmentLow_); // unset bits (numbers) < start_ if (segmentLow_ <= start_) { if (start_ <= limitPreSieve_) sieve_[0] = 0xff; for (int i = 0; bitValues_[i] < getByteRemainder(start_); i++) sieve_[0] &= 0xfe << i; } } /// Sieve the remaining segments after that addSievingPrime(uint_t) /// has been called for all primes up to sqrt(stop). /// void SieveOfEratosthenes::sieve() { while (segmentHigh_ < stop_) { sieveSegment(); segmentLow_ += sieveSize_ * NUMBERS_PER_BYTE; segmentHigh_ += sieveSize_ * NUMBERS_PER_BYTE; } // sieve the last segment uint64_t remainder = getByteRemainder(stop_); sieveSize_ = static_cast((stop_ - remainder) - segmentLow_) / NUMBERS_PER_BYTE + 1; segmentHigh_ = segmentLow_ + sieveSize_ * NUMBERS_PER_BYTE + 1; preSieve(); crossOffMultiples(); int i; // unset bits (numbers) > stop_ for (i = 0; i < 8; i++) if (bitValues_[i] > remainder) break; int unsetBits = ~(0xff << i); sieve_[sieveSize_ - 1] &= unsetBits; for (uint_t j = sieveSize_; j % 8 != 0; j++) sieve_[j] = 0; segmentFinished(sieve_, sieveSize_); } } // namespace primesieve primesieve-5.6.0/src/primesieve/WheelFactorization.cpp000066400000000000000000000267361263266076300231670ustar00rootroot00000000000000/// /// @file WheelFactorization.cpp /// @brief Precomputed arrays for wheel factorization. /// /// Copyright (C) 2013 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include namespace primesieve { const WheelInit wheel30Init[30] = { {1, 0}, {0, 0}, {5, 1}, {4, 1}, {3, 1}, {2, 1}, {1, 1}, {0, 1}, {3, 2}, {2, 2}, {1, 2}, {0, 2}, {1, 3}, {0, 3}, {3, 4}, {2, 4}, {1, 4}, {0, 4}, {1, 5}, {0, 5}, {3, 6}, {2, 6}, {1, 6}, {0, 6}, {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7}, {0, 7} }; const WheelInit wheel210Init[210] = { {1, 0}, {0, 0}, {9, 1}, {8, 1}, {7, 1}, {6, 1}, {5, 1}, {4, 1}, {3, 1}, {2, 1}, {1, 1}, {0, 1}, {1, 2}, {0, 2}, {3, 3}, {2, 3}, {1, 3}, {0, 3}, {1, 4}, {0, 4}, {3, 5}, {2, 5}, {1, 5}, {0, 5}, {5, 6}, {4, 6}, {3, 6}, {2, 6}, {1, 6}, {0, 6}, {1, 7}, {0, 7}, {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8}, {0, 8}, {3, 9}, {2, 9}, {1, 9}, {0, 9}, {1, 10}, {0, 10}, {3, 11}, {2, 11}, {1, 11}, {0, 11}, {5, 12}, {4, 12}, {3, 12}, {2, 12}, {1, 12}, {0, 12}, {5, 13}, {4, 13}, {3, 13}, {2, 13}, {1, 13}, {0, 13}, {1, 14}, {0, 14}, {5, 15}, {4, 15}, {3, 15}, {2, 15}, {1, 15}, {0, 15}, {3, 16}, {2, 16}, {1, 16}, {0, 16}, {1, 17}, {0, 17}, {5, 18}, {4, 18}, {3, 18}, {2, 18}, {1, 18}, {0, 18}, {3, 19}, {2, 19}, {1, 19}, {0, 19}, {5, 20}, {4, 20}, {3, 20}, {2, 20}, {1, 20}, {0, 20}, {7, 21}, {6, 21}, {5, 21}, {4, 21}, {3, 21}, {2, 21}, {1, 21}, {0, 21}, {3, 22}, {2, 22}, {1, 22}, {0, 22}, {1, 23}, {0, 23}, {3, 24}, {2, 24}, {1, 24}, {0, 24}, {1, 25}, {0, 25}, {3, 26}, {2, 26}, {1, 26}, {0, 26}, {7, 27}, {6, 27}, {5, 27}, {4, 27}, {3, 27}, {2, 27}, {1, 27}, {0, 27}, {5, 28}, {4, 28}, {3, 28}, {2, 28}, {1, 28}, {0, 28}, {3, 29}, {2, 29}, {1, 29}, {0, 29}, {5, 30}, {4, 30}, {3, 30}, {2, 30}, {1, 30}, {0, 30}, {1, 31}, {0, 31}, {3, 32}, {2, 32}, {1, 32}, {0, 32}, {5, 33}, {4, 33}, {3, 33}, {2, 33}, {1, 33}, {0, 33}, {1, 34}, {0, 34}, {5, 35}, {4, 35}, {3, 35}, {2, 35}, {1, 35}, {0, 35}, {5, 36}, {4, 36}, {3, 36}, {2, 36}, {1, 36}, {0, 36}, {3, 37}, {2, 37}, {1, 37}, {0, 37}, {1, 38}, {0, 38}, {3, 39}, {2, 39}, {1, 39}, {0, 39}, {5, 40}, {4, 40}, {3, 40}, {2, 40}, {1, 40}, {0, 40}, {1, 41}, {0, 41}, {5, 42}, {4, 42}, {3, 42}, {2, 42}, {1, 42}, {0, 42}, {3, 43}, {2, 43}, {1, 43}, {0, 43}, {1, 44}, {0, 44}, {3, 45}, {2, 45}, {1, 45}, {0, 45}, {1, 46}, {0, 46}, {9, 47}, {8, 47}, {7, 47}, {6, 47}, {5, 47}, {4, 47}, {3, 47}, {2, 47}, {1, 47}, {0, 47} }; const WheelElement wheel30[8*8] = { { BIT0, 6, 1, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 2, 1, -7 }, { BIT1, 6, 2, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 2, 1, -7 }, { BIT2, 6, 2, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 2, 1, -7 }, { BIT3, 6, 3, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 2, 1, -7 }, { BIT4, 6, 4, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 2, 1, -7 }, { BIT5, 6, 5, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 2, 1, -7 }, { BIT6, 6, 6, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 2, 2, -7 }, { BIT7, 6, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 2, 0, -7 } }; const WheelElement wheel210[48*8] = { { BIT0, 10, 2, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 2, 1, 1 }, { BIT0, 6, 1, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 6, 2, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 2, 1, 1 }, { BIT0, 6, 1, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 6, 2, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 8, 2, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 8, 2, 1 }, { BIT0, 6, 1, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 6, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 2, 1, 1 }, { BIT0, 6, 1, 1 }, { BIT4, 6, 1, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 4, 1, 1 }, { BIT1, 6, 1, 1 }, { BIT5, 2, 1, 1 }, { BIT0, 6, 1, 1 }, { BIT4, 4, 1, 1 }, { BIT3, 2, 0, 1 }, { BIT7, 4, 1, 1 }, { BIT6, 2, 1, 1 }, { BIT2, 10, 2, 1 }, { BIT5, 2, 1, -47 }, { BIT1, 10, 3, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT1, 6, 2, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 6, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT1, 6, 2, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 6, 2, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 8, 3, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 8, 3, 1 }, { BIT1, 6, 2, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 6, 3, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT1, 6, 2, 1 }, { BIT3, 6, 2, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 4, 2, 1 }, { BIT2, 6, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT1, 6, 2, 1 }, { BIT3, 4, 1, 1 }, { BIT7, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT0, 2, 0, 1 }, { BIT6, 10, 4, 1 }, { BIT4, 2, 1, -47 }, { BIT2, 10, 4, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 2, 1, 1 }, { BIT2, 6, 2, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 6, 2, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 2, 1, 1 }, { BIT2, 6, 2, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 6, 3, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 8, 3, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 8, 4, 1 }, { BIT2, 6, 2, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 6, 3, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 2, 1, 1 }, { BIT2, 6, 2, 1 }, { BIT7, 6, 3, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 4, 1, 1 }, { BIT6, 6, 3, 1 }, { BIT3, 2, 1, 1 }, { BIT2, 6, 2, 1 }, { BIT7, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT4, 4, 2, 1 }, { BIT1, 2, 1, 1 }, { BIT0, 10, 4, 1 }, { BIT3, 2, 1, -47 }, { BIT3, 10, 6, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 2, 1, 1 }, { BIT3, 6, 3, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 6, 3, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 2, 1, 1 }, { BIT3, 6, 3, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 6, 3, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 8, 4, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 8, 5, 1 }, { BIT3, 6, 3, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 6, 3, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 2, 1, 1 }, { BIT3, 6, 3, 1 }, { BIT6, 6, 4, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 4, 2, 1 }, { BIT7, 6, 4, 1 }, { BIT2, 2, 1, 1 }, { BIT3, 6, 3, 1 }, { BIT6, 4, 3, 1 }, { BIT0, 2, 1, 1 }, { BIT1, 4, 2, 1 }, { BIT4, 2, 1, 1 }, { BIT5, 10, 6, 1 }, { BIT2, 2, 1, -47 }, { BIT4, 10, 6, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 2, 1, 1 }, { BIT4, 6, 4, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 6, 4, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 2, 1, 1 }, { BIT4, 6, 4, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 6, 3, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 8, 5, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 8, 5, 1 }, { BIT4, 6, 4, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 6, 4, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 2, 1, 1 }, { BIT4, 6, 4, 1 }, { BIT2, 6, 4, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 4, 3, 1 }, { BIT3, 6, 4, 1 }, { BIT1, 2, 1, 1 }, { BIT4, 6, 4, 1 }, { BIT2, 4, 2, 1 }, { BIT6, 2, 2, 1 }, { BIT0, 4, 2, 1 }, { BIT5, 2, 1, 1 }, { BIT7, 10, 7, 1 }, { BIT1, 2, 1, -47 }, { BIT5, 10, 8, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 2, 1, 1 }, { BIT5, 6, 5, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 6, 5, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 2, 1, 1 }, { BIT5, 6, 5, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 6, 5, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 8, 6, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 8, 6, 1 }, { BIT5, 6, 5, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 6, 4, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 2, 1, 1 }, { BIT5, 6, 5, 1 }, { BIT1, 6, 4, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 4, 3, 1 }, { BIT4, 6, 5, 1 }, { BIT0, 2, 1, 1 }, { BIT5, 6, 5, 1 }, { BIT1, 4, 3, 1 }, { BIT2, 2, 1, 1 }, { BIT6, 4, 3, 1 }, { BIT7, 2, 2, 1 }, { BIT3, 10, 8, 1 }, { BIT0, 2, 1, -47 }, { BIT6, 10,10, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 2, 2, 1 }, { BIT6, 6, 6, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 6, 6, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 2, 2, 1 }, { BIT6, 6, 6, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 6, 6, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 8, 8, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 8, 7, 1 }, { BIT6, 6, 6, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 6, 6, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 2, 2, 1 }, { BIT6, 6, 6, 1 }, { BIT5, 6, 6, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 4, 4, 1 }, { BIT0, 6, 5, 1 }, { BIT7, 2, 2, 1 }, { BIT6, 6, 6, 1 }, { BIT5, 4, 4, 1 }, { BIT4, 2, 2, 1 }, { BIT3, 4, 4, 1 }, { BIT2, 2, 2, 1 }, { BIT1, 10, 9, 1 }, { BIT7, 2, 2, -47 }, { BIT7, 10, 1, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 2, 0, 1 }, { BIT7, 6, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 6, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 2, 0, 1 }, { BIT7, 6, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 6, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 8, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 8, 0, 1 }, { BIT7, 6, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 6, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 2, 0, 1 }, { BIT7, 6, 1, 1 }, { BIT0, 6, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 4, 0, 1 }, { BIT5, 6, 0, 1 }, { BIT6, 2, 0, 1 }, { BIT7, 6, 1, 1 }, { BIT0, 4, 0, 1 }, { BIT1, 2, 0, 1 }, { BIT2, 4, 0, 1 }, { BIT3, 2, 0, 1 }, { BIT4, 10, 0, 1 }, { BIT6, 2, 0, -47 } }; } // namespace primesieve primesieve-5.6.0/src/primesieve/iterator.cpp000066400000000000000000000055211263266076300212040ustar00rootroot00000000000000/// /// @file iterator.cpp /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include namespace primesieve { iterator::iterator(uint64_t start, uint64_t stop_hint) { skipto(start, stop_hint); } void iterator::skipto(uint64_t start, uint64_t stop_hint) { if (start > get_max_stop()) throw primesieve_error("start must be <= " + PrimeFinder::getMaxStopString()); start_ = start; stop_ = start; stop_hint_ = stop_hint; i_ = 0; last_idx_ = 0; tiny_cache_size_ = 1 << 11; primes_.clear(); } uint64_t add_overflow_safe(uint64_t a, uint64_t b) { uint64_t max_stop = get_max_stop(); return (a < max_stop - b) ? a + b : max_stop; } uint64_t subtract_underflow_safe(uint64_t a, uint64_t b) { return (a > b) ? a - b : 0; } void iterator::generate_next_primes() { primes_.clear(); while (primes_.empty()) { start_ = add_overflow_safe(stop_, 1); stop_ = add_overflow_safe(start_, get_interval_size(start_)); if (start_ <= stop_hint_ && stop_ >= stop_hint_) stop_ = add_overflow_safe(stop_hint_, max_prime_gap(stop_hint_)); generate_primes(start_, stop_, &primes_); if (primes_.empty() && stop_ >= get_max_stop()) throw primesieve_error("next_prime() > " + PrimeFinder::getMaxStopString()); } last_idx_ = primes_.size() - 1; i_ = 0; } void iterator::generate_previous_primes() { primes_.clear(); while (primes_.empty()) { stop_ = subtract_underflow_safe(start_, 1); start_ = subtract_underflow_safe(stop_, get_interval_size(stop_)); if (start_ <= stop_hint_ && stop_ >= stop_hint_) start_ = subtract_underflow_safe(stop_hint_, max_prime_gap(stop_hint_)); if (start_ <= 2) primes_.push_back(0); generate_primes(start_, stop_, &primes_); } last_idx_ = primes_.size() - 1; i_ = last_idx_; } /// Calculate an interval size that ensures a good load balance. /// @param n Start or stop number. /// uint64_t iterator::get_interval_size(uint64_t n) { n = (n > 10) ? n : 10; uint64_t cache_size = config::ITERATOR_CACHE_SMALL; if (tiny_cache_size_ < cache_size) { cache_size = tiny_cache_size_; tiny_cache_size_ *= 2; } double x = static_cast(n); double sqrtx = std::sqrt(x); uint64_t sqrtx_primes = static_cast(sqrtx / (std::log(sqrtx) - 1)); uint64_t cache_min_primes = cache_size / sizeof(uint64_t); uint64_t cache_max_primes = config::ITERATOR_CACHE_MAX / sizeof(uint64_t); uint64_t primes = getInBetween(cache_min_primes, sqrtx_primes, cache_max_primes); return static_cast(primes * std::log(x)); } } // end namespace primesieve-5.6.0/src/primesieve/popcount.cpp000066400000000000000000000056611263266076300212270ustar00rootroot00000000000000/// /// @file popcount.cpp /// @brief Fast algorithm to count the number of 1 bits in an array /// using only integer operations. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #if !defined(__STDC_CONSTANT_MACROS) #define __STDC_CONSTANT_MACROS #endif #include namespace { /// This uses fewer arithmetic operations than any other known /// implementation on machines with fast multiplication. /// It uses 12 arithmetic operations, one of which is a multiply. /// http://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation /// uint64_t popcount_mul(uint64_t x) { const uint64_t m1 = UINT64_C(0x5555555555555555); const uint64_t m2 = UINT64_C(0x3333333333333333); const uint64_t m4 = UINT64_C(0x0F0F0F0F0F0F0F0F); const uint64_t h01 = UINT64_C(0x0101010101010101); x -= (x >> 1) & m1; x = (x & m2) + ((x >> 2) & m2); x = (x + (x >> 4)) & m4; return (x * h01) >> 56; } /// Carry-save adder (CSA). /// @see Chapter 5 in "Hacker's Delight". /// void CSA(uint64_t& h, uint64_t& l, uint64_t a, uint64_t b, uint64_t c) { uint64_t u = a ^ b; h = (a & b) | (u & c); l = u ^ c; } } // namespace namespace primesieve { /// Harley-Seal popcount (4th iteration). /// The Harley-Seal popcount algorithm is one of the fastest algorithms /// for counting 1 bits in an array using only integer operations. /// This implementation uses only 5.69 instructions per 64-bit word. /// @see Chapter 5 in "Hacker's Delight" 2nd edition. /// uint64_t popcount(const uint64_t* array, uint64_t size) { uint64_t total = 0; uint64_t ones = 0, twos = 0, fours = 0, eights = 0, sixteens = 0; uint64_t twosA, twosB, foursA, foursB, eightsA, eightsB; uint64_t limit = size - size % 16; uint64_t i = 0; for(; i < limit; i += 16) { CSA(twosA, ones, ones, array[i+0], array[i+1]); CSA(twosB, ones, ones, array[i+2], array[i+3]); CSA(foursA, twos, twos, twosA, twosB); CSA(twosA, ones, ones, array[i+4], array[i+5]); CSA(twosB, ones, ones, array[i+6], array[i+7]); CSA(foursB, twos, twos, twosA, twosB); CSA(eightsA,fours, fours, foursA, foursB); CSA(twosA, ones, ones, array[i+8], array[i+9]); CSA(twosB, ones, ones, array[i+10], array[i+11]); CSA(foursA, twos, twos, twosA, twosB); CSA(twosA, ones, ones, array[i+12], array[i+13]); CSA(twosB, ones, ones, array[i+14], array[i+15]); CSA(foursB, twos, twos, twosA, twosB); CSA(eightsB, fours, fours, foursA, foursB); CSA(sixteens, eights, eights, eightsA, eightsB); total += popcount_mul(sixteens); } total *= 16; total += 8 * popcount_mul(eights); total += 4 * popcount_mul(fours); total += 2 * popcount_mul(twos); total += 1 * popcount_mul(ones); for(; i < size; i++) total += popcount_mul(array[i]); return total; } } // namespace primesieve primesieve-5.6.0/src/primesieve/primesieve-api-c.cpp000066400000000000000000000313031263266076300225070ustar00rootroot00000000000000/// /// @file primesieve-api-c.cpp /// @brief Contains the implementations of the functions declared in /// the primesieve.h header file. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #include #include ////////////////////////////////////////////////////////////////////// // Internal helper functions ////////////////////////////////////////////////////////////////////// namespace { using namespace primesieve; template void* generate_primes_helper(uint64_t start, uint64_t stop, size_t* size) { try { malloc_vector primes; PushBackPrimes > pb(primes); pb.pushBackPrimes(start, stop); if (size) *size = primes.size(); primes.disable_free(); return reinterpret_cast(primes.data()); } catch (std::exception&) { errno = EDOM; if (size) *size = 0; } return NULL; } template void* generate_n_primes_helper(uint64_t n, uint64_t start) { try { malloc_vector primes; PushBack_N_Primes > pb(primes); pb.pushBack_N_Primes(n, start); primes.disable_free(); return reinterpret_cast(primes.data()); } catch (std::exception&) { errno = EDOM; } return NULL; } } // namespace /// All C API functions declared in primesieve.h /// have extern "C" linkage. extern "C" { ////////////////////////////////////////////////////////////////////// // Return an array of primes ////////////////////////////////////////////////////////////////////// void* primesieve_generate_primes(uint64_t start, uint64_t stop, size_t* size, int type) { switch (type) { case SHORT_PRIMES: return generate_primes_helper(start, stop, size); case USHORT_PRIMES: return generate_primes_helper(start, stop, size); case INT_PRIMES: return generate_primes_helper(start, stop, size); case UINT_PRIMES: return generate_primes_helper(start, stop, size); case LONG_PRIMES: return generate_primes_helper(start, stop, size); case ULONG_PRIMES: return generate_primes_helper(start, stop, size); case LONGLONG_PRIMES: return generate_primes_helper(start, stop, size); case ULONGLONG_PRIMES: return generate_primes_helper(start, stop, size); case INT16_PRIMES: return generate_primes_helper(start, stop, size); case UINT16_PRIMES: return generate_primes_helper(start, stop, size); case INT32_PRIMES: return generate_primes_helper(start, stop, size); case UINT32_PRIMES: return generate_primes_helper(start, stop, size); case INT64_PRIMES: return generate_primes_helper(start, stop, size); case UINT64_PRIMES: return generate_primes_helper(start, stop, size); } errno = EDOM; if (size) *size = 0; return NULL; } void* primesieve_generate_n_primes(uint64_t n, uint64_t start, int type) { switch (type) { case SHORT_PRIMES: return generate_n_primes_helper(n, start); case USHORT_PRIMES: return generate_n_primes_helper(n, start); case INT_PRIMES: return generate_n_primes_helper(n, start); case UINT_PRIMES: return generate_n_primes_helper(n, start); case LONG_PRIMES: return generate_n_primes_helper(n, start); case ULONG_PRIMES: return generate_n_primes_helper(n, start); case LONGLONG_PRIMES: return generate_n_primes_helper(n, start); case ULONGLONG_PRIMES: return generate_n_primes_helper(n, start); case INT16_PRIMES: return generate_n_primes_helper(n, start); case UINT16_PRIMES: return generate_n_primes_helper(n, start); case INT32_PRIMES: return generate_n_primes_helper(n, start); case UINT32_PRIMES: return generate_n_primes_helper(n, start); case INT64_PRIMES: return generate_n_primes_helper(n, start); case UINT64_PRIMES: return generate_n_primes_helper(n, start); } errno = EDOM; return NULL; } void primesieve_free(void* primes) { free(primes); } ////////////////////////////////////////////////////////////////////// // Nth prime functions ////////////////////////////////////////////////////////////////////// uint64_t primesieve_nth_prime(int64_t n, uint64_t start) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.nthPrime(n, start); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_nth_prime(int64_t n, uint64_t start) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.nthPrime(n, start); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } ////////////////////////////////////////////////////////////////////// // Count functions ////////////////////////////////////////////////////////////////////// uint64_t primesieve_count_primes(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countPrimes(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_count_twins(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countTwins(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_count_triplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countTriplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_count_quadruplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countQuadruplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_count_quintuplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countQuintuplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_count_sextuplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); return ps.countSextuplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } ////////////////////////////////////////////////////////////////////// // Parallel count functions ////////////////////////////////////////////////////////////////////// uint64_t primesieve_parallel_count_primes(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countPrimes(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_count_twins(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countTwins(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_count_triplets(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countTriplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_count_quadruplets(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countQuadruplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_count_quintuplets(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countQuintuplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } uint64_t primesieve_parallel_count_sextuplets(uint64_t start, uint64_t stop) { try { primesieve::ParallelPrimeSieve pps; pps.setSieveSize (primesieve::get_sieve_size()); pps.setNumThreads(primesieve::get_num_threads()); return pps.countSextuplets(start, stop); } catch (std::exception&) { errno = EDOM; } return PRIMESIEVE_ERROR; } ////////////////////////////////////////////////////////////////////// // Print functions ////////////////////////////////////////////////////////////////////// void primesieve_print_primes(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printPrimes(start, stop); } catch (std::exception&) { errno = EDOM; } } void primesieve_print_twins(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printTwins(start, stop); } catch (std::exception&) { errno = EDOM; } } void primesieve_print_triplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printTriplets(start, stop); } catch (std::exception&) { errno = EDOM; } } void primesieve_print_quadruplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printQuadruplets(start, stop); } catch (std::exception&) { errno = EDOM; } } void primesieve_print_quintuplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printQuintuplets(start, stop); } catch (std::exception&) { errno = EDOM; } } void primesieve_print_sextuplets(uint64_t start, uint64_t stop) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); ps.printSextuplets(start, stop); } catch (std::exception&) { errno = EDOM; } } ////////////////////////////////////////////////////////////////////// // Callback function ////////////////////////////////////////////////////////////////////// void primesieve_callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t)) { try { primesieve::PrimeSieve ps; ps.setSieveSize(primesieve::get_sieve_size()); // temporarily cast away extern "C" linkage ps.callbackPrimes_c(start, stop, reinterpret_cast(callback)); } catch (std::exception&) { errno = EDOM; } } ////////////////////////////////////////////////////////////////////// // Getters and Setters ////////////////////////////////////////////////////////////////////// int primesieve_get_sieve_size() { return primesieve::get_sieve_size(); } int primesieve_get_num_threads() { return primesieve::get_num_threads(); } uint64_t primesieve_get_max_stop() { return primesieve::get_max_stop(); } void primesieve_set_sieve_size(int sieve_size) { primesieve::set_sieve_size(sieve_size); } void primesieve_set_num_threads(int num_threads) { primesieve::set_num_threads(num_threads); } ////////////////////////////////////////////////////////////////////// // Miscellaneous ////////////////////////////////////////////////////////////////////// int primesieve_test() { return primesieve::primesieve_test(); } const char* primesieve_version() { return PRIMESIEVE_VERSION; } } // extern "C" primesieve-5.6.0/src/primesieve/primesieve-api.cpp000066400000000000000000000146271263266076300223010ustar00rootroot00000000000000/// /// @file primesieve-api.cpp /// @brief Contains the implementations of the functions declared in /// the primesieve.hpp header file. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include #ifdef _OPENMP #include #endif namespace { /// Number of threads used for sieving in parallel int num_threads = primesieve::MAX_THREADS; /// Sieve size in kilobytes used for sieving int sieve_size = SIEVESIZE; } namespace primesieve { ////////////////////////////////////////////////////////////////////// // Nth prime functions ////////////////////////////////////////////////////////////////////// uint64_t nth_prime(int64_t n, uint64_t start) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.nthPrime(n, start); } uint64_t parallel_nth_prime(int64_t n, uint64_t start) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.nthPrime(n, start); } ////////////////////////////////////////////////////////////////////// // Count functions ////////////////////////////////////////////////////////////////////// uint64_t count_primes(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countPrimes(start, stop); } uint64_t count_twins(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countTwins(start, stop); } uint64_t count_triplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countTriplets(start, stop); } uint64_t count_quadruplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countQuadruplets(start, stop); } uint64_t count_quintuplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countQuintuplets(start, stop); } uint64_t count_sextuplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); return ps.countSextuplets(start, stop); } ////////////////////////////////////////////////////////////////////// // Parallel count functions ////////////////////////////////////////////////////////////////////// uint64_t parallel_count_primes(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countPrimes(start, stop); } uint64_t parallel_count_twins(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countTwins(start, stop); } uint64_t parallel_count_triplets(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countTriplets(start, stop); } uint64_t parallel_count_quadruplets(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countQuadruplets(start, stop); } uint64_t parallel_count_quintuplets(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countQuintuplets(start, stop); } uint64_t parallel_count_sextuplets(uint64_t start, uint64_t stop) { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); return pps.countSextuplets(start, stop); } ////////////////////////////////////////////////////////////////////// // Print functions ////////////////////////////////////////////////////////////////////// void print_primes(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printPrimes(start, stop); } void print_twins(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printTwins(start, stop); } void print_triplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printTriplets(start, stop); } void print_quadruplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printQuadruplets(start, stop); } void print_quintuplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printQuintuplets(start, stop); } void print_sextuplets(uint64_t start, uint64_t stop) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.printSextuplets(start, stop); } ////////////////////////////////////////////////////////////////////// // Callback functions ////////////////////////////////////////////////////////////////////// void callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t)) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.callbackPrimes(start, stop, callback); } void callback_primes(uint64_t start, uint64_t stop, Callback* callback) { PrimeSieve ps; ps.setSieveSize(get_sieve_size()); ps.callbackPrimes(start, stop, callback); } ////////////////////////////////////////////////////////////////////// // Getters and Setters ////////////////////////////////////////////////////////////////////// uint64_t get_max_stop() { return PrimeFinder::getMaxStop(); } int get_sieve_size() { return sieve_size; } int get_num_threads() { return num_threads; } void set_sieve_size(int kilobytes) { sieve_size = getInBetween(1, kilobytes, 2048); } void set_num_threads(int threads) { if (threads != MAX_THREADS) { #ifdef _OPENMP int max_threads = omp_get_max_threads(); threads = getInBetween(1, threads, max_threads); #else // no multi-threading threads = 1; #endif } num_threads = threads; } ////////////////////////////////////////////////////////////////////// // Miscellaneous ////////////////////////////////////////////////////////////////////// std::string primesieve_version() { return PRIMESIEVE_VERSION; } } // end namespace primesieve-5.6.0/src/primesieve/primesieve_iterator.cpp000066400000000000000000000104551263266076300234360ustar00rootroot00000000000000/// /// @file primesieve_iterator.cpp /// @brief C port of primesieve::iterator. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include using namespace std; using namespace primesieve; namespace { /// Convert pimpl pointer to vector vector& to_vector(uint64_t* primes_pimpl) { vector* primes = reinterpret_cast*>(primes_pimpl); return *primes; } uint64_t add_overflow_safe(uint64_t a, uint64_t b) { uint64_t max_stop = get_max_stop(); return (a < max_stop - b) ? a + b : max_stop; } uint64_t subtract_underflow_safe(uint64_t a, uint64_t b) { return (a > b) ? a - b : 0; } /// Calculate an interval size that ensures a good load balance. /// @param n Start or stop number. /// uint64_t get_interval_size(uint64_t n, uint64_t& tiny_cache_size) { n = (n > 10) ? n : 10; uint64_t cache_size = config::ITERATOR_CACHE_SMALL; if (tiny_cache_size < cache_size) { cache_size = tiny_cache_size; tiny_cache_size *= 2; } double x = static_cast(n); double sqrtx = sqrt(x); uint64_t sqrtx_primes = static_cast(sqrtx / (log(sqrtx) - 1)); uint64_t cache_min_primes = cache_size / sizeof(uint64_t); uint64_t cache_max_primes = config::ITERATOR_CACHE_MAX / sizeof(uint64_t); uint64_t primes = getInBetween(cache_min_primes, sqrtx_primes, cache_max_primes); return static_cast(primes * log(x)); } } /// C constructor void primesieve_init(primesieve_iterator* pi) { pi->primes_pimpl_ = reinterpret_cast(new vector()); primesieve_skipto(pi, 0, primesieve_get_max_stop()); } /// C destructor void primesieve_free_iterator(primesieve_iterator* pi) { if (pi) { vector* primes = &to_vector(pi->primes_pimpl_); delete primes; } } void primesieve_skipto(primesieve_iterator* pi, uint64_t start, uint64_t stop_hint) { vector& primes = to_vector(pi->primes_pimpl_); primes.clear(); pi->start_ = start; pi->stop_ = start; pi->stop_hint_ = stop_hint; pi->i_ = 0; pi->last_idx_ = 0; pi->tiny_cache_size_ = 1 << 11; pi->is_error_ = false; } void primesieve_generate_next_primes(primesieve_iterator* pi) { vector& primes = to_vector(pi->primes_pimpl_); if (!pi->is_error_) { try { primes.clear(); while (primes.empty()) { pi->start_ = add_overflow_safe(pi->stop_, 1); pi->stop_ = add_overflow_safe(pi->start_, get_interval_size(pi->start_, pi->tiny_cache_size_)); if (pi->start_ <= pi->stop_hint_ && pi->stop_ >= pi->stop_hint_) pi->stop_ = add_overflow_safe(pi->stop_hint_, max_prime_gap(pi->stop_hint_)); generate_primes(pi->start_, pi->stop_, &primes); if (primes.empty() && pi->stop_ >= get_max_stop()) throw primesieve_error("next_prime() > primesieve_get_max_stop()"); } } catch (exception&) { primes.clear(); primes.resize(64, PRIMESIEVE_ERROR); pi->is_error_ = true; errno = EDOM; } } pi->primes_ = &primes[0]; pi->last_idx_ = primes.size() - 1; pi->i_ = 0; } void primesieve_generate_previous_primes(primesieve_iterator* pi) { vector& primes = to_vector(pi->primes_pimpl_); if (!pi->is_error_) { try { primes.clear(); while (primes.empty()) { pi->stop_ = subtract_underflow_safe(pi->start_, 1); pi->start_ = subtract_underflow_safe(pi->stop_, get_interval_size(pi->stop_, pi->tiny_cache_size_)); if (pi->start_ <= pi->stop_hint_ && pi->stop_ >= pi->stop_hint_) pi->start_ = subtract_underflow_safe(pi->stop_hint_, max_prime_gap(pi->stop_hint_)); if (pi->start_ <= 2) primes.push_back(0); generate_primes(pi->start_, pi->stop_, &primes); } } catch (exception&) { primes.clear(); primes.resize(64, PRIMESIEVE_ERROR); pi->is_error_ = true; errno = EDOM; } } pi->primes_ = &primes[0]; pi->last_idx_ = primes.size() - 1; pi->i_ = pi->last_idx_; } primesieve-5.6.0/src/primesieve/primesieve_test.cpp000066400000000000000000000113511263266076300225600ustar00rootroot00000000000000/// /// @file primesieve_test.cpp /// @brief bool primesieve_test(); runs sieving tests to ensure that /// ParallelPrimeSieve objects return correct results. /// /// Copyright (C) 2015 Kim Walisch, /// /// This file is distributed under the BSD License. See the COPYING /// file in the top level directory. /// #include #include #include #include #include #include #include #include #include using namespace std; namespace primesieve { /// Correct values to compare with test results const unsigned int primeCounts[19] = { 4, // pi(10^1) 25, // pi(10^2) 168, // pi(10^3) 1229, // pi(10^4) 9592, // pi(10^5) 78498, // pi(10^6) 664579, // pi(10^7) 5761455, // pi(10^8) 50847534, // pi(10^9) 455052511, // pi(10^10) 155428406, // pi[10^12, 10^12+2^32] 143482916, // pi[10^13, 10^13+2^32] 133235063, // pi[10^14, 10^14+2^32] 124350420, // pi[10^15, 10^15+2^32] 116578809, // pi[10^16, 10^16+2^32] 109726486, // pi[10^17, 10^17+2^32] 103626726, // pi[10^18, 10^18+2^32] 98169972, // pi[10^19, 10^19+2^32] 2895317534U // pi[10^15, 10^15+10^11] }; /// Keeps the memory usage below 1GB const int maxThreads[8] = { 32, 32, 32, 32, 32, 8, 4, 1 }; uint64_t ipow(uint64_t x, int n) { uint64_t result = 1; while (n != 0) { if ((n & 1) != 0) { result *= x; n -= 1; } x *= x; n /= 2; } return result; } /// Get a random 64-bit integer < limit uint64_t getRand64(uint64_t limit) { uint64_t rand64 = 0; for (int i = 0; i < 4; i++) rand64 = rand() % (1 << 16) + (rand64 << (i * 16)); return rand64 % limit; } void check(bool isCorrect) { cout << (isCorrect ? "OK" : "ERROR") << endl; if (!isCorrect) throw runtime_error("test failed!"); } /// Count the primes up to 10^10 void testPix() { cout << "pi(x) : Prime-counting function test" << endl; ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); pps.setStart(0); pps.setStop(0); uint64_t primeCount = 0; // pi(x) with x = 10^i for i = 1 to 10 for (int i = 1; i <= 10; i++) { primeCount += pps.countPrimes(pps.getStop() + 1, ipow(10, i)); cout << "pi(10^" << i << (i < 10 ? ") = " : ") = ") << setw(12) << primeCount; check(primeCount == primeCounts[i - 1]); } cout << endl; } /// Count the primes within [10^i, 10^i+2^32] for i = 12 to 19 void testBigPrimes() { ParallelPrimeSieve pps; pps.setSieveSize(get_sieve_size()); pps.setNumThreads(get_num_threads()); pps.setFlags(pps.COUNT_PRIMES | pps.PRINT_STATUS); for (int i = 12; i <= 19; i++) { cout << "Sieving the primes within [10^" << i << ", 10^" << i << "+2^32]" << endl; pps.setStart(ipow(10, i)); pps.setStop(pps.getStart() + ipow(2, 32)); pps.setNumThreads(min(pps.getNumThreads(), maxThreads[i - 12])); pps.sieve(); cout << "\rPrime count: " << setw(11) << pps.getPrimeCount(); check(pps.getPrimeCount() == primeCounts[i - 2]); } cout << endl; } /// Sieve about 200 small random intervals until the interval /// [10^15, 10^15+10^11] has been completed. /// void testRandomIntervals() { cout << "Sieving the primes within [10^15, 10^15+10^11] randomly" << endl; uint64_t maxInterval = ipow(10, 9); uint64_t lowerBound = ipow(10, 15); uint64_t upperBound = lowerBound + ipow(10, 11); uint64_t primeCount = 0; srand(static_cast(time(0))); ParallelPrimeSieve pps; pps.setNumThreads(get_num_threads()); pps.setStart(lowerBound - 1); pps.setStop(lowerBound - 1); while (pps.getStop() < upperBound) { pps.setStart(pps.getStop() + 1); pps.setStop(min(pps.getStart() + getRand64(maxInterval), upperBound)); pps.setSieveSize(1 << (rand() % 12)); pps.sieve(); primeCount += pps.getPrimeCount(); cout << "\rRemaining chunk: " << "\rRemaining chunk: " << upperBound - pps.getStop() << flush; } cout << endl << "Prime count: " << setw(11) << primeCount; check(primeCount == primeCounts[18]); cout << endl; } /// Run various sieving tests to ensure that ParallelPrimeSieve /// (and PrimeSieve) objects produce correct results. /// The tests use up to 1 gigabyte of memory and take about /// 1 minute to complete on a quad core CPU from 2013. /// @return true if success else false. /// bool primesieve_test() { try { cout << left; testPix(); testBigPrimes(); testRandomIntervals(); } catch (exception& e) { cerr << endl << "primesieve error: " << e.what() << endl; return false; } cout << "All tests passed successfully!" << endl; return true; } } // end namespace