From 90702a435d8e4b019d511fc129e6b713afc56c6b Mon Sep 17 00:00:00 2001 From: maartenkeijzer Date: Thu, 6 Oct 2005 12:13:53 +0000 Subject: [PATCH] Added mathsym+tcc and boost against all advice --- eo/contrib/boost/config.hpp | 70 +++ eo/contrib/boost/config/abi_prefix.hpp | 20 + eo/contrib/boost/config/abi_suffix.hpp | 23 + eo/contrib/boost/config/auto_link.hpp | 354 +++++++++++ eo/contrib/boost/config/compiler/borland.hpp | 175 ++++++ eo/contrib/boost/config/compiler/comeau.hpp | 59 ++ .../boost/config/compiler/common_edg.hpp | 62 ++ .../boost/config/compiler/compaq_cxx.hpp | 19 + .../boost/config/compiler/digitalmars.hpp | 49 ++ eo/contrib/boost/config/compiler/gcc.hpp | 105 ++++ .../boost/config/compiler/greenhills.hpp | 28 + eo/contrib/boost/config/compiler/hp_acc.hpp | 70 +++ eo/contrib/boost/config/compiler/intel.hpp | 146 +++++ eo/contrib/boost/config/compiler/kai.hpp | 35 ++ .../boost/config/compiler/metrowerks.hpp | 104 ++++ eo/contrib/boost/config/compiler/mpw.hpp | 51 ++ .../boost/config/compiler/sgi_mipspro.hpp | 24 + .../boost/config/compiler/sunpro_cc.hpp | 90 +++ eo/contrib/boost/config/compiler/vacpp.hpp | 58 ++ eo/contrib/boost/config/compiler/visualc.hpp | 147 +++++ eo/contrib/boost/config/platform/aix.hpp | 33 + eo/contrib/boost/config/platform/amigaos.hpp | 15 + eo/contrib/boost/config/platform/beos.hpp | 26 + eo/contrib/boost/config/platform/bsd.hpp | 71 +++ eo/contrib/boost/config/platform/cygwin.hpp | 48 ++ eo/contrib/boost/config/platform/hpux.hpp | 68 +++ eo/contrib/boost/config/platform/irix.hpp | 31 + eo/contrib/boost/config/platform/linux.hpp | 98 +++ eo/contrib/boost/config/platform/macos.hpp | 78 +++ eo/contrib/boost/config/platform/solaris.hpp | 21 + eo/contrib/boost/config/platform/win32.hpp | 50 ++ eo/contrib/boost/config/posix_features.hpp | 87 +++ eo/contrib/boost/config/requires_threads.hpp | 92 +++ .../boost/config/select_compiler_config.hpp | 83 +++ .../boost/config/select_platform_config.hpp | 86 +++ .../boost/config/select_stdlib_config.hpp | 68 +++ eo/contrib/boost/config/stdlib/dinkumware.hpp | 106 ++++ eo/contrib/boost/config/stdlib/libcomo.hpp | 46 ++ eo/contrib/boost/config/stdlib/libstdcpp3.hpp | 61 ++ eo/contrib/boost/config/stdlib/modena.hpp | 30 + eo/contrib/boost/config/stdlib/msl.hpp | 59 ++ eo/contrib/boost/config/stdlib/roguewave.hpp | 127 ++++ eo/contrib/boost/config/stdlib/sgi.hpp | 111 ++++ eo/contrib/boost/config/stdlib/stlport.hpp | 201 +++++++ eo/contrib/boost/config/stdlib/vacpp.hpp | 18 + eo/contrib/boost/config/suffix.hpp | 547 +++++++++++++++++ eo/contrib/boost/config/user.hpp | 124 ++++ eo/contrib/boost/limits.hpp | 143 +++++ eo/contrib/boost/numeric/interval.hpp | 32 + eo/contrib/boost/numeric/interval/arith.hpp | 305 ++++++++++ eo/contrib/boost/numeric/interval/arith2.hpp | 212 +++++++ eo/contrib/boost/numeric/interval/arith3.hpp | 69 +++ .../boost/numeric/interval/checking.hpp | 130 ++++ eo/contrib/boost/numeric/interval/compare.hpp | 19 + .../numeric/interval/compare/certain.hpp | 113 ++++ .../numeric/interval/compare/explicit.hpp | 248 ++++++++ .../interval/compare/lexicographic.hpp | 122 ++++ .../numeric/interval/compare/possible.hpp | 113 ++++ .../boost/numeric/interval/compare/set.hpp | 101 ++++ .../numeric/interval/compare/tribool.hpp | 138 +++++ .../boost/numeric/interval/constants.hpp | 85 +++ .../interval/detail/bcc_rounding_control.hpp | 57 ++ .../boost/numeric/interval/detail/bugs.hpp | 79 +++ .../interval/detail/c99_rounding_control.hpp | 47 ++ .../detail/c99sub_rounding_control.hpp | 43 ++ .../numeric/interval/detail/division.hpp | 194 ++++++ .../interval/detail/interval_prototype.hpp | 41 ++ .../interval/detail/msvc_rounding_control.hpp | 88 +++ .../interval/detail/ppc_rounding_control.hpp | 95 +++ .../detail/sparc_rounding_control.hpp | 112 ++++ .../numeric/interval/detail/test_input.hpp | 76 +++ .../interval/detail/x86_rounding_control.hpp | 108 ++++ .../detail/x86gcc_rounding_control.hpp | 51 ++ .../boost/numeric/interval/ext/integer.hpp | 70 +++ .../ext/x86_fast_rounding_control.hpp | 70 +++ .../boost/numeric/interval/hw_rounding.hpp | 64 ++ .../boost/numeric/interval/interval.hpp | 450 ++++++++++++++ eo/contrib/boost/numeric/interval/io.hpp | 41 ++ eo/contrib/boost/numeric/interval/limits.hpp | 51 ++ .../boost/numeric/interval/policies.hpp | 75 +++ .../boost/numeric/interval/rounded_arith.hpp | 120 ++++ .../boost/numeric/interval/rounded_transc.hpp | 140 +++++ .../boost/numeric/interval/rounding.hpp | 101 ++++ eo/contrib/boost/numeric/interval/transc.hpp | 232 +++++++ eo/contrib/boost/numeric/interval/utility.hpp | 331 ++++++++++ eo/contrib/mathsym/COPYING | 340 +++++++++++ eo/contrib/mathsym/GNUmakefile | 87 +++ eo/contrib/mathsym/README | 172 ++++++ eo/contrib/mathsym/README.TCC | 5 + eo/contrib/mathsym/eo_interface/eoSym.h | 62 ++ .../mathsym/eo_interface/eoSymCrossover.cpp | 76 +++ .../mathsym/eo_interface/eoSymCrossover.h | 64 ++ eo/contrib/mathsym/eo_interface/eoSymEval.h | 94 +++ eo/contrib/mathsym/eo_interface/eoSymInit.h | 64 ++ eo/contrib/mathsym/eo_interface/eoSymMutate.h | 122 ++++ eo/contrib/mathsym/eval/BoundsCheck.cpp | 80 +++ eo/contrib/mathsym/eval/BoundsCheck.h | 58 ++ eo/contrib/mathsym/eval/Interval.h | 115 ++++ eo/contrib/mathsym/eval/c_compile.c | 40 ++ eo/contrib/mathsym/eval/sym_compile.cpp | 181 ++++++ eo/contrib/mathsym/eval/sym_compile.h | 36 ++ eo/contrib/mathsym/fun/FunDef.cpp | 569 ++++++++++++++++++ eo/contrib/mathsym/fun/FunDef.h | 124 ++++ eo/contrib/mathsym/fun/SymOps.cpp | 109 ++++ eo/contrib/mathsym/fun/SymOps.h | 31 + eo/contrib/mathsym/fun/util.cpp | 27 + eo/contrib/mathsym/gen/LanguageTable.cpp | 97 +++ eo/contrib/mathsym/gen/LanguageTable.h | 56 ++ eo/contrib/mathsym/gen/NodeSelector.cpp | 40 ++ eo/contrib/mathsym/gen/NodeSelector.h | 47 ++ eo/contrib/mathsym/gen/TreeBuilder.cpp | 46 ++ eo/contrib/mathsym/gen/TreeBuilder.h | 45 ++ eo/contrib/mathsym/header | 17 + eo/contrib/mathsym/regression/Dataset.cpp | 133 ++++ eo/contrib/mathsym/regression/Dataset.h | 51 ++ .../mathsym/regression/ErrorMeasure.cpp | 237 ++++++++ eo/contrib/mathsym/regression/ErrorMeasure.h | 61 ++ eo/contrib/mathsym/regression/Scaling.cpp | 417 +++++++++++++ eo/contrib/mathsym/regression/Scaling.h | 93 +++ eo/contrib/mathsym/regression/TargetInfo.cpp | 138 +++++ eo/contrib/mathsym/regression/TargetInfo.h | 65 ++ eo/contrib/mathsym/shared_ptr.h | 102 ++++ eo/contrib/mathsym/sym/README.cpp | 364 +++++++++++ eo/contrib/mathsym/sym/Sym.cpp | 135 +++++ eo/contrib/mathsym/sym/Sym.h | 164 +++++ eo/contrib/mathsym/sym/SymImpl.cpp | 109 ++++ eo/contrib/mathsym/sym/SymImpl.h | 103 ++++ eo/contrib/mathsym/sym/token.h | 28 + eo/contrib/mathsym/symreg.cpp | 359 +++++++++++ eo/contrib/mathsym/tcc.tar.gz | Bin 0 -> 427170 bytes eo/contrib/mathsym/test/test.o | Bin 0 -> 1768 bytes eo/contrib/mathsym/test/test_compile.cpp | 185 ++++++ eo/contrib/mathsym/test/test_compile.o | Bin 0 -> 380656 bytes eo/contrib/mathsym/test/testeo.cpp | 119 ++++ eo/contrib/mathsym/test/testeo.o | Bin 0 -> 706724 bytes eo/contrib/mathsym/test_data.txt | 102 ++++ 136 files changed, 14409 insertions(+) create mode 100644 eo/contrib/boost/config.hpp create mode 100644 eo/contrib/boost/config/abi_prefix.hpp create mode 100644 eo/contrib/boost/config/abi_suffix.hpp create mode 100644 eo/contrib/boost/config/auto_link.hpp create mode 100644 eo/contrib/boost/config/compiler/borland.hpp create mode 100644 eo/contrib/boost/config/compiler/comeau.hpp create mode 100644 eo/contrib/boost/config/compiler/common_edg.hpp create mode 100644 eo/contrib/boost/config/compiler/compaq_cxx.hpp create mode 100644 eo/contrib/boost/config/compiler/digitalmars.hpp create mode 100644 eo/contrib/boost/config/compiler/gcc.hpp create mode 100644 eo/contrib/boost/config/compiler/greenhills.hpp create mode 100644 eo/contrib/boost/config/compiler/hp_acc.hpp create mode 100644 eo/contrib/boost/config/compiler/intel.hpp create mode 100644 eo/contrib/boost/config/compiler/kai.hpp create mode 100644 eo/contrib/boost/config/compiler/metrowerks.hpp create mode 100644 eo/contrib/boost/config/compiler/mpw.hpp create mode 100644 eo/contrib/boost/config/compiler/sgi_mipspro.hpp create mode 100644 eo/contrib/boost/config/compiler/sunpro_cc.hpp create mode 100644 eo/contrib/boost/config/compiler/vacpp.hpp create mode 100644 eo/contrib/boost/config/compiler/visualc.hpp create mode 100644 eo/contrib/boost/config/platform/aix.hpp create mode 100644 eo/contrib/boost/config/platform/amigaos.hpp create mode 100644 eo/contrib/boost/config/platform/beos.hpp create mode 100644 eo/contrib/boost/config/platform/bsd.hpp create mode 100644 eo/contrib/boost/config/platform/cygwin.hpp create mode 100644 eo/contrib/boost/config/platform/hpux.hpp create mode 100644 eo/contrib/boost/config/platform/irix.hpp create mode 100644 eo/contrib/boost/config/platform/linux.hpp create mode 100644 eo/contrib/boost/config/platform/macos.hpp create mode 100644 eo/contrib/boost/config/platform/solaris.hpp create mode 100644 eo/contrib/boost/config/platform/win32.hpp create mode 100644 eo/contrib/boost/config/posix_features.hpp create mode 100644 eo/contrib/boost/config/requires_threads.hpp create mode 100644 eo/contrib/boost/config/select_compiler_config.hpp create mode 100644 eo/contrib/boost/config/select_platform_config.hpp create mode 100644 eo/contrib/boost/config/select_stdlib_config.hpp create mode 100644 eo/contrib/boost/config/stdlib/dinkumware.hpp create mode 100644 eo/contrib/boost/config/stdlib/libcomo.hpp create mode 100644 eo/contrib/boost/config/stdlib/libstdcpp3.hpp create mode 100644 eo/contrib/boost/config/stdlib/modena.hpp create mode 100644 eo/contrib/boost/config/stdlib/msl.hpp create mode 100644 eo/contrib/boost/config/stdlib/roguewave.hpp create mode 100644 eo/contrib/boost/config/stdlib/sgi.hpp create mode 100644 eo/contrib/boost/config/stdlib/stlport.hpp create mode 100644 eo/contrib/boost/config/stdlib/vacpp.hpp create mode 100644 eo/contrib/boost/config/suffix.hpp create mode 100644 eo/contrib/boost/config/user.hpp create mode 100644 eo/contrib/boost/limits.hpp create mode 100644 eo/contrib/boost/numeric/interval.hpp create mode 100644 eo/contrib/boost/numeric/interval/arith.hpp create mode 100644 eo/contrib/boost/numeric/interval/arith2.hpp create mode 100644 eo/contrib/boost/numeric/interval/arith3.hpp create mode 100644 eo/contrib/boost/numeric/interval/checking.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/certain.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/explicit.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/lexicographic.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/possible.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/set.hpp create mode 100644 eo/contrib/boost/numeric/interval/compare/tribool.hpp create mode 100644 eo/contrib/boost/numeric/interval/constants.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/bcc_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/bugs.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/c99_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/c99sub_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/division.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/interval_prototype.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/msvc_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/ppc_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/sparc_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/test_input.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/x86_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/detail/x86gcc_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/ext/integer.hpp create mode 100644 eo/contrib/boost/numeric/interval/ext/x86_fast_rounding_control.hpp create mode 100644 eo/contrib/boost/numeric/interval/hw_rounding.hpp create mode 100644 eo/contrib/boost/numeric/interval/interval.hpp create mode 100644 eo/contrib/boost/numeric/interval/io.hpp create mode 100644 eo/contrib/boost/numeric/interval/limits.hpp create mode 100644 eo/contrib/boost/numeric/interval/policies.hpp create mode 100644 eo/contrib/boost/numeric/interval/rounded_arith.hpp create mode 100644 eo/contrib/boost/numeric/interval/rounded_transc.hpp create mode 100644 eo/contrib/boost/numeric/interval/rounding.hpp create mode 100644 eo/contrib/boost/numeric/interval/transc.hpp create mode 100644 eo/contrib/boost/numeric/interval/utility.hpp create mode 100644 eo/contrib/mathsym/COPYING create mode 100644 eo/contrib/mathsym/GNUmakefile create mode 100644 eo/contrib/mathsym/README create mode 100644 eo/contrib/mathsym/README.TCC create mode 100644 eo/contrib/mathsym/eo_interface/eoSym.h create mode 100644 eo/contrib/mathsym/eo_interface/eoSymCrossover.cpp create mode 100644 eo/contrib/mathsym/eo_interface/eoSymCrossover.h create mode 100644 eo/contrib/mathsym/eo_interface/eoSymEval.h create mode 100644 eo/contrib/mathsym/eo_interface/eoSymInit.h create mode 100644 eo/contrib/mathsym/eo_interface/eoSymMutate.h create mode 100644 eo/contrib/mathsym/eval/BoundsCheck.cpp create mode 100644 eo/contrib/mathsym/eval/BoundsCheck.h create mode 100644 eo/contrib/mathsym/eval/Interval.h create mode 100644 eo/contrib/mathsym/eval/c_compile.c create mode 100644 eo/contrib/mathsym/eval/sym_compile.cpp create mode 100644 eo/contrib/mathsym/eval/sym_compile.h create mode 100644 eo/contrib/mathsym/fun/FunDef.cpp create mode 100644 eo/contrib/mathsym/fun/FunDef.h create mode 100644 eo/contrib/mathsym/fun/SymOps.cpp create mode 100644 eo/contrib/mathsym/fun/SymOps.h create mode 100644 eo/contrib/mathsym/fun/util.cpp create mode 100644 eo/contrib/mathsym/gen/LanguageTable.cpp create mode 100644 eo/contrib/mathsym/gen/LanguageTable.h create mode 100644 eo/contrib/mathsym/gen/NodeSelector.cpp create mode 100644 eo/contrib/mathsym/gen/NodeSelector.h create mode 100644 eo/contrib/mathsym/gen/TreeBuilder.cpp create mode 100644 eo/contrib/mathsym/gen/TreeBuilder.h create mode 100644 eo/contrib/mathsym/header create mode 100644 eo/contrib/mathsym/regression/Dataset.cpp create mode 100644 eo/contrib/mathsym/regression/Dataset.h create mode 100644 eo/contrib/mathsym/regression/ErrorMeasure.cpp create mode 100644 eo/contrib/mathsym/regression/ErrorMeasure.h create mode 100644 eo/contrib/mathsym/regression/Scaling.cpp create mode 100644 eo/contrib/mathsym/regression/Scaling.h create mode 100644 eo/contrib/mathsym/regression/TargetInfo.cpp create mode 100644 eo/contrib/mathsym/regression/TargetInfo.h create mode 100644 eo/contrib/mathsym/shared_ptr.h create mode 100644 eo/contrib/mathsym/sym/README.cpp create mode 100644 eo/contrib/mathsym/sym/Sym.cpp create mode 100644 eo/contrib/mathsym/sym/Sym.h create mode 100644 eo/contrib/mathsym/sym/SymImpl.cpp create mode 100644 eo/contrib/mathsym/sym/SymImpl.h create mode 100644 eo/contrib/mathsym/sym/token.h create mode 100644 eo/contrib/mathsym/symreg.cpp create mode 100644 eo/contrib/mathsym/tcc.tar.gz create mode 100644 eo/contrib/mathsym/test/test.o create mode 100644 eo/contrib/mathsym/test/test_compile.cpp create mode 100644 eo/contrib/mathsym/test/test_compile.o create mode 100644 eo/contrib/mathsym/test/testeo.cpp create mode 100644 eo/contrib/mathsym/test/testeo.o create mode 100644 eo/contrib/mathsym/test_data.txt diff --git a/eo/contrib/boost/config.hpp b/eo/contrib/boost/config.hpp new file mode 100644 index 00000000..055a2785 --- /dev/null +++ b/eo/contrib/boost/config.hpp @@ -0,0 +1,70 @@ +// Boost config.hpp configuration header file ------------------------------// + +// (C) Copyright John Maddock 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/config for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config +// +// CAUTION: This file is intended to be completely stable - +// DO NOT MODIFY THIS FILE! +// + +#ifndef BOOST_CONFIG_HPP +#define BOOST_CONFIG_HPP + +// if we don't have a user config, then use the default location: +#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) +# define BOOST_USER_CONFIG +#endif +// include it first: +#ifdef BOOST_USER_CONFIG +# include BOOST_USER_CONFIG +#endif + +// if we don't have a compiler config set, try and find one: +#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a compiler config, include it now: +#ifdef BOOST_COMPILER_CONFIG +# include BOOST_COMPILER_CONFIG +#endif + +// if we don't have a std library config set, try and find one: +#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a std library config, include it now: +#ifdef BOOST_STDLIB_CONFIG +# include BOOST_STDLIB_CONFIG +#endif + +// if we don't have a platform config set, try and find one: +#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a platform config, include it now: +#ifdef BOOST_PLATFORM_CONFIG +# include BOOST_PLATFORM_CONFIG +#endif + +// get config suffix code: +#include + +#endif // BOOST_CONFIG_HPP + + + + + + + + + + + diff --git a/eo/contrib/boost/config/abi_prefix.hpp b/eo/contrib/boost/config/abi_prefix.hpp new file mode 100644 index 00000000..1733dc03 --- /dev/null +++ b/eo/contrib/boost/config/abi_prefix.hpp @@ -0,0 +1,20 @@ +// abi_prefix header -------------------------------------------------------// + +// © Copyright John Maddock 2003 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). + +#ifndef BOOST_CONFIG_ABI_PREFIX_HPP +# define BOOST_CONFIG_ABI_PREFIX_HPP +#else +# error double inclusion of header boost/config/abi_prefix.hpp is an error +#endif + +#include + +// this must occur after all other includes and before any code appears: +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif diff --git a/eo/contrib/boost/config/abi_suffix.hpp b/eo/contrib/boost/config/abi_suffix.hpp new file mode 100644 index 00000000..6339da63 --- /dev/null +++ b/eo/contrib/boost/config/abi_suffix.hpp @@ -0,0 +1,23 @@ +// abi_sufffix header -------------------------------------------------------// + +// © Copyright John Maddock 2003 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). + +// This header should be #included AFTER code that was preceded by a #include +// . + +#ifndef BOOST_CONFIG_ABI_PREFIX_HPP +# error Header boost/config/abi_prefix.hpp must only be used after boost/config/abi_prefix.hpp +#else +# undef BOOST_CONFIG_ABI_PREFIX_HPP +#endif + +// the suffix header occurs after all of our code: +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + + diff --git a/eo/contrib/boost/config/auto_link.hpp b/eo/contrib/boost/config/auto_link.hpp new file mode 100644 index 00000000..0c36f7b0 --- /dev/null +++ b/eo/contrib/boost/config/auto_link.hpp @@ -0,0 +1,354 @@ +// (C) Copyright John Maddock 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + /* + * LOCATION: see http://www.boost.org for most recent version. + * FILE auto_link.hpp + * VERSION see + * DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers. + */ + +/************************************************************************* + +USAGE: +~~~~~~ + +Before including this header you must define one or more of define the following macros: + +BOOST_LIB_NAME: Required: A string containing the basename of the library, + for example boost_regex. +BOOST_LIB_TOOLSET: Optional: the base name of the toolset. +BOOST_DYN_LINK: Optional: when set link to dll rather than static library. +BOOST_LIB_DIAGNOSTIC: Optional: when set the header will print out the name + of the library selected (useful for debugging). +BOOST_AUTO_LINK_NOMANGLE: Specifies that we should link to BOOST_LIB_NAME.lib, + rather than a mangled-name version. + +These macros will be undef'ed at the end of the header, further this header +has no include guards - so be sure to include it only once from your library! + +Algorithm: +~~~~~~~~~~ + +Libraries for Borland and Microsoft compilers are automatically +selected here, the name of the lib is selected according to the following +formula: + +BOOST_LIB_PREFIX + + BOOST_LIB_NAME + + "_" + + BOOST_LIB_TOOLSET + + BOOST_LIB_THREAD_OPT + + BOOST_LIB_RT_OPT + "-" + + BOOST_LIB_VERSION + +These are defined as: + +BOOST_LIB_PREFIX: "lib" for static libraries otherwise "". + +BOOST_LIB_NAME: The base name of the lib ( for example boost_regex). + +BOOST_LIB_TOOLSET: The compiler toolset name (vc6, vc7, bcb5 etc). + +BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing. + +BOOST_LIB_RT_OPT: A suffix that indicates the runtime library used, + contains one or more of the following letters after + a hiphen: + + s static runtime (dynamic if not present). + d debug build (release if not present). + g debug/diagnostic runtime (release if not present). + p STLPort Build. + +BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. + + +***************************************************************************/ + +#ifdef __cplusplus +# ifndef BOOST_CONFIG_HPP +# include +# endif +#elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__) +// +// C language compatability (no, honestly) +// +# define BOOST_MSVC _MSC_VER +# define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) +# define BOOST_DO_STRINGIZE(X) #X +#endif +// +// Only include what follows for known and supported compilers: +// +#if defined(BOOST_MSVC) \ + || defined(__BORLANDC__) \ + || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \ + || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) + +#ifndef BOOST_VERSION_HPP +# include +#endif + +#ifndef BOOST_LIB_NAME +# error "Macro BOOST_LIB_NAME not set (internal error)" +#endif + +// +// error check: +// +#if defined(__MSVC_RUNTIME_CHECKS) && !defined(_DEBUG) +# pragma message("Using the /RTC option without specifying a debug runtime will lead to linker errors") +# pragma message("Hint: go to the code generation options and switch to one of the debugging runtimes") +# error "Incompatible build options" +#endif +// +// select toolset if not defined already: +// +#ifndef BOOST_LIB_TOOLSET +#if defined(BOOST_MSVC) && (BOOST_MSVC == 1200) + + // vc6: +# define BOOST_LIB_TOOLSET "vc6" + +#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300) + + // vc7: +# define BOOST_LIB_TOOLSET "vc7" + +#elif defined(BOOST_MSVC) && (BOOST_MSVC == 1310) + + // vc71: +# define BOOST_LIB_TOOLSET "vc71" + +#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) + + // vc80: +# define BOOST_LIB_TOOLSET "vc80" + +#elif defined(__BORLANDC__) + + // CBuilder 6: +# define BOOST_LIB_TOOLSET "bcb" + +#elif defined(__ICL) + + // Intel C++, no version number: +# define BOOST_LIB_TOOLSET "iw" + +#elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF ) + + // Metrowerks CodeWarrior 8.x +# define BOOST_LIB_TOOLSET "cw8" + +#elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF ) + + // Metrowerks CodeWarrior 9.x +# define BOOST_LIB_TOOLSET "cw9" + +#endif +#endif // BOOST_LIB_TOOLSET + +// +// select thread opt: +// +#if defined(_MT) || defined(__MT__) +# define BOOST_LIB_THREAD_OPT "-mt" +#else +# define BOOST_LIB_THREAD_OPT +#endif + +#if defined(_MSC_VER) || defined(__MWERKS__) + +# ifdef _DLL + +# if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS)) + +# if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) +# define BOOST_LIB_RT_OPT "-gdp" +# elif defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-gdp" +# pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") +# error "Build options aren't compatible with pre-built libraries" +# else +# define BOOST_LIB_RT_OPT "-p" +# endif + +# elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) + +# if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) +# define BOOST_LIB_RT_OPT "-gdpn" +# elif defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-gdpn" +# pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") +# error "Build options aren't compatible with pre-built libraries" +# else +# define BOOST_LIB_RT_OPT "-pn" +# endif + +# else + +# if defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-gd" +# else +# define BOOST_LIB_RT_OPT +# endif + +# endif + +# else + +# if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS)) + +# if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) +# define BOOST_LIB_RT_OPT "-sgdp" +# elif defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-sgdp" +# pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") +# error "Build options aren't compatible with pre-built libraries" +# else +# define BOOST_LIB_RT_OPT "-sp" +# endif + +# elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) + +# if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) +# define BOOST_LIB_RT_OPT "-sgdpn" +# elif defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-sgdpn" +# pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") +# error "Build options aren't compatible with pre-built libraries" +# else +# define BOOST_LIB_RT_OPT "-spn" +# endif + +# else + +# if defined(_DEBUG) +# define BOOST_LIB_RT_OPT "-sgd" +# else +# define BOOST_LIB_RT_OPT "-s" +# endif + +# endif + +# endif + +#elif defined(__BORLANDC__) + +// +// figure out whether we want the debug builds or not: +// +#if __BORLANDC__ > 0x561 +#pragma defineonoption BOOST_BORLAND_DEBUG -v +#endif +// +// sanity check: +// +#if defined(__STL_DEBUG) || defined(_STLP_DEBUG) +#error "Pre-built versions of the Boost libraries are not provided in STLPort-debug form" +#endif + +# ifdef _RTLDLL + +# ifdef BOOST_BORLAND_DEBUG +# define BOOST_LIB_RT_OPT "-d" +# else +# define BOOST_LIB_RT_OPT +# endif + +# else + +# ifdef BOOST_BORLAND_DEBUG +# define BOOST_LIB_RT_OPT "-sd" +# else +# define BOOST_LIB_RT_OPT "-s" +# endif + +# endif + +#endif + +// +// select linkage opt: +// +#if (defined(_DLL) || defined(_RTLDLL)) && defined(BOOST_DYN_LINK) +# define BOOST_LIB_PREFIX +#elif defined(BOOST_DYN_LINK) +# error "Mixing a dll boost library with a static runtime is a really bad idea..." +#else +# define BOOST_LIB_PREFIX "lib" +#endif + +// +// now include the lib: +// +#if defined(BOOST_LIB_NAME) \ + && defined(BOOST_LIB_PREFIX) \ + && defined(BOOST_LIB_TOOLSET) \ + && defined(BOOST_LIB_THREAD_OPT) \ + && defined(BOOST_LIB_RT_OPT) \ + && defined(BOOST_LIB_VERSION) + +#ifndef BOOST_AUTO_LINK_NOMANGLE +# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib") +# ifdef BOOST_LIB_DIAGNOSTIC +# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib") +# endif +#else +# pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") +# ifdef BOOST_LIB_DIAGNOSTIC +# pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") +# endif +#endif + +#else +# error "some required macros where not defined (internal logic error)." +#endif + + +#endif // _MSC_VER || __BORLANDC__ + +// +// finally undef any macros we may have set: +// +#ifdef BOOST_LIB_PREFIX +# undef BOOST_LIB_PREFIX +#endif +#if defined(BOOST_LIB_NAME) +# undef BOOST_LIB_NAME +#endif +#if defined(BOOST_LIB_TOOLSET) +# undef BOOST_LIB_TOOLSET +#endif +#if defined(BOOST_LIB_THREAD_OPT) +# undef BOOST_LIB_THREAD_OPT +#endif +#if defined(BOOST_LIB_RT_OPT) +# undef BOOST_LIB_RT_OPT +#endif +#if defined(BOOST_LIB_LINK_OPT) +# undef BOOST_LIB_LINK_OPT +#endif +#if defined(BOOST_LIB_DEBUG_OPT) +# undef BOOST_LIB_DEBUG_OPT +#endif +#if defined(BOOST_DYN_LINK) +# undef BOOST_DYN_LINK +#endif +#if defined(BOOST_AUTO_LINK_NOMANGLE) +# undef BOOST_AUTO_LINK_NOMANGLE +#endif + + + + + + + + + + diff --git a/eo/contrib/boost/config/compiler/borland.hpp b/eo/contrib/boost/config/compiler/borland.hpp new file mode 100644 index 00000000..66769bec --- /dev/null +++ b/eo/contrib/boost/config/compiler/borland.hpp @@ -0,0 +1,175 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Aleksey Gurtovoy 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Borland C++ compiler setup: + +// Version 5.0 and below: +# if __BORLANDC__ <= 0x0550 +// Borland C++Builder 4 and 5: +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# if __BORLANDC__ == 0x0550 +// Borland C++Builder 5, command-line compiler 5.5: +# define BOOST_NO_OPERATORS_IN_NAMESPACE +# endif +# endif + +// Version 5.51 and below: +#if (__BORLANDC__ <= 0x551) +# define BOOST_NO_CV_SPECIALIZATIONS +# define BOOST_NO_CV_VOID_SPECIALIZATIONS +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_DEDUCED_TYPENAME +// workaround for missing WCHAR_MAX/WCHAR_MIN: +#include +#include +#ifndef WCHAR_MAX +# define WCHAR_MAX 0xffff +#endif +#ifndef WCHAR_MIN +# define WCHAR_MIN 0 +#endif +#endif + +// Version 7.0 (Kylix) and below: +#if (__BORLANDC__ <= 0x570) +# define BOOST_NO_SFINAE +# define BOOST_NO_INTEGRAL_INT64_T +# define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS +# define BOOST_NO_PRIVATE_IN_AGGREGATE +# define BOOST_NO_USING_TEMPLATE +# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG +# define BOOST_NO_TEMPLATE_TEMPLATES +# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS + // we shouldn't really need this - but too many things choke + // without it, this needs more investigation: +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +# define BOOST_NO_IS_ABSTRACT +# ifdef NDEBUG + // fix broken so that Boost.test works: +# include +# undef strcmp +# endif + +// +// new bug in 5.61: +#if (__BORLANDC__ >= 0x561) && (__BORLANDC__ <= 0x570) + // this seems to be needed by the command line compiler, but not the IDE: +# define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS +#endif + +# ifdef _WIN32 +# define BOOST_NO_SWPRINTF +# elif defined(linux) || defined(__linux__) || defined(__linux) + // we should really be able to do without this + // but the wcs* functions aren't imported into std:: +# define BOOST_NO_STDC_NAMESPACE + // _CPPUNWIND doesn't get automatically set for some reason: +# pragma defineonoption BOOST_CPPUNWIND -x +# endif +#endif + +// +// Post 0x561 we have long long and stdint.h: +#if __BORLANDC__ >= 0x561 +# ifndef __NO_LONG_LONG +# define BOOST_HAS_LONG_LONG +# endif + // On non-Win32 platforms let the platform config figure this out: +# ifdef _WIN32 +# define BOOST_HAS_STDINT_H +# endif +#endif + +// Borland C++Builder 6 defaults to using STLPort. If _USE_OLD_RW_STL is +// defined, then we have 0x560 or greater with the Rogue Wave implementation +// which presumably has the std::DBL_MAX bug. +#if ((__BORLANDC__ >= 0x550) && (__BORLANDC__ < 0x560)) || defined(_USE_OLD_RW_STL) +// is partly broken, some macros define symbols that are really in +// namespace std, so you end up having to use illegal constructs like +// std::DBL_MAX, as a fix we'll just include float.h and have done with: +#include +#endif +// +// __int64: +// +#if (__BORLANDC__ >= 0x530) && !defined(__STRICT_ANSI__) +# define BOOST_HAS_MS_INT64 +#endif +// +// check for exception handling support: +// +#if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) +# define BOOST_NO_EXCEPTIONS +#endif +// +// all versions have a : +// +#ifndef __STRICT_ANSI__ +# define BOOST_HAS_DIRENT_H +#endif +// +// all versions support __declspec: +// +#ifndef __STRICT_ANSI__ +# define BOOST_HAS_DECLSPEC +#endif +// +// ABI fixing headers: +// +#if __BORLANDC__ < 0x600 // not implemented for version 6 compiler yet +#ifndef BOOST_ABI_PREFIX +# define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp" +#endif +#ifndef BOOST_ABI_SUFFIX +# define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp" +#endif +#endif +// +// Disable Win32 support in ANSI mode: +// +#if __BORLANDC__ < 0x600 +# pragma defineonoption BOOST_DISABLE_WIN32 -A +#elif defined(__STRICT_ANSI__) +# define BOOST_DISABLE_WIN32 +#endif +// +// MSVC compatibility mode does some nasty things: +// +#if defined(_MSC_VER) && (_MSC_VER <= 1200) +# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +# define BOOST_NO_VOID_RETURNS +#endif + +#define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__) + +// +// versions check: +// we don't support Borland prior to version 5.4: +#if __BORLANDC__ < 0x540 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 1536 (Builder X preview): +#if (__BORLANDC__ > 1536) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# else +# pragma message( "Unknown compiler version - please run the configure tests and report the results") +# endif +#endif + + + + + + + + diff --git a/eo/contrib/boost/config/compiler/comeau.hpp b/eo/contrib/boost/config/compiler/comeau.hpp new file mode 100644 index 00000000..1b71008e --- /dev/null +++ b/eo/contrib/boost/config/compiler/comeau.hpp @@ -0,0 +1,59 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Douglas Gregor 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Aleksey Gurtovoy 2003. +// (C) Copyright Beman Dawes 2003. +// (C) Copyright Jens Maurer 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Comeau C++ compiler setup: + +#include "boost/config/compiler/common_edg.hpp" + +#if (__COMO_VERSION__ <= 4245) + +# if defined(_MSC_VER) && _MSC_VER <= 1300 +# if _MSC_VER > 100 + // only set this in non-strict mode: +# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +# endif +# endif + +// Void returns don't work when emulating VC 6 (Peter Dimov) + +# if defined(_MSC_VER) && (_MSC_VER == 1200) +# define BOOST_NO_VOID_RETURNS +# endif + +#endif // version 4245 + +// +// enable __int64 support in VC emulation mode +// +# if defined(_MSC_VER) && (_MSC_VER >= 1200) +# define BOOST_HAS_MS_INT64 +# endif + +#define BOOST_COMPILER "Comeau compiler version " BOOST_STRINGIZE(__COMO_VERSION__) + +// +// versions check: +// we don't know Comeau prior to version 4245: +#if __COMO_VERSION__ < 4245 +# error "Compiler not configured - please reconfigure" +#endif +// +// last known and checked version is 4245: +#if (__COMO_VERSION__ > 4245) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + + diff --git a/eo/contrib/boost/config/compiler/common_edg.hpp b/eo/contrib/boost/config/compiler/common_edg.hpp new file mode 100644 index 00000000..0443be1a --- /dev/null +++ b/eo/contrib/boost/config/compiler/common_edg.hpp @@ -0,0 +1,62 @@ +// (C) Copyright John Maddock 2001 - 2002. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright David Abrahams 2002. +// (C) Copyright Aleksey Gurtovoy 2002. +// (C) Copyright Markus Schoepflin 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// +// Options common to all edg based compilers. +// +// This is included from within the individual compiler mini-configs. + +#ifndef __EDG_VERSION__ +# error This file requires that __EDG_VERSION__ be defined. +#endif + +#if (__EDG_VERSION__ <= 238) +# define BOOST_NO_INTEGRAL_INT64_T +# define BOOST_NO_SFINAE +#endif + +#if (__EDG_VERSION__ <= 240) +# define BOOST_NO_VOID_RETURNS +#endif + +#if (__EDG_VERSION__ <= 241) && !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) +# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +#endif + +#if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES) +# define BOOST_NO_TEMPLATE_TEMPLATES +#endif + +#if (__EDG_VERSION__ < 300) && !defined(BOOST_NO_IS_ABSTRACT) +# define BOOST_NO_IS_ABSTRACT +#endif + +#if (__EDG_VERSION__ <= 303) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) +# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +#endif + +// See also kai.hpp which checks a Kai-specific symbol for EH +# if !defined(__KCC) && !defined(__EXCEPTIONS) +# define BOOST_NO_EXCEPTIONS +# endif + +# if !defined(__NO_LONG_LONG) +# define BOOST_HAS_LONG_LONG +# endif + +#ifdef c_plusplus +// EDG has "long long" in non-strict mode +// However, some libraries have insufficient "long long" support +// #define BOOST_HAS_LONG_LONG +#endif + + + diff --git a/eo/contrib/boost/config/compiler/compaq_cxx.hpp b/eo/contrib/boost/config/compiler/compaq_cxx.hpp new file mode 100644 index 00000000..a52e66a2 --- /dev/null +++ b/eo/contrib/boost/config/compiler/compaq_cxx.hpp @@ -0,0 +1,19 @@ +// (C) Copyright John Maddock 2001 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Dec Alpha True64 C++ compiler setup: + +#define BOOST_COMPILER "Dec Alpha True64 " BOOST_STRINGIZE(__DECCXX_VER) + +#include "boost/config/compiler/common_edg.hpp" + +// +// versions check: +// Nothing to do here? + + + diff --git a/eo/contrib/boost/config/compiler/digitalmars.hpp b/eo/contrib/boost/config/compiler/digitalmars.hpp new file mode 100644 index 00000000..32fc71fa --- /dev/null +++ b/eo/contrib/boost/config/compiler/digitalmars.hpp @@ -0,0 +1,49 @@ +// Copyright (C) Christof Meerwald 2003 +// Copyright (C) Dan Watkins 2003 +// +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Digital Mars C++ compiler setup: +#define BOOST_COMPILER __DMC_VERSION_STRING__ + +#define BOOST_HAS_LONG_LONG +#define BOOST_HAS_PRAGMA_ONCE + +#if (__DMC__ <= 0x833) +#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +#define BOOST_NO_TEMPLATE_TEMPLATES +#define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING +#define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS +#define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +#endif +#if (__DMC__ <= 0x840) || !defined(BOOST_STRICT_CONFIG) +#define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +#define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +#define BOOST_NO_OPERATORS_IN_NAMESPACE +#define BOOST_NO_UNREACHABLE_RETURN_DETECTION +#define BOOST_NO_SFINAE +#define BOOST_NO_USING_TEMPLATE +#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +#endif + +// +// has macros: +#if (__DMC__ >= 0x840) +#define BOOST_HAS_DIRENT_H +#define BOOST_HAS_STDINT_H +#define BOOST_HAS_WINTHREADS +#endif + + +// check for exception handling support: +#ifndef _CPPUNWIND +# define BOOST_NO_EXCEPTIONS +#endif + +#if (__DMC__ < 0x840) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif diff --git a/eo/contrib/boost/config/compiler/gcc.hpp b/eo/contrib/boost/config/compiler/gcc.hpp new file mode 100644 index 00000000..d94b16b7 --- /dev/null +++ b/eo/contrib/boost/config/compiler/gcc.hpp @@ -0,0 +1,105 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001 - 2002. +// (C) Copyright Jens Maurer 2001 - 2002. +// (C) Copyright Beman Dawes 2001 - 2003. +// (C) Copyright Douglas Gregor 2002. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Synge Todo 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// GNU C++ compiler setup: + +#if __GNUC__ < 3 +# if __GNUC_MINOR__ == 91 + // egcs 1.1 won't parse shared_ptr.hpp without this: +# define BOOST_NO_AUTO_PTR +# endif +# if __GNUC_MINOR__ < 95 + // + // Prior to gcc 2.95 member templates only partly + // work - define BOOST_MSVC6_MEMBER_TEMPLATES + // instead since inline member templates mostly work. + // +# define BOOST_NO_MEMBER_TEMPLATES +# if __GNUC_MINOR__ >= 9 +# define BOOST_MSVC6_MEMBER_TEMPLATES +# endif +# endif + +# if __GNUC_MINOR__ < 96 +# define BOOST_NO_SFINAE +# endif + +# if __GNUC_MINOR__ <= 97 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# define BOOST_NO_OPERATORS_IN_NAMESPACE +# endif + +# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE +# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +# define BOOST_NO_IS_ABSTRACT +#elif __GNUC__ == 3 + // + // gcc-3.x problems: + // + // Bug specific to gcc 3.1 and 3.2: + // +# if ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2)) +# define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +# endif +# if __GNUC_MINOR__ < 4 +# define BOOST_NO_IS_ABSTRACT +# endif +#endif + +#ifndef __EXCEPTIONS +# define BOOST_NO_EXCEPTIONS +#endif + + +// +// Threading support: Turn this on unconditionally here (except for +// those platforms where we can know for sure). It will get turned off again +// later if no threading API is detected. +// +#if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__) +# define BOOST_HAS_THREADS +#endif + +// +// gcc has "long long" +// +#define BOOST_HAS_LONG_LONG + +// +// gcc implements the named return value optimization since version 3.1 +// +#if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) +#define BOOST_HAS_NRVO +#endif + +#define BOOST_COMPILER "GNU C++ version " __VERSION__ + +// +// versions check: +// we don't know gcc prior to version 2.90: +#if (__GNUC__ == 2) && (__GNUC_MINOR__ < 90) +# error "Compiler not configured - please reconfigure" +#endif +// +// last known and checked version is 4.0 (Pre-release): +#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# else +// we don't emit warnings here anymore since there are no defect macros defined for +// gcc post 3.4, so any failures are gcc regressions... +//# warning "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + diff --git a/eo/contrib/boost/config/compiler/greenhills.hpp b/eo/contrib/boost/config/compiler/greenhills.hpp new file mode 100644 index 00000000..038b6b2b --- /dev/null +++ b/eo/contrib/boost/config/compiler/greenhills.hpp @@ -0,0 +1,28 @@ +// (C) Copyright John Maddock 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Greenhills C++ compiler setup: + +#define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs) + +#include "boost/config/compiler/common_edg.hpp" + +// +// versions check: +// we don't support Greenhills prior to version 0: +#if __ghs < 0 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 0: +#if (__ghs > 0) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + diff --git a/eo/contrib/boost/config/compiler/hp_acc.hpp b/eo/contrib/boost/config/compiler/hp_acc.hpp new file mode 100644 index 00000000..3d05ba56 --- /dev/null +++ b/eo/contrib/boost/config/compiler/hp_acc.hpp @@ -0,0 +1,70 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001 - 2003. +// (C) Copyright Aleksey Gurtovoy 2002. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Toon Knapen 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// HP aCC C++ compiler setup: + +#if (__HP_aCC <= 33100) +# define BOOST_NO_INTEGRAL_INT64_T +# define BOOST_NO_OPERATORS_IN_NAMESPACE +# if !defined(_NAMESPACE_STD) +# define BOOST_NO_STD_LOCALE +# define BOOST_NO_STRINGSTREAM +# endif +#endif + +#if (__HP_aCC <= 33300) +// member templates are sufficiently broken that we disable them for now +# define BOOST_NO_MEMBER_TEMPLATES +# define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS +# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE +#endif + +#if (__HP_aCC <= 33900) || !defined(BOOST_STRICT_CONFIG) +# define BOOST_NO_UNREACHABLE_RETURN_DETECTION +# define BOOST_NO_TEMPLATE_TEMPLATES +# define BOOST_NO_SWPRINTF +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +# define BOOST_NO_IS_ABSTRACT +// std lib config should set this one already: +//# define BOOST_NO_STD_ALLOCATOR +#endif + +// optional features rather than defects: +#if (__HP_aCC >= 33900) +# define BOOST_HAS_LONG_LONG +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +#endif + +#if (__HP_aCC >= 50000 ) && (__HP_aCC <= 53800 ) || (__HP_aCC < 31300 ) +# define BOOST_NO_MEMBER_TEMPLATE_KEYWORD +#endif + +#define BOOST_NO_MEMBER_TEMPLATE_FRIENDS + +#define BOOST_COMPILER "HP aCC version " BOOST_STRINGIZE(__HP_aCC) + +// +// versions check: +// we don't support HP aCC prior to version 0: +#if __HP_aCC < 33000 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 0: +#if (__HP_aCC > 53800) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + + diff --git a/eo/contrib/boost/config/compiler/intel.hpp b/eo/contrib/boost/config/compiler/intel.hpp new file mode 100644 index 00000000..65255776 --- /dev/null +++ b/eo/contrib/boost/config/compiler/intel.hpp @@ -0,0 +1,146 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Aleksey Gurtovoy 2002 - 2003. +// (C) Copyright Guillaume Melquiond 2002 - 2003. +// (C) Copyright Beman Dawes 2003. +// (C) Copyright Martin Wille 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Intel compiler setup: + +#include "boost/config/compiler/common_edg.hpp" + +#if defined(__INTEL_COMPILER) +# define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER +#elif defined(__ICL) +# define BOOST_INTEL_CXX_VERSION __ICL +#elif defined(__ICC) +# define BOOST_INTEL_CXX_VERSION __ICC +#elif defined(__ECC) +# define BOOST_INTEL_CXX_VERSION __ECC +#endif + +#define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION) +#define BOOST_INTEL BOOST_INTEL_CXX_VERSION + +#if defined(_WIN32) || defined(_WIN64) +# define BOOST_INTEL_WIN BOOST_INTEL +#else +# define BOOST_INTEL_LINUX BOOST_INTEL +#endif + +#if (BOOST_INTEL_CXX_VERSION <= 500) && defined(_MSC_VER) +# define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +# define BOOST_NO_TEMPLATE_TEMPLATES +#endif + +#if (BOOST_INTEL_CXX_VERSION <= 600) + +# if defined(_MSC_VER) && (_MSC_VER <= 1300) // added check for <= VC 7 (Peter Dimov) + +// Boost libraries assume strong standard conformance unless otherwise +// indicated by a config macro. As configured by Intel, the EDG front-end +// requires certain compiler options be set to achieve that strong conformance. +// Particularly /Qoption,c,--arg_dep_lookup (reported by Kirk Klobe & Thomas Witt) +// and /Zc:wchar_t,forScope. See boost-root/tools/build/intel-win32-tools.jam for +// details as they apply to particular versions of the compiler. When the +// compiler does not predefine a macro indicating if an option has been set, +// this config file simply assumes the option has been set. +// Thus BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP will not be defined, even if +// the compiler option is not enabled. + +# define BOOST_NO_SWPRINTF +# endif + +// Void returns, 64 bit integrals don't work when emulating VC 6 (Peter Dimov) + +# if defined(_MSC_VER) && (_MSC_VER <= 1200) +# define BOOST_NO_VOID_RETURNS +# define BOOST_NO_INTEGRAL_INT64_T +# endif + +#endif + +#if (BOOST_INTEL_CXX_VERSION <= 710) && defined(_WIN32) +# define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS +#endif + +// See http://aspn.activestate.com/ASPN/Mail/Message/boost/1614864 +#if BOOST_INTEL_CXX_VERSION < 600 +# define BOOST_NO_INTRINSIC_WCHAR_T +#else +// We should test the macro _WCHAR_T_DEFINED to check if the compiler +// supports wchar_t natively. *BUT* there is a problem here: the standard +// headers define this macro if they typedef wchar_t. Anyway, we're lucky +// because they define it without a value, while Intel C++ defines it +// to 1. So we can check its value to see if the macro was defined natively +// or not. +// Under UNIX, the situation is exactly the same, but the macro _WCHAR_T +// is used instead. +# if ((_WCHAR_T_DEFINED + 0) == 0) && ((_WCHAR_T + 0) == 0) +# define BOOST_NO_INTRINSIC_WCHAR_T +# endif +#endif + +// +// Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T +// set correctly, if we don't do this now, we will get errors later +// in type_traits code among other things, getting this correct +// for the Intel compiler is actually remarkably fragile and tricky: +// +#if defined(BOOST_NO_INTRINSIC_WCHAR_T) +#include +template< typename T > struct assert_no_intrinsic_wchar_t; +template<> struct assert_no_intrinsic_wchar_t { typedef void type; }; +// if you see an error here then you need to unset BOOST_NO_INTRINSIC_WCHAR_T +// where it is defined above: +typedef assert_no_intrinsic_wchar_t::type assert_no_intrinsic_wchar_t_; +#else +template< typename T > struct assert_intrinsic_wchar_t; +template<> struct assert_intrinsic_wchar_t {}; +// if you see an error here then define BOOST_NO_INTRINSIC_WCHAR_T on the command line: +template<> struct assert_intrinsic_wchar_t {}; +#endif + +#if _MSC_VER+0 >= 1000 +# if _MSC_VER >= 1200 +# define BOOST_HAS_MS_INT64 +# endif +# define BOOST_NO_SWPRINTF +#elif defined(_WIN32) +# define BOOST_DISABLE_WIN32 +#endif + +// I checked version 6.0 build 020312Z, it implements the NRVO. +// Correct this as you find out which version of the compiler +// implemented the NRVO first. (Daniel Frey) +#if (BOOST_INTEL_CXX_VERSION >= 600) +# define BOOST_HAS_NRVO +#endif + +// +// versions check: +// we don't support Intel prior to version 5.0: +#if BOOST_INTEL_CXX_VERSION < 500 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version: +#if (BOOST_INTEL_CXX_VERSION > 900) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# elif defined(_MSC_VER) +# pragma message("Unknown compiler version - please run the configure tests and report the results") +# endif +#endif + + + + + diff --git a/eo/contrib/boost/config/compiler/kai.hpp b/eo/contrib/boost/config/compiler/kai.hpp new file mode 100644 index 00000000..de16f1a6 --- /dev/null +++ b/eo/contrib/boost/config/compiler/kai.hpp @@ -0,0 +1,35 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright David Abrahams 2002. +// (C) Copyright Aleksey Gurtovoy 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Kai C++ compiler setup: + +#include "boost/config/compiler/common_edg.hpp" + +# if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG) + // at least on Sun, the contents of is not in namespace std +# define BOOST_NO_STDC_NAMESPACE +# endif + +// see also common_edg.hpp which needs a special check for __KCC +# if !defined(_EXCEPTIONS) +# define BOOST_NO_EXCEPTIONS +# endif + +#define BOOST_COMPILER "Kai C++ version " BOOST_STRINGIZE(__KCC_VERSION) + +// +// last known and checked version is 4001: +#if (__KCC_VERSION > 4001) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + diff --git a/eo/contrib/boost/config/compiler/metrowerks.hpp b/eo/contrib/boost/config/compiler/metrowerks.hpp new file mode 100644 index 00000000..f173295e --- /dev/null +++ b/eo/contrib/boost/config/compiler/metrowerks.hpp @@ -0,0 +1,104 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright David Abrahams 2001 - 2002. +// (C) Copyright Beman Dawes 2001 - 2003. +// (C) Copyright Stefan Slapeta 2004. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Metrowerks C++ compiler setup: + +// locale support is disabled when linking with the dynamic runtime +# ifdef _MSL_NO_LOCALE +# define BOOST_NO_STD_LOCALE +# endif + +# if __MWERKS__ <= 0x2301 // 5.3 +# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# define BOOST_NO_POINTER_TO_MEMBER_CONST +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +# define BOOST_NO_MEMBER_TEMPLATE_KEYWORD +# endif + +# if __MWERKS__ <= 0x2401 // 6.2 +//# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# endif + +# if(__MWERKS__ <= 0x2407) // 7.x +# define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS +# define BOOST_NO_UNREACHABLE_RETURN_DETECTION +# endif + +# if(__MWERKS__ <= 0x3003) // 8.x +# define BOOST_NO_SFINAE +# endif + +// the "|| !defined(BOOST_STRICT_CONFIG)" part should apply to the last +// tested version *only*: +# if(__MWERKS__ <= 0x3206) || !defined(BOOST_STRICT_CONFIG) // 9.5 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# define BOOST_NO_IS_ABSTRACT +# endif + +#if !__option(wchar_type) +# define BOOST_NO_INTRINSIC_WCHAR_T +#endif + +#if !__option(exceptions) +# define BOOST_NO_EXCEPTIONS +#endif + +#if (__INTEL__ && _WIN32) || (__POWERPC__ && macintosh) +# if __MWERKS__ == 0x3000 +# define BOOST_COMPILER_VERSION 8.0 +# elif __MWERKS__ == 0x3001 +# define BOOST_COMPILER_VERSION 8.1 +# elif __MWERKS__ == 0x3002 +# define BOOST_COMPILER_VERSION 8.2 +# elif __MWERKS__ == 0x3003 +# define BOOST_COMPILER_VERSION 8.3 +# elif __MWERKS__ == 0x3200 +# define BOOST_COMPILER_VERSION 9.0 +# elif __MWERKS__ == 0x3201 +# define BOOST_COMPILER_VERSION 9.1 +# elif __MWERKS__ == 0x3202 +# define BOOST_COMPILER_VERSION 9.2 +# elif __MWERKS__ == 0x3204 +# define BOOST_COMPILER_VERSION 9.3 +# elif __MWERKS__ == 0x3205 +# define BOOST_COMPILER_VERSION 9.4 +# elif __MWERKS__ == 0x3206 +# define BOOST_COMPILER_VERSION 9.5 +# else +# define BOOST_COMPILER_VERSION __MWERKS__ +# endif +#else +# define BOOST_COMPILER_VERSION __MWERKS__ +#endif + +#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) + +// +// versions check: +// we don't support Metrowerks prior to version 5.3: +#if __MWERKS__ < 0x2301 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version: +#if (__MWERKS__ > 0x3205) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + + + + + diff --git a/eo/contrib/boost/config/compiler/mpw.hpp b/eo/contrib/boost/config/compiler/mpw.hpp new file mode 100644 index 00000000..8ab2aacb --- /dev/null +++ b/eo/contrib/boost/config/compiler/mpw.hpp @@ -0,0 +1,51 @@ +// (C) Copyright John Maddock 2001 - 2002. +// (C) Copyright Aleksey Gurtovoy 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// MPW C++ compilers setup: + +# if defined(__SC__) +# define BOOST_COMPILER "MPW SCpp version " BOOST_STRINGIZE(__SC__) +# elif defined(__MRC__) +# define BOOST_COMPILER "MPW MrCpp version " BOOST_STRINGIZE(__MRC__) +# else +# error "Using MPW compiler configuration by mistake. Please update." +# endif + +// +// MPW 8.90: +// +#if (MPW_CPLUS <= 0x890) || !defined(BOOST_STRICT_CONFIG) +# define BOOST_NO_CV_SPECIALIZATIONS +# define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_NO_INTRINSIC_WCHAR_T +# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# define BOOST_NO_USING_TEMPLATE + +# define BOOST_NO_CWCHAR +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + +# define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */ +#endif + +// +// versions check: +// we don't support MPW prior to version 8.9: +#if MPW_CPLUS < 0x890 +# error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 0x890: +#if (MPW_CPLUS > 0x890) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + diff --git a/eo/contrib/boost/config/compiler/sgi_mipspro.hpp b/eo/contrib/boost/config/compiler/sgi_mipspro.hpp new file mode 100644 index 00000000..689b67ee --- /dev/null +++ b/eo/contrib/boost/config/compiler/sgi_mipspro.hpp @@ -0,0 +1,24 @@ +// (C) Copyright John Maddock 2001 - 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// SGI C++ compiler setup: + +#define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION) + +#include "boost/config/compiler/common_edg.hpp" + +// +// Threading support: +// Turn this on unconditionally here, it will get turned off again later +// if no threading API is detected. +// +#define BOOST_HAS_THREADS +// +// version check: +// probably nothing to do here? + + diff --git a/eo/contrib/boost/config/compiler/sunpro_cc.hpp b/eo/contrib/boost/config/compiler/sunpro_cc.hpp new file mode 100644 index 00000000..eca19feb --- /dev/null +++ b/eo/contrib/boost/config/compiler/sunpro_cc.hpp @@ -0,0 +1,90 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Jens Maurer 2001 - 2003. +// (C) Copyright Peter Dimov 2002. +// (C) Copyright Aleksey Gurtovoy 2002 - 2003. +// (C) Copyright David Abrahams 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Sun C++ compiler setup: + +# if __SUNPRO_CC <= 0x500 +# define BOOST_NO_MEMBER_TEMPLATES +# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# endif + +# if (__SUNPRO_CC <= 0x520) + // + // Sunpro 5.2 and earler: + // + // although sunpro 5.2 supports the syntax for + // inline initialization it often gets the value + // wrong, especially where the value is computed + // from other constants (J Maddock 6th May 2001) +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION + + // Although sunpro 5.2 supports the syntax for + // partial specialization, it often seems to + // bind to the wrong specialization. Better + // to disable it until suppport becomes more stable + // (J Maddock 6th May 2001). +# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif + +# if (__SUNPRO_CC <= 0x530) + // Requesting debug info (-g) with Boost.Python results + // in an internal compiler error for "static const" + // initialized in-class. + // >> Assertion: (../links/dbg_cstabs.cc, line 611) + // while processing ../test.cpp at line 0. + // (Jens Maurer according to Gottfried Ganßauge 04 Mar 2002) +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION + + // SunPro 5.3 has better support for partial specialization, + // but breaks when compiling std::less > + // (Jens Maurer 4 Nov 2001). + + // std::less specialization fixed as reported by George + // Heintzelman; partial specialization re-enabled + // (Peter Dimov 17 Jan 2002) + +//# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + // integral constant expressions with 64 bit numbers fail +# define BOOST_NO_INTEGRAL_INT64_T +# endif + +# if (__SUNPRO_CC < 0x570) +# define BOOST_NO_TEMPLATE_TEMPLATES + // see http://lists.boost.org/MailArchives/boost/msg47184.php + // and http://lists.boost.org/MailArchives/boost/msg47220.php +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_NO_SFINAE +# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS +# define BOOST_NO_IS_ABSTRACT +# endif + +#define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC) + +// +// versions check: +// we don't support sunpro prior to version 4: +#if __SUNPRO_CC < 0x400 +#error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 0x570: +#if (__SUNPRO_CC > 0x570) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + + + + diff --git a/eo/contrib/boost/config/compiler/vacpp.hpp b/eo/contrib/boost/config/compiler/vacpp.hpp new file mode 100644 index 00000000..4cf0de7c --- /dev/null +++ b/eo/contrib/boost/config/compiler/vacpp.hpp @@ -0,0 +1,58 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Toon Knapen 2001 - 2003. +// (C) Copyright Lie-Quan Lee 2001. +// (C) Copyright Markus Schöpflin 2002 - 2003. +// (C) Copyright Beman Dawes 2002 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Visual Age (IBM) C++ compiler setup: + +#if __IBMCPP__ <= 501 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS +#endif + +#if (__IBMCPP__ <= 502) +// Actually the compiler supports inclass member initialization but it +// requires a definition for the class member and it doesn't recognize +// it as an integral constant expression when used as a template argument. +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_NO_INTEGRAL_INT64_T +# define BOOST_NO_MEMBER_TEMPLATE_KEYWORD +#endif + +#if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG) +# define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS +# define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES 1 +#endif + +// +// On AIX thread support seems to be indicated by _THREAD_SAFE: +// +#ifdef _THREAD_SAFE +# define BOOST_HAS_THREADS +#endif + +#define BOOST_COMPILER "IBM Visual Age version " BOOST_STRINGIZE(__IBMCPP__) + +// +// versions check: +// we don't support Visual age prior to version 5: +#if __IBMCPP__ < 500 +#error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 600: +#if (__IBMCPP__ > 600) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + + + + diff --git a/eo/contrib/boost/config/compiler/visualc.hpp b/eo/contrib/boost/config/compiler/visualc.hpp new file mode 100644 index 00000000..1ce600cc --- /dev/null +++ b/eo/contrib/boost/config/compiler/visualc.hpp @@ -0,0 +1,147 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001 - 2002. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Aleksey Gurtovoy 2002. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Beman Dawes 2002 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Microsoft Visual C++ compiler setup: + +#define BOOST_MSVC _MSC_VER + +// turn off the warnings before we #include anything +#pragma warning( disable : 4503 ) // warning: decorated name length exceeded + +#if _MSC_VER < 1300 // 1200 == VC++ 6.0, 1201 == EVC4.2 +#pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +# define BOOST_NO_VOID_RETURNS +# define BOOST_NO_EXCEPTION_STD_NAMESPACE + // disable min/max macro defines on vc6: + // +#endif + +#if (_MSC_VER <= 1300) // 1300 == VC++ 7.0 + +#if !defined(_MSC_EXTENSIONS) && !defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) // VC7 bug with /Za +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +#endif + +# define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_NO_PRIVATE_IN_AGGREGATE +# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +# define BOOST_NO_INTEGRAL_INT64_T +# define BOOST_NO_DEDUCED_TYPENAME +# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE + +// VC++ 6/7 has member templates but they have numerous problems including +// cases of silent failure, so for safety we define: +# define BOOST_NO_MEMBER_TEMPLATES +// For VC++ experts wishing to attempt workarounds, we define: +# define BOOST_MSVC6_MEMBER_TEMPLATES + +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# define BOOST_NO_CV_VOID_SPECIALIZATIONS +# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# define BOOST_NO_USING_TEMPLATE +# define BOOST_NO_SWPRINTF +# define BOOST_NO_TEMPLATE_TEMPLATES +# define BOOST_NO_SFINAE +# define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS +# define BOOST_NO_IS_ABSTRACT +# if (_MSC_VER > 1200) +# define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS +# endif + +#endif + +#if _MSC_VER < 1310 // 1310 == VC++ 7.1 +# define BOOST_NO_SWPRINTF +#endif + +#if _MSC_VER <= 1400 // 1400 == VC++ 8.0 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +#endif + +#ifndef _NATIVE_WCHAR_T_DEFINED +# define BOOST_NO_INTRINSIC_WCHAR_T +#endif + +#ifdef _WIN32_WCE +# define BOOST_NO_THREADEX +# define BOOST_NO_GETSYSTEMTIMEASFILETIME +#endif + +// +// check for exception handling support: +#ifndef _CPPUNWIND +# define BOOST_NO_EXCEPTIONS +#endif + +// +// __int64 support: +// +#if (_MSC_VER >= 1200) +# define BOOST_HAS_MS_INT64 +#endif +#if (_MSC_VER >= 1310) && defined(_MSC_EXTENSIONS) +# define BOOST_HAS_LONG_LONG +#endif +// +// disable Win32 API's if compiler extentions are +// turned off: +// +#ifndef _MSC_EXTENSIONS +# define BOOST_DISABLE_WIN32 +#endif + +// +// all versions support __declspec: +// +#define BOOST_HAS_DECLSPEC +// +// prefix and suffix headers: +// +#ifndef BOOST_ABI_PREFIX +# define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp" +#endif +#ifndef BOOST_ABI_SUFFIX +# define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp" +#endif + +# if _MSC_VER == 1200 +# define BOOST_COMPILER_VERSION 6.0 +# elif _MSC_VER == 1300 +# define BOOST_COMPILER_VERSION 7.0 +# elif _MSC_VER == 1310 +# define BOOST_COMPILER_VERSION 7.1 +# elif _MSC_VER == 1400 +# define BOOST_COMPILER_VERSION 8.0 +# else +# define BOOST_COMPILER_VERSION _MSC_VER +# endif + +#define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) + +// +// versions check: +// we don't support Visual C++ prior to version 6: +#if _MSC_VER < 1200 +#error "Compiler not supported or configured - please reconfigure" +#endif +// +// last known and checked version is 1310: +#if (_MSC_VER > 1400) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# else +# pragma message("Unknown compiler version - please run the configure tests and report the results") +# endif +#endif diff --git a/eo/contrib/boost/config/platform/aix.hpp b/eo/contrib/boost/config/platform/aix.hpp new file mode 100644 index 00000000..894ef42c --- /dev/null +++ b/eo/contrib/boost/config/platform/aix.hpp @@ -0,0 +1,33 @@ +// (C) Copyright John Maddock 2001 - 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// IBM/Aix specific config options: + +#define BOOST_PLATFORM "IBM Aix" + +#define BOOST_HAS_UNISTD_H +#define BOOST_HAS_NL_TYPES_H +#define BOOST_HAS_NANOSLEEP +#define BOOST_HAS_CLOCK_GETTIME + +// This needs support in "boost/cstdint.hpp" exactly like FreeBSD. +// This platform has header named which includes all +// the things needed. +#define BOOST_HAS_STDINT_H + +// Threading API's: +#define BOOST_HAS_PTHREADS +#define BOOST_HAS_PTHREAD_DELAY_NP +#define BOOST_HAS_SCHED_YIELD +//#define BOOST_HAS_PTHREAD_YIELD + +// boilerplate code: +#include + + + + diff --git a/eo/contrib/boost/config/platform/amigaos.hpp b/eo/contrib/boost/config/platform/amigaos.hpp new file mode 100644 index 00000000..34bcf412 --- /dev/null +++ b/eo/contrib/boost/config/platform/amigaos.hpp @@ -0,0 +1,15 @@ +// (C) Copyright John Maddock 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +#define BOOST_PLATFORM "AmigaOS" + +#define BOOST_DISABLE_THREADS +#define BOOST_NO_CWCHAR +#define BOOST_NO_STD_WSTRING +#define BOOST_NO_INTRINSIC_WCHAR_T + + diff --git a/eo/contrib/boost/config/platform/beos.hpp b/eo/contrib/boost/config/platform/beos.hpp new file mode 100644 index 00000000..48c3d8dc --- /dev/null +++ b/eo/contrib/boost/config/platform/beos.hpp @@ -0,0 +1,26 @@ +// (C) Copyright John Maddock 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// BeOS specific config options: + +#define BOOST_PLATFORM "BeOS" + +#define BOOST_NO_CWCHAR +#define BOOST_NO_CWCTYPE +#define BOOST_HAS_UNISTD_H + +#define BOOST_HAS_BETHREADS + +#ifndef BOOST_DISABLE_THREADS +# define BOOST_HAS_THREADS +#endif + +// boilerplate code: +#include + + + diff --git a/eo/contrib/boost/config/platform/bsd.hpp b/eo/contrib/boost/config/platform/bsd.hpp new file mode 100644 index 00000000..09988e0c --- /dev/null +++ b/eo/contrib/boost/config/platform/bsd.hpp @@ -0,0 +1,71 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Douglas Gregor 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// generic BSD config options: + +#if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) +#error "This platform is not BSD" +#endif + +#ifdef __FreeBSD__ +#define BOOST_PLATFORM "FreeBSD " BOOST_STRINGIZE(__FreeBSD__) +#elif defined(__NetBSD__) +#define BOOST_PLATFORM "NetBSD " BOOST_STRINGIZE(__NetBSD__) +#elif defined(__OpenBSD__) +#define BOOST_PLATFORM "OpenBSD " BOOST_STRINGIZE(__OpenBSD__) +#endif + +// +// is this the correct version check? +// FreeBSD has but does not +// advertise the fact in : +// +#if defined(__FreeBSD__) && (__FreeBSD__ >= 3) +# define BOOST_HAS_NL_TYPES_H +#endif + +// +// FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in +// and not in +// +#if defined(__FreeBSD__) && (__FreeBSD__ <= 3) +# define BOOST_HAS_PTHREADS +#endif + +// +// No wide character support in the BSD header files: +// +#if !(defined(__FreeBSD__) && (__FreeBSD__ >= 5)) +# define BOOST_NO_CWCHAR +#endif +// +// The BSD has macros only, no functions: +// +#if !defined(__OpenBSD__) +# define BOOST_NO_CTYPE_FUNCTIONS +#endif + +// +// thread API's not auto detected: +// +#define BOOST_HAS_SCHED_YIELD +#define BOOST_HAS_NANOSLEEP +#define BOOST_HAS_GETTIMEOFDAY +#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +#define BOOST_HAS_SIGACTION + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + + + + + + diff --git a/eo/contrib/boost/config/platform/cygwin.hpp b/eo/contrib/boost/config/platform/cygwin.hpp new file mode 100644 index 00000000..0fd2ebe2 --- /dev/null +++ b/eo/contrib/boost/config/platform/cygwin.hpp @@ -0,0 +1,48 @@ +// (C) Copyright John Maddock 2001 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// cygwin specific config options: + +#define BOOST_PLATFORM "Cygwin" +#define BOOST_NO_CWCTYPE +#define BOOST_NO_CWCHAR +#define BOOST_NO_SWPRINTF +#define BOOST_HAS_DIRENT_H + +// +// Threading API: +// See if we have POSIX threads, if we do use them, otherwise +// revert to native Win threads. +#define BOOST_HAS_UNISTD_H +#include +#if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) +# define BOOST_HAS_PTHREADS +# define BOOST_HAS_SCHED_YIELD +# define BOOST_HAS_GETTIMEOFDAY +# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# define BOOST_HAS_SIGACTION +#else +# if !defined(BOOST_HAS_WINTHREADS) +# define BOOST_HAS_WINTHREADS +# endif +# define BOOST_HAS_FTIME +#endif + +// +// find out if we have a stdint.h, there should be a better way to do this: +// +#include +#ifdef _STDINT_H +#define BOOST_HAS_STDINT_H +#endif + +// boilerplate code: +#include + + + + diff --git a/eo/contrib/boost/config/platform/hpux.hpp b/eo/contrib/boost/config/platform/hpux.hpp new file mode 100644 index 00000000..fa773aa7 --- /dev/null +++ b/eo/contrib/boost/config/platform/hpux.hpp @@ -0,0 +1,68 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001 - 2003. +// (C) Copyright David Abrahams 2002. +// (C) Copyright Toon Knapen 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// hpux specific config options: + +#define BOOST_PLATFORM "HP-UX" + +// In principle, HP-UX has a nice under the name +// However, it has the following problem: +// Use of UINT32_C(0) results in "0u l" for the preprocessed source +// (verifyable with gcc 2.95.3, assumed for HP aCC) +// #define BOOST_HAS_STDINT_H + +#define BOOST_NO_SWPRINTF +#define BOOST_NO_CWCTYPE + +#if defined(__GNUC__) +# if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3)) + // GNU C on HP-UX does not support threads (checked up to gcc 3.3) +# define BOOST_DISABLE_THREADS +# elif !defined(BOOST_DISABLE_THREADS) + // threads supported from gcc-3.3 onwards: +# define BOOST_HAS_THREADS +# define BOOST_HAS_PTHREADS +# endif +#endif + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + +// the following are always available: +#ifndef BOOST_HAS_GETTIMEOFDAY +# define BOOST_HAS_GETTIMEOFDAY +#endif +#ifndef BOOST_HAS_SCHED_YIELD +# define BOOST_HAS_SCHED_YIELD +#endif +#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +#endif +#ifndef BOOST_HAS_NL_TYPES_H +# define BOOST_HAS_NL_TYPES_H +#endif +#ifndef BOOST_HAS_NANOSLEEP +# define BOOST_HAS_NANOSLEEP +#endif +#ifndef BOOST_HAS_GETTIMEOFDAY +# define BOOST_HAS_GETTIMEOFDAY +#endif +#ifndef BOOST_HAS_DIRENT_H +# define BOOST_HAS_DIRENT_H +#endif +#ifndef BOOST_HAS_CLOCK_GETTIME +# define BOOST_HAS_CLOCK_GETTIME +#endif +#ifndef BOOST_HAS_SIGACTION +# define BOOST_HAS_SIGACTION +#endif + + diff --git a/eo/contrib/boost/config/platform/irix.hpp b/eo/contrib/boost/config/platform/irix.hpp new file mode 100644 index 00000000..aeae49c8 --- /dev/null +++ b/eo/contrib/boost/config/platform/irix.hpp @@ -0,0 +1,31 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// See http://www.boost.org for most recent version. + +// SGI Irix specific config options: + +#define BOOST_PLATFORM "SGI Irix" + +#define BOOST_NO_SWPRINTF +// +// these are not auto detected by POSIX feature tests: +// +#define BOOST_HAS_GETTIMEOFDAY +#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE + +#ifdef __GNUC__ + // GNU C on IRIX does not support threads (checked up to gcc 3.3) +# define BOOST_DISABLE_THREADS +#endif + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + + + diff --git a/eo/contrib/boost/config/platform/linux.hpp b/eo/contrib/boost/config/platform/linux.hpp new file mode 100644 index 00000000..51ae1334 --- /dev/null +++ b/eo/contrib/boost/config/platform/linux.hpp @@ -0,0 +1,98 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// linux specific config options: + +#define BOOST_PLATFORM "linux" + +// make sure we have __GLIBC_PREREQ if available at all +#include + +// +// added to glibc 2.1.1 +// We can only test for 2.1 though: +// +#if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1))) + // defines int64_t unconditionally, but defines + // int64_t only if __GNUC__. Thus, assume a fully usable + // only when using GCC. +# if defined __GNUC__ +# define BOOST_HAS_STDINT_H +# endif +#endif + +#if defined(__LIBCOMO__) + // + // como on linux doesn't have std:: c functions: + // NOTE: versions of libcomo prior to beta28 have octal version numbering, + // e.g. version 25 is 21 (dec) + // +# if __LIBCOMO_VERSION__ <= 20 +# define BOOST_NO_STDC_NAMESPACE +# endif + +# if __LIBCOMO_VERSION__ <= 21 +# define BOOST_NO_SWPRINTF +# endif + +#endif + +// +// If glibc is past version 2 then we definitely have +// gettimeofday, earlier versions may or may not have it: +// +#if defined(__GLIBC__) && (__GLIBC__ >= 2) +# define BOOST_HAS_GETTIMEOFDAY +#endif + +#ifdef __USE_POSIX199309 +# define BOOST_HAS_NANOSLEEP +#endif + +#if defined(__GLIBC__) && defined(__GLIBC_PREREQ) +// __GLIBC_PREREQ is available since 2.1.2 + + // swprintf is available since glibc 2.2.0 +# if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98)) +# define BOOST_NO_SWPRINTF +# endif +#else +# define BOOST_NO_SWPRINTF +#endif + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + +#ifndef __GNUC__ +// +// if the compiler is not gcc we still need to be able to parse +// the GNU system headers, some of which (mainly ) +// use GNU specific extensions: +// +# ifndef __extension__ +# define __extension__ +# endif +# ifndef __const__ +# define __const__ const +# endif +# ifndef __volatile__ +# define __volatile__ volatile +# endif +# ifndef __signed__ +# define __signed__ signed +# endif +# ifndef __typeof__ +# define __typeof__ typeof +# endif +# ifndef __inline__ +# define __inline__ inline +# endif +#endif + + diff --git a/eo/contrib/boost/config/platform/macos.hpp b/eo/contrib/boost/config/platform/macos.hpp new file mode 100644 index 00000000..d6877d31 --- /dev/null +++ b/eo/contrib/boost/config/platform/macos.hpp @@ -0,0 +1,78 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001 - 2002. +// (C) Copyright Bill Kempf 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Mac OS specific config options: + +#define BOOST_PLATFORM "Mac OS" + +#if __MACH__ && !defined(_MSL_USING_MSL_C) + +// Using the Mac OS X system BSD-style C library. + +# ifndef BOOST_HAS_UNISTD_H +# define BOOST_HAS_UNISTD_H +# endif +// +// Begin by including our boilerplate code for POSIX +// feature detection, this is safe even when using +// the MSL as Metrowerks supply their own +// to replace the platform-native BSD one. G++ users +// should also always be able to do this on MaxOS X. +// +# include +# ifndef BOOST_HAS_STDINT_H +# define BOOST_HAS_STDINT_H +# endif + +// +// BSD runtime has pthreads, sigaction, sched_yield and gettimeofday, +// of these only pthreads are advertised in , so set the +// other options explicitly: +// +# define BOOST_HAS_SCHED_YIELD +# define BOOST_HAS_GETTIMEOFDAY +# define BOOST_HAS_SIGACTION + +# if (__GNUC__ < 3) && !defined( __APPLE_CC__) + +// GCC strange "ignore std" mode works better if you pretend everything +// is in the std namespace, for the most part. + +# define BOOST_NO_STDC_NAMESPACE +# endif + +#else + +// Using the MSL C library. + +// We will eventually support threads in non-Carbon builds, but we do +// not support this yet. +# if ( defined(TARGET_API_MAC_CARBON) && TARGET_API_MAC_CARBON ) || ( defined(TARGET_CARBON) && TARGET_CARBON ) + +# if !defined(BOOST_HAS_PTHREADS) +# define BOOST_HAS_MPTASKS +# elif ( __dest_os == __mac_os_x ) +// We are doing a Carbon/Mach-O/MSL build which has pthreads, but only the +// gettimeofday and no posix. +# define BOOST_HAS_GETTIMEOFDAY +# endif + +// The MP task implementation of Boost Threads aims to replace MP-unsafe +// parts of the MSL, so we turn on threads unconditionally. +# define BOOST_HAS_THREADS + +// The remote call manager depends on this. +# define BOOST_BIND_ENABLE_PASCAL + +# endif + +#endif + + + diff --git a/eo/contrib/boost/config/platform/solaris.hpp b/eo/contrib/boost/config/platform/solaris.hpp new file mode 100644 index 00000000..700dc3ce --- /dev/null +++ b/eo/contrib/boost/config/platform/solaris.hpp @@ -0,0 +1,21 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// sun specific config options: + +#define BOOST_PLATFORM "Sun Solaris" + +#define BOOST_HAS_GETTIMEOFDAY + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + + + + diff --git a/eo/contrib/boost/config/platform/win32.hpp b/eo/contrib/boost/config/platform/win32.hpp new file mode 100644 index 00000000..548bff28 --- /dev/null +++ b/eo/contrib/boost/config/platform/win32.hpp @@ -0,0 +1,50 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Bill Kempf 2001. +// (C) Copyright Aleksey Gurtovoy 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Win32 specific config options: + +#define BOOST_PLATFORM "Win32" + +#if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF) +# define BOOST_NO_SWPRINTF +#endif + +#if !defined(__GNUC__) && !defined(BOOST_HAS_DECLSPEC) +# define BOOST_HAS_DECLSPEC +#endif + +#if defined(__MINGW32__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 2))) +# define BOOST_HAS_STDINT_H +# define __STDC_LIMIT_MACROS +#endif + +// +// Win32 will normally be using native Win32 threads, +// but there is a pthread library avaliable as an option, +// we used to disable this when BOOST_DISABLE_WIN32 was +// defined but no longer - this should allow some +// files to be compiled in strict mode - while maintaining +// a consistent setting of BOOST_HAS_THREADS across +// all translation units (needed for shared_ptr etc). +// + +#ifdef _WIN32_WCE +# define BOOST_NO_ANSI_APIS +#endif + +#ifndef BOOST_HAS_PTHREADS +# define BOOST_HAS_WINTHREADS +#endif + +#ifndef BOOST_DISABLE_WIN32 +// WEK: Added +#define BOOST_HAS_FTIME +#define BOOST_WINDOWS 1 + +#endif diff --git a/eo/contrib/boost/config/posix_features.hpp b/eo/contrib/boost/config/posix_features.hpp new file mode 100644 index 00000000..4afb476b --- /dev/null +++ b/eo/contrib/boost/config/posix_features.hpp @@ -0,0 +1,87 @@ +// (C) Copyright John Maddock 2001 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// See http://www.boost.org for most recent version. + +// All POSIX feature tests go in this file, +// Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well +// _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's +// may be present but none-functional unless _POSIX_C_SOURCE and +// _XOPEN_SOURCE have been defined to the right value (it's up +// to the user to do this *before* including any header, although +// in most cases the compiler will do this for you). + +# if defined(BOOST_HAS_UNISTD_H) +# include + + // XOpen has , but is this the correct version check? +# if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3) +# define BOOST_HAS_NL_TYPES_H +# endif + + // POSIX version 6 requires +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100) +# define BOOST_HAS_STDINT_H +# endif + + // POSIX version 2 requires +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L) +# define BOOST_HAS_DIRENT_H +# endif + + // POSIX version 3 requires to have sigaction: +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L) +# define BOOST_HAS_SIGACTION +# endif + // POSIX defines _POSIX_THREADS > 0 for pthread support, + // however some platforms define _POSIX_THREADS without + // a value, hence the (_POSIX_THREADS+0 >= 0) check. + // Strictly speaking this may catch platforms with a + // non-functioning stub , but such occurrences should + // occur very rarely if at all. +# if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS) +# define BOOST_HAS_PTHREADS +# endif + + // BOOST_HAS_NANOSLEEP: + // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME: +# if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \ + || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) +# define BOOST_HAS_NANOSLEEP +# endif + + // BOOST_HAS_CLOCK_GETTIME: + // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME + // but at least one platform - linux - defines that flag without + // defining clock_gettime): +# if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) +# define BOOST_HAS_CLOCK_GETTIME +# endif + + // BOOST_HAS_SCHED_YIELD: + // This is predicated on _POSIX_PRIORITY_SCHEDULING or + // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME. +# if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\ + || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\ + || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) +# define BOOST_HAS_SCHED_YIELD +# endif + + // BOOST_HAS_GETTIMEOFDAY: + // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE: + // These are predicated on _XOPEN_VERSION, and appears to be first released + // in issue 4, version 2 (_XOPEN_VERSION > 500). +# if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500) +# define BOOST_HAS_GETTIMEOFDAY +# if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500) +# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# endif +# endif + +# endif + + + diff --git a/eo/contrib/boost/config/requires_threads.hpp b/eo/contrib/boost/config/requires_threads.hpp new file mode 100644 index 00000000..cfaff230 --- /dev/null +++ b/eo/contrib/boost/config/requires_threads.hpp @@ -0,0 +1,92 @@ +// (C) Copyright John Maddock 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_CONFIG_REQUIRES_THREADS_HPP +#define BOOST_CONFIG_REQUIRES_THREADS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_DISABLE_THREADS) + +// +// special case to handle versions of gcc which don't currently support threads: +// +#if defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC_MINOR__ <= 3) || !defined(BOOST_STRICT_CONFIG)) +// +// this is checked up to gcc 3.3: +// +#if defined(__sgi) || defined(__hpux) +# error "Multi-threaded programs are not supported by gcc on HPUX or Irix (last checked with gcc 3.3)" +#endif + +#endif + +# error "Threading support unavaliable: it has been explicitly disabled with BOOST_DISABLE_THREADS" + +#elif !defined(BOOST_HAS_THREADS) + +# if defined __COMO__ +// Comeau C++ +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_MT (Windows) or -D_REENTRANT (Unix)" + +#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) +// Intel +#ifdef _WIN32 +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd" +#else +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -openmp" +#endif + +# elif defined __GNUC__ +// GNU C++: +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)" + +#elif defined __sgi +// SGI MIPSpro C++ +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_SGI_MP_SOURCE" + +#elif defined __DECCXX +// Compaq Tru64 Unix cxx +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread" + +#elif defined __BORLANDC__ +// Borland +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM" + +#elif defined __MWERKS__ +// Metrowerks CodeWarrior +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: either -runtime sm, -runtime smd, -runtime dm, or -runtime dmd" + +#elif defined __SUNPRO_CC +// Sun Workshop Compiler C++ +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt" + +#elif defined __HP_aCC +// HP aCC +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt" + +#elif defined(__IBMCPP__) +// IBM Visual Age +# error "Compiler threading support is not turned on. Please compile the code with the xlC_r compiler" + +#elif defined _MSC_VER +// Microsoft Visual C++ +// +// Must remain the last #elif since some other vendors (Metrowerks, for +// example) also #define _MSC_VER +# error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd" + +#else + +# error "Compiler threading support is not turned on. Please consult your compiler's documentation for the appropriate options to use" + +#endif // compilers + +#endif // BOOST_HAS_THREADS + +#endif // BOOST_CONFIG_REQUIRES_THREADS_HPP diff --git a/eo/contrib/boost/config/select_compiler_config.hpp b/eo/contrib/boost/config/select_compiler_config.hpp new file mode 100644 index 00000000..3453f1a3 --- /dev/null +++ b/eo/contrib/boost/config/select_compiler_config.hpp @@ -0,0 +1,83 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Martin Wille 2003. +// (C) Copyright Guillaume Melquiond 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// locate which compiler we are using and define +// BOOST_COMPILER_CONFIG as needed: + +# if defined __COMO__ +// Comeau C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp" + +#elif defined __DMC__ +// Digital Mars C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp" + +#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) +// Intel +# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp" + +# elif defined __GNUC__ +// GNU C++: +# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp" + +#elif defined __KCC +// Kai C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp" + +#elif defined __sgi +// SGI MIPSpro C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp" + +#elif defined __DECCXX +// Compaq Tru64 Unix cxx +# define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp" + +#elif defined __ghs +// Greenhills C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp" + +#elif defined __BORLANDC__ +// Borland +# define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp" + +#elif defined __MWERKS__ +// Metrowerks CodeWarrior +# define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp" + +#elif defined __SUNPRO_CC +// Sun Workshop Compiler C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp" + +#elif defined __HP_aCC +// HP aCC +# define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp" + +#elif defined(__MRC__) || defined(__SC__) +// MPW MrCpp or SCpp +# define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp" + +#elif defined(__IBMCPP__) +// IBM Visual Age +# define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp" + +#elif defined _MSC_VER +// Microsoft Visual C++ +// +// Must remain the last #elif since some other vendors (Metrowerks, for +// example) also #define _MSC_VER +# define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the compiler: +# error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)" + +#endif diff --git a/eo/contrib/boost/config/select_platform_config.hpp b/eo/contrib/boost/config/select_platform_config.hpp new file mode 100644 index 00000000..60bfa509 --- /dev/null +++ b/eo/contrib/boost/config/select_platform_config.hpp @@ -0,0 +1,86 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2002. +// (C) Copyright Jens Maurer 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed. +// Note that we define the headers to include using "header_name" not +// in order to prevent macro expansion within the header +// name (for example "linux" is a macro on linux systems). + +#if defined(linux) || defined(__linux) || defined(__linux__) +// linux: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp" + +#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) +// BSD: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp" + +#elif defined(sun) || defined(__sun) +// solaris: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp" + +#elif defined(__sgi) +// SGI Irix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp" + +#elif defined(__hpux) +// hp unix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp" + +#elif defined(__CYGWIN__) +// cygwin is not win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +// win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp" + +#elif defined(__BEOS__) +// BeOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp" + +#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) +// MacOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp" + +#elif defined(__IBMCPP__) || defined(_AIX) +// IBM +# define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp" + +#elif defined(__amigaos__) +// AmigaOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp" + +#else + +# if defined(unix) \ + || defined(__unix) \ + || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) + + // generic unix platform: + +# ifndef BOOST_HAS_UNISTD_H +# define BOOST_HAS_UNISTD_H +# endif + +# include + +# endif + +# if defined (BOOST_ASSERT_CONFIG) + // this must come last - generate an error if we don't + // recognise the platform: +# error "Unknown platform - please configure and report the results to boost.org" +# endif + +#endif + + + diff --git a/eo/contrib/boost/config/select_stdlib_config.hpp b/eo/contrib/boost/config/select_stdlib_config.hpp new file mode 100644 index 00000000..b7bf5914 --- /dev/null +++ b/eo/contrib/boost/config/select_stdlib_config.hpp @@ -0,0 +1,68 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001 - 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// See http://www.boost.org for most recent version. + +// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed: + +// we need to include a std lib header here in order to detect which +// library is in use, use as it's about the smallest +// of the std lib headers - do not rely on this header being included - +// users can short-circuit this header if they know whose std lib +// they are using. + +#include + +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +// STLPort library; this _must_ come first, otherwise since +// STLport typically sits on top of some other library, we +// can end up detecting that first rather than STLport: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp" + +#elif defined(__LIBCOMO__) +// Comeau STL: +#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp" + +#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) +// Rogue Wave library: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp" + +#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) +// GNU libstdc++ 3 +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp" + +#elif defined(__STL_CONFIG_H) +// generic SGI STL +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp" + +#elif defined(__MSL_CPP__) +// MSL standard lib: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp" + +#elif defined(__IBMCPP__) +// take the default VACPP std lib +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp" + +#elif defined(MSIPL_COMPILE_H) +// Modena C++ standard library +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp" + +#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) +// Dinkumware Library (this has to appear after any possible replacement libraries): +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the library: +# error "Unknown standard library - please configure and report the results to boost.org" + +#endif + + + diff --git a/eo/contrib/boost/config/stdlib/dinkumware.hpp b/eo/contrib/boost/config/stdlib/dinkumware.hpp new file mode 100644 index 00000000..aa214fc1 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/dinkumware.hpp @@ -0,0 +1,106 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright David Abrahams 2002. +// (C) Copyright Guillaume Melquiond 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Dinkumware standard library config: + +#if !defined(_YVALS) && !defined(_CPPLIB_VER) +#include +#if !defined(_YVALS) && !defined(_CPPLIB_VER) +#error This is not the Dinkumware lib! +#endif +#endif + + +#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306) + // full dinkumware 3.06 and above + // fully conforming provided the compiler supports it: +# if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h +# define BOOST_NO_STDC_NAMESPACE +# endif +# if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC) +# define BOOST_NO_STD_ALLOCATOR +# endif +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +# if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) + // if this lib version is set up for vc6 then there is no std::use_facet: +# define BOOST_NO_STD_USE_FACET +# define BOOST_HAS_TWO_ARG_USE_FACET + // C lib functions aren't in namespace std either: +# define BOOST_NO_STDC_NAMESPACE + // and nor is +# define BOOST_NO_EXCEPTION_STD_NAMESPACE +# endif +// There's no numeric_limits support unless _LONGLONG is defined: +# if !defined(_LONGLONG) && (_CPPLIB_VER <= 310) +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# endif +// 3.06 appears to have (non-sgi versions of) & , +// and no at all +#else +# define BOOST_MSVC_STD_ITERATOR 1 +# define BOOST_NO_STD_ITERATOR +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# define BOOST_NO_STD_ALLOCATOR +# define BOOST_NO_STDC_NAMESPACE +# define BOOST_NO_STD_USE_FACET +# define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN +# define BOOST_HAS_MACRO_USE_FACET +# ifndef _CPPLIB_VER + // Updated Dinkum library defines this, and provides + // its own min and max definitions. +# define BOOST_NO_STD_MIN_MAX +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# endif +#endif + +// +// std extension namespace is stdext for vc7.1 and later, +// the same applies to other compilers that sit on top +// of vc7.1 (Intel and Comeau): +// +#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__) +# define BOOST_STD_EXTENSION_NAMESPACE stdext +#endif + + +#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306) + // if we're using a dinkum lib that's + // been configured for VC6/7 then there is + // no iterator traits (true even for icl) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310) +// Intel C++ chokes over any non-trivial use of +// this may be an overly restrictive define, but regex fails without it: +# define BOOST_NO_STD_LOCALE +#endif + +#ifdef _CPPLIB_VER +# define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER +#else +# define BOOST_DINKUMWARE_STDLIB 1 +#endif + +#ifdef _CPPLIB_VER +# define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER) +#else +# define BOOST_STDLIB "Dinkumware standard library version 1.x" +#endif + + + + + + + + + diff --git a/eo/contrib/boost/config/stdlib/libcomo.hpp b/eo/contrib/boost/config/stdlib/libcomo.hpp new file mode 100644 index 00000000..b2c8e440 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/libcomo.hpp @@ -0,0 +1,46 @@ +// (C) Copyright John Maddock 2002 - 2003. +// (C) Copyright Jens Maurer 2002 - 2003. +// (C) Copyright Beman Dawes 2002 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Comeau STL: + +#if !defined(__LIBCOMO__) +# include +# if !defined(__LIBCOMO__) +# error "This is not the Comeau STL!" +# endif +#endif + +// +// std::streambuf is non-standard +// NOTE: versions of libcomo prior to beta28 have octal version numbering, +// e.g. version 25 is 21 (dec) +#if __LIBCOMO_VERSION__ <= 22 +# define BOOST_NO_STD_WSTREAMBUF +#endif + +#if (__LIBCOMO_VERSION__ <= 31) && defined(_WIN32) +#define BOOST_NO_SWPRINTF +#endif + +#if __LIBCOMO_VERSION__ >= 31 +# define BOOST_HAS_HASH +# define BOOST_HAS_SLIST +#endif + +// +// Intrinsic type_traits support. +// The SGI STL has it's own __type_traits class, which +// has intrinsic compiler support with SGI's compilers. +// Whatever map SGI style type traits to boost equivalents: +// +#define BOOST_HAS_SGI_TYPE_TRAITS + +#define BOOST_STDLIB "Comeau standard library " BOOST_STRINGIZE(__LIBCOMO_VERSION__) + + diff --git a/eo/contrib/boost/config/stdlib/libstdcpp3.hpp b/eo/contrib/boost/config/stdlib/libstdcpp3.hpp new file mode 100644 index 00000000..f367fa0f --- /dev/null +++ b/eo/contrib/boost/config/stdlib/libstdcpp3.hpp @@ -0,0 +1,61 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Jens Maurer 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// config for libstdc++ v3 +// not much to go in here: + +#ifdef __GLIBCXX__ +#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__) +#else +#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCPP__) +#endif + +#if !defined(_GLIBCPP_USE_WCHAR_T) && !defined(_GLIBCXX_USE_WCHAR_T) +# define BOOST_NO_CWCHAR +# define BOOST_NO_CWCTYPE +# define BOOST_NO_STD_WSTRING +# define BOOST_NO_STD_WSTREAMBUF +#endif + +#if defined(__osf__) && !defined(_REENTRANT) \ + && ( defined(_GLIBCXX_HAVE_GTHR_DEFAULT) || defined(_GLIBCPP_HAVE_GTHR_DEFAULT) ) +// GCC 3 on Tru64 forces the definition of _REENTRANT when any std lib header +// file is included, therefore for consistency we define it here as well. +# define _REENTRANT +#endif + +#ifdef __GLIBCXX__ // gcc 3.4 and greater: +# ifdef _GLIBCXX_HAVE_GTHR_DEFAULT + // + // If the std lib has thread support turned on, then turn it on in Boost + // as well. We do this because some gcc-3.4 std lib headers define _REENTANT + // while others do not... + // +# define BOOST_HAS_THREADS +# else +# define BOOST_DISABLE_THREADS +# endif +#elif defined(__GLIBCPP__) && !defined(_GLIBCPP_HAVE_GTHR_DEFAULT) + // disable thread support if the std lib was built single threaded: +# define BOOST_DISABLE_THREADS +#endif + +#if (defined(linux) || defined(__linux) || defined(__linux__)) && defined(__arm__) && defined(_GLIBCPP_HAVE_GTHR_DEFAULT) +// linux on arm apparently doesn't define _REENTRANT +// so just turn on threading support whenever the std lib is thread safe: +# define BOOST_HAS_THREADS +#endif + + +#if !defined(_GLIBCPP_USE_LONG_LONG) \ + && !defined(_GLIBCXX_USE_LONG_LONG)\ + && defined(BOOST_HAS_LONG_LONG) +// May have been set by compiler/*.hpp, but "long long" without library +// support is useless. +# undef BOOST_HAS_LONG_LONG +#endif diff --git a/eo/contrib/boost/config/stdlib/modena.hpp b/eo/contrib/boost/config/stdlib/modena.hpp new file mode 100644 index 00000000..61e31b7d --- /dev/null +++ b/eo/contrib/boost/config/stdlib/modena.hpp @@ -0,0 +1,30 @@ +// (C) Copyright Jens Maurer 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Modena C++ standard library (comes with KAI C++) + +#if !defined(MSIPL_COMPILE_H) +# include +# if !defined(__MSIPL_COMPILE_H) +# error "This is not the Modena C++ library!" +# endif +#endif + +#ifndef MSIPL_NL_TYPES +#define BOOST_NO_STD_MESSAGES +#endif + +#ifndef MSIPL_WCHART +#define BOOST_NO_STD_WSTRING +#endif + +#define BOOST_STDLIB "Modena C++ standard library" + + + + + diff --git a/eo/contrib/boost/config/stdlib/msl.hpp b/eo/contrib/boost/config/stdlib/msl.hpp new file mode 100644 index 00000000..0df8e0e3 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/msl.hpp @@ -0,0 +1,59 @@ +// (C) Copyright John Maddock 2001. +// (C) Copyright Darin Adler 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Metrowerks standard library: + +#ifndef __MSL_CPP__ +# include +# ifndef __MSL_CPP__ +# error This is not the MSL standard library! +# endif +#endif + +#if __MSL_CPP__ >= 0x6000 // Pro 6 +# define BOOST_HAS_HASH +# define BOOST_STD_EXTENSION_NAMESPACE Metrowerks +#endif +#define BOOST_HAS_SLIST + +#if __MSL_CPP__ < 0x6209 +# define BOOST_NO_STD_MESSAGES +#endif + +// check C lib version for +#include + +#if defined(__MSL__) && (__MSL__ >= 0x5000) +# define BOOST_HAS_STDINT_H +# if !defined(__PALMOS_TRAPS__) +# define BOOST_HAS_UNISTD_H +# endif + // boilerplate code: +# include +#endif + +#if defined(_MWMT) || _MSL_THREADSAFE +# define BOOST_HAS_THREADS +#endif + +#ifdef _MSL_NO_EXPLICIT_FUNC_TEMPLATE_ARG +# define BOOST_NO_STD_USE_FACET +# define BOOST_HAS_TWO_ARG_USE_FACET +#endif + + +#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__) + + + + + + + + + diff --git a/eo/contrib/boost/config/stdlib/roguewave.hpp b/eo/contrib/boost/config/stdlib/roguewave.hpp new file mode 100644 index 00000000..b331f653 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/roguewave.hpp @@ -0,0 +1,127 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright David Abrahams 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Rogue Wave std lib: + +#if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER) +# include +# if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER) +# error This is not the Rogue Wave standard library +# endif +#endif +// +// figure out a consistent version number: +// +#ifndef _RWSTD_VER +# define BOOST_RWSTD_VER 0x010000 +#elif _RWSTD_VER < 0x010000 +# define BOOST_RWSTD_VER (_RWSTD_VER << 8) +#else +# define BOOST_RWSTD_VER _RWSTD_VER +#endif + +#ifndef _RWSTD_VER +# define BOOST_STDLIB "Rogue Wave standard library version (Unknown version)" +#else +# define BOOST_STDLIB "Rogue Wave standard library version " BOOST_STRINGIZE(_RWSTD_VER) +#endif + +// +// Prior to version 2.2.0 the primary template for std::numeric_limits +// does not have compile time constants, even though specializations of that +// template do: +// +#if BOOST_RWSTD_VER < 0x020200 +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +#endif + +// Sun CC 5.5 patch 113817-07 adds long long specialization, but does not change the +// library version number (http://sunsolve6.sun.com/search/document.do?assetkey=1-21-113817): +#if BOOST_RWSTD_VER <= 0x020101 && (!defined(__SUNPRO_CC) || (__SUNPRO_CC < 0x550)) +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +# endif + +// +// Borland version of numeric_limits lacks __int64 specialisation: +// +#ifdef __BORLANDC__ +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +#endif + +// +// No std::iterator if it can't figure out default template args: +// +#if defined(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || defined(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || (BOOST_RWSTD_VER < 0x020000) +# define BOOST_NO_STD_ITERATOR +#endif + +// +// No iterator traits without partial specialization: +// +#if defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) || defined(RWSTD_NO_CLASS_PARTIAL_SPEC) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +// +// Prior to version 2.0, std::auto_ptr was buggy, and there were no +// new-style iostreams, and no conformant std::allocator: +// +#if (BOOST_RWSTD_VER < 0x020000) +# define BOOST_NO_AUTO_PTR +# define BOOST_NO_STRINGSTREAM +# define BOOST_NO_STD_ALLOCATOR +# define BOOST_NO_STD_LOCALE +#endif + +// +// No template iterator constructors without member template support: +// +#if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +#endif + +// +// RW defines _RWSTD_ALLOCATOR if the allocator is conformant and in use +// (the or _HPACC_ part is a hack - the library seems to define _RWSTD_ALLOCATOR +// on HP aCC systems even though the allocator is in fact broken): +// +#if !defined(_RWSTD_ALLOCATOR) || (defined(__HP_aCC) && __HP_aCC <= 33100) +# define BOOST_NO_STD_ALLOCATOR +#endif + +// +// If we have a std::locale, we still may not have std::use_facet: +// +#if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(BOOST_NO_STD_LOCALE) +# define BOOST_NO_STD_USE_FACET +# define BOOST_HAS_TWO_ARG_USE_FACET +#endif + +// +// There's no std::distance prior to version 2, or without +// partial specialization support: +// +#if (BOOST_RWSTD_VER < 0x020000) || defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) + #define BOOST_NO_STD_DISTANCE +#endif + +// +// Some versions of the rogue wave library don't have assignable +// OutputIterators: +// +#if BOOST_RWSTD_VER < 0x020100 +# define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN +#endif + +// +// Disable BOOST_HAS_LONG_LONG when the library has no support for it. +// +#if !defined(_RWSTD_LONG_LONG) && defined(BOOST_HAS_LONG_LONG) +# undef BOOST_HAS_LONG_LONG +#endif diff --git a/eo/contrib/boost/config/stdlib/sgi.hpp b/eo/contrib/boost/config/stdlib/sgi.hpp new file mode 100644 index 00000000..67f7a0a4 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/sgi.hpp @@ -0,0 +1,111 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Jens Maurer 2001 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// generic SGI STL: + +#if !defined(__STL_CONFIG_H) +# include +# if !defined(__STL_CONFIG_H) +# error "This is not the SGI STL!" +# endif +#endif + +// +// No std::iterator traits without partial specialisation: +// +#if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +// +// No std::stringstream with gcc < 3 +// +#if defined(__GNUC__) && (__GNUC__ < 3) && \ + ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \ + !defined(__STL_USE_NEW_IOSTREAMS) || \ + defined(__APPLE_CC__) + // Note that we only set this for GNU C++ prior to 2.95 since the + // latest patches for that release do contain a minimal + // If you are running a 2.95 release prior to 2.95.3 then this will need + // setting, but there is no way to detect that automatically (other + // than by running the configure script). + // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't + // have . +# define BOOST_NO_STRINGSTREAM +#endif + +// +// Assume no std::locale without own iostreams (this may be an +// incorrect assumption in some cases): +// +#if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS) +# define BOOST_NO_STD_LOCALE +#endif + +// +// Original native SGI streams have non-standard std::messages facet: +// +#if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS) +# define BOOST_NO_STD_LOCALE +#endif + +// +// SGI's new iostreams have missing "const" in messages<>::open +// +#if defined(__sgi) && (_COMPILER_VERSION <= 740) && defined(__STL_USE_NEW_IOSTREAMS) +# define BOOST_NO_STD_MESSAGES +#endif + +// +// No template iterator constructors, or std::allocator +// without member templates: +// +#if !defined(__STL_MEMBER_TEMPLATES) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# define BOOST_NO_STD_ALLOCATOR +#endif + +// +// We always have SGI style hash_set, hash_map, and slist: +// +#define BOOST_HAS_HASH +#define BOOST_HAS_SLIST + +// +// If this is GNU libstdc++2, then no and no std::wstring: +// +#if (defined(__GNUC__) && (__GNUC__ < 3)) +# include +# if defined(__BASTRING__) +# define BOOST_NO_LIMITS +// Note: will provide compile-time constants +# undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_STD_WSTRING +# endif +#endif + +// +// There is no standard iterator unless we have namespace support: +// +#if !defined(__STL_USE_NAMESPACES) +# define BOOST_NO_STD_ITERATOR +#endif + +// +// Intrinsic type_traits support. +// The SGI STL has it's own __type_traits class, which +// has intrinsic compiler support with SGI's compilers. +// Whatever map SGI style type traits to boost equivalents: +// +#define BOOST_HAS_SGI_TYPE_TRAITS + +#define BOOST_STDLIB "SGI standard library" + + + diff --git a/eo/contrib/boost/config/stdlib/stlport.hpp b/eo/contrib/boost/config/stdlib/stlport.hpp new file mode 100644 index 00000000..4843ea59 --- /dev/null +++ b/eo/contrib/boost/config/stdlib/stlport.hpp @@ -0,0 +1,201 @@ +// (C) Copyright John Maddock 2001 - 2002. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Jens Maurer 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// STLPort standard library config: + +#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) +# include +# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) +# error "This is not STLPort!" +# endif +#endif + +// +// __STL_STATIC_CONST_INIT_BUG implies BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +// for versions prior to 4.1(beta) +// +#if (defined(__STL_STATIC_CONST_INIT_BUG) || defined(_STLP_STATIC_CONST_INIT_BUG)) && (__SGI_STL_PORT <= 0x400) +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +#endif + +// +// If STLport thinks that there is no partial specialisation, then there is no +// std::iterator traits: +// +#if !(defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined(__STL_CLASS_PARTIAL_SPECIALIZATION)) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +// +// No new style iostreams on GCC without STLport's iostreams enabled: +// +#if (defined(__GNUC__) && (__GNUC__ < 3)) && !(defined(__SGI_STL_OWN_IOSTREAMS) || defined(_STLP_OWN_IOSTREAMS)) +# define BOOST_NO_STRINGSTREAM +#endif + +// +// No new iostreams implies no std::locale, and no std::stringstream: +// +#if defined(__STL_NO_IOSTREAMS) || defined(__STL_NO_NEW_IOSTREAMS) || defined(_STLP_NO_IOSTREAMS) || defined(_STLP_NO_NEW_IOSTREAMS) +# define BOOST_NO_STD_LOCALE +# define BOOST_NO_STRINGSTREAM +#endif + +// +// If the streams are not native, and we have a "using ::x" compiler bug +// then the io stream facets are not available in namespace std:: +// +#ifdef _STLPORT_VERSION +# if !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__) +# define BOOST_NO_STD_LOCALE +# endif +#else +# if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__) +# define BOOST_NO_STD_LOCALE +# endif +#endif + +// +// Without member template support enabled, their are no template +// iterate constructors, and no std::allocator: +// +#if !(defined(__STL_MEMBER_TEMPLATES) || defined(_STLP_MEMBER_TEMPLATES)) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# define BOOST_NO_STD_ALLOCATOR +#endif +// +// however we always have at least a partial allocator: +// +#define BOOST_HAS_PARTIAL_STD_ALLOCATOR + +#if !defined(_STLP_MEMBER_TEMPLATE_CLASSES) +# define BOOST_NO_STD_ALLOCATOR +#endif + +#if defined(_STLP_NO_MEMBER_TEMPLATE_KEYWORD) && defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) +# define BOOST_NO_STD_ALLOCATOR +#endif + +// +// If STLport thinks there is no wchar_t at all, then we have to disable +// the support for the relevant specilazations of std:: templates. +// +#if !defined(_STLP_HAS_WCHAR_T) && !defined(_STLP_WCHAR_T_IS_USHORT) +# ifndef BOOST_NO_STD_WSTRING +# define BOOST_NO_STD_WSTRING +# endif +# ifndef BOOST_NO_STD_WSTREAMBUF +# define BOOST_NO_STD_WSTREAMBUF +# endif +#endif + +// +// We always have SGI style hash_set, hash_map, and slist: +// +#define BOOST_HAS_HASH +#define BOOST_HAS_SLIST + +// +// STLport does a good job of importing names into namespace std::, +// but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since our +// workaround does not conflict with STLports: +// +// +// Harold Howe says: +// Borland switched to STLport in BCB6. Defining BOOST_NO_STDC_NAMESPACE with +// BCB6 does cause problems. If we detect C++ Builder, then don't define +// BOOST_NO_STDC_NAMESPACE +// +#if !defined(__BORLANDC__) && !defined(__DMC__) +// +// If STLport is using it's own namespace, and the real names are in +// the global namespace, then we duplicate STLport's using declarations +// (by defining BOOST_NO_STDC_NAMESPACE), we do this because STLport doesn't +// necessarily import all the names we need into namespace std:: +// +# if (defined(__STL_IMPORT_VENDOR_CSTD) \ + || defined(__STL_USE_OWN_NAMESPACE) \ + || defined(_STLP_IMPORT_VENDOR_CSTD) \ + || defined(_STLP_USE_OWN_NAMESPACE)) \ + && (defined(__STL_VENDOR_GLOBAL_CSTD) || defined (_STLP_VENDOR_GLOBAL_CSTD)) +# define BOOST_NO_STDC_NAMESPACE +# define BOOST_NO_EXCEPTION_STD_NAMESPACE +# endif +#elif defined(__BORLANDC__) && __BORLANDC__ < 0x560 +// STLport doesn't import std::abs correctly: +#include +namespace std { using ::abs; } +// and strcmp/strcpy don't get imported either ('cos they are macros) +#include +#ifdef strcpy +# undef strcpy +#endif +#ifdef strcmp +# undef strcmp +#endif +#ifdef _STLP_VENDOR_CSTD +namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; } +#endif +#endif + +// +// std::use_facet may be non-standard, uses a class instead: +// +#if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) || defined(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS) +# define BOOST_NO_STD_USE_FACET +# define BOOST_HAS_STLP_USE_FACET +#endif + +// +// If STLport thinks there are no wide functions, etc. is not working; but +// only if BOOST_NO_STDC_NAMESPACE is not defined (if it is then we do the import +// into std:: ourselves). +// +#if defined(_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined(BOOST_NO_STDC_NAMESPACE) +# define BOOST_NO_CWCHAR +# define BOOST_NO_CWCTYPE +#endif + +// +// If STLport for some reason was configured so that it thinks that wchar_t +// is not an intrinsic type, then we have to disable the support for it as +// well (we would be missing required specializations otherwise). +// +#if !defined( _STLP_HAS_WCHAR_T) || defined(_STLP_WCHAR_T_IS_USHORT) +# undef BOOST_NO_INTRINSIC_WCHAR_T +# define BOOST_NO_INTRINSIC_WCHAR_T +#endif + +// +// Borland ships a version of STLport with C++ Builder 6 that lacks +// hashtables and the like: +// +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x560) +# undef BOOST_HAS_HASH +#endif + +// +// gcc-2.95.3/STLPort does not like the using declarations we use to get ADL with std::min/max +// +#if defined(__GNUC__) && (__GNUC__ < 3) +# include // for std::min and std::max +# define BOOST_USING_STD_MIN() ((void)0) +# define BOOST_USING_STD_MAX() ((void)0) +namespace boost { using std::min; using std::max; } +#endif + +#define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT) + + + + + + + + diff --git a/eo/contrib/boost/config/stdlib/vacpp.hpp b/eo/contrib/boost/config/stdlib/vacpp.hpp new file mode 100644 index 00000000..8321ee0c --- /dev/null +++ b/eo/contrib/boost/config/stdlib/vacpp.hpp @@ -0,0 +1,18 @@ +// (C) Copyright John Maddock 2001 - 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +#if __IBMCPP__ <= 501 +# define BOOST_NO_STD_ALLOCATOR +#endif + +#define BOOST_HAS_MACRO_USE_FACET +#define BOOST_NO_STD_MESSAGES + +#define BOOST_STDLIB "Visual Age default standard library" + + + diff --git a/eo/contrib/boost/config/suffix.hpp b/eo/contrib/boost/config/suffix.hpp new file mode 100644 index 00000000..d4d9502d --- /dev/null +++ b/eo/contrib/boost/config/suffix.hpp @@ -0,0 +1,547 @@ +// Boost config.hpp configuration header file ------------------------------// + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Bill Kempf 2002. +// (C) Copyright Jens Maurer 2002. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Gennaro Prota 2003. +// (C) Copyright Eric Friedman 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config +// +// This file is intended to be stable, and relatively unchanging. +// It should contain boilerplate code only - no compiler specific +// code unless it is unavoidable - no changes unless unavoidable. + +#ifndef BOOST_CONFIG_SUFFIX_HPP +#define BOOST_CONFIG_SUFFIX_HPP + +// +// look for long long by looking for the appropriate macros in . +// Note that we use limits.h rather than climits for maximal portability, +// remember that since these just declare a bunch of macros, there should be +// no namespace issues from this. +// +#include +# if !defined(BOOST_HAS_LONG_LONG) \ + && !defined(BOOST_MSVC) && !defined(__BORLANDC__) \ + && (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) +# define BOOST_HAS_LONG_LONG +#endif + +// TODO: Remove the following lines after the 1.33 release because the presence +// of an integral 64 bit type has nothing to do with support for long long. + +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(__DECCXX_VER) +# define BOOST_NO_INTEGRAL_INT64_T +#endif + +// GCC 3.x will clean up all of those nasty macro definitions that +// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine +// it under GCC 3.x. +#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) +# undef BOOST_NO_CTYPE_FUNCTIONS +#endif + + +// +// Assume any extensions are in namespace std:: unless stated otherwise: +// +# ifndef BOOST_STD_EXTENSION_NAMESPACE +# define BOOST_STD_EXTENSION_NAMESPACE std +# endif + +// +// If cv-qualified specializations are not allowed, then neither are cv-void ones: +// +# if defined(BOOST_NO_CV_SPECIALIZATIONS) \ + && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) +# define BOOST_NO_CV_VOID_SPECIALIZATIONS +# endif + +// +// If there is no numeric_limits template, then it can't have any compile time +// constants either! +// +# if defined(BOOST_NO_LIMITS) \ + && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +# endif + +// +// if there is no long long then there is no specialisation +// for numeric_limits either: +// +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +#endif + +// +// if there is no __int64 then there is no specialisation +// for numeric_limits<__int64> either: +// +#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +#endif + +// +// if member templates are supported then so is the +// VC6 subset of member templates: +// +# if !defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) +# define BOOST_MSVC6_MEMBER_TEMPLATES +# endif + +// +// Without partial specialization, can't test for partial specialisation bugs: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) +# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG +# endif + +// +// Without partial specialization, we can't have array-type partial specialisations: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS +# endif + +// +// Without partial specialization, std::iterator_traits can't work: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_STD_ITERATOR_TRAITS) +# define BOOST_NO_STD_ITERATOR_TRAITS +# endif + +// +// Without member template support, we can't have template constructors +// in the standard library either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# endif + +// +// Without member template support, we can't have a conforming +// std::allocator template either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_NO_STD_ALLOCATOR +# endif + +// +// without ADL support then using declarations will break ADL as well: +// +#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) +# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +#endif + +// +// If we have a standard allocator, then we have a partial one as well: +// +#if !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +#endif + +// +// We can't have a working std::use_facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) +# define BOOST_NO_STD_USE_FACET +# endif + +// +// We can't have a std::messages facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) +# define BOOST_NO_STD_MESSAGES +# endif + +// +// We can't have a working std::wstreambuf if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) +# define BOOST_NO_STD_WSTREAMBUF +# endif + +// +// We can't have a if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) +# define BOOST_NO_CWCTYPE +# endif + +// +// We can't have a swprintf if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) +# define BOOST_NO_SWPRINTF +# endif + +// +// If Win32 support is turned off, then we must turn off +// threading support also, unless there is some other +// thread API enabled: +// +#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ + && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) +# define BOOST_DISABLE_THREADS +#endif + +// +// Turn on threading support if the compiler thinks that it's in +// multithreaded mode. We put this here because there are only a +// limited number of macros that identify this (if there's any missing +// from here then add to the appropriate compiler section): +// +#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ + || defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS) +# define BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if BOOST_DISABLE_THREADS is defined: +// +#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) +# undef BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if we don't recognise the threading API: +// +#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ + && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ + && !defined(BOOST_HAS_MPTASKS) +# undef BOOST_HAS_THREADS +#endif + +// +// Turn threading detail macros off if we don't (want to) use threading +// +#ifndef BOOST_HAS_THREADS +# undef BOOST_HAS_PTHREADS +# undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# undef BOOST_HAS_WINTHREADS +# undef BOOST_HAS_BETHREADS +# undef BOOST_HAS_MPTASKS +#endif + +// +// If the compiler claims to be C99 conformant, then it had better +// have a : +// +# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) +# define BOOST_HAS_STDINT_H +# endif + +// +// Define BOOST_NO_SLIST and BOOST_NO_HASH if required. +// Note that this is for backwards compatibility only. +// +# ifndef BOOST_HAS_SLIST +# define BOOST_NO_SLIST +# endif + +# ifndef BOOST_HAS_HASH +# define BOOST_NO_HASH +# endif + +// BOOST_HAS_ABI_HEADERS +// This macro gets set if we have headers that fix the ABI, +// and prevent ODR violations when linking to external libraries: +#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS) +# define BOOST_HAS_ABI_HEADERS +#endif + +#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS) +# undef BOOST_HAS_ABI_HEADERS +#endif + +// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// +// Because std::size_t usage is so common, even in boost headers which do not +// otherwise use the C library, the workaround is included here so +// that ugly workaround code need not appear in many other boost headers. +// NOTE WELL: This is a workaround for non-conforming compilers; +// must still be #included in the usual places so that inclusion +// works as expected with standard conforming compilers. The resulting +// double inclusion of is harmless. + +# ifdef BOOST_NO_STDC_NAMESPACE +# include + namespace std { using ::ptrdiff_t; using ::size_t; } +# endif + +// Workaround for the unfortunate min/max macros defined by some platform headers + +#define BOOST_PREVENT_MACRO_SUBSTITUTION + +#ifndef BOOST_USING_STD_MIN +# define BOOST_USING_STD_MIN() using std::min +#endif + +#ifndef BOOST_USING_STD_MAX +# define BOOST_USING_STD_MAX() using std::max +#endif + +// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// + +# ifdef BOOST_NO_STD_MIN_MAX + +namespace std { + template + inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { + return __b < __a ? __b : __a; + } + template + inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { + return __a < __b ? __b : __a; + } +} + +# endif + +// BOOST_STATIC_CONSTANT workaround --------------------------------------- // +// On compilers which don't allow in-class initialization of static integral +// constant members, we must use enums as a workaround if we want the constants +// to be available at compile-time. This macro gives us a convenient way to +// declare such constants. + +# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } +# else +# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment +# endif + +// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------// +// When the standard library does not have a conforming std::use_facet there +// are various workarounds available, but they differ from library to library. +// The same problem occurs with has_facet. +// These macros provide a consistent way to access a locale's facets. +// Usage: +// replace +// std::use_facet(loc); +// with +// BOOST_USE_FACET(Type, loc); +// Note do not add a std:: prefix to the front of BOOST_USE_FACET! +// Use for BOOST_HAS_FACET is analagous. + +#if defined(BOOST_NO_STD_USE_FACET) +# ifdef BOOST_HAS_TWO_ARG_USE_FACET +# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast(0)) +# define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast(0)) +# elif defined(BOOST_HAS_MACRO_USE_FACET) +# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) +# define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type) +# elif defined(BOOST_HAS_STLP_USE_FACET) +# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet(loc)) +# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) +# endif +#else +# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) +# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) +#endif + +// BOOST_NESTED_TEMPLATE workaround ------------------------------------------// +// Member templates are supported by some compilers even though they can't use +// the A::template member syntax, as a workaround replace: +// +// typedef typename A::template rebind binder; +// +// with: +// +// typedef typename A::BOOST_NESTED_TEMPLATE rebind binder; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD +# define BOOST_NESTED_TEMPLATE template +#else +# define BOOST_NESTED_TEMPLATE +#endif + +// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// +// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION +// is defined, in which case it evaluates to return x; Use when you have a return +// statement that can never be reached. + +#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION +# define BOOST_UNREACHABLE_RETURN(x) return x; +#else +# define BOOST_UNREACHABLE_RETURN(x) +#endif + +// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// +// +// Some compilers don't support the use of `typename' for dependent +// types in deduced contexts, e.g. +// +// template void f(T, typename T::type); +// ^^^^^^^^ +// Replace these declarations with: +// +// template void f(T, BOOST_DEDUCED_TYPENAME T::type); + +#ifndef BOOST_NO_DEDUCED_TYPENAME +# define BOOST_DEDUCED_TYPENAME typename +#else +# define BOOST_DEDUCED_TYPENAME +#endif + +// long long workaround ------------------------------------------// +// On gcc (and maybe other compilers?) long long is alway supported +// but it's use may generate either warnings (with -ansi), or errors +// (with -pedantic -ansi) unless it's use is prefixed by __extension__ +// +#if defined(BOOST_HAS_LONG_LONG) +namespace boost{ +# ifdef __GNUC__ + __extension__ typedef long long long_long_type; + __extension__ typedef unsigned long long ulong_long_type; +# else + typedef long long long_long_type; + typedef unsigned long long ulong_long_type; +# endif +} +#endif + +// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// +// +// Some compilers have problems with function templates whose +// template parameters don't appear in the function parameter +// list (basically they just link one instantiation of the +// template in the final executable). These macros provide a +// uniform way to cope with the problem with no effects on the +// calling syntax. + +// Example: +// +// #include +// #include +// #include +// +// template +// void f() { std::cout << n << ' '; } +// +// template +// void g() { std::cout << typeid(T).name() << ' '; } +// +// int main() { +// f<1>(); +// f<2>(); +// +// g(); +// g(); +// } +// +// With VC++ 6.0 the output is: +// +// 2 2 double double +// +// To fix it, write +// +// template +// void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... } +// +// template +// void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... } +// + + +#if defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS + +# include "boost/type.hpp" +# include "boost/non_type.hpp" + +# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type* = 0 +# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type* +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type* = 0 +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type* + +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \ + , BOOST_EXPLICIT_TEMPLATE_TYPE(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \ + , BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \ + , BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \ + , BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) + +#else + +// no workaround needed: expand to nothing + +# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) +# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) + +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) + + +#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS + + +// ---------------------------------------------------------------------------// + +// +// Helper macro BOOST_STRINGIZE: +// Converts the parameter X to a string after macro replacement +// on X has been performed. +// +#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) +#define BOOST_DO_STRINGIZE(X) #X + +// +// Helper macro BOOST_JOIN: +// The following piece of macro magic joins the two +// arguments together, even when one of the arguments is +// itself a macro (see 16.3.1 in C++ standard). The key +// is that macro expansion of macro arguments does not +// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. +// +#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) +#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) +#define BOOST_DO_JOIN2( X, Y ) X##Y + +// +// Set some default values for compiler/library/platform names. +// These are for debugging config setup only: +// +# ifndef BOOST_COMPILER +# define BOOST_COMPILER "Unknown ISO C++ Compiler" +# endif +# ifndef BOOST_STDLIB +# define BOOST_STDLIB "Unknown ISO standard library" +# endif +# ifndef BOOST_PLATFORM +# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) +# define BOOST_PLATFORM "Generic Unix" +# else +# define BOOST_PLATFORM "Unknown" +# endif +# endif + +#endif + + + diff --git a/eo/contrib/boost/config/user.hpp b/eo/contrib/boost/config/user.hpp new file mode 100644 index 00000000..5a4a9d47 --- /dev/null +++ b/eo/contrib/boost/config/user.hpp @@ -0,0 +1,124 @@ +// boost/config/user.hpp ---------------------------------------------------// + +// (C) Copyright John Maddock 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Do not check in modified versions of this file, +// This file may be customized by the end user, but not by boost. + +// +// Use this file to define a site and compiler specific +// configuration policy: +// + +// define this to locate a compiler config file: +// #define BOOST_COMPILER_CONFIG + +// define this to locate a stdlib config file: +// #define BOOST_STDLIB_CONFIG + +// define this to locate a platform config file: +// #define BOOST_PLATFORM_CONFIG + +// define this to disable compiler config, +// use if your compiler config has nothing to set: +// #define BOOST_NO_COMPILER_CONFIG + +// define this to disable stdlib config, +// use if your stdlib config has nothing to set: +// #define BOOST_NO_STDLIB_CONFIG + +// define this to disable platform config, +// use if your platform config has nothing to set: +// #define BOOST_NO_PLATFORM_CONFIG + +// define this to disable all config options, +// excluding the user config. Use if your +// setup is fully ISO compliant, and has no +// useful extensions, or for autoconf generated +// setups: +// #define BOOST_NO_CONFIG + +// define this to make the config "optimistic" +// about unknown compiler versions. Normally +// unknown compiler versions are assumed to have +// all the defects of the last known version, however +// setting this flag, causes the config to assume +// that unknown compiler versions are fully conformant +// with the standard: +// #define BOOST_STRICT_CONFIG + +// define this to cause the config to halt compilation +// with an #error if it encounters anything unknown -- +// either an unknown compiler version or an unknown +// compiler/platform/library: +// #define BOOST_ASSERT_CONFIG + + +// define if you want to disable threading support, even +// when available: +// #define BOOST_DISABLE_THREADS + +// define when you want to disable Win32 specific features +// even when available: +// #define BOOST_DISABLE_WIN32 + +// BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any +// prefix/suffix headers that normally control things like struct +// packing and alignment. +// #define BOOST_DISABLE_ABI_HEADERS + +// BOOST_ABI_PREFIX: A prefix header to include in place of whatever +// boost.config would normally select, any replacement should set up +// struct packing and alignment options as required. +// #define BOOST_ABI_PREFIX my-header-name + +// BOOST_ABI_SUFFIX: A suffix header to include in place of whatever +// boost.config would normally select, any replacement should undo +// the effects of the prefix header. +// #define BOOST_ABI_SUFFIX my-header-name + +// BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, +// to be linked as dll's rather than static libraries on Microsoft Windows +// (this macro is used to turn on __declspec(dllimport) modifiers, so that +// the compiler knows which symbols to look for in a dll rather than in a +// static library). Note that there may be some libraries that can only +// be statically linked (Boost.Test for example) and others which may only +// be dynamically linked (Boost.Threads for example), in these cases this +// macro has no effect. +// #define BOOST_ALL_DYN_LINK + +// BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll +// rather than a static library on Microsoft Windows: replace the WHATEVER +// part of the macro name with the name of the library that you want to +// dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or +// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) +// modifiers, so that the compiler knows which symbols to look for in a dll +// rather than in a static library). +// Note that there may be some libraries that can only be statically linked +// (Boost.Test for example) and others which may only be dynamically linked +// (Boost.Threads for example), in these cases this macro is unsupported. +// #define BOOST_WHATEVER_DYN_LINK + +// BOOST_ALL_NO_LIB: Tells the config system not to automatically select +// which libraries to link against. +// Normally if a compiler supports #pragma lib, then the correct library +// build variant will be automatically selected and linked against, +// simply by the act of including one of that library's headers. +// This macro turns that feature off. +// #define BOOST_ALL_NO_LIB + +// BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically +// select which library to link against for library "whatever", +// replace WHATEVER in the macro name with the name of the library; +// for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB. +// Normally if a compiler supports #pragma lib, then the correct library +// build variant will be automatically selected and linked against, simply +// by the act of including one of that library's headers. This macro turns +// that feature off. +// #define BOOST_WHATEVER_NO_LIB + + + diff --git a/eo/contrib/boost/limits.hpp b/eo/contrib/boost/limits.hpp new file mode 100644 index 00000000..f468dbce --- /dev/null +++ b/eo/contrib/boost/limits.hpp @@ -0,0 +1,143 @@ + +// (C) Copyright John maddock 1999. +// (C) David Abrahams 2002. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +// use this header as a workaround for missing + +// See http://www.boost.org/libs/utility/limits.html for documentation. + +#ifndef BOOST_LIMITS +#define BOOST_LIMITS + +#include + +#ifdef BOOST_NO_LIMITS +# include +#else +# include +#endif + +#if (defined(BOOST_HAS_LONG_LONG) && defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)) \ + || (defined(BOOST_HAS_MS_INT64) && defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)) +// Add missing specializations for numeric_limits: +#ifdef BOOST_HAS_MS_INT64 +# define BOOST_LLT __int64 +# define BOOST_ULLT unsigned __int64 +#else +# define BOOST_LLT ::boost::long_long_type +# define BOOST_ULLT ::boost::ulong_long_type +#endif + +namespace std +{ + template<> + class numeric_limits + { + public: + + BOOST_STATIC_CONSTANT(bool, is_specialized = true); +#ifdef BOOST_HAS_MS_INT64 + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8000000000000000i64; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7FFFFFFFFFFFFFFFi64; } +#elif defined(LLONG_MAX) + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MIN; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MAX; } +#elif defined(LONGLONG_MAX) + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MIN; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MAX; } +#else + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL << (sizeof(BOOST_LLT) * CHAR_BIT - 1); } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(min)(); } +#endif + BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT -1); + BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT) - 1) * 301L / 1000); + BOOST_STATIC_CONSTANT(bool, is_signed = true); + BOOST_STATIC_CONSTANT(bool, is_integer = true); + BOOST_STATIC_CONSTANT(bool, is_exact = true); + BOOST_STATIC_CONSTANT(int, radix = 2); + static BOOST_LLT epsilon() throw() { return 0; }; + static BOOST_LLT round_error() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(int, min_exponent = 0); + BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); + BOOST_STATIC_CONSTANT(int, max_exponent = 0); + BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); + + BOOST_STATIC_CONSTANT(bool, has_infinity = false); + BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_denorm = false); + BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); + static BOOST_LLT infinity() throw() { return 0; }; + static BOOST_LLT quiet_NaN() throw() { return 0; }; + static BOOST_LLT signaling_NaN() throw() { return 0; }; + static BOOST_LLT denorm_min() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(bool, is_iec559 = false); + BOOST_STATIC_CONSTANT(bool, is_bounded = false); + BOOST_STATIC_CONSTANT(bool, is_modulo = false); + + BOOST_STATIC_CONSTANT(bool, traps = false); + BOOST_STATIC_CONSTANT(bool, tinyness_before = false); + BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); + + }; + + template<> + class numeric_limits + { + public: + + BOOST_STATIC_CONSTANT(bool, is_specialized = true); +#ifdef BOOST_HAS_MS_INT64 + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0ui64; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0xFFFFFFFFFFFFFFFFui64; } +#elif defined(ULLONG_MAX) && defined(ULLONG_MIN) + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MIN; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MAX; } +#elif defined(ULONGLONG_MAX) && defined(ULONGLONG_MIN) + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MIN; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MAX; } +#else + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0uLL; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0uLL; } +#endif + BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT); + BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT)) * 301L / 1000); + BOOST_STATIC_CONSTANT(bool, is_signed = false); + BOOST_STATIC_CONSTANT(bool, is_integer = true); + BOOST_STATIC_CONSTANT(bool, is_exact = true); + BOOST_STATIC_CONSTANT(int, radix = 2); + static BOOST_ULLT epsilon() throw() { return 0; }; + static BOOST_ULLT round_error() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(int, min_exponent = 0); + BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); + BOOST_STATIC_CONSTANT(int, max_exponent = 0); + BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); + + BOOST_STATIC_CONSTANT(bool, has_infinity = false); + BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_denorm = false); + BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); + static BOOST_ULLT infinity() throw() { return 0; }; + static BOOST_ULLT quiet_NaN() throw() { return 0; }; + static BOOST_ULLT signaling_NaN() throw() { return 0; }; + static BOOST_ULLT denorm_min() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(bool, is_iec559 = false); + BOOST_STATIC_CONSTANT(bool, is_bounded = false); + BOOST_STATIC_CONSTANT(bool, is_modulo = false); + + BOOST_STATIC_CONSTANT(bool, traps = false); + BOOST_STATIC_CONSTANT(bool, tinyness_before = false); + BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); + + }; +} +#endif + +#endif diff --git a/eo/contrib/boost/numeric/interval.hpp b/eo/contrib/boost/numeric/interval.hpp new file mode 100644 index 00000000..e6f976df --- /dev/null +++ b/eo/contrib/boost/numeric/interval.hpp @@ -0,0 +1,32 @@ +/* Boost interval.hpp header file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_HPP +#define BOOST_NUMERIC_INTERVAL_HPP + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#endif // BOOST_NUMERIC_INTERVAL_HPP diff --git a/eo/contrib/boost/numeric/interval/arith.hpp b/eo/contrib/boost/numeric/interval/arith.hpp new file mode 100644 index 00000000..64a8e97e --- /dev/null +++ b/eo/contrib/boost/numeric/interval/arith.hpp @@ -0,0 +1,305 @@ +/* Boost interval/arith.hpp template implementation file + * + * Copyright 2000 Jens Maurer + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ARITH_HPP +#define BOOST_NUMERIC_INTERVAL_ARITH_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { + +/* + * Basic arithmetic operators + */ + +template inline +const interval& operator+(const interval& x) +{ + return x; +} + +template inline +interval operator-(const interval& x) +{ + if (interval_lib::detail::test_input(x)) + return interval::empty(); + return interval(-x.upper(), -x.lower(), true); +} + +template inline +interval& interval::operator+=(const interval& r) +{ + if (interval_lib::detail::test_input(*this, r)) + set_empty(); + else { + typename Policies::rounding rnd; + set(rnd.add_down(low, r.low), rnd.add_up(up, r.up)); + } + return *this; +} + +template inline +interval& interval::operator+=(const T& r) +{ + if (interval_lib::detail::test_input(*this, r)) + set_empty(); + else { + typename Policies::rounding rnd; + set(rnd.add_down(low, r), rnd.add_up(up, r)); + } + return *this; +} + +template inline +interval& interval::operator-=(const interval& r) +{ + if (interval_lib::detail::test_input(*this, r)) + set_empty(); + else { + typename Policies::rounding rnd; + set(rnd.sub_down(low, r.up), rnd.sub_up(up, r.low)); + } + return *this; +} + +template inline +interval& interval::operator-=(const T& r) +{ + if (interval_lib::detail::test_input(*this, r)) + set_empty(); + else { + typename Policies::rounding rnd; + set(rnd.sub_down(low, r), rnd.sub_up(up, r)); + } + return *this; +} + +template inline +interval& interval::operator*=(const interval& r) +{ + return *this = *this * r; +} + +template inline +interval& interval::operator*=(const T& r) +{ + return *this = r * *this; +} + +template inline +interval& interval::operator/=(const interval& r) +{ + return *this = *this / r; +} + +template inline +interval& interval::operator/=(const T& r) +{ + return *this = *this / r; +} + +template inline +interval operator+(const interval& x, + const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.add_down(x.lower(), y.lower()), + rnd.add_up (x.upper(), y.upper()), true); +} + +template inline +interval operator+(const T& x, const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.add_down(x, y.lower()), + rnd.add_up (x, y.upper()), true); +} + +template inline +interval operator+(const interval& x, const T& y) +{ return y + x; } + +template inline +interval operator-(const interval& x, + const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.sub_down(x.lower(), y.upper()), + rnd.sub_up (x.upper(), y.lower()), true); +} + +template inline +interval operator-(const T& x, const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.sub_down(x, y.upper()), + rnd.sub_up (x, y.lower()), true); +} + +template inline +interval operator-(const interval& x, const T& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.sub_down(x.lower(), y), + rnd.sub_up (x.upper(), y), true); +} + +template inline +interval operator*(const interval& x, + const interval& y) +{ + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + typename Policies::rounding rnd; + const T& xl = x.lower(); + const T& xu = x.upper(); + const T& yl = y.lower(); + const T& yu = y.upper(); + + if (interval_lib::user::is_neg(xl)) + if (interval_lib::user::is_pos(xu)) + if (interval_lib::user::is_neg(yl)) + if (interval_lib::user::is_pos(yu)) // M * M + return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_down(xl, yu), rnd.mul_down(xu, yl)), + max BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_up (xl, yl), rnd.mul_up (xu, yu)), true); + else // M * N + return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yl), true); + else + if (interval_lib::user::is_pos(yu)) // M * P + return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yu), true); + else // M * Z + return I(static_cast(0), static_cast(0), true); + else + if (interval_lib::user::is_neg(yl)) + if (interval_lib::user::is_pos(yu)) // N * M + return I(rnd.mul_down(xl, yu), rnd.mul_up(xl, yl), true); + else // N * N + return I(rnd.mul_down(xu, yu), rnd.mul_up(xl, yl), true); + else + if (interval_lib::user::is_pos(yu)) // N * P + return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yl), true); + else // N * Z + return I(static_cast(0), static_cast(0), true); + else + if (interval_lib::user::is_pos(xu)) + if (interval_lib::user::is_neg(yl)) + if (interval_lib::user::is_pos(yu)) // P * M + return I(rnd.mul_down(xu, yl), rnd.mul_up(xu, yu), true); + else // P * N + return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yu), true); + else + if (interval_lib::user::is_pos(yu)) // P * P + return I(rnd.mul_down(xl, yl), rnd.mul_up(xu, yu), true); + else // P * Z + return I(static_cast(0), static_cast(0), true); + else // Z * ? + return I(static_cast(0), static_cast(0), true); +} + +template inline +interval operator*(const T& x, const interval& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + typename Policies::rounding rnd; + const T& yl = y.lower(); + const T& yu = y.upper(); + // x is supposed not to be infinite + if (interval_lib::user::is_neg(x)) + return I(rnd.mul_down(x, yu), rnd.mul_up(x, yl), true); + else if (interval_lib::user::is_zero(x)) + return I(static_cast(0), static_cast(0), true); + else + return I(rnd.mul_down(x, yl), rnd.mul_up(x, yu), true); +} + +template inline +interval operator*(const interval& x, const T& y) +{ return y * x; } + +template inline +interval operator/(const interval& x, + const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + if (in_zero(y)) + if (!interval_lib::user::is_zero(y.lower())) + if (!interval_lib::user::is_zero(y.upper())) + return interval_lib::detail::div_zero(x); + else + return interval_lib::detail::div_negative(x, y.lower()); + else + if (!interval_lib::user::is_zero(y.upper())) + return interval_lib::detail::div_positive(x, y.upper()); + else + return interval::empty(); + else + return interval_lib::detail::div_non_zero(x, y); +} + +template inline +interval operator/(const T& x, const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + if (in_zero(y)) + if (!interval_lib::user::is_zero(y.lower())) + if (!interval_lib::user::is_zero(y.upper())) + return interval_lib::detail::div_zero(x); + else + return interval_lib::detail::div_negative(x, y.lower()); + else + if (!interval_lib::user::is_zero(y.upper())) + return interval_lib::detail::div_positive(x, y.upper()); + else + return interval::empty(); + else + return interval_lib::detail::div_non_zero(x, y); +} + +template inline +interval operator/(const interval& x, const T& y) +{ + if (interval_lib::detail::test_input(x, y) || interval_lib::user::is_zero(y)) + return interval::empty(); + typename Policies::rounding rnd; + const T& xl = x.lower(); + const T& xu = x.upper(); + if (interval_lib::user::is_neg(y)) + return interval(rnd.div_down(xu, y), rnd.div_up(xl, y), true); + else + return interval(rnd.div_down(xl, y), rnd.div_up(xu, y), true); +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ARITH_HPP diff --git a/eo/contrib/boost/numeric/interval/arith2.hpp b/eo/contrib/boost/numeric/interval/arith2.hpp new file mode 100644 index 00000000..274a6811 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/arith2.hpp @@ -0,0 +1,212 @@ +/* Boost interval/arith2.hpp template implementation file + * + * This header provides some auxiliary arithmetic + * functions: fmod, sqrt, square, pov, inverse and + * a multi-interval division. + * + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ARITH2_HPP +#define BOOST_NUMERIC_INTERVAL_ARITH2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { + +template inline +interval fmod(const interval& x, + const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + typedef typename interval_lib::unprotect >::type I; + T const &yb = interval_lib::user::is_neg(x.lower()) ? y.lower() : y.upper(); + T n = rnd.int_down(rnd.div_down(x.lower(), yb)); + return (const I&)x - n * (const I&)y; +} + +template inline +interval fmod(const interval& x, const T& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + typedef typename interval_lib::unprotect >::type I; + T n = rnd.int_down(rnd.div_down(x.lower(), y)); + return (const I&)x - n * I(y); +} + +template inline +interval fmod(const T& x, const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + typename Policies::rounding rnd; + typedef typename interval_lib::unprotect >::type I; + T const &yb = interval_lib::user::is_neg(x) ? y.lower() : y.upper(); + T n = rnd.int_down(rnd.div_down(x, yb)); + return x - n * (const I&)y; +} + +namespace interval_lib { + +template inline +interval division_part1(const interval& x, + const interval& y, bool& b) +{ + typedef interval I; + b = false; + if (detail::test_input(x, y)) + return I::empty(); + if (in_zero(y)) + if (!user::is_zero(y.lower())) + if (!user::is_zero(y.upper())) + return detail::div_zero_part1(x, y, b); + else + return detail::div_negative(x, y.lower()); + else + if (!user::is_zero(y.upper())) + return detail::div_positive(x, y.upper()); + else + return I::empty(); + else + return detail::div_non_zero(x, y); +} + +template inline +interval division_part2(const interval& x, + const interval& y, bool b = true) +{ + if (!b) return interval::empty(); + return detail::div_zero_part2(x, y); +} + +template inline +interval multiplicative_inverse(const interval& x) +{ + typedef interval I; + if (detail::test_input(x)) + return I::empty(); + T one = static_cast(1); + typename Policies::rounding rnd; + if (in_zero(x)) { + typedef typename Policies::checking checking; + if (!user::is_zero(x.lower())) + if (!user::is_zero(x.upper())) + return I::whole(); + else + return I(checking::neg_inf(), rnd.div_up(one, x.lower()), true); + else + if (!user::is_zero(x.upper())) + return I(rnd.div_down(one, x.upper()), checking::pos_inf(), true); + else + return I::empty(); + } else + return I(rnd.div_down(one, x.upper()), rnd.div_up(one, x.lower()), true); +} + +namespace detail { + +template inline +T pow_aux(const T& x_, int pwr, Rounding& rnd) // x and pwr are positive +{ + T x = x_; + T y = (pwr & 1) ? x_ : static_cast(1); + pwr >>= 1; + while (pwr > 0) { + x = rnd.mul_up(x, x); + if (pwr & 1) y = rnd.mul_up(x, y); + pwr >>= 1; + } + return y; +} + +} // namespace detail +} // namespace interval_lib + +template inline +interval pow(const interval& x, int pwr) +{ + BOOST_USING_STD_MAX(); + using interval_lib::detail::pow_aux; + typedef interval I; + + if (interval_lib::detail::test_input(x)) + return I::empty(); + + if (pwr == 0) + if (interval_lib::user::is_zero(x.lower()) + && interval_lib::user::is_zero(x.upper())) + return I::empty(); + else + return I(static_cast(1)); + else if (pwr < 0) + return interval_lib::multiplicative_inverse(pow(x, -pwr)); + + typename Policies::rounding rnd; + + if (interval_lib::user::is_neg(x.upper())) { // [-2,-1] + T yl = pow_aux(-x.upper(), pwr, rnd); + T yu = pow_aux(-x.lower(), pwr, rnd); + if (pwr & 1) // [-2,-1]^1 + return I(-yu, -yl, true); + else // [-2,-1]^2 + return I(yl, yu, true); + } else if (interval_lib::user::is_neg(x.lower())) { // [-1,1] + if (pwr & 1) { // [-1,1]^1 + return I(-pow_aux(-x.lower(), pwr, rnd), pow_aux(x.upper(), pwr, rnd), true); + } else { // [-1,1]^2 + return I(static_cast(0), pow_aux(max BOOST_PREVENT_MACRO_SUBSTITUTION(-x.lower(), x.upper()), pwr, rnd), true); + } + } else { // [1,2] + return I(pow_aux(x.lower(), pwr, rnd), pow_aux(x.upper(), pwr, rnd), true); + } +} + +template inline +interval sqrt(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) || interval_lib::user::is_neg(x.upper())) + return I::empty(); + typename Policies::rounding rnd; + T l = !interval_lib::user::is_pos(x.lower()) ? static_cast(0) : rnd.sqrt_down(x.lower()); + return I(l, rnd.sqrt_up(x.upper()), true); +} + +template inline +interval square(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + const T& xl = x.lower(); + const T& xu = x.upper(); + if (interval_lib::user::is_neg(xu)) + return I(rnd.mul_down(xu, xu), rnd.mul_up(xl, xl), true); + else if (interval_lib::user::is_pos(x.lower())) + return I(rnd.mul_down(xl, xl), rnd.mul_up(xu, xu), true); + else + return I(static_cast(0), (-xl > xu ? rnd.mul_up(xl, xl) : rnd.mul_up(xu, xu)), true); +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ARITH2_HPP diff --git a/eo/contrib/boost/numeric/interval/arith3.hpp b/eo/contrib/boost/numeric/interval/arith3.hpp new file mode 100644 index 00000000..518e6182 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/arith3.hpp @@ -0,0 +1,69 @@ +/* Boost interval/arith3.hpp template implementation file + * + * This headers provides arithmetical functions + * which compute an interval given some base + * numbers. The resulting interval encloses the + * real result of the arithmetic operation. + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ARITH3_HPP +#define BOOST_NUMERIC_INTERVAL_ARITH3_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +template inline +I add(const typename I::base_type& x, const typename I::base_type& y) +{ + typedef typename I::traits_type Policies; + if (detail::test_input(x, y)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.add_down(x, y), rnd.add_up(x, y), true); +} + +template inline +I sub(const typename I::base_type& x, const typename I::base_type& y) +{ + typedef typename I::traits_type Policies; + if (detail::test_input(x, y)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.sub_down(x, y), rnd.sub_up(x, y), true); +} + +template inline +I mul(const typename I::base_type& x, const typename I::base_type& y) +{ + typedef typename I::traits_type Policies; + if (detail::test_input(x, y)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.mul_down(x, y), rnd.mul_up(x, y), true); +} + +template inline +I div(const typename I::base_type& x, const typename I::base_type& y) +{ + typedef typename I::traits_type Policies; + if (detail::test_input(x, y) || user::is_zero(y)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.div_down(x, y), rnd.div_up(x, y), true); +} + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ARITH3_HPP diff --git a/eo/contrib/boost/numeric/interval/checking.hpp b/eo/contrib/boost/numeric/interval/checking.hpp new file mode 100644 index 00000000..2db486a0 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/checking.hpp @@ -0,0 +1,130 @@ +/* Boost interval/checking.hpp template implementation file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_CHECKING_HPP +#define BOOST_NUMERIC_INTERVAL_CHECKING_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +struct exception_create_empty +{ + void operator()() + { + throw std::runtime_error("boost::interval: empty interval created"); + } +}; + +struct exception_invalid_number +{ + void operator()() + { + throw std::invalid_argument("boost::interval: invalid number"); + } +}; + +template +struct checking_base +{ + static T pos_inf() + { + assert(std::numeric_limits::has_infinity); + return std::numeric_limits::infinity(); + } + static T neg_inf() + { + assert(std::numeric_limits::has_infinity); + return -std::numeric_limits::infinity(); + } + static T nan() + { + assert(std::numeric_limits::has_quiet_NaN); + return std::numeric_limits::quiet_NaN(); + } + static bool is_nan(const T& x) + { + return std::numeric_limits::has_quiet_NaN && (x != x); + } + static T empty_lower() + { + return (std::numeric_limits::has_quiet_NaN ? + std::numeric_limits::quiet_NaN() : static_cast(1)); + } + static T empty_upper() + { + return (std::numeric_limits::has_quiet_NaN ? + std::numeric_limits::quiet_NaN() : static_cast(0)); + } + static bool is_empty(const T& l, const T& u) + { + return !(l <= u); // safety for partial orders + } +}; + +template, + class Exception = exception_create_empty> +struct checking_no_empty: Checking +{ + static T nan() + { + assert(false); + return Checking::nan(); + } + static T empty_lower() + { + Exception()(); + return Checking::empty_lower(); + } + static T empty_upper() + { + Exception()(); + return Checking::empty_upper(); + } + static bool is_empty(const T&, const T&) + { + return false; + } +}; + +template > +struct checking_no_nan: Checking +{ + static bool is_nan(const T&) + { + return false; + } +}; + +template, + class Exception = exception_invalid_number> +struct checking_catch_nan: Checking +{ + static bool is_nan(const T& x) + { + if (Checking::is_nan(x)) Exception()(); + return false; + } +}; + +template +struct checking_strict: + checking_no_nan > +{}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_CHECKING_HPP diff --git a/eo/contrib/boost/numeric/interval/compare.hpp b/eo/contrib/boost/numeric/interval/compare.hpp new file mode 100644 index 00000000..f21753e7 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare.hpp @@ -0,0 +1,19 @@ +/* Boost interval/compare.hpp template implementation file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_HPP + +#include +#include +#include +#include +#include + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/certain.hpp b/eo/contrib/boost/numeric/interval/compare/certain.hpp new file mode 100644 index 00000000..9232d5cd --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/certain.hpp @@ -0,0 +1,113 @@ +/* Boost interval/compare/certain.hpp template implementation file + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace compare { +namespace certain { + +template inline +bool operator<(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() < y.lower(); +} + +template inline +bool operator<(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() < y; +} + +template inline +bool operator<=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() <= y.lower(); +} + +template inline +bool operator<=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() <= y; +} + +template inline +bool operator>(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() > y.upper(); +} + +template inline +bool operator>(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() > y; +} + +template inline +bool operator>=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() >= y.upper(); +} + +template inline +bool operator>=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() >= y; +} + +template inline +bool operator==(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() == y.lower() && x.lower() == y.upper(); +} + +template inline +bool operator==(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() == y && x.lower() == y; +} + +template inline +bool operator!=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() < y.lower() || x.lower() > y.upper(); +} + +template inline +bool operator!=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() < y || x.lower() > y; +} + +} // namespace certain +} // namespace compare +} // namespace interval_lib +} // namespace numeric +} // namespace boost + + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/explicit.hpp b/eo/contrib/boost/numeric/interval/compare/explicit.hpp new file mode 100644 index 00000000..8c68be89 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/explicit.hpp @@ -0,0 +1,248 @@ +/* Boost interval/compare/explicit.hpp template implementation file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP + +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +/* + * Certainly... operations + */ + +template inline +bool cerlt(const interval& x, const interval& y) +{ + return x.upper() < y.lower(); +} + +template inline +bool cerlt(const interval& x, const T& y) +{ + return x.upper() < y; +} + +template inline +bool cerlt(const T& x, const interval& y) +{ + return x < y.lower(); +} + +template inline +bool cerle(const interval& x, const interval& y) +{ + return x.upper() <= y.lower(); +} + +template inline +bool cerle(const interval& x, const T& y) +{ + return x.upper() <= y; +} + +template inline +bool cerle(const T& x, const interval& y) +{ + return x <= y.lower(); +} + +template inline +bool cergt(const interval& x, const interval& y) +{ + return x.lower() > y.upper(); +} + +template inline +bool cergt(const interval& x, const T& y) +{ + return x.lower() > y; +} + +template inline +bool cergt(const T& x, const interval& y) +{ + return x > y.upper(); +} + +template inline +bool cerge(const interval& x, const interval& y) +{ + return x.lower() >= y.upper(); +} + +template inline +bool cerge(const interval& x, const T& y) +{ + return x.lower() >= y; +} + +template inline +bool cerge(const T& x, const interval& y) +{ + return x >= y.upper(); +} + +template inline +bool cereq(const interval& x, const interval& y) +{ + return x.lower() == y.upper() && y.lower() == x.upper(); +} + +template inline +bool cereq(const interval& x, const T& y) +{ + return x.lower() == y && x.upper() == y; +} + +template inline +bool cereq(const T& x, const interval& y) +{ + return x == y.lower() && x == y.upper(); +} + +template inline +bool cerne(const interval& x, const interval& y) +{ + return x.upper() < y.lower() || y.upper() < x.lower(); +} + +template inline +bool cerne(const interval& x, const T& y) +{ + return x.upper() < y || y < x.lower(); +} + +template inline +bool cerne(const T& x, const interval& y) +{ + return x < y.lower() || y.upper() < x; +} + +/* + * Possibly... comparisons + */ + +template inline +bool poslt(const interval& x, const interval& y) +{ + return x.lower() < y.upper(); +} + +template inline +bool poslt(const interval& x, const T& y) +{ + return x.lower() < y; +} + +template inline +bool poslt(const T& x, const interval& y) +{ + return x < y.upper(); +} + +template inline +bool posle(const interval& x, const interval& y) +{ + return x.lower() <= y.upper(); +} + +template inline +bool posle(const interval& x, const T& y) +{ + return x.lower() <= y; +} + +template inline +bool posle(const T& x, const interval& y) +{ + return x <= y.upper(); +} + +template inline +bool posgt(const interval& x, const interval& y) +{ + return x.upper() > y.lower(); +} + +template inline +bool posgt(const interval& x, const T& y) +{ + return x.upper() > y; +} + +template inline +bool posgt(const T& x, const interval & y) +{ + return x > y.lower(); +} + +template inline +bool posge(const interval& x, const interval& y) +{ + return x.upper() >= y.lower(); +} + +template inline +bool posge(const interval& x, const T& y) +{ + return x.upper() >= y; +} + +template inline +bool posge(const T& x, const interval& y) +{ + return x >= y.lower(); +} + +template inline +bool poseq(const interval& x, const interval& y) +{ + return x.upper() >= y.lower() && y.upper() >= x.lower(); +} + +template inline +bool poseq(const interval& x, const T& y) +{ + return x.upper() >= y && y >= x.lower(); +} + +template inline +bool poseq(const T& x, const interval& y) +{ + return x >= y.lower() && y.upper() >= x; +} + +template inline +bool posne(const interval& x, const interval& y) +{ + return x.upper() != y.lower() || y.upper() != x.lower(); +} + +template inline +bool posne(const interval& x, const T& y) +{ + return x.upper() != y || y != x.lower(); +} + +template inline +bool posne(const T& x, const interval& y) +{ + return x != y.lower() || y.upper() != x; +} + +} // namespace interval_lib +} // namespace numeric +} //namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/lexicographic.hpp b/eo/contrib/boost/numeric/interval/compare/lexicographic.hpp new file mode 100644 index 00000000..03f6036d --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/lexicographic.hpp @@ -0,0 +1,122 @@ +/* Boost interval/compare/lexicographic.hpp template implementation file + * + * Copyright 2002-2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace compare { +namespace lexicographic { + +template inline +bool operator<(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + const T& yl = y.lower(); + return xl < yl || (xl == yl && x.upper() < y.upper()); +} + +template inline +bool operator<(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() < y; +} + +template inline +bool operator<=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + const T& yl = y.lower(); + return xl < yl || (xl == yl && x.upper() <= y.upper()); +} + +template inline +bool operator<=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + return xl < y || (xl == y && x.upper() <= y); +} + +template inline +bool operator>(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + const T& yl = y.lower(); + return xl > yl || (xl == yl && x.upper() > y.upper()); +} + +template inline +bool operator>(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + return xl > y || (xl == y && x.upper() > y); +} + +template inline +bool operator>=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + const T& xl = x.lower(); + const T& yl = y.lower(); + return xl > yl || (xl == yl && x.upper() >= y.upper()); +} + +template inline +bool operator>=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() >= y; +} + +template inline +bool operator==(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() == y.lower() && x.upper() == y.upper(); +} + +template inline +bool operator==(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() == y && x.upper() == y; +} + +template inline +bool operator!=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() != y.lower() || x.upper() != y.upper(); +} + +template inline +bool operator!=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() != y || x.upper() != y; +} + +} // namespace lexicographic +} // namespace compare +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/possible.hpp b/eo/contrib/boost/numeric/interval/compare/possible.hpp new file mode 100644 index 00000000..59bec31b --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/possible.hpp @@ -0,0 +1,113 @@ +/* Boost interval/compare/possible.hpp template implementation file + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace compare { +namespace possible { + +template inline +bool operator<(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() < y.upper(); +} + +template inline +bool operator<(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() < y; +} + +template inline +bool operator<=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() <= y.upper(); +} + +template inline +bool operator<=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() <= y; +} + +template inline +bool operator>(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() > y.lower(); +} + +template inline +bool operator>(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() > y; +} + +template inline +bool operator>=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() >= y.lower(); +} + +template inline +bool operator>=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.upper() >= y; +} + +template inline +bool operator==(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() <= y.upper() && x.upper() >= y.lower(); +} + +template inline +bool operator==(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() <= y && x.upper() >= y; +} + +template inline +bool operator!=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() != y.upper() || x.upper() != y.lower(); +} + +template inline +bool operator!=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + return x.lower() != y || x.upper() != y; +} + +} // namespace possible +} // namespace compare +} // namespace interval_lib +} // namespace numeric +} // namespace boost + + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/set.hpp b/eo/contrib/boost/numeric/interval/compare/set.hpp new file mode 100644 index 00000000..aa4f1716 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/set.hpp @@ -0,0 +1,101 @@ +/* Boost interval/compare/set.hpp template implementation file + * + * Copyright 2002-2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace compare { +namespace set { + +template inline +bool operator<(const interval& x, const interval& y) +{ + return proper_subset(x, y); +} + +template inline +bool operator<(const interval& x, const T& y) +{ + throw comparison_error(); +} + +template inline +bool operator<=(const interval& x, const interval& y) +{ + return subset(x, y); +} + +template inline +bool operator<=(const interval& x, const T& y) +{ + throw comparison_error(); +} + +template inline +bool operator>(const interval& x, const interval& y) +{ + return proper_subset(y, x); +} + +template inline +bool operator>(const interval& x, const T& y) +{ + throw comparison_error(); +} + +template inline +bool operator>=(const interval& x, const interval& y) +{ + return subset(y, x); +} + +template inline +bool operator>=(const interval& x, const T& y) +{ + throw comparison_error(); +} + +template inline +bool operator==(const interval& x, const interval& y) +{ + return equal(y, x); +} + +template inline +bool operator==(const interval& x, const T& y) +{ + throw comparison_error(); +} + +template inline +bool operator!=(const interval& x, const interval& y) +{ + return !equal(y, x); +} + +template inline +bool operator!=(const interval& x, const T& y) +{ + throw comparison_error(); +} + +} // namespace set +} // namespace compare +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP diff --git a/eo/contrib/boost/numeric/interval/compare/tribool.hpp b/eo/contrib/boost/numeric/interval/compare/tribool.hpp new file mode 100644 index 00000000..6e4a83e2 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/compare/tribool.hpp @@ -0,0 +1,138 @@ +/* Boost interval/compare/tribool.hpp template implementation file + * + * Copyright 2002-2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP +#define BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace compare { +namespace tribool { + +template inline +logic::tribool operator<(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() < y.lower()) return true; + if (x.lower() >= y.upper()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator<(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() < y) return true; + if (x.lower() >= y) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator<=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() <= y.lower()) return true; + if (x.lower() > y.upper()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator<=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() <= y) return true; + if (x.lower() > y) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator>(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.lower() > y.upper()) return true; + if (x.upper() <= y.lower()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator>(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.lower() > y) return true; + if (x.upper() <= y) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator>=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.lower() >= y.upper()) return true; + if (x.upper() < y.lower()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator>=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.lower() >= y) return true; + if (x.upper() < y) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator==(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() == y.lower() && x.lower() == y.upper()) return true; + if (x.upper() < y.lower() || x.lower() > y.upper()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator==(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() == y && x.lower() == y) return true; + if (x.upper() < y || x.lower() > y) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator!=(const interval& x, const interval& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() < y.lower() || x.lower() > y.upper()) return true; + if (x.upper() == y.lower() && x.lower() == y.upper()) return false; + return logic::indeterminate; +} + +template inline +logic::tribool operator!=(const interval& x, const T& y) +{ + if (detail::test_input(x, y)) throw comparison_error(); + if (x.upper() < y || x.lower() > y) return true; + if (x.upper() == y && x.lower() == y) return false; + return logic::indeterminate; +} + +} // namespace tribool +} // namespace compare +} // namespace interval_lib +} // namespace numeric +} // namespace boost + + +#endif // BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP diff --git a/eo/contrib/boost/numeric/interval/constants.hpp b/eo/contrib/boost/numeric/interval/constants.hpp new file mode 100644 index 00000000..a3a42efe --- /dev/null +++ b/eo/contrib/boost/numeric/interval/constants.hpp @@ -0,0 +1,85 @@ +/* Boost interval/constants.hpp template implementation file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP +#define BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace constants { + +// These constants should be exactly computed. +// Decimal representations wouldn't do it since the standard doesn't +// specify the rounding (even nearest) that should be used. + +static const float pi_f_l = 13176794.0f/(1<<22); +static const float pi_f_u = 13176795.0f/(1<<22); +static const double pi_d_l = (3373259426.0 + 273688.0 / (1<<21)) / (1<<30); +static const double pi_d_u = (3373259426.0 + 273689.0 / (1<<21)) / (1<<30); + +template inline T pi_lower() { return 3; } +template inline T pi_upper() { return 4; } +template inline T pi_half_lower() { return 1; } +template inline T pi_half_upper() { return 2; } +template inline T pi_twice_lower() { return 6; } +template inline T pi_twice_upper() { return 7; } + +template<> inline float pi_lower() { return pi_f_l; } +template<> inline float pi_upper() { return pi_f_u; } +template<> inline float pi_half_lower() { return pi_f_l / 2; } +template<> inline float pi_half_upper() { return pi_f_u / 2; } +template<> inline float pi_twice_lower() { return pi_f_l * 2; } +template<> inline float pi_twice_upper() { return pi_f_u * 2; } + +template<> inline double pi_lower() { return pi_d_l; } +template<> inline double pi_upper() { return pi_d_u; } +template<> inline double pi_half_lower() { return pi_d_l / 2; } +template<> inline double pi_half_upper() { return pi_d_u / 2; } +template<> inline double pi_twice_lower() { return pi_d_l * 2; } +template<> inline double pi_twice_upper() { return pi_d_u * 2; } + +template<> inline long double pi_lower() { return pi_d_l; } +template<> inline long double pi_upper() { return pi_d_u; } +template<> inline long double pi_half_lower() { return pi_d_l / 2; } +template<> inline long double pi_half_upper() { return pi_d_u / 2; } +template<> inline long double pi_twice_lower() { return pi_d_l * 2; } +template<> inline long double pi_twice_upper() { return pi_d_u * 2; } + +} // namespace constants + +template inline +I pi() +{ + typedef typename I::base_type T; + return I(constants::pi_lower(), + constants::pi_upper(), true); +} + +template inline +I pi_half() +{ + typedef typename I::base_type T; + return I(constants::pi_half_lower(), + constants::pi_half_upper(), true); +} + +template inline +I pi_twice() +{ + typedef typename I::base_type T; + return I(constants::pi_twice_lower(), + constants::pi_twice_upper(), true); +} + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/bcc_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/bcc_rounding_control.hpp new file mode 100644 index 00000000..e3aaf046 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/bcc_rounding_control.hpp @@ -0,0 +1,57 @@ +/* Boost interval/detail/bcc_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP + +#ifndef __BORLANDC__ +# error This header is only intended for Borland C++. +#endif + +#ifndef _M_IX86 +# error This header only works on x86 CPUs. +#endif + +#include // Borland C++ rounding control + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +#ifndef BOOST_NUMERIC_INTERVAL_KEEP_EXCEPTIONS_FOR_BCC +extern "C" { unsigned int _RTLENTRY _fm_init(void); } + +struct borland_workaround { + borland_workaround() { _fm_init(); } +}; + +static borland_workaround borland_workaround_exec; +#endif // BOOST_NUMERIC_INTERVAL_KEEP_EXCEPTIONS_FOR_BCC + +__inline double rint(double) +{ __emit__(0xD9); __emit__(0xFC); /* asm FRNDINT */ } + +struct x86_rounding +{ + typedef unsigned int rounding_mode; + static void get_rounding_mode(rounding_mode& mode) + { mode = _control87(0, 0); } + static void set_rounding_mode(const rounding_mode mode) + { _control87(mode, 0xffff); } + static double to_int(const double& x) { return rint(x); } +}; + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/detail/bugs.hpp b/eo/contrib/boost/numeric/interval/detail/bugs.hpp new file mode 100644 index 00000000..2058b9ae --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/bugs.hpp @@ -0,0 +1,79 @@ +/* Boost interval/detail/bugs.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_BUGS +#define BOOST_NUMERIC_INTERVAL_DETAIL_BUGS + +#include + +#if defined(__GLIBC__) && (defined(__USE_MISC) || defined(__USE_XOPEN_EXTENDED) || defined(__USE_ISOC99)) && !defined(__ICC) +# define BOOST_HAS_INV_HYPERBOLIC +#endif + +#ifdef BOOST_NO_STDC_NAMESPACE +# define BOOST_NUMERIC_INTERVAL_using_math(a) using ::a +# ifdef BOOST_HAS_INV_HYPERBOLIC +# define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using ::a +# endif +#else +# define BOOST_NUMERIC_INTERVAL_using_math(a) using std::a +# if defined(BOOST_HAS_INV_HYPERBOLIC) +# if defined(__GLIBCPP__) || defined(__GLIBCXX__) +# define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using ::a +# else +# define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using std::a +# endif +# endif +#endif + +#if defined(__COMO__) || defined(BOOST_INTEL) +# define BOOST_NUMERIC_INTERVAL_using_max(a) using std::a +#elif defined(BOOST_NO_STDC_NAMESPACE) +# define BOOST_NUMERIC_INTERVAL_using_max(a) using ::a +#else +# define BOOST_NUMERIC_INTERVAL_using_max(a) using std::a +#endif + +#ifndef BOOST_NUMERIC_INTERVAL_using_ahyp +# define BOOST_NUMERIC_INTERVAL_using_ahyp(a) +#endif + +#if defined(__GNUC__) && (__GNUC__ <= 2) +// cf PR c++/1981 for a description of the bug +#include +#include +namespace boost { +namespace numeric { + using std::min; + using std::max; + using std::sqrt; + using std::exp; + using std::log; + using std::cos; + using std::tan; + using std::asin; + using std::acos; + using std::atan; + using std::ceil; + using std::floor; + using std::sinh; + using std::cosh; + using std::tanh; +# undef BOOST_NUMERIC_INTERVAL_using_max +# undef BOOST_NUMERIC_INTERVAL_using_math +# define BOOST_NUMERIC_INTERVAL_using_max(a) +# define BOOST_NUMERIC_INTERVAL_using_math(a) +# undef BOOST_NUMERIC_INTERVAL_using_ahyp +# define BOOST_NUMERIC_INTERVAL_using_ahyp(a) +} // namespace numeric +} // namespace boost +#endif + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_BUGS diff --git a/eo/contrib/boost/numeric/interval/detail/c99_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/c99_rounding_control.hpp new file mode 100644 index 00000000..181d2866 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/c99_rounding_control.hpp @@ -0,0 +1,47 @@ +/* Boost interval/detail/c99_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP + +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +struct c99_rounding_control: c99_rounding +{ + template + static T force_rounding(const T& r) { volatile T r_ = r; return r_; } +}; + +} // namespace detail + +template<> +struct rounding_control: + detail::c99_rounding_control { }; + +template<> +struct rounding_control: + detail::c99_rounding_control { }; + +template<> +struct rounding_control: + detail::c99_rounding_control { }; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/c99sub_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/c99sub_rounding_control.hpp new file mode 100644 index 00000000..571c51fc --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/c99sub_rounding_control.hpp @@ -0,0 +1,43 @@ +/* Boost interval/detail/c99sub_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUNDING_CONTROL_HPP + +#include // ISO C 99 rounding mode control + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +extern "C" { double rint(double); } + +struct c99_rounding +{ + typedef int rounding_mode; + + static void set_rounding_mode(const rounding_mode mode) { fesetround(mode); } + static void get_rounding_mode(rounding_mode &mode) { mode = fegetround(); } + static void downward() { set_rounding_mode(FE_DOWNWARD); } + static void upward() { set_rounding_mode(FE_UPWARD); } + static void to_nearest() { set_rounding_mode(FE_TONEAREST); } + static void toward_zero() { set_rounding_mode(FE_TOWARDZERO); } + + template + static T to_int(const T& r) { return rint(r); } +}; + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUBDING_CONTROL_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/division.hpp b/eo/contrib/boost/numeric/interval/detail/division.hpp new file mode 100644 index 00000000..24fb025a --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/division.hpp @@ -0,0 +1,194 @@ +/* Boost interval/detail/division.hpp file + * + * Copyright 2003 Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP + +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +template inline +interval div_non_zero(const interval& x, + const interval& y) +{ + // assert(!in_zero(y)); + typename Policies::rounding rnd; + typedef interval I; + const T& xl = x.lower(); + const T& xu = x.upper(); + const T& yl = y.lower(); + const T& yu = y.upper(); + if (::boost::numeric::interval_lib::user::is_neg(xu)) + if (::boost::numeric::interval_lib::user::is_neg(yu)) + return I(rnd.div_down(xu, yl), rnd.div_up(xl, yu), true); + else + return I(rnd.div_down(xl, yl), rnd.div_up(xu, yu), true); + else if (::boost::numeric::interval_lib::user::is_neg(xl)) + if (::boost::numeric::interval_lib::user::is_neg(yu)) + return I(rnd.div_down(xu, yu), rnd.div_up(xl, yu), true); + else + return I(rnd.div_down(xl, yl), rnd.div_up(xu, yl), true); + else + if (::boost::numeric::interval_lib::user::is_neg(yu)) + return I(rnd.div_down(xu, yu), rnd.div_up(xl, yl), true); + else + return I(rnd.div_down(xl, yu), rnd.div_up(xu, yl), true); +} + +template inline +interval div_non_zero(const T& x, const interval& y) +{ + // assert(!in_zero(y)); + typename Policies::rounding rnd; + typedef interval I; + const T& yl = y.lower(); + const T& yu = y.upper(); + if (::boost::numeric::interval_lib::user::is_neg(x)) + return I(rnd.div_down(x, yl), rnd.div_up(x, yu), true); + else + return I(rnd.div_down(x, yu), rnd.div_up(x, yl), true); +} + +template inline +interval div_positive(const interval& x, const T& yu) +{ + // assert(::boost::numeric::interval_lib::user::is_pos(yu)); + if (::boost::numeric::interval_lib::user::is_zero(x.lower()) && + ::boost::numeric::interval_lib::user::is_zero(x.upper())) + return x; + typename Policies::rounding rnd; + typedef interval I; + const T& xl = x.lower(); + const T& xu = x.upper(); + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(xu)) + return I(checking::neg_inf(), rnd.div_up(xu, yu), true); + else if (::boost::numeric::interval_lib::user::is_neg(xl)) + return I(checking::neg_inf(), checking::pos_inf(), true); + else + return I(rnd.div_down(xl, yu), checking::pos_inf(), true); +} + +template inline +interval div_positive(const T& x, const T& yu) +{ + // assert(::boost::numeric::interval_lib::user::is_pos(yu)); + typedef interval I; + if (::boost::numeric::interval_lib::user::is_zero(x)) + return I(static_cast(0), static_cast(0), true); + typename Policies::rounding rnd; + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(x)) + return I(checking::neg_inf(), rnd.div_up(x, yu), true); + else + return I(rnd.div_down(x, yu), checking::pos_inf(), true); +} + +template inline +interval div_negative(const interval& x, const T& yl) +{ + // assert(::boost::numeric::interval_lib::user::is_neg(yl)); + if (::boost::numeric::interval_lib::user::is_zero(x.lower()) && + ::boost::numeric::interval_lib::user::is_zero(x.upper())) + return x; + typename Policies::rounding rnd; + typedef interval I; + const T& xl = x.lower(); + const T& xu = x.upper(); + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(xu)) + return I(rnd.div_down(xu, yl), checking::pos_inf(), true); + else if (::boost::numeric::interval_lib::user::is_neg(xl)) + return I(checking::neg_inf(), checking::pos_inf(), true); + else + return I(checking::neg_inf(), rnd.div_up(xl, yl), true); +} + +template inline +interval div_negative(const T& x, const T& yl) +{ + // assert(::boost::numeric::interval_lib::user::is_neg(yl)); + typedef interval I; + if (::boost::numeric::interval_lib::user::is_zero(x)) + return I(static_cast(0), static_cast(0), true); + typename Policies::rounding rnd; + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(x)) + return I(rnd.div_down(x, yl), checking::pos_inf(), true); + else + return I(checking::neg_inf(), rnd.div_up(x, yl), true); +} + +template inline +interval div_zero(const interval& x) +{ + if (::boost::numeric::interval_lib::user::is_zero(x.lower()) && + ::boost::numeric::interval_lib::user::is_zero(x.upper())) + return x; + else return interval::whole(); +} + +template inline +interval div_zero(const T& x) +{ + if (::boost::numeric::interval_lib::user::is_zero(x)) + return interval(static_cast(0), static_cast(0), true); + else return interval::whole(); +} + +template inline +interval div_zero_part1(const interval& x, + const interval& y, bool& b) +{ + // assert(::boost::numeric::interval_lib::user::is_neg(y.lower()) && ::boost::numeric::interval_lib::user::is_pos(y.upper())); + if (::boost::numeric::interval_lib::user::is_zero(x.lower()) && ::boost::numeric::interval_lib::user::is_zero(x.upper())) + { b = false; return x; } + typename Policies::rounding rnd; + typedef interval I; + const T& xl = x.lower(); + const T& xu = x.upper(); + const T& yl = y.lower(); + const T& yu = y.upper(); + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(xu)) + { b = true; return I(checking::neg_inf(), rnd.div_up(xu, yu), true); } + else if (::boost::numeric::interval_lib::user::is_neg(xl)) + { b = false; return I(checking::neg_inf(), checking::pos_inf(), true); } + else + { b = true; return I(checking::neg_inf(), rnd.div_up(xl, yl), true); } +} + +template inline +interval div_zero_part2(const interval& x, + const interval& y) +{ + // assert(::boost::numeric::interval_lib::user::is_neg(y.lower()) && ::boost::numeric::interval_lib::user::is_pos(y.upper()) && (div_zero_part1(x, y, b), b)); + typename Policies::rounding rnd; + typedef interval I; + typedef typename Policies::checking checking; + if (::boost::numeric::interval_lib::user::is_neg(x.upper())) + return I(rnd.div_down(x.upper(), y.lower()), checking::pos_inf(), true); + else + return I(rnd.div_down(x.lower(), y.upper()), checking::pos_inf(), true); +} + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/interval_prototype.hpp b/eo/contrib/boost/numeric/interval/detail/interval_prototype.hpp new file mode 100644 index 00000000..ac9029b7 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/interval_prototype.hpp @@ -0,0 +1,41 @@ +/* Boost interval/detail/interval_prototype.hpp file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP + +namespace boost { +namespace numeric { + +namespace interval_lib { + +template struct rounded_math; +template struct checking_strict; +class comparison_error; +template struct policies; + +/* + * default policies class + */ + +template +struct default_policies +{ + typedef policies, checking_strict > type; +}; + +} // namespace interval_lib + +template::type > +class interval; + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/msvc_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/msvc_rounding_control.hpp new file mode 100644 index 00000000..2068c934 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/msvc_rounding_control.hpp @@ -0,0 +1,88 @@ +/* Boost interval/detail/msvc_rounding_control.hpp file + * + * Copyright 2000 Maarten Keijzer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP + +#ifndef _MSC_VER +# error This header is only intended for MSVC, but might work for Borland as well +#endif + +#include // MSVC rounding control + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +extern "C" { double rint(double); } + +struct x86_rounding +{ + static unsigned int hard2msvc(unsigned short m) { + unsigned int n = 0; + if (m & 0x01) n |= _EM_INVALID; + if (m & 0x02) n |= _EM_DENORMAL; + if (m & 0x04) n |= _EM_ZERODIVIDE; + if (m & 0x08) n |= _EM_OVERFLOW; + if (m & 0x10) n |= _EM_UNDERFLOW; + if (m & 0x20) n |= _EM_INEXACT; + switch (m & 0x300) { + case 0x000: n |= _PC_24; break; + case 0x200: n |= _PC_53; break; + case 0x300: n |= _PC_64; break; + } + switch (m & 0xC00) { + case 0x000: n |= _RC_NEAR; break; + case 0x400: n |= _RC_DOWN; break; + case 0x800: n |= _RC_UP; break; + case 0xC00: n |= _RC_CHOP; break; + } + if (m & 0x1000) n |= _IC_AFFINE; // only useful on 287 + return n; + } + + static unsigned short msvc2hard(unsigned int n) { + unsigned short m = 0; + if (n & _EM_INVALID) m |= 0x01; + if (n & _EM_DENORMAL) m |= 0x02; + if (n & _EM_ZERODIVIDE) m |= 0x04; + if (n & _EM_OVERFLOW) m |= 0x08; + if (n & _EM_UNDERFLOW) m |= 0x10; + if (n & _EM_INEXACT) m |= 0x20; + switch (n & _MCW_RC) { + case _RC_NEAR: m |= 0x000; break; + case _RC_DOWN: m |= 0x400; break; + case _RC_UP: m |= 0x800; break; + case _RC_CHOP: m |= 0xC00; break; + } + switch (n & _MCW_PC) { + case _PC_24: m |= 0x000; break; + case _PC_53: m |= 0x200; break; + case _PC_64: m |= 0x300; break; + } + if ((n & _MCW_IC) == _IC_AFFINE) m |= 0x1000; + return m; + } + + typedef unsigned short rounding_mode; + static void get_rounding_mode(rounding_mode& mode) + { mode = msvc2hard(_control87(0, 0)); } + static void set_rounding_mode(const rounding_mode mode) + { _control87(hard2msvc(mode), _MCW_EM | _MCW_RC | _MCW_PC | _MCW_IC); } + static double to_int(const double& x) { return rint(x); } +}; + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/detail/ppc_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/ppc_rounding_control.hpp new file mode 100644 index 00000000..400522a7 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/ppc_rounding_control.hpp @@ -0,0 +1,95 @@ +/* Boost interval/detail/ppc_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * Copyright 2005 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP + +#if !defined(powerpc) && !defined(__powerpc__) && !defined(__ppc__) +#error This header only works on PPC CPUs. +#endif + +#if defined(__GNUC__ ) || (__IBMCPP__ >= 700) + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +typedef union { + ::boost::long_long_type imode; + double dmode; +} rounding_mode_struct; + +static const rounding_mode_struct mode_upward = { 0xFFF8000000000002LL }; +static const rounding_mode_struct mode_downward = { 0xFFF8000000000003LL }; +static const rounding_mode_struct mode_to_nearest = { 0xFFF8000000000001LL }; +static const rounding_mode_struct mode_toward_zero = { 0xFFF8000000000000LL }; + +struct ppc_rounding_control +{ + typedef double rounding_mode; + + static void set_rounding_mode(const rounding_mode mode) + { __asm__ __volatile__ ("mtfsf 255,%0" : : "f"(mode)); } + + static void get_rounding_mode(rounding_mode& mode) + { __asm__ __volatile__ ("mffs %0" : "=f"(mode)); } + + static void downward() { set_rounding_mode(mode_downward.dmode); } + static void upward() { set_rounding_mode(mode_upward.dmode); } + static void to_nearest() { set_rounding_mode(mode_to_nearest.dmode); } + static void toward_zero() { set_rounding_mode(mode_toward_zero.dmode); } +}; + +} // namespace detail + +extern "C" { + float rintf(float); + double rint(double); +} + +template<> +struct rounding_control: + detail::ppc_rounding_control +{ + static float force_rounding(const float r) + { + float tmp; + __asm__ __volatile__ ("frsp %0, %1" : "=f" (tmp) : "f" (r)); + return tmp; + } + static float to_int(const float& x) { return rintf(x); } +}; + +template<> +struct rounding_control: + detail::ppc_rounding_control +{ + static const double & force_rounding(const double& r) { return r; } + static double to_int(const double& r) { return rint(r); } +}; + +template<> +struct rounding_control: + detail::ppc_rounding_control +{ + static const long double & force_rounding(const long double& r) { return r; } + static long double to_int(const long double& r) { return rint(r); } +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE +#endif + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/detail/sparc_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/sparc_rounding_control.hpp new file mode 100644 index 00000000..6ba5baf0 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/sparc_rounding_control.hpp @@ -0,0 +1,112 @@ +/* Boost interval/detail/sparc_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + * + * The basic code in this file was kindly provided by Jeremy Siek. + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP + +#if !defined(sparc) && !defined(__sparc__) +# error This header is only intended for SPARC CPUs. +#endif + +#ifdef __SUNPRO_CC +# include +#endif + + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +struct sparc_rounding_control +{ + typedef unsigned int rounding_mode; + + static void set_rounding_mode(const rounding_mode& mode) + { +# if defined(__GNUC__) + __asm__ __volatile__("ld %0, %%fsr" : : "m"(mode)); +# elif defined (__SUNPRO_CC) + fpsetround(fp_rnd(mode)); +# elif defined(__KCC) + asm("sethi %hi(mode), %o1"); + asm("ld [%o1+%lo(mode)], %fsr"); +# else +# error Unsupported compiler for Sparc rounding control. +# endif + } + + static void get_rounding_mode(rounding_mode& mode) + { +# if defined(__GNUC__) + __asm__ __volatile__("st %%fsr, %0" : "=m"(mode)); +# elif defined (__SUNPRO_CC) + mode = fpgetround(); +# elif defined(__KCC) +# error KCC on Sun SPARC get_round_mode: please fix me + asm("st %fsr, [mode]"); +# else +# error Unsupported compiler for Sparc rounding control. +# endif + } + +#if defined(__SUNPRO_CC) + static void downward() { set_rounding_mode(FP_RM); } + static void upward() { set_rounding_mode(FP_RP); } + static void to_nearest() { set_rounding_mode(FP_RN); } + static void toward_zero() { set_rounding_mode(FP_RZ); } +#else + static void downward() { set_rounding_mode(0xc0000000); } + static void upward() { set_rounding_mode(0x80000000); } + static void to_nearest() { set_rounding_mode(0x00000000); } + static void toward_zero() { set_rounding_mode(0x40000000); } +#endif +}; + +} // namespace detail + +extern "C" { + float rintf(float); + double rint(double); +} + +template<> +struct rounding_control: + detail::sparc_rounding_control +{ + static const float& force_rounding(const float& x) { return x; } + static float to_int(const float& x) { return rintf(x); } +}; + +template<> +struct rounding_control: + detail::sparc_rounding_control +{ + static const double& force_rounding(const double& x) { return x; } + static double to_int(const double& x) { return rint(x); } +}; + +template<> +struct rounding_control: + detail::sparc_rounding_control +{ + static const long double& force_rounding(const long double& x) { return x; } + static long double to_int(const long double& x) { return rint(x); } +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/detail/test_input.hpp b/eo/contrib/boost/numeric/interval/detail/test_input.hpp new file mode 100644 index 00000000..58695fec --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/test_input.hpp @@ -0,0 +1,76 @@ +/* Boost interval/detail/test_input.hpp file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP + +#include + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace user { + +template inline +bool is_zero(T const &v) { return v == static_cast(0); } + +template inline +bool is_neg (T const &v) { return v < static_cast(0); } + +template inline +bool is_pos (T const &v) { return v > static_cast(0); } + +} // namespace user + +namespace detail { + +template inline +bool test_input(const interval& x) { + typedef typename Policies::checking checking; + return checking::is_empty(x.lower(), x.upper()); +} + +template inline +bool test_input(const interval& x, const interval& y) { + typedef typename Policies1::checking checking1; + typedef typename Policies2::checking checking2; + return checking1::is_empty(x.lower(), x.upper()) || + checking2::is_empty(y.lower(), y.upper()); +} + +template inline +bool test_input(const T& x, const interval& y) { + typedef typename Policies::checking checking; + return checking::is_nan(x) || checking::is_empty(y.lower(), y.upper()); +} + +template inline +bool test_input(const interval& x, const T& y) { + typedef typename Policies::checking checking; + return checking::is_empty(x.lower(), x.upper()) || checking::is_nan(y); +} + +template inline +bool test_input(const T& x) { + typedef typename Policies::checking checking; + return checking::is_nan(x); +} + +template inline +bool test_input(const T& x, const T& y) { + typedef typename Policies::checking checking; + return checking::is_nan(x) || checking::is_nan(y); +} + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP diff --git a/eo/contrib/boost/numeric/interval/detail/x86_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/x86_rounding_control.hpp new file mode 100644 index 00000000..3eebdbac --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/x86_rounding_control.hpp @@ -0,0 +1,108 @@ +/* Boost interval/detail/x86_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP + +#ifdef __GNUC__ +# include +#elif defined(__BORLANDC__) +# include +#elif defined(_MSC_VER) +# include +#elif defined(__MWERKS__) || defined(__ICC) +# define BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM +# include +#else +# error Unsupported C++ compiler. +#endif + +namespace boost { +namespace numeric { +namespace interval_lib { + +namespace detail { + +#ifdef BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM +typedef c99_rounding x86_rounding_control; +#undef BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM +#else +struct fpu_rounding_modes +{ + unsigned short to_nearest; + unsigned short downward; + unsigned short upward; + unsigned short toward_zero; +}; + +// exceptions masked, extended precision +// hardware default is 0x037f (0x1000 only has a meaning on 287) +static const fpu_rounding_modes rnd_mode = { 0x137f, 0x177f, 0x1b7f, 0x1f7f }; + +struct x86_rounding_control: x86_rounding +{ + static void to_nearest() { set_rounding_mode(rnd_mode.to_nearest); } + static void downward() { set_rounding_mode(rnd_mode.downward); } + static void upward() { set_rounding_mode(rnd_mode.upward); } + static void toward_zero() { set_rounding_mode(rnd_mode.toward_zero); } +}; +#endif // BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM + +} // namespace detail + +template<> +struct rounding_control: detail::x86_rounding_control +{ + static float force_rounding(const float& r) + { volatile float r_ = r; return r_; } +}; + +template<> +struct rounding_control: detail::x86_rounding_control +{ + /*static double force_rounding(double r) + { asm volatile ("" : "+m"(r) : ); return r; }*/ + static double force_rounding(const double& r) + { volatile double r_ = r; return r_; } +}; + +namespace detail { + +template +struct x86_rounding_control_long_double; + +template<> +struct x86_rounding_control_long_double: x86_rounding_control +{ + static long double force_rounding(long double const &r) + { volatile long double r_ = r; return r_; } +}; + +template<> +struct x86_rounding_control_long_double: x86_rounding_control +{ + static long double const &force_rounding(long double const &r) + { return r; } +}; + +} // namespace detail + +template<> +struct rounding_control: + detail::x86_rounding_control_long_double< (sizeof(long double) >= 10) > +{}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/detail/x86gcc_rounding_control.hpp b/eo/contrib/boost/numeric/interval/detail/x86gcc_rounding_control.hpp new file mode 100644 index 00000000..079d681d --- /dev/null +++ b/eo/contrib/boost/numeric/interval/detail/x86gcc_rounding_control.hpp @@ -0,0 +1,51 @@ +/* Boost interval/detail/x86gcc_rounding_control.hpp file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP + +#ifndef __GNUC__ +# error This header only works with GNU CC. +#endif + +#ifndef __i386__ +# error This header only works on x86 CPUs. +#endif + +namespace boost { +namespace numeric { +namespace interval_lib { +namespace detail { + +struct x86_rounding +{ + typedef unsigned short rounding_mode; + + static void set_rounding_mode(const rounding_mode& mode) + { __asm__ __volatile__ ("fldcw %0" : : "m"(mode)); } + + static void get_rounding_mode(rounding_mode& mode) + { __asm__ __volatile__ ("fnstcw %0" : "=m"(mode)); } + + template + static T to_int(T r) + { + T r_; + __asm__ ("frndint" : "=&t"(r_) : "0"(r)); + return r_; + } +}; + +} // namespace detail +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP */ diff --git a/eo/contrib/boost/numeric/interval/ext/integer.hpp b/eo/contrib/boost/numeric/interval/ext/integer.hpp new file mode 100644 index 00000000..628a343a --- /dev/null +++ b/eo/contrib/boost/numeric/interval/ext/integer.hpp @@ -0,0 +1,70 @@ +/* Boost interval/ext/integer.hpp template implementation file + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP +#define BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP + +#include +#include + +namespace boost { +namespace numeric { + +template inline +interval operator+ (const interval& x, int y) +{ + return x + static_cast(y); +} + +template inline +interval operator+ (int x, const interval& y) +{ + return static_cast(x) + y; +} + +template inline +interval operator- (const interval& x, int y) +{ + return x - static_cast(y); +} + +template inline +interval operator- (int x, const interval& y) +{ + return static_cast(x) - y; +} + +template inline +interval operator* (const interval& x, int y) +{ + return x * static_cast(y); +} + +template inline +interval operator* (int x, const interval& y) +{ + return static_cast(x) * y; +} + +template inline +interval operator/ (const interval& x, int y) +{ + return x / static_cast(y); +} + +template inline +interval operator/ (int x, const interval& y) +{ + return static_cast(x) / y; +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP diff --git a/eo/contrib/boost/numeric/interval/ext/x86_fast_rounding_control.hpp b/eo/contrib/boost/numeric/interval/ext/x86_fast_rounding_control.hpp new file mode 100644 index 00000000..7f89a4e5 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/ext/x86_fast_rounding_control.hpp @@ -0,0 +1,70 @@ +/* Boost interval/detail/x86gcc_rounding_control.hpp file + * + * This header provides a rounding control policy + * that avoids flushing results to memory. In + * order for this optimization to be reliable, it + * should be used only when no underflow or + * overflow would happen without it. Indeed, only + * values in range are correctly rounded. + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP +#define BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP + +namespace boost { +namespace numeric { +namespace interval_lib { + +namespace detail { + +// exceptions masked, expected precision (the mask is 0x0300) +static const fpu_rounding_modes rnd_mode_f = { 0x107f, 0x147f, 0x187f, 0x1c7f }; +static const fpu_rounding_modes rnd_mode_d = { 0x127f, 0x167f, 0x1a7f, 0x1e7f }; +static const fpu_rounding_modes rnd_mode_l = { 0x137f, 0x177f, 0x1b7f, 0x1f7f }; + +} // namespace detail + +template +struct x86_fast_rounding_control; + +template<> +struct x86_fast_rounding_control: detail::x86_rounding +{ + static void to_nearest() { set_rounding_mode(detail::rnd_mode_f.to_nearest); } + static void downward() { set_rounding_mode(detail::rnd_mode_f.downward); } + static void upward() { set_rounding_mode(detail::rnd_mode_f.upward); } + static void toward_zero() { set_rounding_mode(detail::rnd_mode_f.toward_zero); } + static const float& force_rounding(const float& r) { return r; } +}; + +template<> +struct x86_fast_rounding_control: detail::x86_rounding +{ + static void to_nearest() { set_rounding_mode(detail::rnd_mode_d.to_nearest); } + static void downward() { set_rounding_mode(detail::rnd_mode_d.downward); } + static void upward() { set_rounding_mode(detail::rnd_mode_d.upward); } + static void toward_zero() { set_rounding_mode(detail::rnd_mode_d.toward_zero); } + static const double& force_rounding(const double& r) { return r; } +}; + +template<> +struct x86_fast_rounding_control: detail::x86_rounding +{ + static void to_nearest() { set_rounding_mode(detail::rnd_mode_l.to_nearest); } + static void downward() { set_rounding_mode(detail::rnd_mode_l.downward); } + static void upward() { set_rounding_mode(detail::rnd_mode_l.upward); } + static void toward_zero() { set_rounding_mode(detail::rnd_mode_l.toward_zero); } + static const long double& force_rounding(const long double& r) { return r; } +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP diff --git a/eo/contrib/boost/numeric/interval/hw_rounding.hpp b/eo/contrib/boost/numeric/interval/hw_rounding.hpp new file mode 100644 index 00000000..ed225d40 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/hw_rounding.hpp @@ -0,0 +1,64 @@ +/* Boost interval/hw_rounding.hpp template implementation file + * + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * Copyright 2005 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP +#define BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP + +#include +#include + +#define BOOST_NUMERIC_INTERVAL_NO_HARDWARE + +// define appropriate specialization of rounding_control for built-in types +#if defined(__i386__) || defined(_M_IX86) || defined(__BORLANDC__) +# include +#elif defined(powerpc) || defined(__powerpc__) || defined(__ppc__) +# include +#elif defined(sparc) || defined(__sparc__) +# include +#endif + +#if defined(BOOST_NUMERIC_INTERVAL_NO_HARDWARE) && (defined(__USE_ISOC99) || defined(__MSL__)) +# include +#endif + +#if defined(BOOST_NUMERIC_INTERVAL_NO_HARDWARE) +# undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE +# error Boost.Numeric.Interval: Please specify rounding control mechanism. +#endif + +namespace boost { +namespace numeric { +namespace interval_lib { + +/* + * Three specializations of rounded_math + */ + +template<> +struct rounded_math + : save_state > +{}; + +template<> +struct rounded_math + : save_state > +{}; + +template<> +struct rounded_math + : save_state > +{}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP diff --git a/eo/contrib/boost/numeric/interval/interval.hpp b/eo/contrib/boost/numeric/interval/interval.hpp new file mode 100644 index 00000000..0b2d0eec --- /dev/null +++ b/eo/contrib/boost/numeric/interval/interval.hpp @@ -0,0 +1,450 @@ +/* Boost interval/interval.hpp header file + * + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_INTERVAL_HPP +#define BOOST_NUMERIC_INTERVAL_INTERVAL_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { + +namespace interval_lib { + +class comparison_error + : public std::runtime_error +{ +public: + comparison_error() + : std::runtime_error("boost::interval: uncertain comparison") + { } +}; + +} // namespace interval_lib + +/* + * interval class + */ + +template +class interval +{ +private: + struct interval_holder; + struct number_holder; +public: + typedef T base_type; + typedef Policies traits_type; + + T const &lower() const; + T const &upper() const; + + interval(); + interval(T const &v); + template interval(T1 const &v); + interval(T const &l, T const &u); + template interval(T1 const &l, T2 const &u); + interval(interval const &r); + template interval(interval const &r); + template interval(interval const &r); + + interval &operator=(T const &v); + template interval &operator=(T1 const &v); + interval &operator=(interval const &r); + template interval &operator=(interval const &r); + template interval &operator=(interval const &r); + + void assign(const T& l, const T& u); + + static interval empty(); + static interval whole(); + static interval hull(const T& x, const T& y); + + interval& operator+= (const T& r); + interval& operator+= (const interval& r); + interval& operator-= (const T& r); + interval& operator-= (const interval& r); + interval& operator*= (const T& r); + interval& operator*= (const interval& r); + interval& operator/= (const T& r); + interval& operator/= (const interval& r); + + bool operator< (const interval_holder& r) const; + bool operator> (const interval_holder& r) const; + bool operator<= (const interval_holder& r) const; + bool operator>= (const interval_holder& r) const; + bool operator== (const interval_holder& r) const; + bool operator!= (const interval_holder& r) const; + + bool operator< (const number_holder& r) const; + bool operator> (const number_holder& r) const; + bool operator<= (const number_holder& r) const; + bool operator>= (const number_holder& r) const; + bool operator== (const number_holder& r) const; + bool operator!= (const number_holder& r) const; + + // the following is for internal use only, it is not a published interface + // nevertheless, it's public because friends don't always work correctly. + interval(const T& l, const T& u, bool): low(l), up(u) {} + void set_empty(); + void set_whole(); + void set(const T& l, const T& u); + +private: + struct interval_holder { + template + interval_holder(const interval& r) + : low(r.lower()), up(r.upper()) + { + typedef typename Policies2::checking checking2; + if (checking2::is_empty(low, up)) + throw interval_lib::comparison_error(); + } + + const T& low; + const T& up; + }; + + struct number_holder { + number_holder(const T& r) : val(r) + { + typedef typename Policies::checking checking; + if (checking::is_nan(r)) + throw interval_lib::comparison_error(); + } + + const T& val; + }; + + typedef typename Policies::checking checking; + typedef typename Policies::rounding rounding; + + T low; + T up; +}; + +template inline +interval::interval(): + low(static_cast(0)), up(static_cast(0)) +{} + +template inline +interval::interval(T const &v): low(v), up(v) +{ + if (checking::is_nan(v)) set_empty(); +} + +template template inline +interval::interval(T1 const &v) +{ + if (checking::is_nan(v)) set_empty(); + else { + rounding rnd; + low = rnd.conv_down(v); + up = rnd.conv_up (v); + } +} + +template template inline +interval::interval(T1 const &l, T2 const &u) +{ + if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u)) set_empty(); + else { + rounding rnd; + low = rnd.conv_down(l); + up = rnd.conv_up (u); + } +} + +template inline +interval::interval(T const &l, T const &u): low(l), up(u) +{ + if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u)) + set_empty(); +} + + +template inline +interval::interval(interval const &r): low(r.lower()), up(r.upper()) +{} + +template template inline +interval::interval(interval const &r): low(r.lower()), up(r.upper()) +{ + typedef typename Policies1::checking checking1; + if (checking1::is_empty(r.lower(), r.upper())) set_empty(); +} + +template template inline +interval::interval(interval const &r) +{ + typedef typename Policies1::checking checking1; + if (checking1::is_empty(r.lower(), r.upper())) set_empty(); + else { + rounding rnd; + low = rnd.conv_down(r.lower()); + up = rnd.conv_up (r.upper()); + } +} + +template inline +interval &interval::operator=(T const &v) +{ + if (checking::is_nan(v)) set_empty(); + else low = up = v; + return *this; +} + +template template inline +interval &interval::operator=(T1 const &v) +{ + if (checking::is_nan(v)) set_empty(); + else { + rounding rnd; + low = rnd.conv_down(v); + up = rnd.conv_up (v); + } + return *this; +} + +template inline +interval &interval::operator=(interval const &r) +{ + low = r.lower(); + up = r.upper(); + return *this; +} + +template template inline +interval &interval::operator=(interval const &r) +{ + typedef typename Policies1::checking checking1; + if (checking1::is_empty(r.lower(), r.upper())) set_empty(); + else { + low = r.lower(); + up = r.upper(); + } + return *this; +} + +template template inline +interval &interval::operator=(interval const &r) +{ + typedef typename Policies1::checking checking1; + if (checking1::is_empty(r.lower(), r.upper())) set_empty(); + else { + rounding rnd; + low = rnd.conv_down(r.lower()); + up = rnd.conv_up (r.upper()); + } + return *this; +} + +template inline +void interval::assign(const T& l, const T& u) +{ + if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u)) + set_empty(); + else set(l, u); +} + +template inline +void interval::set(const T& l, const T& u) +{ + low = l; + up = u; +} + +template inline +void interval::set_empty() +{ + low = checking::empty_lower(); + up = checking::empty_upper(); +} + +template inline +void interval::set_whole() +{ + low = checking::neg_inf(); + up = checking::pos_inf(); +} + +template inline +interval interval::hull(const T& x, const T& y) +{ + bool bad_x = checking::is_nan(x); + bool bad_y = checking::is_nan(y); + if (bad_x) + if (bad_y) return interval::empty(); + else return interval(y, y, true); + else + if (bad_y) return interval(x, x, true); + if (x <= y) return interval(x, y, true); + else return interval(y, x, true); +} + +template inline +interval interval::empty() +{ + return interval(checking::empty_lower(), + checking::empty_upper(), true); +} + +template inline +interval interval::whole() +{ + return interval(checking::neg_inf(), checking::pos_inf(), true); +} + +template inline +const T& interval::lower() const +{ + return low; +} + +template inline +const T& interval::upper() const +{ + return up; +} + +/* + * interval/interval comparisons + */ + +template inline +bool interval::operator< (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up < r.low) return true; + else if (low >= r.up) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator> (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (low > r.up) return true; + else if (up <= r.low) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator<= (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up <= r.low) return true; + else if (low > r.up) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator>= (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (low >= r.up) return true; + else if (up < r.low) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator== (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up == r.low && low == r.up) return true; + else if (up < r.low || low > r.up) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator!= (const interval_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up < r.low || low > r.up) return true; + else if (up == r.low && low == r.up) return false; + } + throw interval_lib::comparison_error(); +} + +/* + * interval/number comparisons + */ + +template inline +bool interval::operator< (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up < r.val) return true; + else if (low >= r.val) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator> (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (low > r.val) return true; + else if (up <= r.val) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator<= (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up <= r.val) return true; + else if (low > r.val) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator>= (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (low >= r.val) return true; + else if (up < r.val) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator== (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up == r.val && low == r.val) return true; + else if (up < r.val || low > r.val) return false; + } + throw interval_lib::comparison_error(); +} + +template inline +bool interval::operator!= (const number_holder& r) const +{ + if (!checking::is_empty(low, up)) { + if (up < r.val || low > r.val) return true; + else if (up == r.val && low == r.val) return false; + } + throw interval_lib::comparison_error(); +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_INTERVAL_HPP diff --git a/eo/contrib/boost/numeric/interval/io.hpp b/eo/contrib/boost/numeric/interval/io.hpp new file mode 100644 index 00000000..dc4179e5 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/io.hpp @@ -0,0 +1,41 @@ +/* Boost interval/io.hpp header file + * + * This file is only meant to provide a quick + * implementation of the output operator. It is + * provided for test programs that aren't even + * interested in the precision of the results. + * A real progam should define its own operators + * and never include this header. + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_IO_HPP +#define BOOST_NUMERIC_INTERVAL_IO_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { + +template +std::basic_ostream &operator<< + (std::basic_ostream &stream, + interval const &value) +{ + if (empty(value)) + return stream << "[]"; + else + return stream << '[' << lower(value) << ',' << upper(value) << ']'; +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_IO_HPP diff --git a/eo/contrib/boost/numeric/interval/limits.hpp b/eo/contrib/boost/numeric/interval/limits.hpp new file mode 100644 index 00000000..d691ccee --- /dev/null +++ b/eo/contrib/boost/numeric/interval/limits.hpp @@ -0,0 +1,51 @@ +/* Boost interval/limits.hpp template implementation file + * + * Copyright 2000 Jens Maurer + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_LIMITS_HPP +#define BOOST_NUMERIC_INTERVAL_LIMITS_HPP + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#include +#include +#include + +namespace std { + +template +class numeric_limits > + : public numeric_limits +{ +private: + typedef boost::numeric::interval I; + typedef numeric_limits bl; +public: + static I min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return I((bl::min)(), (bl::min)()); } + static I max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return I((bl::max)(), (bl::max)()); } + static I epsilon() throw() { return I(bl::epsilon(), bl::epsilon()); } + + BOOST_STATIC_CONSTANT(float_round_style, round_style = round_indeterminate); + BOOST_STATIC_CONSTANT(bool, is_iec559 = false); + + static I infinity () throw() { return I::whole(); } + static I quiet_NaN() throw() { return I::empty(); } + static I signaling_NaN() throw() + { return I(bl::signaling_NaN(), bl::signaling_Nan()); } + static I denorm_min() throw() + { return I(bl::denorm_min(), bl::denorm_min()); } +private: + static I round_error(); // hide this on purpose, not yet implemented +}; + +} // namespace std + +#endif + +#endif // BOOST_NUMERIC_INTERVAL_LIMITS_HPP diff --git a/eo/contrib/boost/numeric/interval/policies.hpp b/eo/contrib/boost/numeric/interval/policies.hpp new file mode 100644 index 00000000..70ad220d --- /dev/null +++ b/eo/contrib/boost/numeric/interval/policies.hpp @@ -0,0 +1,75 @@ +/* Boost interval/policies.hpp template implementation file + * + * Copyright 2003 Guillaume Melquiond + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_POLICIES_HPP +#define BOOST_NUMERIC_INTERVAL_POLICIES_HPP + +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +/* + * policies class + */ + +template +struct policies +{ + typedef Rounding rounding; + typedef Checking checking; +}; + +/* + * policies switching classes + */ + +template +class change_rounding +{ + typedef typename OldInterval::base_type T; + typedef typename OldInterval::traits_type p; + typedef typename p::checking checking; +public: + typedef interval > type; +}; + +template +class change_checking +{ + typedef typename OldInterval::base_type T; + typedef typename OldInterval::traits_type p; + typedef typename p::rounding rounding; +public: + typedef interval > type; +}; + +/* + * Protect / unprotect: control whether the rounding mode is set/reset + * at each operation, rather than once and for all. + */ + +template +class unprotect +{ + typedef typename OldInterval::base_type T; + typedef typename OldInterval::traits_type p; + typedef typename p::rounding r; + typedef typename r::unprotected_rounding newRounding; +public: + typedef typename change_rounding::type type; +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + + +#endif // BOOST_NUMERIC_INTERVAL_POLICIES_HPP diff --git a/eo/contrib/boost/numeric/interval/rounded_arith.hpp b/eo/contrib/boost/numeric/interval/rounded_arith.hpp new file mode 100644 index 00000000..6ce5c7f7 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/rounded_arith.hpp @@ -0,0 +1,120 @@ +/* Boost interval/rounded_arith.hpp template implementation file + * + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP +#define BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +/* + * Three classes of rounding: exact, std, opp + * See documentation for details. + */ + +template +struct rounded_arith_exact: Rounding { + void init() { } + template T conv_down(U const &v) { return v; } + template T conv_up (U const &v) { return v; } + T add_down (const T& x, const T& y) { return x + y; } + T add_up (const T& x, const T& y) { return x + y; } + T sub_down (const T& x, const T& y) { return x - y; } + T sub_up (const T& x, const T& y) { return x - y; } + T mul_down (const T& x, const T& y) { return x * y; } + T mul_up (const T& x, const T& y) { return x * y; } + T div_down (const T& x, const T& y) { return x / y; } + T div_up (const T& x, const T& y) { return x / y; } + T median (const T& x, const T& y) { return (x + y) / 2; } + T sqrt_down(const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); } + T sqrt_up (const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); } + T int_down (const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(floor); return floor(x); } + T int_up (const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(ceil); return ceil(x); } +}; + +template +struct rounded_arith_std: Rounding { +# define BOOST_DN(EXPR) this->downward(); return this->force_rounding(EXPR) +# define BOOST_NR(EXPR) this->to_nearest(); return this->force_rounding(EXPR) +# define BOOST_UP(EXPR) this->upward(); return this->force_rounding(EXPR) + void init() { } + template T conv_down(U const &v) { BOOST_DN(v); } + template T conv_up (U const &v) { BOOST_UP(v); } + T add_down(const T& x, const T& y) { BOOST_DN(x + y); } + T sub_down(const T& x, const T& y) { BOOST_DN(x - y); } + T mul_down(const T& x, const T& y) { BOOST_DN(x * y); } + T div_down(const T& x, const T& y) { BOOST_DN(x / y); } + T add_up (const T& x, const T& y) { BOOST_UP(x + y); } + T sub_up (const T& x, const T& y) { BOOST_UP(x - y); } + T mul_up (const T& x, const T& y) { BOOST_UP(x * y); } + T div_up (const T& x, const T& y) { BOOST_UP(x / y); } + T median(const T& x, const T& y) { BOOST_NR((x + y) / 2); } + T sqrt_down(const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); } + T sqrt_up (const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); } + T int_down(const T& x) { this->downward(); return to_int(x); } + T int_up (const T& x) { this->upward(); return to_int(x); } +# undef BOOST_DN +# undef BOOST_NR +# undef BOOST_UP +}; + +template +struct rounded_arith_opp: Rounding { + void init() { this->upward(); } +# define BOOST_DN(EXPR) \ + this->downward(); \ + T r = this->force_rounding(EXPR); \ + this->upward(); \ + return r +# define BOOST_NR(EXPR) \ + this->to_nearest(); \ + T r = this->force_rounding(EXPR); \ + this->upward(); \ + return r +# define BOOST_UP(EXPR) return this->force_rounding(EXPR) +# define BOOST_UP_NEG(EXPR) return -this->force_rounding(EXPR) + template T conv_down(U const &v) { BOOST_UP_NEG(-v); } + template T conv_up (U const &v) { BOOST_UP(v); } + T add_down(const T& x, const T& y) { BOOST_UP_NEG((-x) - y); } + T sub_down(const T& x, const T& y) { BOOST_UP_NEG(y - x); } + T mul_down(const T& x, const T& y) { BOOST_UP_NEG(x * (-y)); } + T div_down(const T& x, const T& y) { BOOST_UP_NEG(x / (-y)); } + T add_up (const T& x, const T& y) { BOOST_UP(x + y); } + T sub_up (const T& x, const T& y) { BOOST_UP(x - y); } + T mul_up (const T& x, const T& y) { BOOST_UP(x * y); } + T div_up (const T& x, const T& y) { BOOST_UP(x / y); } + T median (const T& x, const T& y) { BOOST_NR((x + y) / 2); } + T sqrt_down(const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); } + T sqrt_up (const T& x) + { BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); } + T int_down(const T& x) { return -to_int(-x); } + T int_up (const T& x) { return to_int(x); } +# undef BOOST_DN +# undef BOOST_NR +# undef BOOST_UP +# undef BOOST_UP_NEG +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP diff --git a/eo/contrib/boost/numeric/interval/rounded_transc.hpp b/eo/contrib/boost/numeric/interval/rounded_transc.hpp new file mode 100644 index 00000000..e1704f5f --- /dev/null +++ b/eo/contrib/boost/numeric/interval/rounded_transc.hpp @@ -0,0 +1,140 @@ +/* Boost interval/rounded_transc.hpp template implementation file + * + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP +#define BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace interval_lib { + +template +struct rounded_transc_exact: Rounding +{ +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) { BOOST_NUMERIC_INTERVAL_using_math(f); return f(x); } \ + T f##_up (const T& x) { BOOST_NUMERIC_INTERVAL_using_math(f); return f(x); } + BOOST_NUMERIC_INTERVAL_new_func(exp) + BOOST_NUMERIC_INTERVAL_new_func(log) + BOOST_NUMERIC_INTERVAL_new_func(sin) + BOOST_NUMERIC_INTERVAL_new_func(cos) + BOOST_NUMERIC_INTERVAL_new_func(tan) + BOOST_NUMERIC_INTERVAL_new_func(asin) + BOOST_NUMERIC_INTERVAL_new_func(acos) + BOOST_NUMERIC_INTERVAL_new_func(atan) + BOOST_NUMERIC_INTERVAL_new_func(sinh) + BOOST_NUMERIC_INTERVAL_new_func(cosh) + BOOST_NUMERIC_INTERVAL_new_func(tanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) { BOOST_NUMERIC_INTERVAL_using_ahyp(f); return f(x); } \ + T f##_up (const T& x) { BOOST_NUMERIC_INTERVAL_using_ahyp(f); return f(x); } + BOOST_NUMERIC_INTERVAL_new_func(asinh) + BOOST_NUMERIC_INTERVAL_new_func(acosh) + BOOST_NUMERIC_INTERVAL_new_func(atanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +}; + +template +struct rounded_transc_std: Rounding +{ +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + this->downward(); return this->force_rounding(f(x)); } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + this->upward(); return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(exp) + BOOST_NUMERIC_INTERVAL_new_func(log) + BOOST_NUMERIC_INTERVAL_new_func(sin) + BOOST_NUMERIC_INTERVAL_new_func(cos) + BOOST_NUMERIC_INTERVAL_new_func(tan) + BOOST_NUMERIC_INTERVAL_new_func(asin) + BOOST_NUMERIC_INTERVAL_new_func(acos) + BOOST_NUMERIC_INTERVAL_new_func(atan) + BOOST_NUMERIC_INTERVAL_new_func(sinh) + BOOST_NUMERIC_INTERVAL_new_func(cosh) + BOOST_NUMERIC_INTERVAL_new_func(tanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + this->downward(); return this->force_rounding(f(x)); } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + this->upward(); return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(asinh) + BOOST_NUMERIC_INTERVAL_new_func(acosh) + BOOST_NUMERIC_INTERVAL_new_func(atanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +}; + +template +struct rounded_transc_opp: Rounding +{ +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + this->downward(); T y = this->force_rounding(f(x)); \ + this->upward(); return y; } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(exp) + BOOST_NUMERIC_INTERVAL_new_func(log) + BOOST_NUMERIC_INTERVAL_new_func(cos) + BOOST_NUMERIC_INTERVAL_new_func(acos) + BOOST_NUMERIC_INTERVAL_new_func(cosh) +# undef BOOST_NUMERIC_INTERVAL_new_func +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + return -this->force_rounding(-f(x)); } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_math(f); \ + return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(sin) + BOOST_NUMERIC_INTERVAL_new_func(tan) + BOOST_NUMERIC_INTERVAL_new_func(asin) + BOOST_NUMERIC_INTERVAL_new_func(atan) + BOOST_NUMERIC_INTERVAL_new_func(sinh) + BOOST_NUMERIC_INTERVAL_new_func(tanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + this->downward(); T y = this->force_rounding(f(x)); \ + this->upward(); return y; } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(asinh) + BOOST_NUMERIC_INTERVAL_new_func(atanh) +# undef BOOST_NUMERIC_INTERVAL_new_func +# define BOOST_NUMERIC_INTERVAL_new_func(f) \ + T f##_down(const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + return -this->force_rounding(-f(x)); } \ + T f##_up (const T& x) \ + { BOOST_NUMERIC_INTERVAL_using_ahyp(f); \ + return this->force_rounding(f(x)); } + BOOST_NUMERIC_INTERVAL_new_func(acosh) +# undef BOOST_NUMERIC_INTERVAL_new_func +}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP diff --git a/eo/contrib/boost/numeric/interval/rounding.hpp b/eo/contrib/boost/numeric/interval/rounding.hpp new file mode 100644 index 00000000..f69e2e4b --- /dev/null +++ b/eo/contrib/boost/numeric/interval/rounding.hpp @@ -0,0 +1,101 @@ +/* Boost interval/rounding.hpp template implementation file + * + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_ROUNDING_HPP +#define BOOST_NUMERIC_INTERVAL_ROUNDING_HPP + +namespace boost { +namespace numeric { +namespace interval_lib { + +/* + * Default rounding_control class (does nothing) + */ + +template +struct rounding_control +{ + typedef int rounding_mode; + static void get_rounding_mode(rounding_mode&) {} + static void set_rounding_mode(rounding_mode) {} + static void upward() {} + static void downward() {} + static void to_nearest() {} + static const T& to_int(const T& x) { return x; } + static const T& force_rounding(const T& x) { return x; } +}; + +/* + * A few rounding control classes (exact/std/opp: see documentation) + * rounded_arith_* control the rounding of the arithmetic operators + * rounded_transc_* control the rounding of the transcendental functions + */ + +template > +struct rounded_arith_exact; + +template > +struct rounded_arith_std; + +template > +struct rounded_arith_opp; + +template +struct rounded_transc_dummy; + +template > +struct rounded_transc_exact; + +template > +struct rounded_transc_std; + +template > +struct rounded_transc_opp; + +/* + * State-saving classes: allow to set and reset rounding control + */ + +namespace detail { + +template +struct save_state_unprotected: Rounding +{ + typedef save_state_unprotected unprotected_rounding; +}; + +} // namespace detail + +template +struct save_state: Rounding +{ + typename Rounding::rounding_mode mode; + save_state() { + this->get_rounding_mode(mode); + this->init(); + } + ~save_state() { this->set_rounding_mode(mode); } + typedef detail::save_state_unprotected unprotected_rounding; +}; + +template +struct save_state_nothing: Rounding +{ + typedef save_state_nothing unprotected_rounding; +}; + +template +struct rounded_math: save_state_nothing > +{}; + +} // namespace interval_lib +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_ROUNDING_HPP diff --git a/eo/contrib/boost/numeric/interval/transc.hpp b/eo/contrib/boost/numeric/interval/transc.hpp new file mode 100644 index 00000000..88aebd6b --- /dev/null +++ b/eo/contrib/boost/numeric/interval/transc.hpp @@ -0,0 +1,232 @@ +/* Boost interval/transc.hpp template implementation file + * + * Copyright 2000 Jens Maurer + * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_TRANSC_HPP +#define BOOST_NUMERIC_INTERVAL_TRANSC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { + +template inline +interval exp(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.exp_down(x.lower()), rnd.exp_up(x.upper()), true); +} + +template inline +interval log(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) || + !interval_lib::user::is_pos(x.upper())) + return I::empty(); + typename Policies::rounding rnd; + typedef typename Policies::checking checking; + T l = !interval_lib::user::is_pos(x.lower()) + ? checking::neg_inf() : rnd.log_down(x.lower()); + return I(l, rnd.log_up(x.upper()), true); +} + +template inline +interval cos(const interval& x) +{ + if (interval_lib::detail::test_input(x)) + return interval::empty(); + typename Policies::rounding rnd; + typedef interval I; + typedef typename interval_lib::unprotect::type R; + + // get lower bound within [0, pi] + const R pi2 = interval_lib::pi_twice(); + R tmp = fmod((const R&)x, pi2); + if (width(tmp) >= pi2.lower()) + return I(static_cast(-1), static_cast(1), true); // we are covering a full period + if (tmp.lower() >= interval_lib::constants::pi_upper()) + return -cos(tmp - interval_lib::pi()); + T l = tmp.lower(); + T u = tmp.upper(); + + BOOST_USING_STD_MIN(); + // separate into monotone subintervals + if (u <= interval_lib::constants::pi_lower()) + return I(rnd.cos_down(u), rnd.cos_up(l), true); + else if (u <= pi2.lower()) + return I(static_cast(-1), rnd.cos_up(min BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.sub_down(pi2.lower(), u), l)), true); + else + return I(static_cast(-1), static_cast(1), true); +} + +template inline +interval sin(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + typedef typename interval_lib::unprotect::type R; + I r = cos((const R&)x - interval_lib::pi_half()); + (void)&rnd; + return r; +} + +template inline +interval tan(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + typedef typename interval_lib::unprotect::type R; + + // get lower bound within [-pi/2, pi/2] + const R pi = interval_lib::pi(); + R tmp = fmod((const R&)x, pi); + const T pi_half_d = interval_lib::constants::pi_half_lower(); + if (tmp.lower() >= pi_half_d) + tmp -= pi; + if (tmp.lower() <= -pi_half_d || tmp.upper() >= pi_half_d) + return I::whole(); + return I(rnd.tan_down(tmp.lower()), rnd.tan_up(tmp.upper()), true); +} + +template inline +interval asin(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) + || x.upper() < static_cast(-1) || x.lower() > static_cast(1)) + return I::empty(); + typename Policies::rounding rnd; + T l = (x.lower() <= static_cast(-1)) + ? -interval_lib::constants::pi_half_upper() + : rnd.asin_down(x.lower()); + T u = (x.upper() >= static_cast(1) ) + ? interval_lib::constants::pi_half_upper() + : rnd.asin_up (x.upper()); + return I(l, u, true); +} + +template inline +interval acos(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) + || x.upper() < static_cast(-1) || x.lower() > static_cast(1)) + return I::empty(); + typename Policies::rounding rnd; + T l = (x.upper() >= static_cast(1) ) + ? static_cast(0) + : rnd.acos_down(x.upper()); + T u = (x.lower() <= static_cast(-1)) + ? interval_lib::constants::pi_upper() + : rnd.acos_up (x.lower()); + return I(l, u, true); +} + +template inline +interval atan(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.atan_down(x.lower()), rnd.atan_up(x.upper()), true); +} + +template inline +interval sinh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.sinh_down(x.lower()), rnd.sinh_up(x.upper()), true); +} + +template inline +interval cosh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + if (interval_lib::user::is_neg(x.upper())) + return I(rnd.cosh_down(x.upper()), rnd.cosh_up(x.lower()), true); + else if (!interval_lib::user::is_neg(x.lower())) + return I(rnd.cosh_down(x.lower()), rnd.cosh_up(x.upper()), true); + else + return I(static_cast(0), rnd.cosh_up(-x.lower() > x.upper() ? x.lower() : x.upper()), true); +} + +template inline +interval tanh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.tanh_down(x.lower()), rnd.tanh_up(x.upper()), true); +} + +template inline +interval asinh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + typename Policies::rounding rnd; + return I(rnd.asinh_down(x.lower()), rnd.asinh_up(x.upper()), true); +} + +template inline +interval acosh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) || x.upper() < static_cast(1)) + return I::empty(); + typename Policies::rounding rnd; + T l = x.lower() <= static_cast(1) ? static_cast(0) : rnd.acosh_down(x.lower()); + return I(l, rnd.acosh_up(x.upper()), true); +} + +template inline +interval atanh(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x) + || x.upper() < static_cast(-1) || x.lower() > static_cast(1)) + return I::empty(); + typename Policies::rounding rnd; + typedef typename Policies::checking checking; + T l = (x.lower() <= static_cast(-1)) + ? checking::neg_inf() : rnd.atanh_down(x.lower()); + T u = (x.upper() >= static_cast(1) ) + ? checking::pos_inf() : rnd.atanh_up (x.upper()); + return I(l, u, true); +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_TRANSC_HPP diff --git a/eo/contrib/boost/numeric/interval/utility.hpp b/eo/contrib/boost/numeric/interval/utility.hpp new file mode 100644 index 00000000..d24d84d7 --- /dev/null +++ b/eo/contrib/boost/numeric/interval/utility.hpp @@ -0,0 +1,331 @@ +/* Boost interval/utility.hpp template implementation file + * + * Copyright 2000 Jens Maurer + * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or + * copy at http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_NUMERIC_INTERVAL_UTILITY_HPP +#define BOOST_NUMERIC_INTERVAL_UTILITY_HPP + +#include +#include +#include +#include +#include +#include + +/* + * Implementation of simple functions + */ + +namespace boost { +namespace numeric { + +/* + * Utility Functions + */ + +template inline +const T& lower(const interval& x) +{ + return x.lower(); +} + +template inline +const T& upper(const interval& x) +{ + return x.upper(); +} + +template inline +T checked_lower(const interval& x) +{ + if (empty(x)) { + typedef typename Policies::checking checking; + return checking::nan(); + } + return x.lower(); +} + +template inline +T checked_upper(const interval& x) +{ + if (empty(x)) { + typedef typename Policies::checking checking; + return checking::nan(); + } + return x.upper(); +} + +template inline +T width(const interval& x) +{ + if (interval_lib::detail::test_input(x)) return static_cast(0); + typename Policies::rounding rnd; + return rnd.sub_up(x.upper(), x.lower()); +} + +template inline +T median(const interval& x) +{ + if (interval_lib::detail::test_input(x)) { + typedef typename Policies::checking checking; + return checking::nan(); + } + typename Policies::rounding rnd; + return rnd.median(x.lower(), x.upper()); +} + +template inline +interval widen(const interval& x, const T& v) +{ + if (interval_lib::detail::test_input(x)) + return interval::empty(); + typename Policies::rounding rnd; + return interval(rnd.sub_down(x.lower(), v), + rnd.add_up (x.upper(), v), true); +} + +/* + * Set-like operations + */ + +template inline +bool empty(const interval& x) +{ + return interval_lib::detail::test_input(x); +} + +template inline +bool in_zero(const interval& x) +{ + if (interval_lib::detail::test_input(x)) return false; + return (!interval_lib::user::is_pos(x.lower())) && + (!interval_lib::user::is_neg(x.upper())); +} + +template inline +bool in(const T& x, const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) return false; + return y.lower() <= x && x <= y.upper(); +} + +template inline +bool subset(const interval& x, + const interval& y) +{ + if (empty(x)) return true; + return !empty(y) && y.lower() <= x.lower() && x.upper() <= y.upper(); +} + +template inline +bool proper_subset(const interval& x, + const interval& y) +{ + if (empty(y)) return false; + if (empty(x)) return true; + return y.lower() <= x.lower() && x.upper() <= y.upper() && + (y.lower() != x.lower() || x.upper() != y.upper()); +} + +template inline +bool overlap(const interval& x, + const interval& y) +{ + if (interval_lib::detail::test_input(x, y)) return false; + return x.lower() <= y.lower() && y.lower() <= x.upper() || + y.lower() <= x.lower() && x.lower() <= y.upper(); +} + +template inline +bool singleton(const interval& x) +{ + return !empty(x) && x.lower() == x.upper(); +} + +template inline +bool equal(const interval& x, const interval& y) +{ + if (empty(x)) return empty(y); + return !empty(y) && x.lower() == y.lower() && x.upper() == y.upper(); +} + +template inline +interval intersect(const interval& x, + const interval& y) +{ + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + if (interval_lib::detail::test_input(x, y)) + return interval::empty(); + const T& l = max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()); + const T& u = min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()); + if (l <= u) return interval(l, u, true); + else return interval::empty(); +} + +template inline +interval hull(const interval& x, + const interval& y) +{ + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + bool bad_x = interval_lib::detail::test_input(x); + bool bad_y = interval_lib::detail::test_input(y); + if (bad_x) + if (bad_y) return interval::empty(); + else return y; + else + if (bad_y) return x; + return interval(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()), + max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()), true); +} + +template inline +interval hull(const interval& x, const T& y) +{ + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + bool bad_x = interval_lib::detail::test_input(x); + bool bad_y = interval_lib::detail::test_input(y); + if (bad_y) + if (bad_x) return interval::empty(); + else return x; + else + if (bad_x) return interval(y, y, true); + return interval(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), + max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true); +} + +template inline +interval hull(const T& x, const interval& y) +{ + BOOST_USING_STD_MIN(); + BOOST_USING_STD_MAX(); + bool bad_x = interval_lib::detail::test_input(x); + bool bad_y = interval_lib::detail::test_input(y); + if (bad_x) + if (bad_y) return interval::empty(); + else return y; + else + if (bad_y) return interval(x, x, true); + return interval(min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), + max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); +} + +template inline +interval hull(const T& x, const T& y) +{ + return interval::hull(x, y); +} + +template inline +std::pair, interval > +bisect(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return std::pair(I::empty(), I::empty()); + const T m = median(x); + return std::pair(I(x.lower(), m, true), I(m, x.upper(), true)); +} + +/* + * Elementary functions + */ + +template inline +T norm(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) { + typedef typename Policies::checking checking; + return checking::nan(); + } + BOOST_USING_STD_MAX(); + return max BOOST_PREVENT_MACRO_SUBSTITUTION(-x.lower(), x.upper()); +} + +template inline +interval abs(const interval& x) +{ + typedef interval I; + if (interval_lib::detail::test_input(x)) + return I::empty(); + if (!interval_lib::user::is_neg(x.lower())) return x; + if (!interval_lib::user::is_pos(x.upper())) return -x; + BOOST_USING_STD_MAX(); + return I(static_cast(0), max BOOST_PREVENT_MACRO_SUBSTITUTION(-x.lower(), x.upper()), true); +} + +template inline +interval max BOOST_PREVENT_MACRO_SUBSTITUTION (const interval& x, + const interval& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MAX(); + return I(max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()), true); +} + +template inline +interval max BOOST_PREVENT_MACRO_SUBSTITUTION (const interval& x, const T& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MAX(); + return I(max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true); +} + +template inline +interval max BOOST_PREVENT_MACRO_SUBSTITUTION (const T& x, const interval& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MAX(); + return I(max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); +} + +template inline +interval min BOOST_PREVENT_MACRO_SUBSTITUTION (const interval& x, + const interval& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MIN(); + return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()), min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()), true); +} + +template inline +interval min BOOST_PREVENT_MACRO_SUBSTITUTION (const interval& x, const T& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MIN(); + return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true); +} + +template inline +interval min BOOST_PREVENT_MACRO_SUBSTITUTION (const T& x, const interval& y) +{ + typedef interval I; + if (interval_lib::detail::test_input(x, y)) + return I::empty(); + BOOST_USING_STD_MIN(); + return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); +} + +} // namespace numeric +} // namespace boost + +#endif // BOOST_NUMERIC_INTERVAL_UTILITY_HPP diff --git a/eo/contrib/mathsym/COPYING b/eo/contrib/mathsym/COPYING new file mode 100644 index 00000000..d60c31a9 --- /dev/null +++ b/eo/contrib/mathsym/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) 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 +this service 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 make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. 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. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +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 +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the 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 a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE 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. + + 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 +convey 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 2 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, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision 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, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This 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 Library General +Public License instead of this License. diff --git a/eo/contrib/mathsym/GNUmakefile b/eo/contrib/mathsym/GNUmakefile new file mode 100644 index 00000000..bb3ff94e --- /dev/null +++ b/eo/contrib/mathsym/GNUmakefile @@ -0,0 +1,87 @@ +COMPILEFLAGS=-Wno-deprecated -g -Wall -Wshadow #-DINTERVAL_DEBUG +OPTFLAGS= -O2 -DNDEBUG + +PROFILE_FLAGS=#-pg + +INCLUDES=-I. -Isym -Ifun -Igen -Ieval -Iregression -I../../src -Ieo_interface -I.. + +CPPFLAGS=$(COMPILEFLAGS) $(OPTFLAGS) $(INCLUDES) $(PROFILE_FLAGS) -D__I386__ -DSIZEOF_UNSIGNED_LONG=4 +EXTLIBS=tcc/libtcc.a tcc/libtcc1.a ../../src/libeo.a ../../src/utils/libeoutils.a + +LIBS=${EXTLIBS} -ldl + +SYMLIB=libsym.a + +VPATH=sym fun gen eval regression eo_interface + +CXXSOURCES=FunDef.cpp Sym.cpp SymImpl.cpp SymOps.cpp sym_compile.cpp TreeBuilder.cpp LanguageTable.cpp\ + Dataset.cpp ErrorMeasure.cpp Scaling.cpp TargetInfo.cpp BoundsCheck.cpp util.cpp NodeSelector.cpp\ + eoSymCrossover.cpp + +PROGRAMS=test/test test/test_compile test/testeo + +OBJS= $(CXXSOURCES:.cpp=.o) c_compile.o + +all: tcc/ symreg + +include $(CXXSOURCES:.cpp=.d) symreg.d + +clean: + rm *.o *.d $(PROGRAMS) $(SYMLIB) symreg || true + +distclean: clean + rm -rf tcc + +symreg: libsym.a symreg.o $(EXTLIBS) + $(CXX) -o symreg symreg.o libsym.a $(LIBS) $(PROFILE_FLAGS) + +libsym.a: $(OBJS) + rm libsym.a; ar cq $(SYMLIB) $(OBJS) + +check: $(PROGRAMS) + test/test && test/test_compile && test/testeo && echo "all tests succeeded" + +test/test: test/test.o ${SYMLIB} + $(CXX) -o test/test test/test.o ${SYMLIB} ${LIBS} + +test/test_compile: test/test_compile.o ${SYMLIB} + $(CXX) -o test/test_compile test/test_compile.o $(SYMLIB) ${LIBS} + +test/testeo: test/testeo.o ${SYMLIB} + $(CXX) -o test/testeo test/testeo.o $(SYMLIB) ${LIBS} + +# eo +../../src/libeo.a: + make -C ../../src + +../../src/utils/libeoutils.a: + make -C ../../src/utils + +# tiny cc +tcc/: tcc.tar.gz + tar xvfz tcc.tar.gz && cd tcc && ./configure && make + +tcc/Makefile: tcc/ + cd tcc && ./configure + +tcc/libtcc.a: tcc/Makefile + make -Ctcc + +tcc/libtcc1.a: tcc/Makefile + make -Ctcc + +#rules +c_compile.o: eval/c_compile.c + gcc -c eval/c_compile.c -I./tcc $(COMPILEFLAGS) $(OPTFLAGS) + +%.o:%.cpp + $(CXX) -o $@ -c $< $(CPPFLAGS) $(INCLUDE) + +%.d: %.cpp + $(SHELL) -ec '$(CXX) -M $(CPPFLAGS) $< | sed "s/$*.o/& $@/g" > $@ ' + + +%.d: %.c + $(SHELL) -ec '$(CXX) -M $(CPPFLAGS) $< | sed "s/$*.o/& $@/g" > $@ ' + + diff --git a/eo/contrib/mathsym/README b/eo/contrib/mathsym/README new file mode 100644 index 00000000..a0d79b61 --- /dev/null +++ b/eo/contrib/mathsym/README @@ -0,0 +1,172 @@ + +This is not yet another gp system (nyagp). For one, it is not general. +It does one thing, find mathematical functions, and tries to do that well. + +So, if you're trying to steer ants on various New Mexico trails, or build your +own tiny block world, you're in the wrong place. However, if you're interested +in finding mathematical functions either through direct application on data or +running it through a simulator, you might find what you're looking for here. + +=== Representation (sym/ + gen/) ======== + +Mathsym has a few interesting characteristics. First and foremost is the +basic representation. It uses trees, but these trees are stored in a +reference counted hashtable. This means that every subtree that is alive +is stored once and only once. The reference counting mechanism takes care +of memory management. + +The idea of using a hashtable (for offline analysis) comes from Walter Tackett, in his +1994 dissertation. The current system is just a real-time implementation of this +idea, adding the reference counting for ease of use. + +The hashtable brings overhead. It's still pretty fast, but a string based representation +would run rounds around it. However, by virtue of it storing every subtree only once, it +is fairly tight on memory. This helps tremendously when confronted with growing populations, bloat. +The hashtable implementation can not stop bloat, but does make it more manageable. In a typical +GP run, the number of distinct subtrees is only 10-20% of the total number of subtrees. + +Other advantages of the hashtable are in the ability to examine the run more thoroughly. It is easy +to check how many subtrees are present in the system, and for each subtree you can check the reference +count. + +The basic tree is called a Sym. A Sym is simply a tree, and has children, accessible through args(). +A Sym simply contains an iterator (== decorated pointer) to an entry in the hashtable. +Every time you create a Sym, it is either looked up in the hashtable or added to the hashtable. +A Sym has several members: size, depth, args, etc. One interesting member is the refcount(). +This returns the reference count of the Sym in the hashtable, and thus returns the number +of distinct contexts in which the Sym is used. + +Another nice thing of these hashtable Syms is that a check for equality reduces to a pointer comparison. + +The Sym nodes are identified by a simple token, of type token_t (usually an unsigned int). It +is completely generic and could conceivably be adapted to steer ants. The rest of the library +is however targeted at mathematical functions purely. + +sym/Sym.h is the file to look into for the functionality provided by Sym. The sym/ directory +is where the source files are stored that are relevant for the generic Sym functionality. The +'gen/' directory contains some generic functionality to build and traverse trees, independent of +the function and terminal set. + +The file sym/README.cpp documents the use of the sym library for general GP use. + +=== Function Set (fun/) === + +The standard GP function set of binary functions: addition, multiplication, subtraction and +division is NOT supported. + +What is however supported are the functions of: + +summation: arbitrary arity, arity zero meaning 0.0. Arity 2 is standard addition +product: arbitrary arity, arity zero meaning 1.0. Arity 2 is standard multiplication +inversion: 1.0 / x. Only arity 1 +unary minus: -x. Only arity 1 + +Plus a whole bunch of other functions (see "fun/FunDef.h") + +The reason for this is the observation (actually from a friend of mine, thanks Luuk), +that this set of functions is complete and slightly more orthogonal than a binary set. + +The directory 'fun' contains the functionality for the function and terminal set, together +with ERC's etc. fun/FunDef.cpp contains the definition of the functionality. Stuff can be +added here, but best to contact me if you miss particular functions. + +=== Evaluation (eval/) === + +The second important thing is evaluation. Although Syms can be evaluated through an interpreter, +this is not the fastest way to go about with it. The standard way of evaluating a Sym is to +first *compile* it to a function, and then run it in your favourite environment. Compilation +is done through the use of the excellent tinycc compiler, which is blazingly fast and produces +pretty good functions. + +Compilation comes in several flavours: compile a single function and retrieve a pointer to a function +of signature: + +double func(const double* x); + +where x is the input array. Another option is to compile a bunch of functions in one go, and retrieve an array +of such function pointers. The Syms are simply printed and compiled. An example: + +double func(const double* x) { return x*x + x * 1./x; } + +The batch version proceeds significantly more quickly than calling compile every time. The function pointers +can be given to a simulation for extremely quick evaluation. + +A third option is to compile a complete population in one go, and return a single pointer of signature + +void func(const double* x, double* y); + +Where 'y' is the (preallocated) output array. This allows to evaluate a complete population in one function +call, storing the results in 'y'. It uses the hashtable to store every calculation only once. An example +for the two function x*x + x*1./x and x + sin(x*x) is: + +void func(const double* x, double* y) { + double a0 = x; + double a1 = a0 * a0; + double a2 = 1.0; + double a3 = a2 / a0; + double a4 = a2 * a3; + y[0] = a4; + double a5 = sin(a1); + double a6 = a0 + a5; + y[1] = a6; +} + +This is the fastest way to evaluate even humongous populations quickly. You might be surprised at +the amount of code re-use in a GP population. + +The three compilation functions can be found in eval/sym_compile.h + +A limiting factor in tinycc is that the struct TCCState that is used to hold the compilation context, +is not really self-contained. This unfortunately means that with every call to 'compile' ALL previous +pointers that have been produced are invalidated. I'm still looking at ways to circumvent this. + +To work with mathsym, a few small changes in tccelf.c were necessary, check README.TCC for details. + +=== Interval Arithmetic (eval/) === + +GP is pretty good at finding mathematical expressions that are numerically unsound. Take for instance +the function '1 / x'. This is well defined only when x is strictly positive, but will lead to problems +when x equals 0. The standard answer is to define some pseudo-arithmetical function called 'protected +division' that will return some value (usually 1) when a division by zero occurs. This leads to a number +of protected functions (sqrt, log, tan, etc.) which all need to be protected. Interpreting results from +GP using such functions is in general hard. + +Interval arithmetic (through another excellent library boost/numeric/interval) is used to calculate +if particular functions can conceivably produce problems. This completely annihilates the use for Koza-style +protected operators and is a more safe and sound method. For interval arithmetic to function, the bounds +on the input variables need to be known. As for every function we can calculate a guarenteed, +though not necessarily tight, output interval given the input intervals, we can check arbitrary functions +for possible problems. If, for example for division, the input interval contains 0, we know that a division +by zero is theoretically possible. It's then best to throw away the entire function. + +Interval Arithmetic is accessible through the class IntervalBoundsCheck (eval/BoundsCheck.h) + +=== More generic support (gen/) === + +The gen subdirectory contains some general utility classes for defining function sets and for +creating trees. The idea is that these functions are generic and only append on the sym/ part +of the library. Unfortunately, the language table currently needs an ERC function, a default +implementation is hidden inside fun/FunDef.cpp. Will fix at some point. + +gen/LanguageTable.cpp -> defines the functions/terminals that can be used +gen/TreeBuilder.cpp -> can create trees based on a LanguageTable + +=== Data and Errors (regression/) === + +The above classes are generic and apply for any type of problem where a mathematical function can be +used to steer some process, run a simulation, whatever. First check the intervals, then compile the +Sym(s) to a (set of) function pointer(s), and use the pointers in some way to evaluate for fitness. +One particular type of problem for which support is built in is 'symbolic regression'. This type of +problem involves finding an mathematical input/output relationship based on some data. + +To enable this, regression/ introduces the class Dataset to contain the data and ErrorMeasure to calculate +error. Currently supported: mean squared error, mean absolute error and mean squared error scaled (proportional +to correlation squared). They use some helper classes such as Scaling and TargetInfo. + +=== EO interface (eo_interface/) === + +Contains the classes to make it all work with EO. Check the root application 'symreg' for ways to use this + + + + diff --git a/eo/contrib/mathsym/README.TCC b/eo/contrib/mathsym/README.TCC new file mode 100644 index 00000000..8441c232 --- /dev/null +++ b/eo/contrib/mathsym/README.TCC @@ -0,0 +1,5 @@ + +To refrain tcc from searching for libtcc1.a in the path, uncomment +out the lines looking for that in 'tccelf.c'. Search for libtcc1 and uncomment +these two lines. All should be well. + diff --git a/eo/contrib/mathsym/eo_interface/eoSym.h b/eo/contrib/mathsym/eo_interface/eoSym.h new file mode 100644 index 00000000..11443af4 --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSym.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef EOSYM_H_ +#define EOSYM_H_ + +#include +#include +#include + + +template +class EoSym : public EO, public Sym { + + public: + + void set(const Sym& sym) { + invalidate(); + static_cast(this)->operator=(sym); + } + + virtual void printOn(ostream& os) const; + virtual void readFrom(istream& is); +}; + + +template +void EoSym::printOn(ostream& os) const { + EO::printOn(os); + os << ' '; + write_raw(os, *this); +} + +template +void EoSym::readFrom(istream& is) { + EO::readFrom(is); + read_raw(is, *this); +} + +template +inline std::ostream& operator<<(std::ostream& os, const EoSym& f) { f.printOn(os); return os; } +template +inline istream& operator>>(std::istream& is, EoSym& f) { f.readFrom(is); return os; } + + +#endif + + diff --git a/eo/contrib/mathsym/eo_interface/eoSymCrossover.cpp b/eo/contrib/mathsym/eo_interface/eoSymCrossover.cpp new file mode 100644 index 00000000..63d46c20 --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSymCrossover.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include +#include + +#include +#include + +bool subtree_quad(Sym& a, Sym& b, NodeSelector& select) { + unsigned i = select.select_node(a); + unsigned j = select.select_node(b); + + Sym aprime = insert_subtree(a, i, get_subtree(b, j)); + Sym bprime = insert_subtree(b, j, get_subtree(a, i)); + + a = aprime; + b = bprime; + return true; +} + +bool subtree_bin(Sym& a, const Sym& b, NodeSelector& select) { + unsigned i = select.select_node(a); + unsigned j = select.select_node(b); + + a = insert_subtree(a, i, get_subtree(b,j)); + + return true; +} + +Sym homologous_binimpl(Sym a, Sym b) { + + bool use_a = rng.random(2); + + token_t head = (use_a? a : b).token(); + SymVec args = use_a?a.args() : b.args(); + + const SymVec& a_args = a.args(); + const SymVec& b_args = b.args(); + unsigned mn = std::min(a_args.size(), b_args.size()); + + bool changed = !use_a; + + for (unsigned i = 0; i < mn; ++i) { + args[i] = homologous_binimpl(a_args[i], b_args[i]); + if (args[i] != a_args[i]) { + changed = true; + } + } + + return changed? Sym(head, args) : a; +} + +bool homologous_bin(Sym& a, const Sym& b) { + if (a==b) return false; + Sym org = a; + a = homologous_binimpl(a,b); + return org != a; +} + + diff --git a/eo/contrib/mathsym/eo_interface/eoSymCrossover.h b/eo/contrib/mathsym/eo_interface/eoSymCrossover.h new file mode 100644 index 00000000..faa9acfa --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSymCrossover.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef EOSYMCROSSOVER_H +#define EOSYMCROSSOVER_H + +class NodeSelector; +class Sym; + +#include + +extern bool subtree_quad(Sym& a, Sym& b, NodeSelector& select); +template +class eoQuadSubtreeCrossover : public eoQuadOp { + NodeSelector& node_selector; + + public: + eoQuadSubtreeCrossover(NodeSelector& _node_selector) : node_selector(_node_selector) {} + + bool operator()(EoType& a, EoType& b) { return subtree_quad(a,b, node_selector); } +}; + + +extern bool subtree_bin(Sym& a, const Sym& b, NodeSelector& select); +template +class eoBinSubtreeCrossover : public eoBinOp { + NodeSelector& node_selector; + + public : + + eoBinSubtreeCrossover(NodeSelector& _node_selector) : node_selector(_node_selector) {} + + bool operator()(EoType& a, const EoType& b) { return subtree_bin(a, b, node_selector); } +}; + +/** Yet another homologous crossover, afaik not particularly + * defined in the literature + */ +extern bool homologous_bin(Sym& a, const Sym& b); +template +class eoBinHomologousCrossover : public eoBinOp { + public: + bool operator()(EoType& a, const EoType& b) { + return homologous_bin(a,b); + } +}; + + +#endif + diff --git a/eo/contrib/mathsym/eo_interface/eoSymEval.h b/eo/contrib/mathsym/eo_interface/eoSymEval.h new file mode 100644 index 00000000..bbc8392a --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSymEval.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYMEVAL_H +#define SYMEVAL_H + +#include +#include +#include + +#include + +template +class eoSymPopEval : public eoPopEvalFunc { + + BoundsCheck& check; + ErrorMeasure& measure; + + public: + + eoSymPopEval(BoundsCheck& _check, ErrorMeasure& _measure) : + check(_check), measure(_measure) {} + + /** apparently this thing works on two populations, why? + * + * In any case, currently only implemented the population wide + * evaluation version, as that one is much faster. This because the + * compile going on behind the scenes is much faster when done in one + * go (and using subtree similarity) then when done on a case by case + * basis. + */ + void operator()(eoPop& p1, eoPop& p2) { + + std::vector unevaluated; + std::vector tmppop; + + for (unsigned i = 0; i < p1.size(); ++i) { + if (p1[i].invalid()) { + + if (check.in_bounds(p1[i])) { + unevaluated.push_back(i); + tmppop.push_back( static_cast(p1[i]) ); + } else { + p1[i].fitness( measure.worst_performance() ); + } + } + } + + for (unsigned i = 0; i < p2.size(); ++i) { + if (p2[i].invalid()) { + + if (check.in_bounds(p2[i])) { + + unevaluated.push_back(p1.size() + i); + tmppop.push_back( static_cast(p2[i]) ); + + } else { + p2[i].fitness( measure.worst_performance() ); // pretty bad error + } + } + } + + std::vector result = measure.calc_error(tmppop); + + for (unsigned i = 0; i < result.size(); ++i) { + unsigned idx = unevaluated[i]; + + if (idx < p1.size()) { + p1[idx].fitness(result[i].error); + } else { + idx -= p1.size(); + p2[idx].fitness(result[i].error); + } + } + } + +}; + + +#endif diff --git a/eo/contrib/mathsym/eo_interface/eoSymInit.h b/eo/contrib/mathsym/eo_interface/eoSymInit.h new file mode 100644 index 00000000..591b0050 --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSymInit.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef EOSYMINIT_H +#define EOSYMINIT_H + +#include +#include + +/** Default initializer, Koza style */ +template +class eoSymInit : public eoInit { + + TreeBuilder& builder; + + double own_grow_prob; + unsigned own_max_depth; + + + double& grow_prob; + unsigned& max_depth; + + public: + + /** By default build ramped half and half with max depth 6 */ + eoSymInit(TreeBuilder& _builder) + : builder(_builder), + own_grow_prob(0.5), + own_max_depth(6), + grow_prob(own_grow_prob), + max_depth(own_max_depth) + {} + + /** Control the grow_prob and max_depth externally */ + eoSymInit(TreeBuilder& _builder, double& _grow_prob, unsigned& _max_depth) + : builder(_builder), + grow_prob(_grow_prob), + max_depth(_max_depth) + {} + + /** build the tree */ + void operator()(EoType& tree) { + int depth_to_use = rng.random(max_depth-2) + 2; // two levels minimum + builder.build_tree(tree, depth_to_use, rng.flip(grow_prob)); + } + +}; + +#endif + diff --git a/eo/contrib/mathsym/eo_interface/eoSymMutate.h b/eo/contrib/mathsym/eo_interface/eoSymMutate.h new file mode 100644 index 00000000..03a95d1d --- /dev/null +++ b/eo/contrib/mathsym/eo_interface/eoSymMutate.h @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYMMUTATE_H +#define SYMMUTATE_H + +#include +#include + +#include +#include + +template +class eoSymSubtreeMutate : public eoMonOp { + + TreeBuilder& subtree_builder; + NodeSelector& node_selector; + + public : + + eoSymSubtreeMutate(TreeBuilder& _subtree_builder, NodeSelector& _node_selector) + : subtree_builder(_subtree_builder), node_selector(_node_selector) {} + + + bool operator()(EoType& tomutate) { + unsigned xover_point = node_selector.select_node(tomutate); + // create subtree + Sym newtree = subtree_builder.build_tree(6, true); // TODO, parameterize + static_cast(tomutate) = insert_subtree(tomutate, xover_point, newtree); + return true; + } + +}; + +/** Class for doing node mutation + * Two parameters: + * + * mutation_rate (the rate at which to do mutation) + * is_rate_absolute : don't rescale the rate to the size of the tree + */ + +template +class eoSymNodeMutate : public eoMonOp { + + LanguageTable& table; + double own_mutation_rate; + bool own_is_rate_absolute; + + // these two can (should?) move to an impl file + bool mutate(Sym& sym, double p) { + std::pair r = do_mutate(sym, p); + sym = r.first; + return r.second; + } + + std::pair do_mutate(Sym sym, double p) { + + bool changed = false; + SymVec args = sym.args(); + if (rng.flip(p)) { + token_t new_token = table.get_random_function( args.size()); + if (new_token != sym.token()) changed = true; + sym = Sym(new_token, args); + } + + for (unsigned i = 0; i < args.size(); ++i) { + std::pair r = do_mutate(args[i], p); + changed |= r.second; + if (r.second) + args[i] = r.first; + } + + if (changed) + return std::make_pair(Sym(sym.token(), args), true); + // else + return std::make_pair(sym, false); + } + + public: + + double& mutation_rate; + bool& is_rate_absolute; + + eoSymNodeMutate(LanguageTable& _table) + : table(_table), + own_mutation_rate(1.0), + own_is_rate_absolute(false), // this means a probability of node mutation of 1/sym.size() + mutation_rate(own_mutation_rate), + is_rate_absolute(own_is_rate_absolute) + {} + + eoSymNodeMutate(LanguageTable& _table, double& _mutation_rate, bool& _is_rate_absolute) + : table(_table), + mutation_rate(_mutation_rate), + is_rate_absolute(_is_rate_absolute) + {} + + + bool operator()(EoType& _eo) { + double p = mutation_rate; + if (!is_rate_absolute) p /= _eo.size(); + + return mutate(_eo, p); + } + +}; + +#endif diff --git a/eo/contrib/mathsym/eval/BoundsCheck.cpp b/eo/contrib/mathsym/eval/BoundsCheck.cpp new file mode 100644 index 00000000..715ebf52 --- /dev/null +++ b/eo/contrib/mathsym/eval/BoundsCheck.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#include "BoundsCheck.h" +#include +#include +#include + +using namespace std; + +class IntervalBoundsCheckImpl { + public : + vector bounds; +}; + +IntervalBoundsCheck::IntervalBoundsCheck(const vector& mins, const vector& maxes) { + pimpl = new IntervalBoundsCheckImpl; + vector& b = pimpl->bounds; + + b.resize( mins.size()); + + for (unsigned i = 0; i < b.size(); ++i) { + b[i] = Interval(mins[i], maxes[i]); + } + +} + +IntervalBoundsCheck::~IntervalBoundsCheck() { delete pimpl; } +IntervalBoundsCheck::IntervalBoundsCheck(const IntervalBoundsCheck& that) { pimpl = new IntervalBoundsCheckImpl(*that.pimpl); } +IntervalBoundsCheck& IntervalBoundsCheck::operator=(const IntervalBoundsCheck& that) { *pimpl = *that.pimpl; return *this; } + +bool IntervalBoundsCheck::in_bounds(const Sym& sym) const { + Interval bounds; + + try { + bounds = eval(sym, pimpl->bounds); + if (!valid(bounds)) return false; + } catch (interval_error) { + return false; + } + return true; +} + +std::string IntervalBoundsCheck::get_bounds(const Sym& sym) const { + + try { + Interval bounds = eval(sym, pimpl->bounds); + if (!valid(bounds)) return "err"; + ostringstream os; + os << bounds; + return os.str(); + } catch (interval_error) { + return "err"; + } +} + + +std::pair IntervalBoundsCheck::calc_bounds(const Sym& sym) const { + + Interval bounds = eval(sym, pimpl->bounds); + return make_pair(bounds.lower(), bounds.upper()); +} + + diff --git a/eo/contrib/mathsym/eval/BoundsCheck.h b/eo/contrib/mathsym/eval/BoundsCheck.h new file mode 100644 index 00000000..d484d029 --- /dev/null +++ b/eo/contrib/mathsym/eval/BoundsCheck.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef BOUNDS_CHECK_H_ +#define BOUNDS_CHECK_H_ + +#include + +class IntervalBoundsCheckImpl; +class Sym; + +class BoundsCheck { + public : + virtual ~BoundsCheck() {}; + virtual bool in_bounds(const Sym&) const = 0; + virtual std::string get_bounds(const Sym&) const = 0; +}; + +// checks if a formula keeps within bounds using interval arithmetic +class IntervalBoundsCheck : public BoundsCheck { + + IntervalBoundsCheckImpl* pimpl; + + public: + + IntervalBoundsCheck(const std::vector& minima, const std::vector& maxima); + ~IntervalBoundsCheck(); + IntervalBoundsCheck(const IntervalBoundsCheck&); + IntervalBoundsCheck& operator=(const IntervalBoundsCheck&); + + bool in_bounds(const Sym&) const; + std::string get_bounds(const Sym&) const; + + std::pair calc_bounds(const Sym&) const; +}; + +class NoBoundsCheck : public BoundsCheck { + bool in_bounds(const Sym&) const { return false; } + std::string get_bounds(const Sym&) const { return ""; } +}; + +#endif + + diff --git a/eo/contrib/mathsym/eval/Interval.h b/eo/contrib/mathsym/eval/Interval.h new file mode 100644 index 00000000..1849af4c --- /dev/null +++ b/eo/contrib/mathsym/eval/Interval.h @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef INTERVAL__H__ +#define INTERVAL__H__ + +#include +#include +#include + + +typedef boost::numeric::interval_lib::rounded_transc_exact RoundingTransc; +typedef boost::numeric::interval_lib::save_state Rounding; +typedef boost::numeric::interval_lib::checking_base Checking; +typedef boost::numeric::interval_lib::policies Policy; +typedef boost::numeric::interval Interval; + +struct interval_error{}; + +inline bool valid(const Interval& val) { + if (!finite(val.lower()) || !finite(val.upper())) return false; + + return val.lower() > -1e10 && val.upper() < 1e10; +} + +inline Interval sqrt(const Interval& val) { + if (val.lower() < 0.0) { + return Interval::whole(); + } + + return boost::numeric::sqrt(val); +} + +inline Interval sqr(const Interval& val) { + return square(val); +} + +inline Interval acos(const Interval& val) { + if (val.lower() < 1.0 || val.upper() > 1.0) { + return Interval::whole(); + } + + return boost::numeric::acos(val); +} + +inline Interval asin(const Interval& val) { + if (val.lower() < 1.0 || val.upper() > 1.0) { + return Interval::whole(); + } + + return boost::numeric::asin(val); +} + +inline Interval acosh(const Interval& val) { + if (val.lower() < 1.0) return Interval::whole(); + return boost::numeric::acosh(val); +} + +inline +std::ostream& operator<<(std::ostream& os, const Interval& val) { + os << '[' << val.lower() << ", " << val.upper() << ']'; + return os; +} + +#ifdef TEST_INTERVAL +using namespace std; +using namespace boost::numeric; + +int main() { + Interval a(0, 10); + Interval b(-1.5, 2); + cout << "a = " << a << endl; + cout << "b = " << b << endl; + cout << "a + b = " << a + b << endl; + cout << "a - b = " << a - b << endl; + cout << "b - a = " << b - a << endl; + cout << "-a = " << -a << endl; + cout << "a * b = " << a * b << endl; + cout << "b/(a+1) = " << b / (a + 1.0) << endl; + cout << "b * a = " << b * a << endl; + + cout << "b / a = " << b/a << endl; + + cout << "cos(a) = " << cos(a) << endl; + cout << "cos(b) = " << cos(b) << endl; + + cout << "log(b) = " << log(b) << endl; + + cout << "sqrt(b) = " << sqrt(b) << endl; + cout << "sqrt(a) = " << sqrt(a) << endl; + cout << "sqr(b) = " << sqr(b) << endl; + + cout << "exp(b*a)= " << exp(b*a) << endl; + + cout << "atan(a) = " << atan(a) << endl; + cout << "cosh(b) = " << cosh(b) << endl; + +} +#endif + +#endif diff --git a/eo/contrib/mathsym/eval/c_compile.c b/eo/contrib/mathsym/eval/c_compile.c new file mode 100644 index 00000000..2dcdc053 --- /dev/null +++ b/eo/contrib/mathsym/eval/c_compile.c @@ -0,0 +1,40 @@ +#include +#include +#include + +static TCCState* s = 0; + +extern void symc_init() { + if (s != 0) { + tcc_delete(s); + } + s = tcc_new(); + + if (s == 0) { + fprintf(stderr, "Tiny cc doesn't function properly"); + exit(1); + } +} + +extern void symc_compile(const char* func_str) { + //printf("Compiling %s\n", func_str); + tcc_compile_string(s, func_str); +} + +extern void symc_link() { + tcc_relocate(s); +} + +extern void* symc_get_fun(const char* func_name) { + unsigned long val; + tcc_get_symbol(s, &val, func_name); + return (void*) val; +} + +extern void* symc_make(const char* func_str, const char* func_name) { + symc_init(); + symc_compile(func_str); + symc_link(); + return symc_get_fun(func_name); +} + diff --git a/eo/contrib/mathsym/eval/sym_compile.cpp b/eo/contrib/mathsym/eval/sym_compile.cpp new file mode 100644 index 00000000..81254e5f --- /dev/null +++ b/eo/contrib/mathsym/eval/sym_compile.cpp @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#if __GNUC__ == 3 +#include +#else +#include +using std::hash_map; +#endif + +#include "Sym.h" +#include "FunDef.h" +#include "sym_compile.h" + +#include + +using namespace std; + +extern "C" { + void symc_init(); + void symc_compile(const char* func_str); + void symc_link(); + void* symc_get_fun(const char* func_name); + void* symc_make(const char* func_str, const char* func_name); +} + +string make_prototypes() { + string prot = get_prototypes(); + prot += "double sqr(double x) { return x*x; }"; + return prot; +} + +// contains variable names, like 'a0', 'a1', etc. +typedef hash_map HashMap; + +HashMap::iterator find_entry(Sym sym, ostream& os, HashMap& map) { + HashMap::iterator result = map.find(sym); + + if (result == map.end()) { // new entry + const SymVec& args = sym.args(); + vector argstr(args.size()); + for (unsigned i = 0; i < args.size(); ++i) { + argstr[i] = find_entry(args[i], os, map)->second; + } + + unsigned current_entry = map.size(); // current number of variables defined + + // write out the code + const FunDef& fun = get_element(sym.token()); + string code = fun.c_print(argstr, vector()); + os << "double a" << current_entry << "=" << code << ";\n"; + + // insert variable ref in map + ostringstream str; + str << 'a' << current_entry; + + result = map.insert( make_pair(sym, str.str()) ).first; // only want iterator + } + + return result; +} + +void write_entry(Sym sym, ostream& os, HashMap& map, unsigned out) { + HashMap::iterator it = find_entry(sym, os, map); + os << "y[" << out << "]=" << it->second << ";\n"; +} + +multi_function compile(const std::vector& syms) { + + ostringstream os; + + os << make_prototypes(); + + os << "double func(const double* x, double* y) { \n "; + + HashMap map; + + for (unsigned i = 0; i < syms.size(); ++i) { + write_entry(syms[i], os, map, i); + } + + os << ";}"; + string func_str = os.str(); + + //cout << "compiling " << func_str << endl; + + return (multi_function) symc_make(func_str.c_str(), "func"); +} + +single_function compile(Sym sym) { + + ostringstream os; + + os << make_prototypes(); + os << "double func(const double* x) { return "; + + string code = c_print(sym); + os << code; + os << ";}"; + string func_str = os.str(); + + //cout << "compiling " << func_str << endl; + + return (single_function) symc_make(func_str.c_str(), "func"); +} + +/* finds and inserts the full code in a hashmap */ +HashMap::iterator find_code(Sym sym, HashMap& map) { + HashMap::iterator result = map.find(sym); + + if (result == map.end()) { // new entry + const SymVec& args = sym.args(); + vector argstr(args.size()); + for (unsigned i = 0; i < args.size(); ++i) { + argstr[i] = find_code(args[i], map)->second; + } + + // write out the code + const FunDef& fun = get_element(sym.token()); + string code = fun.c_print(argstr, vector()); + result = map.insert( make_pair(sym, code) ).first; // only want iterator + } + + return result; +} + +string print_code(Sym sym, HashMap& map) { + HashMap::iterator it = find_code(sym, map); + return it->second; +} + +void compile(const std::vector& syms, std::vector& functions) { + symc_init(); + + ostringstream os; + os << make_prototypes(); + HashMap map; + for (unsigned i = 0; i < syms.size(); ++i) { + + os << "double func" << i << "(const double* x) { return "; + os << print_code(syms[i], map); //c_print(syms[i]); + os << ";}\n"; + + //symc_compile(os.str().c_str()); + //cout << "compiling " << os.str() << endl; + } + +#ifdef INTERVAL_DEBUG + //cout << "Compiling " << os.str() << endl; +#endif + + symc_compile(os.str().c_str()); + symc_link(); + + functions.resize(syms.size()); + for (unsigned i = 0; i < syms.size(); ++i) { + ostringstream os2; + os2 << "func" << i; + + functions[i] = (single_function) symc_get_fun(os2.str().c_str()); + } + +} + + + diff --git a/eo/contrib/mathsym/eval/sym_compile.h b/eo/contrib/mathsym/eval/sym_compile.h new file mode 100644 index 00000000..2a8b7f95 --- /dev/null +++ b/eo/contrib/mathsym/eval/sym_compile.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYMCOMPILE_H_ +#define SYMCOMPILE_H_ + +#include + + +typedef double (*single_function)(const double *); +typedef void (*multi_function)(const double*, double*); // last argument is output + +/* + * Important, after every call of the functions below, the function pointers of the previous + * call are invalidated. Sorry, but that's the way the cookie crumbles (in tcc) + * */ + +single_function compile(Sym sym); +multi_function compile(const std::vector& sym); +void compile(const std::vector& sym, std::vector& functions); + +#endif diff --git a/eo/contrib/mathsym/fun/FunDef.cpp b/eo/contrib/mathsym/fun/FunDef.cpp new file mode 100644 index 00000000..60891af2 --- /dev/null +++ b/eo/contrib/mathsym/fun/FunDef.cpp @@ -0,0 +1,569 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include +#if __GNUC__ == 3 +#include +#else +#include +using std::hash_map; +#endif + +#include "Sym.h" +#include "FunDef.h" +#include + +using namespace std; +using namespace boost::numeric; + +vector language; + +token_t add_function(FunDef* function) { + language.push_back(function); + return token_t(language.size()-1); +} + +const FunDef& get_element(token_t token) { return *language[token]; } + +/* Printing */ + +string c_print(const Sym& sym) { + return c_print(sym, vector()); +} + +string c_print(const Sym& sym, const vector& vars) { + const SymVec& args = sym.args(); + vector names(args.size()); + for (unsigned i = 0; i < args.size(); ++i) { + names[i] = c_print(args[i], vars); + } + return language[sym.token()]->c_print(names, vars); +} + +/* Evaluation */ + + +double eval(const Sym& sym, const std::vector& inputs) { + return language[sym.token()]->eval(sym.args(), inputs); +} + + +/* Interval Logic */ +Interval eval(const Sym& sym, const vector& inputs) { + const SymVec& args = sym.args(); + vector interv(args.size()); + for (unsigned i = 0; i < args.size(); ++i) { + interv[i] = eval(args[i], inputs); + + if (!valid(interv[i])) throw interval_error(); + } + + return language[sym.token()]->eval(interv, inputs); +} + +/* */ +void add_function_to_table(LanguageTable& table, token_t token) { + const FunDef& fundef = *language[token]; + + if (fundef.has_varargs() == false) { + table.add_function(token, fundef.min_arity()); + } else { // sum or prod (or min or max) + table.add_function(token, 2); + } +} + + +// by default it is eager +double FunDef::eval(const SymVec& args, const vector& inputs) const { + vector values(args.size()); + for (unsigned i = 0; i < args.size(); ++i) { + values[i] = ::eval(args[i], inputs); + } + + return eval(values, inputs); +} + +/* Variable Handling */ +FunDef* make_var(int idx); // defined in FunDefs.h +static vector var_token; + +Sym SymVar(unsigned idx) { + if (var_token.size() <= idx) { + // it is new + var_token.resize(idx+1, token_t(-1)); + var_token[idx] = add_function( make_var(idx) ); + } else if (var_token[idx] == token_t(-1)) { + var_token[idx] = add_function( make_var(idx) ); + } + + return Sym(var_token[idx]); +} + + +/* Constant Handling */ + +struct HashDouble{ + size_t operator()(double val) const { + unsigned long h = 0; + char* s = (char*)&val; + for (unsigned i=0 ; i DoubleSet; + +static DoubleSet doubleSet; // for quick checking if a constant already exists +static vector is_constant; +static vector token_value; + +static std::vector free_list; + +void delete_val(token_t token) { // clean up the information about this constant + if (is_constant[token]) { + double value = token_value[token]; + + delete language[token]; + language[token] = 0; + + doubleSet.erase(value); + free_list.push_back(token); + } +} +FunDef* make_const(double value); + +Sym SymConst(double value) { + + Sym::set_extra_dtor(delete_val); + + DoubleSet::iterator it = doubleSet.find(value); + + if (it != doubleSet.end()) { + return Sym(it->second); + } + + + if (free_list.empty()) { // make space for tokens; + unsigned sz = language.size(); + language.resize(sz + sz+1); // double + is_constant.resize(language.size(), false); + token_value.resize(language.size(), 0.0); + + for (unsigned i = sz; i < language.size(); ++i) { + free_list.push_back(i); + } + } + + token_t token = free_list.back(); + free_list.pop_back(); + + assert(language[token] == 0); + + language[token] = make_const(value); + doubleSet[value] = token; + is_constant[token] = true; + token_value[token] = value; + + return Sym(token); +} + +/* LanguageTable depends on this one, XXX move somewhere safe.*/ +#include +extern Sym default_const() { return SymConst(rng.normal()); } + +/* The functions */ + +class Var : public FunDef { + public : + int idx; + string default_str; + + Var(int _idx) : idx(_idx) { + ostringstream os; + os << "x[" << idx << ']'; // CompiledCode expects this form + default_str = os.str(); + } + + double eval(const vector& _, const vector& inputs) const { return inputs[idx]; } + double eval(const SymVec& _, const vector& inputs) const { return inputs[idx]; } + string c_print(const vector& _, const vector& names) const { + if (names.empty()) { + return default_str; + } + return names[idx]; + } + + Interval eval(const vector& _, const vector& inputs) const { + return inputs[idx]; + } + + unsigned min_arity() const { return 0; } + + string name() const { return "var"; } + +}; + +class Const : public FunDef { + private: + double value; + string value_str; + public: + Const(double _value) : value(_value) { + ostringstream os; + os.precision(17); + os.setf(ios::showpoint); + os << '(' << value << ')'; + value_str = os.str(); + } + + + double eval(const vector& _, const vector& inputs) const { return value; } + double eval(const SymVec& _, const vector& inputs) const { return value; } + string c_print(const vector& _, const vector& names) const { + return value_str; + } + + Interval eval(const vector& _, const vector& inputs) const { + // Profil/Bias seems to have a problem with 0 * inf when the Interval is exact zero (fpe) + //if (value == 0.0) return Interval(-BiasEpsilon,BiasEpsilon); + return Interval(value); + } + + unsigned min_arity() const { return 0; } + + string name() const { return "parameter"; } +}; + + +// Get functions out, excluding Const and Var +vector get_defined_functions() { + vector res; + for (unsigned i = 0; i < language.size(); ++i) { + res.push_back(language[i]); + + if (dynamic_cast(language[i]) != 0 || (dynamic_cast(language[i]) != 0) ) { + res.back() = 0; // erase + } + } + + return res; +} + +class Sum : public FunDef { + + public : + + double eval(const vector& vals, const vector& _) const { + double res = 0; + for (unsigned i = 0; i < vals.size(); ++i) res += vals[i]; + return res; + } + + string c_print(const vector& args, const vector& _) const { + if (args.empty()) { return "0.0"; } + + ostringstream os; + os << "(" << args[0]; + for (unsigned i = 1; i < args.size(); ++i) { + os << "+" << args[i]; + } + os << ")"; + return os.str(); + } + + Interval eval(const vector& args, const vector& inputs) const { + Interval interv(0.0); //(0.0-BiasEpsilon, 0.0+BiasEpsilon); // Profil/Bias seems to have a problem with 0 * inf when the Interval is exact zero (fpe) + for (unsigned i = 0; i < args.size(); ++i) { + Interval a = args[i]; // Profil doesn't know much about const correctness + interv += a; + } + return interv; + } + + unsigned min_arity() const { return 0; } + bool has_varargs() const { return true; } + + string name() const { return "sum"; } +}; + + +class Prod : public FunDef { + + public : + + double eval(const vector& vals, const vector& _) const { + double res = 1; + for (unsigned i = 0; i < vals.size(); ++i) res *= vals[i]; + return res; + } + + string c_print(const vector& args, const vector& _) const { + if (args.empty()) { return "1.0"; } + + ostringstream os; + os << "(" << args[0]; + for (unsigned i = 1; i < args.size(); ++i) { + os << "*" << args[i]; + } + os << ")"; + + return os.str(); + } + + Interval eval(const vector& args, const vector& inputs) const { + Interval interv(1.0); + for (unsigned i = 0; i < args.size(); ++i) { + Interval a = args[i]; // Profil doesn't know much about const correctness + interv *= a; + } + return interv; + } + + unsigned min_arity() const { return 0; } + bool has_varargs() const { return true; } + + string name() const { return "prod"; } +}; + + +class Power : public FunDef { + public : + double eval(const vector& vals, const vector& _) const { + return pow(vals[0], vals[1]); + } + + string c_print(const vector& args, const vector& _) const { + return "pow(" + args[0] + ',' + args[1] + ')'; + } + + Interval eval(const vector& args, const vector& _) const { + Interval first = args[0]; + Interval second = args[1]; + Interval lg = log(first); + if (!valid(lg)) throw interval_error(); + return exp(second * lg); + } + + unsigned min_arity() const { return 2; } + + string name() const { return "pow"; } +}; + +class IsNeg : public FunDef { + + public: + double eval(const vector& vals, const vector& _) const { + if (vals[0] < 0.0) return vals[1]; + return vals[2]; + } + + double eval(const Sym& sym, const vector& inputs) const { + const SymVec& args = sym.args(); + double arg0 = ::eval(args[0], inputs); + if (arg0 < 0.0) { + return ::eval(args[1], inputs); + } + return ::eval(args[2], inputs); + } + + string c_print(const vector& args, const vector& _) const { + return "((" + args[0] + "<0.0)?" + args[1] + ":" + args[2]+")"; + } + + Interval eval(const vector& args, const vector& _) const { + Interval a0 = args[0]; + if (a0.upper() < 0.0) return args[1]; + if (a0.lower() >= 0.0) return args[2]; + + return Interval( std::min(args[1].lower(), args[2].lower()), std::max(args[1].upper(), args[2].upper())); + } + + unsigned min_arity() const { return 3; } + + string name() const { return "ifltz"; } +}; + +template +class Unary : public FunDef { + + Func un; + + double eval(const vector& vals, const vector& _) const { + return un(vals[0]); + } + + string c_print(const vector& args, const vector& _) const { + return un(args[0]); + } + + Interval eval(const vector& args, const vector& _) const { + return un(args[0]); + } + + unsigned min_arity() const { return 1; } + + string name() const { return un.name(); } + +}; + +struct Inv { + double operator()(double val) const { return 1.0 / val; } + string operator()(string v) const { return "(1./" + v + ")"; } + Interval operator()(Interval v) const { return 1.0 / v; } + + string name() const { return "inv"; } +}; + +struct Min { + double operator()(double val) const { return -val; } + string operator()(string v) const { return "(-" + v + ")"; } + Interval operator()(Interval v) const { return -v; } + + string name() const { return "min"; } +}; + +string prototypes = "double pow(double, double);"; +string get_prototypes() { return prototypes; } +unsigned add_prototype(string str) { prototypes += string("double ") + str + "(double);"; return prototypes.size(); } + + +#define FUNCDEF(funcname) struct funcname##_struct { \ + double operator()(double val) const { return funcname(val); }\ + string operator()(string val) const { return string(#funcname) + '(' + val + ')'; }\ + Interval operator()(Interval val) const { return funcname(val); }\ + string name() const { return string(#funcname); }\ +};\ +const token_t funcname##_token = add_function( new Unary);\ +unsigned funcname##_size = add_prototype(#funcname); + + + +FunDef* make_var(int idx) { return new Var(idx); } +FunDef* make_const(double value) { return new Const(value); } + +const token_t sum_token = add_function( new Sum ); +const token_t prod_token = add_function( new Prod); +const token_t inv_token = add_function( new Unary); +const token_t min_token = add_function( new Unary); +const token_t pow_token = add_function( new Power); +const token_t ifltz_token = add_function( new IsNeg); + +FUNCDEF(sin); +FUNCDEF(cos); +FUNCDEF(tan); +FUNCDEF(asin); +FUNCDEF(acos); +FUNCDEF(atan); + +FUNCDEF(sinh); +FUNCDEF(cosh); +FUNCDEF(tanh); +FUNCDEF(asinh); +FUNCDEF(acosh); +FUNCDEF(atanh); + +FUNCDEF(exp); +FUNCDEF(log); + +double sqr(double x) { return x*x; } + +FUNCDEF(sqr); +FUNCDEF(sqrt); + +/* Serialization */ +void write_raw(ostream& os, const Sym& sym) { + token_t token = sym.token(); + const SymVec& args = sym.args(); + + if (is_constant.size() > token && is_constant[token]) { + os << "c" << language[token]->c_print(vector(), vector()); + } else { + + const Var* var = dynamic_cast( language[token] ); + + if (var != 0) { + os << "v" << var->idx; + } else { + os << "f" << token << ' ' << args.size(); + } + } + + for (unsigned i = 0; i < args.size(); ++i) { + write_raw(os, args[i]); + } +} + +string write_raw(const Sym& sym) { + + ostringstream os; + write_raw(os, sym); + + return os.str(); +} + +Sym read_raw(istream& is) { + char id = is.get(); + + switch (id) { + case 'c' : + { + double val; + is.get(); // skip '(' + is >> val; + is.get(); // skip ')' + return SymConst(val); + } + case 'v' : + { + unsigned idx; + is >> idx; + return SymVar(idx); + } + case 'f' : + { + token_t token; + unsigned arity; + is >> token; + is >> arity; + SymVec args(arity); + for (unsigned i = 0; i < arity; ++i) { + args[i] = read_raw(is); + } + + return Sym(token, args); + } + default : { + cerr << "Character = " << id << " Could not read formula from stream" << endl; + exit(1); + } + + } + + return Sym(); +} + +Sym read_raw(string str) { + istringstream is(str); + return read_raw(is); +} + +void read_raw(istream& is, Sym& sym) { + sym = read_raw(is); +} + diff --git a/eo/contrib/mathsym/fun/FunDef.h b/eo/contrib/mathsym/fun/FunDef.h new file mode 100644 index 00000000..d250c3dd --- /dev/null +++ b/eo/contrib/mathsym/fun/FunDef.h @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef FUNCTION_DEF_H_ +#define FUNCTION_DEF_H_ + +#include +#include +#include + +#include "Sym.h" +#include "Interval.h" + +class FunDef { + public: + + virtual ~FunDef() {} + + // (possibly) lazy evaluation function, default implementation calls 'eager' eval + virtual double eval(const SymVec& args, const std::vector& inputs) const; + + // eager evaluation function + virtual double eval(const std::vector& args, const std::vector& inputs) const = 0; + + // interval evaluation + virtual Interval eval(const std::vector& args, const std::vector& inputs) const = 0; + + // prints 'c' like code + virtual std::string c_print(const std::vector& names, const std::vector& names) const = 0; + + virtual unsigned min_arity() const = 0; + virtual bool has_varargs() const { return false; } // sum, prod, min, max are variable arity + + virtual std::string name() const = 0; + + protected: + +}; + +extern std::vector get_defined_functions(); +extern const FunDef& get_element(token_t token); + +/* Single case evaluation */ +extern double eval(const Sym& sym, const std::vector& inputs); + +/* Static analysis through interval arithmetic */ +extern Interval eval(const Sym& sym, const std::vector& inputs); + +/* Pretty printers, second version allows setting of variable names */ +extern std::string c_print(const Sym& sym); +extern std::string c_print(const Sym& sym, const std::vector& var_names); + +/* Pretty printer streamer */ +inline std::ostream& operator<<(std::ostream& os, Sym sym) { return os << c_print(sym); } + +/* Create constant */ +extern Sym SymConst(double value); + +/* Create variable */ +extern Sym SymVar(unsigned idx); + +/* Add function to the language table (and take a guess at the arity) */ +class LanguageTable; +extern void add_function_to_table(LanguageTable& table, token_t token); + +// token names +extern const token_t sum_token; +extern const token_t prod_token; +extern const token_t inv_token; +extern const token_t min_token; +extern const token_t pow_token; +extern const token_t ifltz_token; + +#define HEADERFUNC(name) extern const token_t name##_token;\ + inline Sym name(Sym arg) { return Sym(name##_token, arg); } + +/* This defines the tokens: sin_token, cos_token, etc. */ +HEADERFUNC(sin); +HEADERFUNC(cos); +HEADERFUNC(tan); +HEADERFUNC(asin); +HEADERFUNC(acos); +HEADERFUNC(atan); + +HEADERFUNC(sinh); +HEADERFUNC(cosh); +HEADERFUNC(tanh); +HEADERFUNC(asinh); +HEADERFUNC(acosh); +HEADERFUNC(atanh); + +HEADERFUNC(exp); +HEADERFUNC(log); + +HEADERFUNC(sqr); +HEADERFUNC(sqrt); + +extern std::string get_prototypes(); + +// reading and writing in internal format +extern std::string write_raw(const Sym& sym); +extern void write_raw(ostream& os, const Sym& sym); +extern Sym read_raw(std::string str); +extern Sym read_raw(std::istream& is); +extern void read_raw(std::istream& is, Sym& sym); + +#include "SymOps.h" + +#endif + diff --git a/eo/contrib/mathsym/fun/SymOps.cpp b/eo/contrib/mathsym/fun/SymOps.cpp new file mode 100644 index 00000000..2d66b0d0 --- /dev/null +++ b/eo/contrib/mathsym/fun/SymOps.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "FunDef.h" +#include "SymOps.h" +#include "Sym.h" + +using namespace std; + +void collect(token_t t, Sym a, SymVec& args) { + + if (a.token() == t) { + const SymVec& a_args = a.args(); + for (unsigned i = 0; i < a_args.size(); ++i) { + collect(t, a_args[i], args); + } + return; + } + + args.push_back(a); +} + +Sym operator+(Sym a, Sym b) { + + SymVec args; + + collect(sum_token, a, args); + collect(sum_token, b, args); + + return Sym(sum_token, args); +} + +Sym operator*(Sym a, Sym b) { + + SymVec args; + + collect(prod_token, a, args); + collect(prod_token, b, args); + + return Sym(prod_token, args); +} + +Sym operator/(Sym a, Sym b) { + + SymVec args; + + collect(prod_token, a, args); + + SymVec args2; + collect(prod_token, b, args2); + + SymVec inv; + inv.push_back(Sym(prod_token, args2)); + + args.push_back( Sym(inv_token, inv) ); + + return Sym(prod_token, args); +} + +Sym operator-(Sym a, Sym b) { + + SymVec args; + + collect(sum_token, a, args); + + SymVec args2; + collect(sum_token, b, args2); + + SymVec min; + min.push_back(Sym(sum_token, args2)); + + args.push_back( Sym(min_token, min) ); + + return Sym(sum_token, args); +} + +Sym operator-(Sym a) { + return Sym(min_token, a); +} + +Sym pow(Sym a, Sym b) { + SymVec args; + args.push_back(a); + args.push_back(b); + return Sym(pow_token, args); +} + +Sym ifltz(Sym a, Sym b, Sym c) { + SymVec args; + args.push_back(a); + args.push_back(b); + args.push_back(c); + return Sym(ifltz_token, args); +} + diff --git a/eo/contrib/mathsym/fun/SymOps.h b/eo/contrib/mathsym/fun/SymOps.h new file mode 100644 index 00000000..16eb35fe --- /dev/null +++ b/eo/contrib/mathsym/fun/SymOps.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYMOPS_H +#define SYMOPS_H + +#include "Sym.h" + +extern Sym operator+(Sym a, Sym b); +extern Sym operator*(Sym a, Sym b); +extern Sym operator/(Sym a, Sym b); +extern Sym operator-(Sym a, Sym b); +extern Sym pow(Sym a, Sym b); +extern Sym ifltz(Sym a, Sym b, Sym c); +extern Sym operator-(Sym a); + +#endif diff --git a/eo/contrib/mathsym/fun/util.cpp b/eo/contrib/mathsym/fun/util.cpp new file mode 100644 index 00000000..83e751de --- /dev/null +++ b/eo/contrib/mathsym/fun/util.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include + +using namespace std; + +double error(string errstr) { + cerr << "ERROR: " << errstr << endl; + exit(1); +} + diff --git a/eo/contrib/mathsym/gen/LanguageTable.cpp b/eo/contrib/mathsym/gen/LanguageTable.cpp new file mode 100644 index 00000000..c5906afb --- /dev/null +++ b/eo/contrib/mathsym/gen/LanguageTable.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "LanguageTable.h" +#include "Sym.h" + +#include + +using namespace std; + +eoRng rng(time(0)); + +extern Sym default_const(); + +class LanguageImpl { + public : + std::vector vars; + LanguageTable::erc_func erc; + + std::vector functions; + std::vector< std::vector > functions_per_arity; + + LanguageImpl() : erc(default_const) {} +}; + +LanguageTable::LanguageTable() { + pimpl = new LanguageImpl; +} + +LanguageTable::~LanguageTable() { + delete pimpl; +} + +LanguageTable::LanguageTable(const LanguageTable& that) { + pimpl = new LanguageImpl(*that.pimpl); +} + +LanguageTable& LanguageTable::operator=(const LanguageTable& that) { + *pimpl = *that.pimpl; + return *this; +} + +void LanguageTable::add_function(token_t token, unsigned arity) { + functor_t f = {token, arity}; + add_function( f ); +} + +void LanguageTable::add_function(functor_t f) { + + if (f.arity > 0) { + pimpl->functions.push_back(f); + + } else { + pimpl->vars.push_back(Sym(f.token)); + } + + if (pimpl->functions_per_arity.size() <= f.arity) pimpl->functions_per_arity.resize(f.arity+1); + pimpl->functions_per_arity[f.arity].push_back(f.token); + +} + +void LanguageTable::set_erc( erc_func func) { pimpl->erc = func; } + +/* Getting info out */ + +extern Sym SymConst(double val); + +Sym LanguageTable::get_random_var() const { return rng.choice(pimpl->vars); } +Sym LanguageTable::get_random_const() const { return pimpl->erc(); } + +functor_t LanguageTable::get_random_function() const +{ + return rng.choice(pimpl->functions); +} + +token_t LanguageTable::get_random_function(unsigned arity) const +{ + return rng.choice(pimpl->functions_per_arity[arity]); +} + + + diff --git a/eo/contrib/mathsym/gen/LanguageTable.h b/eo/contrib/mathsym/gen/LanguageTable.h new file mode 100644 index 00000000..a19bc889 --- /dev/null +++ b/eo/contrib/mathsym/gen/LanguageTable.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef LANGUAGE_TABLE_H +#define LANGUAGE_TABLE_H + +#include "token.h" + +class LanguageImpl; +class Sym; + +class LanguageTable { + + LanguageImpl* pimpl; + + public: + + LanguageTable(); + ~LanguageTable(); + + LanguageTable(const LanguageTable& org); + + LanguageTable& operator=(const LanguageTable& org); + + /* setting it up */ + typedef Sym (*erc_func)(); + + void add_function(token_t token, unsigned arity); + void add_function(functor_t functor); + void set_erc(erc_func func); + + /* Getting info out */ + + Sym get_random_var() const; + Sym get_random_const() const; + + functor_t get_random_function() const; + token_t get_random_function(unsigned arity) const; +}; + +#endif + diff --git a/eo/contrib/mathsym/gen/NodeSelector.cpp b/eo/contrib/mathsym/gen/NodeSelector.cpp new file mode 100644 index 00000000..db41448f --- /dev/null +++ b/eo/contrib/mathsym/gen/NodeSelector.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "NodeSelector.h" +#include "Sym.h" + +#include + +unsigned RandomNodeSelector::select_node(Sym sym) const { + return rng.random(sym.size()); +} + +unsigned BiasedNodeSelector::select_node(Sym sym) const { + + unsigned p = rng.random(sym.size()); + for (unsigned i = 0; i < nRounds; ++i) { + Sym res = get_subtree(sym, p); + + if (res.args().size() > 0) break; + + p = rng.random(sym.size()); + } + + return p; +} + diff --git a/eo/contrib/mathsym/gen/NodeSelector.h b/eo/contrib/mathsym/gen/NodeSelector.h new file mode 100644 index 00000000..0a2863d9 --- /dev/null +++ b/eo/contrib/mathsym/gen/NodeSelector.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef NODESELECTOR_H +#define NODESELECTOR_H + +class Sym; + +/** Base class for selecting nodes */ +class NodeSelector { + public: + virtual unsigned select_node(Sym sym) const = 0; +}; + + +/** Select nodes uniformly */ +class RandomNodeSelector : public NodeSelector { + public: + unsigned select_node(Sym sym) const; +}; + +/** A node selector that does a specified number of rounds ignoring terminals */ +class BiasedNodeSelector : public NodeSelector { + public: + unsigned nRounds; + + BiasedNodeSelector() : nRounds(3) {} // 3: for binary trees 87.5% chance of selecting an internal node + BiasedNodeSelector(unsigned n) : nRounds(n) {} + + unsigned select_node(Sym sym) const; +}; + +#endif diff --git a/eo/contrib/mathsym/gen/TreeBuilder.cpp b/eo/contrib/mathsym/gen/TreeBuilder.cpp new file mode 100644 index 00000000..70b7ef53 --- /dev/null +++ b/eo/contrib/mathsym/gen/TreeBuilder.cpp @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include "TreeBuilder.h" + +Sym TreeBuilder::make_terminal() const { + if (rng.flip(vcprob)) { + return table.get_random_var(); + } + + return table.get_random_const(); +} + +Sym TreeBuilder::build_tree(unsigned max_depth, bool grow) const { + if (max_depth == 0 || grow && rng.random(2) == 0) { + return make_terminal(); + } + + // pick a random function, no matter what arity + + functor_t func = table.get_random_function(); + + SymVec args(func.arity); + + for (unsigned i = 0; i < args.size(); ++i) { + args[i] = build_tree(max_depth-1, grow); + } + + return Sym(func.token, args); +} + diff --git a/eo/contrib/mathsym/gen/TreeBuilder.h b/eo/contrib/mathsym/gen/TreeBuilder.h new file mode 100644 index 00000000..1969a52b --- /dev/null +++ b/eo/contrib/mathsym/gen/TreeBuilder.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef TREEBUILDER_H_ +#define TREEBUILDER_H_ + +#include "Sym.h" +#include "LanguageTable.h" + +class TreeBuilder { + const LanguageTable& table; + + // probability of selecting a var versus a const when the choice boils down to selecting a terminal + double vcprob; + + Sym make_terminal() const; + public: + + TreeBuilder(const LanguageTable& t) : table(t), vcprob(0.9) {}; + TreeBuilder(const LanguageTable& t, double vc) : table(t), vcprob(vc) {}; + + void set_var_vs_const_probability(double p) { vcprob = p; } + + Sym build_tree(unsigned max_depth, bool grow) const; + + void build_tree(Sym& tree, unsigned max_depth, bool grow) const { tree = build_tree(max_depth, grow); } + +}; + +#endif + diff --git a/eo/contrib/mathsym/header b/eo/contrib/mathsym/header new file mode 100644 index 00000000..a4ea4458 --- /dev/null +++ b/eo/contrib/mathsym/header @@ -0,0 +1,17 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + diff --git a/eo/contrib/mathsym/regression/Dataset.cpp b/eo/contrib/mathsym/regression/Dataset.cpp new file mode 100644 index 00000000..bdb31455 --- /dev/null +++ b/eo/contrib/mathsym/regression/Dataset.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "Dataset.h" +#include +#include + +#include + +using namespace std; + +class DataSetImpl { + public: + vector< vector > inputs; + vector targets; + + void read_data(vector strings) { + // find the number of inputs + + istringstream cnt(strings[0]); + unsigned n = 0; + for (;;) { + string s; + cnt >> s; + if (!cnt) break; + ++n; + } + + inputs.resize(strings.size(), vector(n-1)); + targets.resize(strings.size()); + + for (unsigned i = 0; i < strings.size(); ++i) { + istringstream is(strings[i]); + for (unsigned j = 0; j < n; ++j) { + + if (!is) { + cerr << "Too few targets in record " << i << endl; + exit(1); + } + + if (j < n-1) { + is >> inputs[i][j]; + } else { + is >> targets[i]; + } + + } + } + + } + +}; + +Dataset::Dataset() { pimpl = new DataSetImpl; } +Dataset::~Dataset() { delete pimpl; } +Dataset::Dataset(const Dataset& that) { pimpl = new DataSetImpl(*that.pimpl); } +Dataset& Dataset::operator=(const Dataset& that) { *pimpl = *that.pimpl; return *this; } + +unsigned Dataset::n_records() const { return pimpl->targets.size(); } +unsigned Dataset::n_fields() const { return pimpl->inputs[0].size(); } +const std::vector& Dataset::get_inputs(unsigned record) const { return pimpl->inputs[record]; } +double Dataset::get_target(unsigned record) const { return pimpl->targets[record]; } + +double error(string errstr); + +void Dataset::load_data(std::string filename) { + vector strings; // first load it in strings + + ifstream is(filename.c_str()); + + for(;;) { + string s; + getline(is, s); + if (!is) break; + + if (s[0] == '#') continue; // comment, skip + + strings.push_back(s); + } + + is.close(); + + if (strings.size() == 0) { + error("No data could be loaded"); + } + + pimpl->read_data(strings); + +} + +std::vector Dataset::input_minima() const { + vector >& in = pimpl->inputs; + + vector mn(in[0].size(), 1e+50); + for (unsigned i = 0; i < in.size(); ++i) { + for (unsigned j = 0; j < in[i].size(); ++j) { + mn[j] = std::min(mn[j], in[i][j]); + } + } + + return mn; +} + +vector Dataset::input_maxima() const { + vector >& in = pimpl->inputs; + + vector mx(in[0].size(), -1e+50); + for (unsigned i = 0; i < in.size(); ++i) { + for (unsigned j = 0; j < in[i].size(); ++j) { + mx[j] = std::max(mx[j], in[i][j]); + } + } + + return mx; +} + + + + diff --git a/eo/contrib/mathsym/regression/Dataset.h b/eo/contrib/mathsym/regression/Dataset.h new file mode 100644 index 00000000..395036db --- /dev/null +++ b/eo/contrib/mathsym/regression/Dataset.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef DATASET_H_ +#define DATASET_H_ + +#include +#include + +class DataSetImpl; + +class Dataset { + + DataSetImpl* pimpl; + + Dataset& operator=(const Dataset&); // cannot assign + public: + + Dataset(); + ~Dataset(); + Dataset(const Dataset&); + + void load_data(std::string filename); + + unsigned n_records() const; + unsigned n_fields() const; + + const std::vector& get_inputs(unsigned record) const; + double get_target(unsigned record) const; + + std::vector input_minima() const; + std::vector input_maxima() const; + +}; + +#endif + diff --git a/eo/contrib/mathsym/regression/ErrorMeasure.cpp b/eo/contrib/mathsym/regression/ErrorMeasure.cpp new file mode 100644 index 00000000..b6a5795f --- /dev/null +++ b/eo/contrib/mathsym/regression/ErrorMeasure.cpp @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include +#include + +#include "ErrorMeasure.h" +#include "Dataset.h" +#include "Sym.h" +#include "sym_compile.h" +#include "TargetInfo.h" + +using namespace std; + +#ifdef INTERVAL_DEBUG + +#include +#include + +vector none; +IntervalBoundsCheck bounds(none, none); + +#endif + + + +static double not_a_number = atof("nan"); + +class ErrorMeasureImpl { + public: + const Dataset& data; + TargetInfo train_info; + + ErrorMeasure::measure measure; + + Scaling no_scaling; + + ErrorMeasureImpl(const Dataset& d, double t_p, ErrorMeasure::measure m) : data(d), measure(m) { + +#ifdef INTERVAL_DEBUG + bounds = IntervalBoundsCheck(d.input_minima(), d.input_maxima()); +#endif + + unsigned nrecords = d.n_records(); + unsigned cases = unsigned(t_p * nrecords); + + valarray t(cases); + + for (unsigned i = 0; i < cases; ++i) { + t[i] = data.get_target(i); + } + + train_info = TargetInfo(t); + no_scaling = Scaling(new NoScaling); + } + + ErrorMeasure::result eval(const valarray& y) { + + ErrorMeasure::result result; + result.scaling = no_scaling; + + + switch(measure) { + case ErrorMeasure::mean_squared: + result.error = pow(train_info.targets() - y, 2.0).sum() / y.size(); + return result; + case ErrorMeasure::absolute: + result.error = abs(train_info.targets() - y).sum() / y.size(); + return result; + case ErrorMeasure::mean_squared_scaled: + result.scaling = ols(y, train_info); + result.error = pow(train_info.targets() - result.scaling->transform(y), 2.0).sum() / y.size(); + return result; + default: + cerr << "Unknown measure encountered: " << measure << " " << __FILE__ << " " << __LINE__ << endl; + } + + return result; + } + + unsigned train_cases() const { + return train_info.targets().size(); + } + + vector multi_function_eval(const vector& pop) { + + multi_function all = compile(pop); + std::vector y(pop.size()); + std::vector err(pop.size()); + + const std::valarray& t = train_info.targets(); + + for (unsigned i = 0; i < train_cases(); ++i) { + // evaluate + all(&data.get_inputs(i)[0], &y[0]); + + for (unsigned j = 0; j < y.size(); ++j) { + double diff = y[j] - t[i]; + if (measure == ErrorMeasure::mean_squared) { // branch prediction will probably solve this inefficiency + err[j] += diff * diff; + } else { + err[j] += fabs(diff); + } + + } + + } + + std::vector result(pop.size()); + + double n = train_cases(); + Scaling no = Scaling(new NoScaling); + for (unsigned i = 0; i < pop.size(); ++i) { + result[i].error = err[i] / n; + result[i].scaling = no; + } + + return result; + + } + + vector single_function_eval(const vector & pop) { + + vector funcs(pop.size()); + compile(pop, funcs); // get one function pointer for each individual + + valarray y(train_cases()); + vector result(pop.size()); + for (unsigned i = 0; i < funcs.size(); ++i) { + for (unsigned j = 0; j < train_cases(); ++j) { + y[j] = funcs[i](&data.get_inputs(j)[0]); + } + +#ifdef INTERVAL_DEBUG + //cout << "eval func " << i << " " << pop[i] << endl; + pair b = bounds.calc_bounds(pop[i]); + + // check if y is in bounds + for (unsigned j = 0; j < y.size(); ++j) { + if (y[j] < b.first -1e-4 || y[j] > b.second + 1e-4 || !finite(y[j])) { + cout << "Error " << y[j] << " not in " << b.first << ' ' << b.second << endl; + cout << "Function " << pop[i] << endl; + exit(1); + } + } +#endif + + result[i] = eval(y); + } + + return result; + } + + vector calc_error(const vector& pop) { + + // currently we can only accumulate simple measures such as absolute and mean_squared + switch(measure) { + case ErrorMeasure::mean_squared: + case ErrorMeasure::absolute: + return multi_function_eval(pop); + case ErrorMeasure::mean_squared_scaled: + return single_function_eval(pop); + } + + return vector(); + } + +}; + +ErrorMeasure::result::result() { + error = 0.0; + scaling = Scaling(0); +} + +bool ErrorMeasure::result::valid() const { + return isfinite(error); +} + +ErrorMeasure::ErrorMeasure(const Dataset& data, double train_perc, measure meas) { + pimpl = new ErrorMeasureImpl(data, train_perc, meas); +} + +ErrorMeasure::~ErrorMeasure() { delete pimpl; } +ErrorMeasure::ErrorMeasure(const ErrorMeasure& that) { pimpl = new ErrorMeasureImpl(*that.pimpl); } + + +ErrorMeasure::result ErrorMeasure::calc_error(Sym sym) { + + single_function f = compile(sym); + + valarray y(pimpl->train_cases()); + + for (unsigned i = 0; i < y.size(); ++i) { + + y[i] = f(&pimpl->data.get_inputs(i)[0]); + + if (!finite(y[i])) { + result res; + res.scaling = Scaling(new NoScaling); + res.error = not_a_number; + return res; + } + + } + + return pimpl->eval(y); +} + +vector ErrorMeasure::calc_error(const vector& syms) { + return pimpl->calc_error(syms); + +} + +double ErrorMeasure::worst_performance() const { + + if (pimpl->measure == mean_squared_scaled) { + return pimpl->train_info.tvar(); + } + + return 1e+20; // TODO: make this general +} + diff --git a/eo/contrib/mathsym/regression/ErrorMeasure.h b/eo/contrib/mathsym/regression/ErrorMeasure.h new file mode 100644 index 00000000..17619fe9 --- /dev/null +++ b/eo/contrib/mathsym/regression/ErrorMeasure.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ERROR_MEASURE_H +#define ERROR_MEASURE_H + +#include "Scaling.h" + +class ErrorMeasureImpl; +class Sym; +class Dataset; + +class ErrorMeasure { + + ErrorMeasureImpl* pimpl; + + public : + + enum measure { + absolute, + mean_squared, + mean_squared_scaled, + }; + + struct result { + double error; + Scaling scaling; + + result(); + bool valid() const; + }; + + ErrorMeasure(const Dataset& data, double train_perc, measure meas = mean_squared); + + ~ErrorMeasure(); + ErrorMeasure(const ErrorMeasure& that); + ErrorMeasure& operator=(const ErrorMeasure& that); + + result calc_error(Sym sym); + + std::vector calc_error(const std::vector& sym); + + double worst_performance() const; +}; + +#endif + diff --git a/eo/contrib/mathsym/regression/Scaling.cpp b/eo/contrib/mathsym/regression/Scaling.cpp new file mode 100644 index 00000000..dd6b0d0f --- /dev/null +++ b/eo/contrib/mathsym/regression/Scaling.cpp @@ -0,0 +1,417 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "Scaling.h" +#include "TargetInfo.h" + +using namespace std; + +Scaling slope(const std::valarray& x, const TargetInfo& targets) { + + double xx = 0.0; + double xy = 0.0; + + const valarray& y = targets.targets(); + + for (unsigned i = 0; i < x.size(); ++i) { + xx += x[i] * x[i]; + xy += x[i] * y[i]; + } + + if (xx < 1e-7) return Scaling(new LinearScaling(0.0,0.0)); + + double b = xy / xx; + + return Scaling(new LinearScaling(0.0, b)); + +} + +// Still needs proper testing with non-trivial lambda +Scaling regularized_least_squares(const std::valarray& inputs, const TargetInfo& targets, double lambda) { + + double n = inputs.size(); + + valarray x = inputs; + + double a,b,d; + a=b=d=0; + + for (unsigned i = 0; i < n; ++i) { + a += 1 + lambda; + b += x[i]; + d += x[i] * x[i] + lambda; + } + + //invert + + double ad_bc = a*d - b * b; + // if ad_bc equals zero there's a problem + + if (ad_bc < 1e-17) return Scaling(new LinearScaling); + + double ai = d/ad_bc; + double bi = -b/ad_bc; + double di = a/ad_bc; + double ci = bi; + + // Now multiply this inverted covariance matrix (C^-1) with x' * t + + std::valarray ones = x; + + // calculate C^-1 * x' ) + for (unsigned i = 0; i < n; ++i) + { + ones[i] = (ai + bi * x[i]); + x[i] = (ci + di * x[i]); + } + + // results are in [ones, x], now multiply with y + + a = 0.0; // intercept + b = 0.0; // slope + + const valarray& t = targets.targets(); + + for (unsigned i = 0; i < n; ++i) + { + a += ones[i] * t[i]; + b += x[i] * t[i]; + } + + return Scaling(new LinearScaling(a,b)); +} + +Scaling ols(const std::valarray& y, const std::valarray& t) { + double n = y.size(); + + double y_mean = y.sum() / n; + double t_mean = t.sum() / n; + + std::valarray y_var = (y - y_mean); + std::valarray t_var = (t - t_mean); + std::valarray cov = t_var * y_var; + + y_var *= y_var; + t_var *= t_var; + + double sumvar = y_var.sum(); + + if (sumvar == 0. || sumvar/n < 1e-7 || sumvar/n > 1e+7) // breakout when numerical problems are likely + return Scaling(new LinearScaling(t_mean,0.)); + + + double b = cov.sum() / sumvar; + double a = t_mean - b * y_mean; + + Scaling s = Scaling(new LinearScaling(a,b)); + + return s; +} + +Scaling ols(const std::valarray& y, const TargetInfo& targets) { + double n = y.size(); + + double y_mean = y.sum() / n; + + std::valarray y_var = (y - y_mean); + std::valarray cov = targets.tcov_part() * y_var; + + y_var *= y_var; + + double sumvar = y_var.sum(); + + if (sumvar == 0. || sumvar/n < 1e-7 || sumvar/n > 1e+7) // breakout when numerical problems are likely + return Scaling(new LinearScaling(targets.tmean(),0.)); + + + double b = cov.sum() / sumvar; + double a = targets.tmean() - b * y_mean; + + if (!finite(b)) { + + cout << a << ' ' << b << endl; + cout << sumvar << endl; + cout << y_mean << endl; + cout << cov.sum() << endl; + exit(1); + } + + Scaling s = Scaling(new LinearScaling(a,b)); + + return s; +} + + +Scaling wls(const std::valarray& inputs, const TargetInfo& targets) { + + std::valarray x = inputs; + const std::valarray& w = targets.weights(); + + unsigned n = x.size(); + // First calculate x'*W (as W is a diagonal matrix it's simply elementwise multiplication + std::valarray wx = targets.weights() * x; + + // Now x'*W is contained in [w,wx], calculate x' * W * x (the covariance) + double a,b,d; + a=b=d=0.0; + + for (unsigned i = 0; i < n; ++i) + { + a += w[i]; + b += wx[i]; + d += x[i] * wx[i]; + } + + //invert + + double ad_bc = a*d - b * b; + // if ad_bc equals zero there's a problem + + if (ad_bc < 1e-17) return Scaling(new LinearScaling); + + double ai = d/ad_bc; + double bi = -b/ad_bc; + double di = a/ad_bc; + double ci = bi; + + // Now multiply this inverted covariance matrix (C^-1) with x' * W * y + + // create alias to reuse the wx we do not need anymore + std::valarray& ones = wx; + + // calculate C^-1 * x' * W (using the fact that W is diagonal) + for (unsigned i = 0; i < n; ++i) + { + ones[i] = w[i]*(ai + bi * x[i]); + x[i] = w[i]*(ci + di * x[i]); + } + + // results are in [ones, x], now multiply with y + + a = 0.0; // intercept + b = 0.0; // slope + + const valarray& t = targets.targets(); + + for (unsigned i = 0; i < n; ++i) + { + a += ones[i] * t[i]; + b += x[i] * t[i]; + } + + return Scaling(new LinearScaling(a,b)); +} + + +//Scaling med(const std::valarray& inputs, const TargetInfo& targets); + +double mse(const std::valarray& y, const TargetInfo& t) { + + valarray residuals = t.targets()-y; + residuals *= residuals; + double sz = residuals.size(); + if (t.has_weights()) { + residuals *= t.weights(); + sz = 1.0; + } + + return residuals.sum() / sz; +} + +double rms(const std::valarray& y, const TargetInfo& t) { + return sqrt(mse(y,t)); +} + +double mae(const std::valarray& y, const TargetInfo& t) { + valarray residuals = abs(t.targets()-y); + if (t.has_weights()) residuals *= t.weights(); + return residuals.sum() / residuals.size(); +} + + +/* + double standard_error(const std::valarray& y, const std::pair& scaling) { + double a = scaling.first; + double b = scaling.second; + double n = y.size(); + double se = sqrt( pow(a+b*y-current_set->targets,2.0).sum() / (n-2)); + + double mean_y = y.sum() / n; + double sxx = pow( y - mean_y, 2.0).sum(); + + return se / sqrt(sxx); + } + + double scaled_mse(const std::valarray& y){ + std::pair scaling; + return scaled_mse(y,scaling); + } + + double scaled_mse(const std::valarray& y, std::pair& scaling) + { + scaling = scale(y); + + double a = scaling.first; + double b = scaling.second; + + std::valarray tmp = current_set->targets - a - b * y; + tmp *= tmp; + + if (weights.size()) + return (weights * tmp).sum(); + + return tmp.sum() / tmp.size(); + } + + double robust_mse(const std::valarray& ny, std::pair& scaling) { + + double smse = scaled_mse(ny,scaling); + + std::valarray y = ny; + // find maximum covariance case + double n = y.size(); + + int largest = 0; + + { + double y_mean = y.sum() / n; + + std::valarray y_var = (y - y_mean); + std::valarray cov = tcov * y_var; + + std::valarray maxcov = cov == cov.max(); + + for (unsigned i = 0; i < maxcov.size(); ++i) { + if (maxcov[i]) { + largest = i; + break; + } + } + } + + double y_mean = (y.sum() - y[largest]) / (n-1); + y[largest] = y_mean; // dissappears from covariance calculation + + std::valarray y_var = (y - y_mean); + std::valarray cov = tcov * y_var; + y_var *= y_var; + + double sumvar = y_var.sum(); + + if (sumvar == 0. || sumvar/n < 1e-7 || sumvar/n > 1e+7) // breakout when numerical problems are likely + return worst_performance(); + + double b = cov.sum() / sumvar; + double a = tmean - b * y_mean; + + std::valarray tmp = current_set->targets - a - b * y; + tmp[largest] = 0.0; + tmp *= tmp; + + double smse2 = tmp.sum() / (tmp.size()-1); + + static std::ofstream os("smse.txt"); + os << smse << ' ' << smse2 << '\n'; + + if (smse2 > smse) { + return worst_performance(); + //std::cerr << "overfit? " << smse << ' ' << smse2 << '\n'; + } + + scaling.first = a; + scaling.second = b; + + return smse2; + } + + class Sorter { + const std::valarray& scores; + public: + Sorter(const std::valarray& _scores) : scores(_scores) {} + + bool operator()(unsigned i, unsigned j) const { + return scores[i] < scores[j]; + } + }; + + double coc(const std::valarray& y) { + std::vector indices(y.size()); + for (unsigned i = 0; i < y.size(); ++i) indices[i] = i; + std::sort(indices.begin(), indices.end(), Sorter(y)); + + const std::valarray& targets = current_set->targets; + + double neg = 1.0 - targets[indices[0]]; + double pos = targets[indices[0]]; + + double cumpos = 0; + double cumneg = 0; + double sum=0; + + double last_score = y[indices[0]]; + + for(unsigned i = 1; i < targets.size(); ++i) { + + if (fabs(y[indices[i]] - last_score) < 1e-9) { // we call it tied + pos += targets[indices[i]]; + neg += 1.0 - targets[indices[i]]; + + if (i < targets.size()-1) + continue; + } + sum += pos * cumneg + (pos * neg) * 0.5; + cumneg += neg; + cumpos += pos; + pos = targets[indices[i]]; + neg = 1.0 - targets[indices[i]]; + last_score = y[indices[i]]; + } + + return sum / (cumneg * cumpos); + } + + // iterative re-weighted least squares (for parameters.classification) + double irls(const std::valarray& scores, std::pair& scaling) { + const std::valarray& t = current_set->targets; + + std::valarray e(scores.size()); + std::valarray u(scores.size()); + std::valarray w(scores.size()); + std::valarray z(scores.size()); + + parameters.use_irls = false; parameters.classification=false; + scaling = scale(scores); + parameters.use_irls=true;parameters.classification=true; + + if (scaling.second == 0.0) return worst_performance(); + + for (unsigned i = 0; i < 10; ++i) { + e = exp(scaling.first + scaling.second*scores); + u = e / (e + exp(-(scaling.first + scaling.second * scores))); + w = u*(1.-u); + z = (t-u)/w; + scaling = wls(scores, u, w); + //double ll = (log(u)*t + (1.-log(u))*(1.-t)).sum(); + //std::cout << "Scale " << i << ' ' << scaling.first << " " << scaling.second << " LL " << 2*ll << std::endl; + } + + // log-likelihood + u = exp(scaling.first + scaling.second*scores) / (1 + exp(scaling.first + scaling.second*scores)); + double ll = (log(u)*t + (1.-log(u))*(1.-t)).sum(); + return 2*ll; + } +*/ diff --git a/eo/contrib/mathsym/regression/Scaling.h b/eo/contrib/mathsym/regression/Scaling.h new file mode 100644 index 00000000..53d53d8b --- /dev/null +++ b/eo/contrib/mathsym/regression/Scaling.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SCALING_H_ +#define SCALING_H_ + +#include "shared_ptr.h" + +#include +#include +#include + +class TargetInfo; + +class ScalingBase { + public: + + std::valarray apply(const std::valarray& x) { + std::valarray xtmp = x; + transform(xtmp); + return xtmp; + } + + virtual double transform(double input) const = 0; + virtual void transform(std::valarray& inputs) const = 0; + virtual std::ostream& print(std::ostream& os, std::string str) const = 0; + virtual std::valarray transform(const std::valarray& inputs) const = 0; +}; + +typedef shared_ptr Scaling; + +class LinearScaling : public ScalingBase { + + double a,b; + + public: + LinearScaling() : a(0.0), b(1.0) {} + LinearScaling(double _a, double _b) : a(_a), b(_b) {} + + double transform(double input) const { input *=b; input += a; return input; } + void transform(std::valarray& inputs) const { inputs *= b; inputs += a; } + std::valarray transform(const std::valarray& inputs) const { + std::valarray y = a + b * inputs; + return y; + } + + double intercept() const { return a; } + double slope() const { return b; } + + std::ostream& print(std::ostream& os, std::string str) const { + os.precision(16); + os << a << " + " << b << " * " << str; + return os; + } +}; + +class NoScaling : public ScalingBase{ + void transform(std::valarray&) const {} + double transform(double input) const { return input; } + std::valarray transform(const std::valarray& inputs) const { return inputs; } + std::ostream& print(std::ostream& os, std::string str) const { return os << str; } +}; + +extern Scaling slope(const std::valarray& inputs, const TargetInfo& targets); // slope only +extern Scaling ols(const std::valarray& inputs, const TargetInfo& targets); +extern Scaling wls(const std::valarray& inputs, const TargetInfo& targets); +extern Scaling med(const std::valarray& inputs, const TargetInfo& targets); + +extern Scaling ols(const std::valarray& inputs, const std::valarray& outputs); + +extern double mse(const std::valarray& y, const TargetInfo& t); +extern double rms(const std::valarray& y, const TargetInfo& t); +extern double mae(const std::valarray& y, const TargetInfo& t); + +// Todo Logistic Scaling + +#endif + + diff --git a/eo/contrib/mathsym/regression/TargetInfo.cpp b/eo/contrib/mathsym/regression/TargetInfo.cpp new file mode 100644 index 00000000..1d386e8c --- /dev/null +++ b/eo/contrib/mathsym/regression/TargetInfo.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "TargetInfo.h" + +using namespace std; + +TargetInfo::TargetInfo(const TargetInfo& org) { operator=(org); } + +TargetInfo& TargetInfo::operator=(const TargetInfo& org) { + _targets.resize(org._targets.size()); + _weights.resize(org._weights.size()); + _tcov_part.resize(org._tcov_part.size()); + + _targets = org._targets; + _weights = org._weights; + _tcov_part = org._tcov_part; + + _tmean = org._tmean; + _tvar = org._tvar; + _tstd = org._tstd; + _tmed = org._tmed; + return *this; +} + + +TargetInfo::TargetInfo(const std::valarray& t) { + _weights.resize(0); + _targets.resize(t.size()); + _targets = t; + + _tmean = _targets.sum()/_targets.size(); + + _tcov_part.resize(_targets.size()); + _tcov_part = _targets; + _tcov_part -= _tmean; + + std::valarray tmp = _tcov_part; + tmp = _tcov_part; + tmp *= tmp; + + _tvar = tmp.sum() / (tmp.size()-1); + _tstd = sqrt(_tvar); + _tmed = 0; +} + +TargetInfo::TargetInfo(const std::valarray& t, const std::valarray& w) { + + _targets.resize(t.size()); + _weights.resize(w.size()); + + _targets = t; + _weights = w; + + double sumw = _weights.sum(); + // scale weights so that they'll add up to 1 + _weights /= sumw; + + _tmean = (_targets * _weights).sum(); + _tcov_part.resize(_targets.size()); + _tcov_part = _targets; + _tcov_part -= _tmean; + + _tvar = (pow(_targets - _tmean, 2.0) * _weights).sum(); + _tstd = sqrt(_tvar); + _tmed = 0.; +} + +// calculate the members, now in the context of a mask +void TargetInfo::set_training_mask(const std::valarray& tmask) { + + TargetInfo tmp; + + if (has_weights() ) { + tmp = TargetInfo( _targets[tmask], _weights[tmask]); + } else { + tmp = TargetInfo( _targets[tmask] ); + } + + _tcov_part.resize(tmp._tcov_part.size()); + _tcov_part = tmp._tcov_part; + + _tmean = tmp._tmean; + _tvar = tmp._tvar; + _tstd = tmp._tstd; + _tmed = tmp._tmed; + + _training_mask.resize(tmask.size()); + _training_mask = tmask; +} + +struct SortOnTargets +{ + const valarray& t; + SortOnTargets(const valarray& v) : t(v) {} + + bool operator()(int i, int j) const { + return fabs(t[i]) < fabs(t[j]); + } +}; + +vector TargetInfo::sort() { + + vector ind(_targets.size()); + for (unsigned i = 0; i < ind.size(); ++i) { ind[i] = i; } + + std::sort(ind.begin(), ind.end(), SortOnTargets(_targets)); + + valarray tmptargets = _targets; + valarray tmpweights = _weights; + valarray tmpcov = _tcov_part; + + for (unsigned i = 0; i < ind.size(); ++i) + { + _targets[i] = tmptargets[ ind[i] ]; + _tcov_part[i] = tmpcov[ ind[i] ]; + if (_weights.size()) _weights[i] = tmpweights[ ind[i] ]; + } + + return ind; +} + + + diff --git a/eo/contrib/mathsym/regression/TargetInfo.h b/eo/contrib/mathsym/regression/TargetInfo.h new file mode 100644 index 00000000..ee9a307f --- /dev/null +++ b/eo/contrib/mathsym/regression/TargetInfo.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef TARGETINFO_H_ +#define TARGETINFO_H_ + +#include +#include + +class TargetInfo { + std::valarray _targets; + std::valarray _weights; + std::valarray _training_mask; + + // some stuff for ols + std::valarray _tcov_part; + double _tmean; + double _tvar; + double _tstd; + double _tmed; + + public: + TargetInfo() {} + + TargetInfo(const std::valarray& t); + TargetInfo(const std::valarray& t, const std::valarray& w); + + TargetInfo(const TargetInfo& org); + TargetInfo& operator=(const TargetInfo& org); + ~TargetInfo() {} + + const std::valarray& targets() const { return _targets; } + const std::valarray& weights() const { return _weights; } + const std::valarray& mask() const { return _training_mask; } + + void set_training_mask(const std::valarray& mask); + + bool has_weights() const { return _weights.size(); } + bool has_mask() const { return _training_mask.size(); } + + std::vector sort(); + + const std::valarray& tcov_part() const { return _tcov_part; } + double tmean() const { return _tmean; } + double tvar() const { return _tvar; } + double tstd() const { return _tstd; } + double devmedian() const { return _tmed; } +}; + +#endif + diff --git a/eo/contrib/mathsym/shared_ptr.h b/eo/contrib/mathsym/shared_ptr.h new file mode 100644 index 00000000..58353fe9 --- /dev/null +++ b/eo/contrib/mathsym/shared_ptr.h @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _SHARED_PTR_H +#define _SHARED_PTR_H + + +template class weak_ptr; + +template +class shared_ptr { + private: + T* ptr; + unsigned* count; // + + /* special case, null pointer (nil-code) */ + static unsigned* nil() { static unsigned nil_counter(1); return &nil_counter; } + + void decref() { if (--(*count) == 0) { delete ptr; delete count; }} + void incref() { ++(*count); } + + friend class weak_ptr; + + public: + + shared_ptr() : ptr(0), count(nil()) { incref(); } + ~shared_ptr() { decref(); } + + shared_ptr(const shared_ptr& o) : ptr(o.ptr), count(o.count) { incref(); } + shared_ptr(T* p) : ptr(p), count(new unsigned(1)) {} + explicit shared_ptr(const weak_ptr& w) : ptr(w.ptr), count(w.count) { incref(); } + + shared_ptr& operator=(const shared_ptr& o) { + if (ptr == o.ptr) return *this; + decref(); + ptr = o.ptr; + count = o.count; + incref(); + return *this; + } + + T* get() { return ptr; } + T* operator->() { return ptr; } + T& operator*() { return *ptr; } + + const T* get() const { return ptr; } + const T* operator->() const { return ptr; } + const T& operator*() const { return *ptr; } + + bool operator==(const shared_ptr& o) const { return ptr == o.ptr; } + bool operator!=(const shared_ptr& o) const { return ptr != o.ptr; } + bool operator<(const shared_ptr& o) const { return ptr < o.ptr; } + + unsigned refcount() const { return *count; } +}; + +template +class weak_ptr { + T* ptr; + unsigned* count; + + friend class shared_ptr; + + public: + + weak_ptr() : ptr(0), count(shared_ptr::nil()) {} + explicit weak_ptr( const shared_ptr& s) : ptr(s.ptr), count(s.count) {} + + shared_ptr lock() const { return shared_ptr(*this); } + + + T* get() { return ptr; } + T* operator->() { return ptr; } + T& operator*() { return *ptr; } + + const T* get() const { return ptr; } + const T* operator->() const { return ptr; } + const T& operator*() const { return *ptr; } + + bool operator==(const shared_ptr& o) const { return ptr == o.ptr; } + bool operator!=(const shared_ptr& o) const { return ptr != o.ptr; } + bool operator<(const shared_ptr& o) const { return ptr < o.ptr; } + + unsigned refcount() const { return *count; } + +}; + +#endif diff --git a/eo/contrib/mathsym/sym/README.cpp b/eo/contrib/mathsym/sym/README.cpp new file mode 100644 index 00000000..c62e6cba --- /dev/null +++ b/eo/contrib/mathsym/sym/README.cpp @@ -0,0 +1,364 @@ + +/* + DESCRIPTION: + + +The class 'Sym' in this package provides a reference counted, hashed tree structure that can be used in genetic programming. +The hash table behind the scenes makes sure that every subtree in the application is stored only once. +This has a couple of advantages: + +o Memory: all subtrees are stored only once +o Comparison: comparison for equality for two subtrees boils down to a pointer comparison +o Overview: by accessing the hashtable, you get an instant overview of the state of the population + + +The disadvantage of this method is the constant time overhead for computing hashes. In practice, +it seems to be fast enough. + + +===== How to Use this ========= + +In essence, the Sym data structure contains two important pieces of data, +the 'token' (of type token_t = int) and the children, a vector of Sym (called SymVec). +The token should contain all information to be able to figure out which +function/terminal is represented by the node in the tree. By retrieving this token value +and the SymVec it is possible to write recursive traversal routines for evaluation, printing, +etc. + +*/ + +#include +#include "Sym.h" + +using namespace std; + + +/* + * Suppose token value '0' designates our terminal, and token value '1' designates a binary function. + * Later on a ternary function will be used as well, designated with token value '2' + * The function below will create a tree of size three +*/ +Sym test1() { + + SymVec children; + children.push_back( Sym(0) ); // push_back is a member from std::vector, SymVec is derived from std::vector + children.push_back( Sym(0) ); + + Sym tree = Sym(token_t(1), children); // creates the tree + + /* Done, now print some information about the node */ + + cout << "Size = " << tree.size() << endl; // prints 3 + cout << "Depth = " << tree.depth() << endl; // prints 2 + cout << "Refcount = " << tree.refcount() << endl; // prints 1 + + Sym tree2 = tree; // make a copy (this only changes refcount) + + cout << "Refcount now = " << tree.refcount() << endl; // print 2 + + return tree; // tree2 will be deleted and reference count returns to 1 +} + +/* To actually use the tree, evaluate it, the following simple recursive function + * can be used +*/ + +int eval(const Sym& sym) { + if (sym.token() == 0) { // it's a terminal in this example + return 1; + } + // else it's the function + const SymVec& children = sym.args(); // get the children out, children.size() is the arity + + // let's assume that we've also got a ternary function designated by token '2' + + if (sym.token() == token_t(1)) + return eval(children[0]) + eval(children[1]); // evaluate + + return eval(children[0]) + eval(children[1]) * eval(children[2]); // a ternary function +} + +/* Note that you simply use the stored token that was defined above. Simply checking the size of SymVec in + * this particular example could have sufficed, but it's instructive to use the tokens. + * + * And to test this: +*/ + +void test_eval() { + + Sym tree = test1(); + + cout << "Evaluating tree1 returns " << eval(tree) << endl; +} + +/* Writing initialization functions. + * + * As the Sym class is recursive in nature, initialization can simply be done using + * recursive routines as above. As an example, the following code does 'full' initialization. + */ + +Sym init_full(int depth_left) { + if (depth_left == 0) return Sym(0); // create terminal + // else create either a binary or a ternary function + + depth_left--; + + if (rand() % 2 == 0) { // create binary + SymVec vec(2); + vec[0] = init_full(depth_left); + vec[1] = init_full(depth_left); + + return Sym(token_t(1), vec); + + } else { // create ternary tree + SymVec vec(3); + vec[0] = init_full(depth_left); + vec[1] = init_full(depth_left); + vec[2] = init_full(depth_left); + + return Sym(token_t(2), vec); // token value 2 designates a ternary now, even though the arity can simply be read from the size of the 'SymVec' + } + +} + + +/* Examining the hash table. + * + * The hash table is a static member of the Sym class, but can be obtained and inspected + * at any point during the run. The hash table follows the SGI implementation of hashmap (and effectively + * uses it in gcc). An example: + */ + +void inspect_hashtable() { + SymMap& dag = Sym::get_dag(); // get the hashmap + unsigned i = 0; + for (SymMap::iterator it = dag.begin(); it != dag.end(); ++it) { + Sym node(it); // initialize a 'sym' with the iterator + + cout << "Node " << i++ << " size " << node.size(); + cout << " refcount " << node.refcount()-1; // -1: note that by creating the Sym above the refcount is increased + cout << " depth " << node.depth(); + cout << '\n'; + } + +} + +/* The above code effectively examines all distinct subtrees in use in the application and prints some stats for the node */ + +/* Manipulating trees + * + * The Sym class is set up in such a way that you cannot change a Sym, so how do you perform crossover and mutation? + * + * Simple, you create new syms. The Sym class supports two functions to make this easier: 'get_subtree' and 'insert_subtree'. + * These traverse the tree by index, where 0 designates the root and other values are indexed depth first. + */ + +Sym subtree_xover(Sym a, Sym b) { + + Sym to_insert = get_subtree(a, rand() % a.size() ); // select random subtree, will crash if too high a value is given + + /* 'insert' it into b. This will not really insert, it will however create a new sym, + * equal to 'b' but with a's subtree inserted at the designated spot. */ + return insert_subtree(b, rand() % b.size(), to_insert); + +} + +/* Tying it together, we can create a simple genetic programming system. Mutation is not implemented here, + * but would be easy enough to add by using recursion and/or 'set'. */ + +void run_gp() { + + int ngens = 50; + int popsize = 1000; + + cout << "Starting running " << popsize << " individuals for " << ngens << " generations." << endl; + + vector pop(popsize); + + // init population + for (unsigned i = 0; i < pop.size(); ++i) { + pop[i] = init_full(5); + } + + double best = 0.0; + + // do a very simple steady state tournament + for (unsigned gen = 0; gen < ngens * pop.size(); ++gen) { + int sel1 = rand()% pop.size(); + int sel2 = rand() % pop.size(); + int sel3 = rand() % pop.size(); + + double ev1 = eval(pop[sel1]); + double ev3 = eval(pop[sel3]); + + double bst = max(ev1,ev3); + if (bst > best) { + best = bst; + } + + if (ev3 > ev1) { + sel1 = sel3; // selection pressure + } + + Sym child = subtree_xover(pop[sel1], pop[sel2]); + + // Check for uniqueness + if (child.refcount() == 1) pop[ rand() % pop.size() ] = child; + } + + // and at the end: + + inspect_hashtable(); + + // and also count number of nodes in the population + int sz = 0; + for (unsigned i = 0; i < pop.size(); ++i) { sz += pop[i].size(); } + cout << "Number of distinct nodes " << Sym::get_dag().size() << endl; + cout << "Nodes in population " << sz << endl; + cout << "ratio " << double(Sym::get_dag().size())/sz << endl; + cout << "Best fitness " << best << endl; + +} + +/* One extra mechanism is supported to add annotations to nodes. Something derived from + * 'UniqueNodeStats' can be used to attach new information to nodes. For this to function, + * we need to supply a 'factory' function that creates these node-stats; attach this function to the + * Sym class, so that it gets called whenever a new node is created. The constructors of the Sym class + * take care of this. + * + * IMPORTANT: + * in a realistic application, the factory function needs to be set BEFORE any Syms are created + * Mixing Syms creating with and without the factory can lead to unexpected results + * + * First we derive some structure from UniqueNodeStats: */ + +struct MyNodeStats : public UniqueNodeStats { + + int sumsize; + + ~MyNodeStats() { cout << "MyNodeStats::~MyNodeStats, sumsize = " << sumsize << endl; } +}; + +/* then define the factory function. It will get a Sym, which is just created. */ +UniqueNodeStats* create_stats(const Sym& sym) { + MyNodeStats* stats = new MyNodeStats; // Sym will take care of memory management + + int sumsize = sym.size(); + for (unsigned i = 0; i < sym.args().size(); ++i) { + // retrieve the extra node stats of the child + UniqueNodeStats* unique_stats = sym.args()[i].extra_stats(); // extra_stats retrieves the stats + MyNodeStats* child_stats = static_cast(unique_stats); // cast it to the right struct + sumsize += child_stats->sumsize; + } + + stats->sumsize = sumsize; + return stats; // now it will get attached to the node and deleted when its reference count goes to zero +} + +void test_node_stats() { + + if (Sym::get_dag().size() != 0) { + cerr << "Cannot mix nodes with and without factory functions" << endl; + exit(1); + } + + /* Very Important: attach the factory function to the Sym class */ + Sym::set_factory_function(create_stats); + + Sym tree = init_full(5); // create a tree + + // get extra node stats out + MyNodeStats* stats = static_cast( tree.extra_stats() ); + + cout << "Size = " << tree.size() << " SumSize = " << stats->sumsize << endl; + + Sym::clear_factory_function(); // reset +} + + +/* And run the code above */ + +int main() { + srand(time(0)); + cout << "********** TEST EVALUATION **************\n"; + test_eval(); + cout << "********** TEST ALGORITHM ***************\n"; + run_gp(); + + cout << "********** TEST FACTORY ****************\n"; + test_node_stats(); // can work because there are no live nodes + +} + +/* ********** Member function reference: ******************** + * + * Sym() The default constructor will create an undefined node (no token and no children), check for empty() to see if a node is undefined + * + * Sym(token_t) Create a terminal + * + * Sym(token_t, const SymVec&) + * Create a node with token and SymVec as the children + * + * Sym(SymIterator it) + * Create a sym from an iterator (taken from the hashtable directly, or from Sym::iterator) + * + * dtor, copy-ctor and assignment + * + * UniqueNodeStats* extra_stats() + * Returns an UniqueNodeStats pointer (= 0 if no factory is defined) + * + * + * int hashcode() returns the hashcode for the node + * + * int refcount() returns the reference count for the node + * + * bool operator== checks for equality (note that this is a pointer compare, really really fast) + * + * bool empty() returns whether the node is undefined, i.e. created through the default ctor + * + * int arity() shorthand for sym.args().size() + * + * token_t token() return identifying token for the node + * + * const SymVec& args() + * returns the children of the node (in a vector) + * + * unsigned size() returns the size, i.e., number of nodes + * + * unsigned depth() returns the depth + * + * iterator() returns the pointer to the node in the hashtable + * + * + ********** Static functions: ******************** + * + * + * + * SymMap& get_dag() returns the hash table containing all nodes. This should only be used for inspection, + * even though the dag itself is not const. This to enable the use of the ctor Sym(SymIterator) to inspect + * using the Sym interface (rather than the hash table interface). This does allow you to make destructive + * changes to the class, so use with care + * + * set_factory_function( UniqueNodeStats (*)(const Sym&) ) + * Set the factory function + * + * clear_factory_function() + * Clears the factory function, allocated UniqueNodeStats will still be deleted, but no new ones will be created. + * + ********** Utility Functions ******************** + * + * Sym get_subtree(const Sym& org, int i) + * Retreive the i-th subtree from the Sym. Standard depth first ordering, where root has index 0 and the + * rightmost terminal has index sym.size()-1 + * + * Sym insert_subtree(const Sym& org, int i, const Sym& subtree) + * Returns a Sym that is equal to 'org', for which the i-th subtree (same ordering as get_subtree) is replaced + * by the third argument subtree. + * + * Sym next(const Sym&) + * Returns the successor of the argument sym from the hashtable with wrap around. This is implemented just because + * it can be done. It may be an interesting way to mutate... + * + * */ + + diff --git a/eo/contrib/mathsym/sym/Sym.cpp b/eo/contrib/mathsym/sym/Sym.cpp new file mode 100644 index 00000000..b426e111 --- /dev/null +++ b/eo/contrib/mathsym/sym/Sym.cpp @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include + +#include "Sym.h" + +using namespace std; + +typedef UniqueNodeStats* (*NodeStatFunc)(Sym&); + +UniqueNodeStats* (*Sym::factory)(const Sym&) = 0; + +void (*Sym::extra_dtor)(token_t) = 0; + +SymMap Sym::dag(100000); // reserve space for so many nodes + +size_t get_size(const SymVec& vec) { + size_t sz = 0; + for (unsigned i = 0; i < vec.size(); ++i) { + sz += vec[i].size(); + } + return sz; +} + +size_t get_depth(const SymVec& vec) { + size_t dp = 1; + for (unsigned i = 0; i < vec.size(); ++i) { + dp = std::max(dp, vec[i].depth()); + } + return dp; +} + +Sym::Sym(token_t tok, const SymVec& args_) +{ + detail::SymKey key(tok, detail::SymArgs(args_)); + detail::SymValue val; + + node = dag.insert(pair(key, val)).first; + + if (__unchecked_refcount() == 0) { // new node, set some stats + node->second.size = 1 + get_size(args_); + node->second.depth = 1 + get_depth(args_); + incref(); + node->first.fixate(); + // call the factory function if available + if (factory) node->second.uniqueNodeStats = factory(*this); + } + else incref(); +} + +Sym::Sym(token_t tok, const Sym& a) { + SymVec args_; args_.push_back(a); + detail::SymKey key(tok, detail::SymArgs(args_)); + detail::SymValue val; + + node = dag.insert(pair(key, val)).first; + + if (__unchecked_refcount() == 0) { // new node, set some stats + node->second.size = 1 + get_size(args_); + node->second.depth = 1 + get_depth(args_); + incref(); + node->first.fixate(); + // call the factory function if available + if (factory) node->second.uniqueNodeStats = factory(*this); + } + else incref(); +} + +Sym::Sym(token_t tok) { + detail::SymKey key(tok); + detail::SymValue val; + node = dag.insert(pair(key, val)).first; + + if (__unchecked_refcount() == 0) { // new node, set some stats + node->second.size = 1; + node->second.depth = 1; + incref(); + + // call the factory function if available + if (factory) node->second.uniqueNodeStats = factory(*this); + } + else incref(); +} + +std::pair insert_subtree_impl(const Sym& cur, size_t w, const Sym& nw) { + if (w-- == 0) return make_pair(nw, !(nw == cur)); + + const SymVec& vec = cur.args(); + std::pair result; + unsigned i; + + for (i = 0; i < vec.size(); ++i) { + if (w < vec[i].size()) { + result = insert_subtree_impl(vec[i], w, nw); + if (result.second == false) return std::make_pair(cur, false); // unchanged + break; + } + w -= vec[i].size(); + } + SymVec newvec = cur.args(); + newvec[i] = result.first; + return make_pair(Sym(cur.token(), newvec), true); +} + +Sym insert_subtree(const Sym& cur, size_t w, const Sym& nw) { + return insert_subtree_impl(cur,w,nw).first; +} +Sym get_subtree(const Sym& cur, size_t w) { + if (w-- == 0) return cur; + + const SymVec& vec = cur.args(); + for (unsigned i = 0; i < vec.size(); ++i) { + if (w < vec[i].size()) return get_subtree(vec[i], w); + w-=vec[i].size(); + } + return cur; +} + + diff --git a/eo/contrib/mathsym/sym/Sym.h b/eo/contrib/mathsym/sym/Sym.h new file mode 100644 index 00000000..0bf46bf0 --- /dev/null +++ b/eo/contrib/mathsym/sym/Sym.h @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYMNODE_H_ +#define SYMNODE_H_ + +#include + +#if __GNUC__ == 3 +#include +#else +#include +using std::hash_map; +#endif + +/* Empty 'extra statistics' structure, derive from this to keep other characteristics of nodes */ +struct UniqueNodeStats { virtual ~UniqueNodeStats(){} }; + +#include "SymImpl.h" +#include "token.h" + +typedef hash_map SymMap; +typedef SymMap::iterator SymIterator; +class Sym; + +typedef std::vector SymVec; + +/* Sym is the tree, for which all the nodes are stored in a hash table. + * This makes checking for equality O(1) */ + +class Sym +{ + public: + + Sym() : node(dag.end()) {} + explicit Sym(token_t token, const SymVec& args); + explicit Sym(token_t token, const Sym& args); + explicit Sym(token_t var); + + explicit Sym(SymIterator it) : node(it) { incref(); } + + Sym(const Sym& oth) : node(oth.node) { incref(); } + ~Sym() { decref(); } + + const Sym& operator=(const Sym& oth) { + if (oth.node == node) return *this; + decref(); + node = oth.node; + incref(); + return *this; + } + + /* Unique Stats are user defined */ + UniqueNodeStats* extra_stats() const { return empty()? 0 : node->second.uniqueNodeStats; } + + int hashcode() const { detail::SymKey::Hash hash; return hash(node->first); } + + // Friends, need to touch the node + friend struct detail::SymKey::Hash; + friend struct detail::SymKey; + + unsigned refcount() const { return empty()? 0: node->second.refcount; } + + bool operator==(const Sym& other) const { + return node == other.node; + } + bool operator!=(const Sym& other) const { return !(*this == other); } + + bool empty() const { return node == dag.end(); } + + /* Support for traversing trees */ + unsigned arity() const { return node->first.arity(); } + token_t token() const { assert(!empty()); return node->first.token; } + + const SymVec& args() const { return node->first.vec(); } + + /* size() - depth */ + unsigned size() const { return empty()? 0 : node->second.size; } + unsigned depth() const { return empty()? 0 : node->second.depth; } + + SymMap::iterator iterator() const { return node; } + + /* Statics accessing some static members */ + static SymMap& get_dag() { return dag; } + + /* This function can be set to create some UniqueNodeStats derivative that can contain extra stats for a node, + * it can for instance be used to create ERC's and what not. */ + static void set_factory_function(UniqueNodeStats* (*f)(const Sym&)) { factory=f; } + static void clear_factory_function() { factory = 0; } + + static void set_extra_dtor( void (*extra)(token_t) ) { extra_dtor = extra; } + + unsigned address() const { return reinterpret_cast(&*node); } + + private : + + // implements getting subtrees + Sym private_get(size_t w) const; + + unsigned __unchecked_refcount() const { return node->second.refcount; } + + void incref() { + if (!empty()) + ++(node->second.refcount); + } + void decref() { + if (!empty() && --(node->second.refcount) == 0) { + if (extra_dtor) { + extra_dtor(token()); + } + dag.erase(node); + } + } + + // The one and only data member, an iterator into the static map below + SymIterator node; + + // A static hash_map that contains all live nodes.. + static SymMap dag; + + // Factory function for creating extra node stats, default will be 0 + static UniqueNodeStats* (*factory)(const Sym&); + + static void (*extra_dtor)(token_t); + +}; + +/* Utility hash functor for syms */ +class HashSym { + public: + int operator()(const Sym& sym) const { return sym.hashcode(); } +}; + +/* Utility Functions */ + +// get_subtree retrieves a subtree by standard ordering (0=root, and then depth first) +Sym get_subtree(const Sym& org, size_t w); + +// insert_subtree uses the same ordering as get and inserts the second argument, returning a new tree +Sym insert_subtree(const Sym& org, size_t w, const Sym& nw); + +/* Get the successor from the hashtable, no particular purpose other than an interesting way to mutate */ +inline Sym next(const Sym& sym) { + SymIterator it = sym.iterator(); + ++it; + if (it == Sym::get_dag().end()) it = Sym::get_dag().begin(); + return Sym(it); +} + +#endif diff --git a/eo/contrib/mathsym/sym/SymImpl.cpp b/eo/contrib/mathsym/sym/SymImpl.cpp new file mode 100644 index 00000000..a0f3d701 --- /dev/null +++ b/eo/contrib/mathsym/sym/SymImpl.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include "Sym.h" + +using namespace std; +namespace detail { + +class SymArgsImpl { + public: + vector owned_args; +}; + +size_t SymArgs::len() const { + return vec().size(); +} + +SymArgs::SymArgs() : pimpl( new SymArgsImpl ) { + args_ptr = &pimpl->owned_args; +} + +SymArgs::SymArgs(const std::vector& v) : pimpl(0) { + args_ptr = &v; +} + +SymArgs::~SymArgs() { + delete pimpl; +} + +SymArgs::SymArgs(const SymArgs& args) : pimpl(0), args_ptr(args.args_ptr) { + if (args.pimpl && args.args_ptr == &args.pimpl->owned_args) { + pimpl = new SymArgsImpl(*args.pimpl); + args_ptr = &pimpl->owned_args; + } +} + +const SymArgs& SymArgs::operator=(const SymArgs& args) { + if (args.pimpl && args.args_ptr == &args.pimpl->owned_args) { + pimpl = new SymArgsImpl(*args.pimpl); + args_ptr = &pimpl->owned_args; + } else { + args_ptr = args.args_ptr; + } + + return *this; +} + +void SymArgs::fixate() const { + assert(pimpl == 0); + pimpl = new SymArgsImpl; + pimpl->owned_args = *args_ptr; + args_ptr = &pimpl->owned_args; +} + +// For Tackett's hashcode +#define PRIMET 21523 +#define HASHMOD 277218551 + +const int nprimes = 4; +const unsigned long primes[] = {3221225473ul, 201326611ul, 1610612741ul, 805306457ul}; + +int SymKey::calc_hash() const { + unsigned long hash = unsigned(token); + hash *= PRIMET; + + const SymVec& v = args.vec(); + for (unsigned i = 0; i < v.size(); ++i) { + hash += ( (v[i].address() >> 3) * primes[i%nprimes]) % HASHMOD; + } + + return hash;// % HASHMOD; +} + +bool SymKey::operator==(const SymKey& other) const { + if (token != other.token) return false; + return args.vec() == other.args.vec(); +} + +/* Just to store this info somewhere: + * + * Address Based Hash Function Implementation + * uint32 address_hash(char* addr) + * { + * register uint32 key; + * key = (uint32) addr; + * return (key >> 3) * 2654435761; + * } + */ + +SymValue::SymValue() : refcount(0), size(0), depth(0), uniqueNodeStats(0) {} + +SymValue::~SymValue() { delete uniqueNodeStats; } + + + +} // namespace detail diff --git a/eo/contrib/mathsym/sym/SymImpl.h b/eo/contrib/mathsym/sym/SymImpl.h new file mode 100644 index 00000000..bc3538fb --- /dev/null +++ b/eo/contrib/mathsym/sym/SymImpl.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef __SYM_IMPL_H__ +#define __SYM_IMPL_H__ + +#include + +#include "token.h" + +class Sym; +namespace detail { + +class SymArgsImpl; +class SymArgs { + + mutable SymArgsImpl* pimpl; // contains circular reference to vector + mutable const std::vector* args_ptr; + + public: + + SymArgs(); + SymArgs(const std::vector& v); + ~SymArgs(); + + SymArgs(const SymArgs& args); + const SymArgs& SymArgs::operator=(const SymArgs& other); + + size_t len() const; + const std::vector& vec() const { return *args_ptr; } + void fixate() const; +}; + +class SymKey +{ + public: + SymKey(token_t _token) : args(), token(_token) {} + SymKey(token_t _token, const detail::SymArgs& _args) : args(_args), token(_token) {} + + + private: + detail::SymArgs args; + public: + bool operator==(const SymKey& other) const; + + struct Hash + { + int operator()(const SymKey& k) const { return k.calc_hash(); }; + }; + + unsigned arity() const { return args.len(); } + const std::vector& vec() const { return args.vec(); } + + token_t token; // identifies the function + + // fixates (i.e. claims memory) for the embedded vector of Syms + void fixate() const { args.fixate(); } + + private: + int calc_hash() const; +}; + +struct SymValue +{ + friend class Sym; + + SymValue(); + ~SymValue(); + + unsigned getRefCount() const { return refcount; } + unsigned getSize() const { return size; } + unsigned getDepth() const { return depth; } + + private : + + // for reference counting + unsigned refcount; + + // some simple stats + unsigned size; + unsigned depth; + + UniqueNodeStats* uniqueNodeStats; +}; + + +} // namespace detail + +#endif + diff --git a/eo/contrib/mathsym/sym/token.h b/eo/contrib/mathsym/sym/token.h new file mode 100644 index 00000000..68008959 --- /dev/null +++ b/eo/contrib/mathsym/sym/token.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef TOKEN_H +#define TOKEN_H + + +typedef unsigned token_t; + +struct functor_t { + token_t token; + unsigned arity; +}; + +#endif diff --git a/eo/contrib/mathsym/symreg.cpp b/eo/contrib/mathsym/symreg.cpp new file mode 100644 index 00000000..ee114964 --- /dev/null +++ b/eo/contrib/mathsym/symreg.cpp @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +using namespace std; + +typedef EoSym EoType; + +static int functions_added = 0; + +void add_function(LanguageTable& table, eoParser& parser, string name, unsigned arity, token_t token, const FunDef& fun); +void setup_language(LanguageTable& table, eoParser& parser); + +template +T& select(bool check, T& a, T& b) { if (check) return a; return b; } + +class eoBestIndividualStat : public eoSortedStat { + public: + eoBestIndividualStat() : eoSortedStat("", "best individual") {} + + void operator()(const vector& _pop) { + ostringstream os; + os << (Sym) *_pop[0]; + value() = os.str(); + } + +}; + +class AverageSizeStat : public eoStat { + public: + AverageSizeStat() : eoStat(0.0, "Average size population") {} + + void operator()(const eoPop& _pop) { + double total = 0.0; + for (unsigned i = 0; i < _pop.size(); ++i) { + total += _pop[i].size(); + } + value() = total/_pop.size(); + } +}; + +class SumSizeStat : public eoStat { + public: + SumSizeStat() : eoStat(0u, "Number of subtrees") {} + + void operator()(const eoPop& _pop) { + unsigned total = 0; + for (unsigned i = 0; i < _pop.size(); ++i) { + total += _pop[i].size(); + } + value() = total; + } +}; + +class DagSizeStat : public eoStat { + public: + DagSizeStat() : eoStat(0u, "Number of distinct subtrees") {} + + void operator()(const eoPop& _pop) { + value() = Sym::get_dag().size(); + } +}; + +int main(int argc, char* argv[]) { + + eoParser parser(argc, argv); + + /* Language */ + LanguageTable table; + setup_language(table, parser); + + /* Data */ + + eoValueParam datafile = parser.createParam(string(""), "datafile", "Training data", 'd', string("Regression"), true); // mandatory + double train_percentage = parser.createParam(1.0, "trainperc", "Percentage of data used for training", 0, string("Regression")).value(); + + /* Population */ + + unsigned pop_size = parser.createParam(1500u, "population-size", "Population Size", 'p', string("Population")).value(); + + uint32_t seed = parser.createParam( uint32_t(time(0)), "random-seed", "Seed for rng", 'D').value(); + + cout << "Seed " << seed << endl; + rng.reseed(seed); + + double var_prob = parser.createParam( + 0.9, + "var-prob", + "Probability of selecting a var vs. const when creating a terminal", + 0, + "Population").value(); + + + double grow_prob = parser.createParam( + 0.5, + "grow-prob", + "Probability of selecting 'grow' method instead of 'full' in initialization and mutation", + 0, + "Population").value(); + + unsigned max_depth = parser.createParam( + 8u, + "max-depth", + "Maximum depth used in initialization and mutation", + 0, + "Population").value(); + + + bool use_uniform = parser.createParam( + false, + "use-uniform", + "Use uniform node selection instead of bias towards internal nodes (functions)", + 0, + "Population").value(); + + + double subtree_mut_prob = parser.createParam( + 0.2, + "subtree-mut-rate", + "Probability of performing subtree mutation", + 0, + "Population").value(); + + double node_mut_prob = parser.createParam( + 0.2, + "node-mut-rate", + "Probability of performing node mutation", + 0, + "Population").value(); + + double subtree_xover_prob = parser.createParam( + 0.4, + "xover-rate", + "Probability of performing subtree crossover", + 0, + "Population").value(); + + double homologous_prob = parser.createParam( + 0.4, + "homologous-rate", + "Probability of performing homologous crossover", + 0, + "Population").value(); + + unsigned max_gens = parser.createParam( + 50, + "max-gens", + "Maximum number of generations to run", + 'g', + "Population").value(); + + unsigned tournamentsize = parser.createParam( + 5, + "tournament-size", + "Tournament size used for selection", + 't', + "Population").value(); + + unsigned meas_param = parser.createParam( + 2u, + "measure", + "Error measure:\n\ + 0 -> absolute error\n\ + 1 -> mean squared error\n\ + 2 -> mean squared error scaled (equivalent with correlation)\n\ + ", + 'm', + "Regression").value(); + + ErrorMeasure::measure meas = ErrorMeasure::mean_squared_scaled; + if (meas_param == 0) meas = ErrorMeasure::absolute; + if (meas_param == 1) meas = ErrorMeasure::mean_squared; + + + if (functions_added == 0) { + cout << "ERROR: no functions defined" << endl; + exit(1); + } + + /* End parsing */ + if (parser.userNeedsHelp()) + { + parser.printHelp(std::cout); + return 1; + } + + Dataset dataset; + dataset.load_data(datafile.value()); + + cout << "Data " << datafile.value() << " loaded " << endl; + + /* Add Variables */ + unsigned nvars = dataset.n_fields(); + for (unsigned i = 0; i < nvars; ++i) { + table.add_function( SymVar(i).token(), 0); + } + + TreeBuilder builder(table, var_prob); + eoSymInit init(builder, grow_prob, max_depth); + + eoPop pop(pop_size, init); + + BiasedNodeSelector biased_sel; + RandomNodeSelector random_sel; + + NodeSelector& node_selector = select(use_uniform, random_sel, biased_sel); + + eoProportionalOp genetic_operator; + + eoSymSubtreeMutate submutate(builder, node_selector); + genetic_operator.add( submutate, subtree_mut_prob); + + eoSymNodeMutate nodemutate(table); + genetic_operator.add(nodemutate, node_mut_prob); + + //eoQuadSubtreeCrossover quad(node_selector); + eoBinSubtreeCrossover bin(node_selector); + genetic_operator.add(bin, subtree_xover_prob); + + eoBinHomologousCrossover hom; + genetic_operator.add(hom, homologous_prob); + + + IntervalBoundsCheck check(dataset.input_minima(), dataset.input_maxima()); + ErrorMeasure measure(dataset, train_percentage, meas); + + eoSymPopEval evaluator(check, measure); + + eoDetTournamentSelect selectOne(tournamentsize); + eoGeneralBreeder breeder(selectOne, genetic_operator); + eoPlusReplacement replace; + + // Terminators + eoGenContinue term(max_gens); + eoCheckPoint checkpoint(term); + + eoBestFitnessStat beststat; + checkpoint.add(beststat); + + eoBestIndividualStat printer; + AverageSizeStat avgSize; + DagSizeStat dagSize; + SumSizeStat sumSize; + + checkpoint.add(printer); + checkpoint.add(avgSize); + checkpoint.add(dagSize); + checkpoint.add(sumSize); + + eoStdoutMonitor genmon; + genmon.add(beststat); + genmon.add(printer); + genmon.add(avgSize); + genmon.add(dagSize); + genmon.add(sumSize); + + checkpoint.add(genmon); + + eoPop dummy; + evaluator(pop, dummy); + + eoEasyEA ea(checkpoint, evaluator, breeder, replace); + + ea(pop); // run + +} + +void add_function(LanguageTable& table, eoParser& parser, string name, unsigned arity, token_t token, const FunDef& fun, bool all) { + ostringstream desc; + desc << "Enable function " << name << " arity = " << arity; + bool enabled = parser.createParam(false, name, desc.str(), 0, "Language").value(); + + if (enabled || all) { + cout << "Func " << name << " enabled" << endl; + table.add_function(token, arity); + if (arity > 0) functions_added++; + } +} + +void setup_language(LanguageTable& table, eoParser& parser) { + + bool all = parser.createParam(false,"all", "Enable all functions").value(); + bool ratio = parser.createParam(false,"ratio","Enable rational functions (inv,min,sum,prod)").value(); + bool poly = parser.createParam(false,"poly","Enable polynomial functions (min,sum,prod)").value(); + + // assumes that at this point all tokens are defined (none are zeroed out, which can happen with ERCs) + vector lang = get_defined_functions(); + + for (token_t i = 0; i < lang.size(); ++i) { + + if (lang[i] == 0) continue; + + bool is_poly = false; + if (poly && (i == prod_token || i == sum_token || i == min_token) ) { + is_poly = true; + } + + bool is_ratio = false; + if (ratio && (is_poly || i == inv_token)) { + is_ratio = true; + } + + const FunDef& fun = *lang[i]; + + if (fun.has_varargs() ) { + + for (unsigned j = fun.min_arity(); j < fun.min_arity() + 8; ++j) { + if (j==1) continue; // prod 1 and sum 1 are useless + ostringstream nm; + nm << fun.name() << j; + bool addanyway = (all || is_ratio || is_poly) && j == 2; + add_function(table, parser, nm.str(), j, i, fun, addanyway); + } + } + else { + add_function(table, parser, fun.name(), fun.min_arity(), i, fun, all || is_ratio || is_poly); + } + } +} + + diff --git a/eo/contrib/mathsym/tcc.tar.gz b/eo/contrib/mathsym/tcc.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5b935473328f928c39320b732179e76b5868aab8 GIT binary patch literal 427170 zcmV(=K-s?^iwFRR_e4Vg1MFLEbK^LU?$7xZ+?}e8-Qzfx{N6o1Q;y>#o_6ekVuF){5bir2zD*f4kl4wAu};3I1={-Od}<_$`zzi4?`#MfJ{&> zw?WGGNxVs%9fKeJgmae0e)ixb{5^Y$bLKh`OSl)LSrV-CjI$tPPUM}(3ERb9;6DjL zFqlUkPgu6)EaS;8Ww9@Qxt`v$Yaa2$3E5q~4g;4>K$9rt%z?RaB;9h4tw|8FT%i^V zsRg@=L9&Aje9w3Qc)|`mN#S>9t4XB98jBMlrQ&3$d;&&7#wuw1#6l-4c&W6oo!=4 z`GJ$HV7Ctg5DiO9oG5#O6$lZxqxtX#cm@~a$$0r07Q(K^%jsybU{|v_8?d{#cR#n7)z}}Sc>l*5Ydkg@RUEvSj|LxMc%5+P z3jvk@CYOWx^{N3-=sC%z-XPF6Kud!bflULnHE0vqGQg$=n*_EcIGGLQoMG&$IXebu zX;9ADH9%W~a?YLsHZ>^c>zCcG$MX>s3xH7FpvQ9xQO3AHT^%@tQ7x$FW` zT#4jT-o0DS1+vc)0?4Lr*HY7ooVMc94f^5Tt+JFQ#4fAQ^ z5k!7jKzB2|!2}9b-rW+Ua^QG+xf)ZF3nH%`P?BqP4EVl)a|w4%ZoA;79N6la+y$IV zxNmZ|3U0~^Eyv_8;9SCMle<@NQ|f5BCS0HddImTzM9YlS;wD^(mRYIgoABtWz_~97 z+6`H;3W78%5m*Mn*wVPPdfPT(yMW1V?WPI03YfHSw@kQKz@&YU0?G3=4U%_n?=i*ha>}r6^6BOH6XxyUK!a;FNRbQUDstPd zOuV-u@$P8QQ-eegm4H<$|bBB>tvYlfL4rp(bH5B*t;J*q+Jl^fJJ-IB%~>5H4W z7?hMvHAou3xYD3Q)}M~9v64gXF+Y-vE0WB=>ck0-S43>H5yv05zv{e8(-od(A2LV#hN;&6!J1uB+;&@q8%@ z>mf*_8OS@syV=E$i0$L`&jRSGZi0Z&(}3zF7P2cyWmnL(rR{$rmWV%So~Be{u^dhY zi-pi4&D;>qCqzJg8!yJw1?m{2L6nk)-L_#DayVH=`MleaQ8!&(4wlryI#E=IBa2NfacLUek6e0wY-_negYudCh-FSD*ateF2ySSkixmUE`WhT9D-DHPdsU+ zc~rt%C~2vNxB(3`CIzadexW34zMe{QWa~6jrtVpVxn`fPAhr#g#RnfkTp6xsACcO} zq_!q)9+9?=Nn4tzWt3 z_K%izyeduT9LYQusR?DvBSKOIWY1NbXfU7CCUO$mUp*B?lhKq;XLLTkAbktb^V4(aBmREHluHqB-n-oN{D^CB*7q%twz6DlF%|FPzLL_N)ikL znd18Gl7yZifzn*RQz9^Mg1aU>HzttTx8Exf7!$}0-0znNWZyv)vajf?YXPl8nwdJR zOR#0&($H>+z%~e^9la7k%OH@e;3a~dK_FM*n*?)1g0zFvC=nPEq#YcqL?GL%k{z7m zykeC$3N3csJl^}|jZZ|!xx_9>BCD*Avxr^J3q*93KZ?Rl*^7vtWsY*%Aflt3QB-+K zZbWpHE$&N1vNW$9*-2durk_6zCZd`0o#^S{Q1|0XLw>v(Psd9<@3>#YO*I{QTr%P9 zN0NYz-WL);a8VcKQ5&nGK5n~R1E!M+;p%YW_KLbX8eFQX${ngeZePPUvoXYjqS(d( z1cW4Vj)_cNB&DI#T9Z!(7m_M;sHJsXL!T?H4#k}7X%MWTdjK$pYyn)Z3GQyj65elV zYq}~)E@vNQa?Ro|GQD~YqrK9xCF9C7%54$CGJHK_BaC$~NYHUXEd>#g90mVx+#&m90@EQmIEpDye^ zzn+XmGwURqFp%A>C2!V;;`YOpw;z_gRv(I+4tJwyZ8a);h~g^3lGo`&apU2Jile1Q zB}Zs*s2X~;q!9Nrg{b0*Cj^D!5uu=6|Z4vqQqZXd{TRW@O@HF+g1k$!;;6y!)u z6-wd~SJe_x-SuQPtjU{biMRzaP>_LPK88)}Kj)@X)VheXDhZ8Yu|0XSKX<|_We zj8oHP$?NfZ2+#5LR3y0^qBGb;GR0Z)hWyiPGFXnqt<)h7oh*=7Q>AMpK&o}fNOZP#vf^6}ng8x*R7qh>zzq5xe>~2q`}voqKI06URY zpfZOcizBf({9GUm)&N*_S7;QZ&N}30PP)TSCiL%Xcgw-b^lbtzDdV`LAj&~pdcFb4 zxCU?&V9@n2k@THPwZ>Mfbq)z0%+DY9+|4RD4>FvdjZURRTnzrSgAB($Emxv|fW5`C za5gt!d+d~93=&i>9022|XX{g32mb72{4vN_Wg2Y288>kf@v3y=S@`()NDjCS+^qxn zaO)&N_9V=RBw6A_>E1~|Fv}zSQe(eH>zwCFdJYZ>bB~{=Pw9CIPUcyC3w+SExB)aG zYrb_3f%taA7aoNFM2zDH6Hh7ofmK$keV(nLok`fvag!J|`$mdgMf@>iX};gbNhUsg zIM35WPa1+%G7xe?A8p8QAJW|S@#`4+P6B)ZF~(CAy9K|&ZaMvdJ=WM0d&hn`#f9V% zmJg2|VBP3aCO*M|%KD3l7FIc}0bL5SpwR=5C*o@oH%?%cS@?vXzN8#1?`<~c>Ok@n)3r_L`Q4IT4Z4zQkIZZCQ7>rz8!%$8e zL|~`DqZ9$-xQoC;DbSxn9;h7HhYzd*TK862^-w*yWGk6(mFJLd~mn4iNr6j;C-_^BDI@JE;L zDJh~bsxg$XAapnQXg6_EHrTI1(D_q@wje?<7dlV)ZFJ{08eu^NEg6IQ>eCFV$V`mgo2@jz`0K-0PL6tm3w`}4pPXB=UYzLhx z?o_NaaSRTMirtQ1!f^;M$VtbVum>m&PMC1VdjeKnSGXtKf?NMCe&EU75I+$d%x@_) zWuU?kMw9HU1hhdj!T5Z<7}8z?v7mr|Td)yL8=4!7S`xc33Cu5pBH_jdt2#O8jtjiZDu4P@js5L!HTJ{1 zs$4QA8ezHhliG|&D@MIwJ`|=C2`m%}wN6t`;%>pnqB9knW%%v4?+T|-vZn122%FW| z4m90?Q%=R(zEhR+koh5qnl|O))hf+AJegyE2AVuR)`cNqnm9aATR}Y^XtASk=Gh5; zI9Zo@?V4w|v6qMZh8hlJ@xm}wIBi{2O)S2me+Maa;umE{_(=9FhZrg$^h&z4tya*z zzujj^6}m=z{;v-+zd!%$2haZ$N_F?Qn&b8Jf4kEWfB#{g|C_B=^Y`=rzv7YK|1X2+ zi4EDUERc`@MOTqhw&2O{e+uyXp91_F{waXE1YqAmL5424zWu&D7R1kn@JsWfu>?;p zV$6p?_Mxbwq8E$H)yklwLN4fd1krzTa(=F^$}VR2)63Q6=;HobypmBjaxujYog2hS z1mjGe8!Ob!)l#6v~EYY;*G-z znowQ8RSYv$p}#Z6y?|%nE*F54Zy*-L3FqSZg6Tw4bab%qrO1I<{sD+yMy*mvKRd8^Ooe@<$@Oxk>b zwD}_Gi1cKwXPVh+S>@$_`?@@2dqGV_EP|3!gSmw(pEl=M_)ci zBGlE=b0JETLQLc2L|%!@t8j|t5uC%H*k8q+I$j{+TR6IK#-1j7{}KQS(D-vfZ}Fz{ zC8i)7RY=g(U(P$kt5wWfB}$%6vehO@4*nV#4-j<6H85oT!xvLlv0`XU!@}V-@*WU zylK?S{f39oI=&#pkn$p%aMvr7i=4m8?Dvo#(WasV?1e$mmU)ETlNbh9|5s_N=$e>R6DB*z&4d{X}s2=&g)MKBzoO#3ubeVnvs3JtL(ml&MHAH-PU zcq74jU(c>bs7YW|<_26`DRtEXS^p%$#&8ezq;V)W0knI*(*{nvdj6)2)(r_~ zo`=oMM4k6!H;FE(660z5^~fiq&{JR8{o-}6v75M{Kn9X_D%TnLCGjcJmN$nyC70X=qOpEMzl4#ixgk`a|F5sQpg zv?wy{C&|o0wuuUQCCF8{e33wR2U8IZkm1A85YP93U-9gXd?pl&G@ytJaRkp5qc$8* zNTc2CRL_sA%}kF6dgVWF7p^s;)cO8rP|(*XqqKp$Y$9Z6U9M$zJDQLep>Y z=j|6shGa|&#Kf2N?mog~F{YJ8icM2Ywyf5ngx)2}qtC*Ge-_KH`(Ro@#I1no(>;5V zj>#6Hz(KV3?>Fx0BmQ|b;h)bG))7o`v3+ln0MjRBQFc0m;{INzV@Q4!)P0OdQ&fl( z2zGXu()&fFO*eBY&CW?9)1PEPh$czDhy96r@K$K1UO4J>;J-579e!jsM#0U{`QZou za+3QYzu`RFIK0|$0HX^liUIp*RKSOy^Y0F@2W-E7&#EfgJmgTvTNSr643tnL|*$3lt=(xG;MPsD)|K8|GKwGt{#FShqkHFUwr9S20k0=ts^N`2Uu9%3ga z!orD-E`NrtICF52U{X$SXyV4=A!zwoORQ01rihaA2nSbx6GqtNXV*YE!CD3VJHgi| zox!?eS*hWCiVZm4y@`)EJ0U-B$QgFEQU9jKJ8fufkE}Vm=D6}&usxqK9;CtelvK$c zHBm3(6{Pwhjd_wG0bi|Esg-dkC7S5rg%wpHF8>|&ZMu+@x}8d#$Gze4wAh;<$8Yr}>L(9L8L2c^i>1pR+0zrDp;(}ZeiyMdPQ7Wg5yy<)GU-Ck*sBx#1td>ES z6ve`F6im7U|jU52oP^ zC5ebT#UKrRu0oW$da%^MJ#rEZS>5e|(QTePbjEX+fV|U2jCzCpNuMV!#N!?NVU$l8Uhl=}{K%T)w%1jyg&PkHcNk=|7n7{B+ zUN)MpSVYmG8}JE8Iz#*}WA;gD+wrIlA%=wxhW|{KxruUGAFt7Y&qOR&JPXG_Lo+%} z#PUPTh>G6ansVhsHT&Uxk2b7Gh#fNwz!W~MYSA~Pa!8#=Z^ZwxUN1t*O!!6~1ch`^`h2eQGG z$PypLeAF;ChJJBi$)ey8EE59Ciu1UCm&JF9%rzJxYW(pCY&%tTVI3n9 zD$Pf^1O`brIF;`x<&2i*;*mn2Ln@3D#mKfRWt?ONZ7DezH}NE_0U29+o!duSKI}LnMi7aus3V)=49aNkNw$ptmHjEIEpo4&rGTC}5Rtgp#Aru$gH1-6U0rLsn6y zM&phJZcrZS79zLtOsqwDh7t)9HW(nEHu-u04Hk%sDbYCHXC%c-2TmphCmZdiMJVg` zljDpH1ur^A_$PLj;kzpdTa1++_24*d%2WD#bgO z=wJiVUX_~X)$}5u=F&=Irop}~o9TXf)Mr{vQ2X`k*UzNW ziWUYe^U;5vW%Y&Z@)@>ObRB$s+v+n}Vx?tZ1(@U`cRZBjw-g?&4S6%f2`Y}U<4}4E zI&~oTC#DWF^dw=n*=i1sE!QE+7VAX!x$&g7@;~k39W;CwAN1Hwqv&QWL&fA~ zE$%a-X@m*a#JxY2mD9MLyX1a5u*Q;m>)3qkx;k~)y1uTfsaxw*$+*L=tC&~Usg`}0 z-DuLh!p@D_m)fyvCq|i>4?)(k$iKl|YOykUG+s*vQ#k`}=S zU!?5@4GDc_~JWhFiX z3prKA2ia+$)E0*Az#g^}F=>cjMQ|gG?_VsvjYd!pM3R<|td1$GWY~pZb!v|Ca;xd> zW1c#k-!R@r@&w5XNdIw6XU#ZvNTgv-h%sFx%Dys#-XnjH43Wd|@7Xl&1!eSF<4JbZ zVJ{+a!B##4B*cusX0Q!u$7}J;!Z^0jJ|nA8bdkyM5cE(EdmY0Mg58qdp~TP_Nm6reK5oAZvMW%rQ?+HH1Ijv{j2$7V16IPjNIp~c}Hl-_@uB6EID{~&j zJZzeCDZ5Y`6`oNOr}wtxBP>K=X)moFD4&9hmjYwe0-Annp(o|OI2 zIGl4HGMK5kBu*zy(ZQ-~8&HP+jC-D6u%uPGKMI78Un%L$N0WsYk#g!53kAaFoL}U9 zBoPH6ELTMI?Cn@i>u7ISuyJ^V{N+hM{{4Zeeu zh(Z$T0Hwp*XY@DFD?6zF1vE%QH;!ITLF#$Zr+8wfcqK`TW+Me2al(8uSQ{O%_(B0^ zq;+J@aohGqr#r`@ ze^os%7S?OkBd9j)4cCv#re1sciGn z;noNrqXo&~_pnm;{T3}UZ+drF02=&%IGI0ZUXb1K*LpLXD`XAO;{Kkq#a@CfrNJEL z*U90btKqXQhXbnIk5z_m<6w)EfNepkhp+UA-mD*2Tcy@vaQO==?9Ntiy?Wkig8_6X zJPzyYmg|{EsnM*%Xu>-DbEfjT(z-aw+O^8fdaK2?9vyb~o@|*_9dA0aJ_u4o^%=}; zXE2%oI->@5SB_PwSw79?u(#R!QIgUy|7~N3s`o^W^en=@^6(HMdRZqO9jt)qTs{0H zo`1lj!)})!9^jJU;BxAbF~fHXX<>xxVB{WdKgPOSN88R;b$fjsX8M`)=M2%5m8p{C zLyjJl$mNj5Hnw`0^nW%Q(nTg$RD^mKU_r?;TO+4?&E{fz#N zPulW7g86KH?f+p$MSLG~YaTCl4$vVtcKq&j;B1r-T^pl#>OXB9IQ;>j?RF*5Ge`b_ zwYmmtxSVy2m0X4K2%JCvKj+UsGBq{~{8(S3p;JUWhuWelkU~{;6WBrFgwRB$pX87IPH?~M{HT1o_I2a{HeAYx25{W7Zq6$lhD#VFuaSKT_ z!M=rWB0Qpe^jqyM7BM#K)!JsQ`2^7khhaK zs5^qXoh8)m#Hl+fldYW~EWcN84$3E$q+PD$G`W{ro%&A>UQ2a$oPEd5%daP;YVFV| zIJ?dh=c(hmj$6QYMAk1^xD!UXJiE}F|3~S=(T@6aMj_4~po_{%0STQmMg~`?iR#aP z9>@;H5=TCU75A8)fH<%VQLT8pz9xU+z?^skOo}!M!T~+-N8zB1oSt%Zqd59dq(9($ zo96F$-*9-otanNDj{PeyjoySVuR1{eL3-Dyd2$bPqxGMVcfyG;1o}GtlZBdpTY&$8 z^rW2D+mG?LTPW@Wn-qb4+&plIv!jYhH32zH6`}hJssdK0xSI%B1V|`a2OQ5FLX@!K ztIZzjW3A%iTHiaT_%?FH{7BM~P2KI8*k4GsyYk1(`u?!b|M0?*EaZRU@($i_UrWX6 zS{Ghp;lxj*@)%Dq+NCCD&udf^)ldbEk_B4y*P=CjBsEQG%6Ae?sKBR@6r*Fw0O7Nt zDby$(yF3lTFgn@cdQ8>-oyTlFYBR|8@%zf-gI~HqzrU1~%6m@|Xown9zuO$Grx-}z z$RY!_0or=OhtR>N>|qxHiz~^f1$y<@MN-Gv8uBaWAXS9xqg+-G1SlIXNeF#U8<3zU zhoKR4*9OCl@F5i=hrfE|xl%h3YE_8745;RI>PLTV9sU{P8_|_9xaEgmA4AiRb53`P znk0S_|LP5g`d|1~GyJQ2{XU$%-wv|Ms0k96%S;Gc3t^(gBg1fVdi97;}V0BFE`>pP=?Sy z@S$z^7rns_|Gn`*I$VYDuf%-nfSulmOzc;}ECFYwQDZTlSv6_OV$eKzn9XD4Z_jRL z76!4tyZD0mv-P#<$l2;U4}WzYf@FCJLncgrHiu~~U70Q$r~|wVe-B6zwFaV#(P3Ak zU`!^G@+c`#kADKni4FLW#MQ%X7(U|iNzgO>UUp?c%+H|6?!0sKKMA>7b0$j$>+AUR zDtFnT|HzID@7cBCMw9=XfzFS6#AF)u2b6AGI0s3POym}+yycNSr_+dO8}JDca?j*0 zL5VQ&fgI-QbuF=;X))4xdg#=tg4XSD3D{iLE0GL7SD1%X(PaW zKq7S#c7P<$=QEQppk;|^!H%znL}?ZHh3sbo7kUEBpD<4|SnU2R4cnpJN;NikL zXi?gGDu1-pZb$=b)Y%TqN~)>jNF8>Yey^gZ)xAk}`vuNb;P3;oG6}0O2F`biDst4S z25CUPXRnHM1a=L2zFz<)pse~y^h?^sZ;b{8fYC|YiLSMsLPru~0z*B!xtySBLHSXEe_rXl|rea5&_IU*VoWYi|QY+bx ze9buB9(_XofENGRz3Dr@%JOaaw0-qYNBo2i`L}$WT7KDbvdJy|&gZ`{hL4q%`IXvO zeE$EW=w^p z2a~($;OctjWV%_Wkk1#LV{bh0ht7-P|JQvFVDjzvBQNCFv<)5M^3FN&E~kU8?;OF3 z^`<>hyNyrGvE@y#m(#W0P(0#(;M@gs@lqY?aQrqerRp2^9tYT>GYUY)-{H48*j7`z zP=MEoL-URKnhzW6H1gCuLd%Ejz0jH9$MBl3E5zQDH{OyzaD0$|)L(UCT#&5^gml9+ z17hh8FJWNxRxr*|wByjjO;x~cr;LK`Y)|ImyACG$4wJZPAtEz#hytH^e^qUt)-T#l z>HH1m1!IVbg|Q*s)mX1iLxsFj*d8JUW1k@WnTHyDPp z|8HQL#RV?9cQy69{@}*Pe4mtF=U!7uS8hM>>L9v+6IY&V_!)JYQ<@&Rs_A&ke>O(BzIfxuVjdVwDz8o&$c7zh92 z0-t5K%?>ono$7g;=+57wpvO>DYKhWb&HO8Ws(WGsp4954wgfDgfMkHDfi?4vZg0mb zagCCF$0{o5A~$c96m?0#E^!O0WXCEwF-X|AOEd{?-Y(G;6e1;>f*rf0+N{vnie6)? z82Q2wM;$&}HpVprgPV*2)UkjfTozB3Ms$)wN_^J%Sy+Dt0%z=vd^WA*{V}x|d{{0b z2DJ^V0lRwWd>;l#vnVpRhSpAOb3!WO9Nh?VrSSecj|`(HA| zdYZ?V%mmAScT>-u%HWzvBIK(HV*1)*uEr*7t=?cA6@Jw6l=2jg@j@Q zc`>0_jF-x6H^Zy6pxKA-Dewdn(HGrBTu zE2t6B^Q*%<(8EXx4r_{nHqFB0!NOHdS1>I4%UnMv` zCPi0`b_jq*x);oGOQt&{Xc1G`CmPAgC~C*`i=$eF(K!3D?{p0q@Kbi1+rbFLnZn5P zOFwaJW>TZ28@ehuoA@5p)0}ku-)B+b-H4~xdgS8F3ua}CiixZOYKspi2Gg>adk>ZEj(9K z<$pbEbXv7~TbBRzLVPgll+>G0!fIn2`28O#E_nRqqm9*CPILFD100pB>l+-az}V(xwC zDhPVc1Qk!x_vpfy*Q1PBmxHSV$?_lSq5IGZQ_19mNRD?M^{@QwoAf$Yww zotb|->j?J?U#k$8GP*JroPK}D*2%RunSg%n^tb)nZA3y(QHq*x#~a#7zX2-h=1j>I zzEy!ab^O~2CQ)GRaXzE_VD#d+6i?fH?}J{HLAswiQ98GtBae0DwRDlJO%$s8$Wf>q z4Flm$Mu^W?J$i)O``|%gcbABG{`_$NGa#I=(}=kTMiVa1`~40La)h0NNzVQtZnV%g zJ-zFU{i{Q|{A1S|cS+-d(qO{ZgP=+X237Yu6HFe!qB$Yo4UWCIXoQZo{Ovw{e&#%W z3=C=(?5F}*7J^YE0qT-8wRady{+7Qj8}BkeLHBU0D}NX_egty2q_B^I8>^(EOK!$1 zw7U~+_typO78LSZ^hD5~K|j+yJp46}?meOH(1@LY{*Qx}{g{Cd&!4+{S^S#)sEAB& zhX-`r`+_D)MiX*u%8L9;w4axbjT@VkMT6sNUI?a3N9W`u5C2;@9C)8gUA49Ob!6P4 zmbW-F-5(3Pds(^)i5`D)4za58~y*DGKW^0RJtlVdy9nniHu;_BQzG!PPq(bM~Lv3!EaJb=)+8=MRwcA5e z#sJ`r5Yw4kmcIe~1HTwK79t7Ies=fX<;FL;agYlNxv`Ptb&&fdCwRyEIsfhu$CZBu zg+u0#e!riG|Mi)*@dNVtk3a5Y56n5kY=7<^U4$3Y0Rr^hVFv!*a^F3FUI2LhH?TlH zcAefWn4o+^e(-1qONx&MT($;%&fGjeH19roKmYPBn>{?Ffm_2-hz`>OtcSB4FD+2% zFS1nLR$gOX7zc4dI4&Fph3L1N!>yao?#MXWlW}raVA945`Z6wXaaw0IW&5dw36j_F zb5JGxCM~9w&BuoYwQ$bS<5* zvWx7|L76fMLUKG%{%QP2-x~~B z_rXtFhfv`W>0S8q@uAR*Ded6%L-{UL9`n55rysY}C%G9wWyZ;KDir6F>g%)0Gi_~y zf__Cu5}=_M3ui}>%kg=+vB}@JdETk>ABhweeJJ=y&SOV}-qruAb95)FU~Z z9m>zh1BZvh*`pmfvkz}!04h?00(Ayf{e+DrGojGKTjv3&$}nGfLm1HakB0_#4re(p z=NkLIekTzJgvWvhK@SiOPA{8o0`w6w10a~8p z0MM$B`1H=yR6V9!yXo`*Eir-)55<@Y1a3jF9MCGL+@V+Mrr#a9JNKkicm-2PjpZc- ze(ci7Mi}Q3lvk1$55aEde}q?K`p3w-#cv8AydLyts&`obIak51;Lit{jQit{Ty4wE zW)teDnzwOJWz{;W9`s*Uww+dr;n=KKONI zlA#3Dy+iyA|4r)17tsG>0{MiM^t79MAdO9@J)2N62s?BrnE|zj>{F#{Js|Ds0W5(B z*hhh*`n!{VYIS&5J^;OlEXR?|oi-*o z4`yC6d*;>Gc<=h%#92>KYONf$NKJ}lg1(vRIP|kv5?%$f^_-MJhWA=a_|}^)lgd0FW2~`{p)Y>#yA2h7MH%(A9|tw-!PprJ#oExTsbZR9ZD`8()Uv-F z#o9^GtdT$a(+ug)+-sODb<?K_!D??dKh z7EC~3!%$|l2-Ti}Y&J<$B?L5xr$R+o8u^bzK*;T(d6L-6VE`7liV`a)cXSGUFm_zW zAWbT4z)*Iyq-d?7Al>T*;wR zir&q0%!ILk1}PDGNGcVWIDiJ+N>XUk?DwKiL z^w4^aZZKn;*b@xhG$O$VjERH3w>jKXC;6WQlTbn-0t3(!?}kTP*RNn*Q7|lGr=>l< z>|hQJy|y`0TfE5xDjSw|MEEv2L+?h;Lk_5A)j+Ie%F#U;dgGsW-u+y7clfV=ZMnHE z_fszAzn`RvI173K#u(+C_r5>L5sm^NIs8{XNB{SUR6U$zi~k~y(5W_Z$OD75es#0j zs9-*@`9yV2CS9ip5%?j7#W`>WTU&Srs%!q}xO>h)*0B1Ci+|o4yp#G@!bVH+@mfHM zHnBdxIrG560qT`}Ey=1cUsEdLlaId^WvM3a(V?Rs@-z&S6-X4yP6EaqMt2`%QlCk{ zwts(YwFT%*h0ee%2bwri%;uI0tzbl(LhyJeaR}AdRq3nM&tJs3gm#=b0d9nVwdA(t z>mU3-lT&e>L>V@JFn~5iJHWO2*_fO0G?>jY2=vHR(oyZ*U&ykIAjYqFLz13b;|O_r z`2v5M&!;crYQiBNJ42bKUmD}rWW{w9jZSJwTh_}h^4=n%QI}kVy{m&x^)pcRJ^++J zYrmp*1o(5D;^4T!HzTa!m}(u!+}Llz58fnW{3K&q|3(a3tFLNhFPT%B)l)V-M1z4v z9xrbqJjUG%xWJMMYQ_|k+N*d09(x5VMEjPbBT^V&+Kyw8E}xiznE<;duBc1XN7mby z)z};}r}wyUjOOFV=|`%KcGYK1is`iq4F(KJz31CGs4GoD(Z~4U;Ro+7^Ny@6hkGm++Ecu0@ zx*)&4JKS%f~OT z#!vD4f8%%R3KW8BARiMW*I+FG{ep<3>#OB6vxd?gy>Xy>2fL=yF zkR7~HTUl0m@$gw*6x*TrOdY_C1@n-S^^PV1<#4dBG@J8{5r&dHrPZNk%uSBt+5%4U za}|#`maCBGh=R<<7+|I0_+cXWU_HGvHbvSNwcpiMEz zM3&_r$g2xtdK4r3u`a-> zgpVg%m{C_TGiovohQSpjnLv@bIopibFI*v0ZeuZ-q0vM^%M<@9NIPSkqu^sQ zWyEXM$Uf9Zg#ZSR`$%7I$OnBl;_l<;b)0Y7VG!A&4w)47SJ0%mCc3f_1y47hYNJ(cW!H^$gNwSu_+*ZVQj`OZ-F-X+Qh{RGM;vH#gl3+5a*bqWDd%zcBiC(t3E?ZrhvLdqq8RWe0~7=H z(&vxHL!JrlL>8-0k4kE`#hcMI;URh%x{6_e3>~>1J!9TsZ>p2oLTW`%w{`>z%`Xud zZj|~JKY0bqaUR|y3_i|SAU&jS)Y2^@_qdb{5h6)2qgpq+PfyCi1Ne|!d%*5LPr8qG z-f3NukDaNjGhsP9NubddAMR^OmnlGI3l*<+|yd^4{kB#fN&2gCWq$rEevt} zf@t!x3Fs&zqJwg1b1=Tyq$?fc8-FU&ygDtCHa3p~g^)BhB*fAaA#I>d5UP=OD#L!$J4 zu?1{0VKf2l(}VGibz=XWrbKAJ`0qn?t|}Ga_|2F#x(JjTPS~EBnVLR7;i%A=_6FUh zU6WOe%P^Be9pFLiEbiM(Sm(P%IlTJ18Va!Z{g}0c%P|u%;AjKQk|_U_Wd34JVp$!8 zLGc#R$xV!*TJF>^9U7Lbt31u0xbFT(bxgWvTk+3D{3>vx{T)bx5;Ig=tzof7U^U3j zMBSWFAOa>&s0^@KJLrv!6u5^$_ z#TTbinCALZ(*K1jqLL}dsiC96%}1Lueq8|GDi1(c-^q_&w#OkU9Uqt7XXL}|^*Hxk z*PB8|j5O1F#}vq)u7G@VD@N1KiZrz@js#7(y{|~q?maqONb2xB^y64d_aM2DL~
~!Q7@eVh?ThfT{xmthOwZD3Ez(Qf#lphrJ#E^6?y7*L2w-6az|F^EP!*cS zarLFdgF@pFKXy93!A&?QYK+B2q+BH9n6Hdv^M}m@_)*Zi2MuTS<0KmHiR7YITZQXH z=$c}@!eQj-B&%DDv#0(d!8-n}Y)kqIEyXUg#z%C-aES1*5OJ#lqNxS`7;y+)FFwOLuUtdS@G{(QkJ?yuj>0=-LMM%!G#D$7%6-=Dx zhw`E%x-8+tkB8!BplKGRDVnybDKqitZb!vf;hD`RDrTDaWY@YA@bBjN^cjou{Kvy- z3hDP|?f#c=W!E$Tp>+_CeG%^2r6q_tmHJcrbUb2>q%iAR_c!2EgAxvros#&+o7S-- zGMinaoK#d?jo#GG)iAj9hIk^9c|h)_VA$)hUlf1psiR|*qBeVVw3QBfGtO+H>@Sm> zCXf}`pG5qqu!1o0LL{_57sx|0`+hXq*DS@@W->Ewa?%kU;dw7k`_AArBGOE%qQeJe zjCwS@pl|RN(V?9=aX2%azy$0`z*xyp_@px54Se74^ata?%+K_*aZ;y;!py_Nj34vc zD#Z*INbS9UxYd^m0M^IfPK;MvFeWy08!{Ea<{wtgxsHcVdM*x^OpExO-sG zx*I9nGpLRAZ6V0>PwrE!-Mck1;MEiS~1DN9I2-cCrqfv_xmPLy>g#f^gNuS*I1*0ieHEgW{0YOTa`bhnI!GNo*nm};;f73Xf@ zIbJOwKPg|1C7M|$?ys+b?b0pa?St56g+-}Nrs*Gsb0$K@kB6($VGK-Sr`IC=)ptCA zJweCny4)5vO>Gr*Thmaq<=zv!#1*A`Wm-RPI3GqB2W=iPrC*(eXe`yd(FDnI4)|Zx zBN{AM57ubjPwV4jn`O*q)v)hqOud`FqUJYem0g2XdSA#YQJQ}vR-wO_YDZ)2lP}8{6B4M;a{w+ zXU*uMiL@qh29raTgeI-BAW>Jwd@re(qm^q5D!+)5@nQiPm=?$UeJ)$NeQ@}z#Va@o z=&OML+SoWmkQrC*A-Lx=o}`@Vj|@x?Fkc|I5cT6wK&X+WiT(|wAGSm`-H;* zgLOH-!o=J&Q2Bw8{*uLuBelVJe(RhxE*yU}AL7eVSQFoi!5rXtQp_H7*z^5=%)Oy- zFdfR~#KpNonf6C!*wA%eRLnZmsnr*^-WP?yQya9sHIf6x*cHw2&131bTn>Uj{{qEjS zm{30!fPotOB^|zB&JI&FRbj$hN+Xe8Wclc*-*ns6`a<_Tm35cwj}go!Ln{qex3x9N zEB$$w9Mc6cn3gX@8`O&SjFF$^qf)s^=Z+Q;P4O@wvUmD@efgRXc6Wv6E8>h1%QK}D z91ms3YH_9vXaH|s?r+5&PQWrs*h+Gw-+x}%-DUY;67|U-?&#P(*>^Q@A9eCSR`l?9 zG{*^h^7NhacubiQ`NS|gGA+LKIi__INi=i&*31>eGBAP_%o78xOeuC!5%$y(%yK&) zch%I#xmG3S5tNumH^bp97>W)Vmm`cSp;_fVZYoP}Gdxssa3lUH$@wCG=|OZH){R7N zh6l=8&nQYaa#ln~RJQad9K1ABVkIUS`miEC8W%qBKb$=<#uh)#9vqr70#@{5 z2{Jo86zfd~rp~SCplKobevC0a{lP7)(Xbz?SQ*JL3RvCxkAd|TfhkKoC80qIHj%d= zR(dN+g%uxj*ex72e$7LJ%s>`6YpvQpA2;Y36h7AlBJ@bPv-k0hB4;_7WR zX^!mfhyC6_ud&3*NdoJogDshybZp-zuW~5A73F$@)>Wjny5;xv)_-gsq|wZiUJ!2U znsQsGxwG#fGjJk}>@-S7V6w+xoa_k1pvp1b6;BczmP)}_3-Ot4_AlbOntUIX)Ra>5 z48tX%0F!9bjcR(>YcMunexv{tI~q;WOOJQ=_{>f`1*ECMuSNi~b)SMKL8@kq4rU(j zLLgC*H(}|;s4w~Rc>VW&;`on03;y8y&)vNz|GxL13vOYjkdMCqT-@9FIoLM*#$-Unf zUqH}r^~5+z5xl0cwuUE>_=f16Qz{tc<=0SV78Z@d<4ECAUKfHCiWIuKkb9PkeAtbA zIEvOdiq* zk-N&_cEo7$! zHq(tYgWM!=GbO!P6}{cW2s<``zlgMO7JI-x(k^nZtc_b1*EZP}3wEu7T~%;oK^$p_ zBMah4L*SNVpxV;~PppC`8kGfcq#=$hh$9VwTaJNhUl%;J3Z80I7Q~T;IIzR4MXHqCfUaGIE zm+G|u4+rBb(0=LRdtRlnck4|QH5&!(Ct~{`6j5+`TU{OaWuxd$5-5^8NQ@5ssCcRN zs`RGSLH)kj#$fxm>v(teEshsGr48S*Z>39KxEbjg`Y~$e*3)H9AJZ;Ci$8?Ve&}uF zoKEMYTB~$A_^(>^9R8I(c)R{d=4Z%f(ZqoDjV9g|SUlY>T0P_Up~$E@0TD-jNu851 zU@MUFKI9M@e?gDs4m4rwU_OyH66J?>@?5}^W4;-E6 zPNjAtCW|_w8mXLh+U0VmU247nF$KTMdwC&sRRUo;cR;#}1zLP`$KEJ61zzX4)Gl?3 zXcaUO7yQ#G{Oehx)2h|mvQYjus+8-EH!Rb*3jQ|8t)0N^mw*#X$H&biI}~d)N-yO6 zaD3tyj9tphm$76V2j=YqDhBb6RbV~JqN94fhBC3k$tyaTyuyORGLD&}Y+nHS{h$vW zOLp_140j%4`2YDut)|Y-#Jiq|>xy59;{zCxlxy5`m*B;!eUOObSwGXyIUCLo`Tf_h zYv9S6aXyEbI4_X%$WckdFj5P?Kc|STY%C)*XK3iil$X8i`kE-|&_vw7Ya$N50RPUKa>8J1*A4hHK_cISLv2#c4AL1-I&W9dnIVBwF58+@k@L7(o0!XbJh8#hKWsftK^qQVo>9tTc) z9+;Ib^po@ZDj`n*DvmNHQ|N&hdFXhT(3zaW!JWV=Atlkh_D6WV>mT^G3cj#HY8&=- z1Uee3n^SRwI}hsFuJx(afKPkYr=uc#dSZP#!CL!v ztpa>{YJDoBO8>u=X5HCx(IjrM^2!cu+%3m}@z5h`l_>7l*-=pDqkd2cNiQs;&%k`S zn5LbKY%n?Av&mE1*#aYJ-3T%;{JJoanW?j78X8$4P9Ed<;b|HZ5eTjPN*oagf&c`n z;jS~b2~las^I5k2$H8=jK75#4oM{;|O1UDag79IfJ2wRFW)}h%1!yq=w6GX7&!EEp zWrG$MgSrCLje=rKy&g$=9-6}H4X;mjO))*p4(NC&q0#)JGne6vtrpc(CPT^E<U8Ihz9`j$k;2Qxtyo6y=jTzeMDxKz*f&jYE9} z8IOXzz=HiV1Ub*m3Ig1<1@L0H;$pZJCP2O#}g$zB- z@-Q@+H=Ir3|1%-ju-h$ngYFokscg=GO*~ZZjwS-4u#q*#?h9!=UQXljy=grDavBYH zfftS>iNb*7|6KBalplfo7`Lz#u2=9Rkh7X^U!tp`A58plW&

Gzj|q_Uv}H0bThp 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

2Zv(mZ{-U?l#S6xXKpZ#PHYAw`UG~ zzomIer1Yn-bOFXClRi#=nYyF*lmoNZrjlWV`! z(rkawn#Sr>uz@5r@@qziQZJNhV?LGYYA}(VnNN0~t*7g6>>{r=U5;TVq_nhZ0FNA{ z=%(p*q-K3M4|Ts-{CdMs1AckKl>D#o18#BXwjw-kP|3LK(h-0`q{Et(%|hRdRx*5X z`omx{O-~acaDn_ANV`&M2~xSpvj^gtBZXwI;vTPFq(hby9tzgQP6p(m%;ZskH1%$} z4B#Iwkl6|KLoiBY?~rR|p&i*NW%Wtgzfm5J?E_fBYyzMQiHm=Ofm4YY;CIQg*lK=(N zyrIbIV_3${IjQBoig?{u-84Cy2*4suThuma(zY$B zuGeV#a3(T94Y^o}6vh0sf;A^hrt>OI7y>ZKY&q`NYOddkm_ifx;N>C~1gPcpI2F(T|O^EZDZvk*=4gQI9}n-|58iobZ5Pr!)Fj!uP|he^0hF<)xdnt>1bl|EyQ!^1{}dX9EpOS|#_9 zL9#MnKO`P#1jYtk=0>-#l)Zj|%wum%R{}FpH3~zc5sh5s@iS8d`8aQfJUlz8NVS(t z!cI~OQU)x*Q3ebooV*o|ZjesiFE0Qcy{{dV`X; zvBD3Px^_~H7B#4zFjU3=^N<1ee-D9`fcIsbg3wIc-Ih^UIS4d|+LUf*$~0$vTRM$_ zWpDc&FZO&qt#5j$)8S9L)hNt^7i}!|@`@F0BfhUs%B}3yjN6*l*0}Ki2%ARO z^flP8&A?&30+}Ps929%QL0e8>KqFza|F=m&3L07V>wlYKY@m@P8viv*Qxyj8nzc}W z&)LzzaWe0Q-1gKf#&Ze1nJ1u2iIi2}o(sez?W!oa?CZ`RvJ(G&^{LcCt_4xG*fvsh z$=>GL=CRFA-QHgpkXj=>nftfo=2h+ZA6RR%{MbeimfTOo9v!9hb z!lf6@0IvX%pSVF@s}O2`3`ceOu+|Jsp=y-V81fxHuRPt;-)fDx&h)|Fkgp^r{gVSY z7Xr+uMFzjbibfp5Y@2fySCJ`H>npy@&cfvFui&HYu~P1XT_wF5%Vee0#?4F$(U0+! z<;~`E;k7^Xo*j+Vm%9b9kzmz+8V)SEX_Q|m4x8#Z$cnPhJ2M2Z#Rn#bL8T5(A}yG+ zWtx7dbtoyjf9W2+xW><@{iQQBVlsQyDza;m#>gKoLnn7S>spned4BKT!aSRTKEt;z zEQ!{u^c6c@be#fe`3Sw|kckmX1$(aQRm83K_!*K*9hF=@eX~_F2~BC)kAHDfm|cb* zog!C>{?Z5HH@5tp2;b(mRyl+U39KqL7Z$62td!|_c*`b`8AG(p=vr;6n8$0@gsf&r znx$gaB^&*<#XQ{kPdkrtHHHvj##2_tD0Ts>FUCqMMamHFQhv$?QkioH?QP|>=$3FY z`e-b*pyJv#52ceSn+>%&+-pt>#^}=ZEJU94m_%U_8iCFD3>*u6-WAoF#cP$X4^*wk$IjW|cYyKB;K0nw_y$y{x1vL(sybJiXE+33(7zW0DD+fwCwkQ%vpm zRk@}a#4VOe;T+6veDQD^azCjUJU%PbWA=#%ID?1C&oXS$X=%p{j8zY2wI&~N&*A^+hUWt-D6Pz_ z^i7Yjr=YG(w~A*rV1tvPa41u-IzTbR1lqHK@GoS#)0&4eOVv(t8+?|1He>h*bi(dY z4N5lyb>?pI@PjN_dW@y;XyZL(tiB8A*!)QY=#CXHGMx`Y)=fxfaE;j&o8#lz%Wv!h zvB7{wfZ8pwzrq;x!CCXghPmgI&%Sr)kfCe#P_TjP@})c;6YA(3yt4OYT86QgM?odL zlo(LrbKJ;VCM7B;DTfm8HgURCZK{PB^LJDnTM2Hy)-z3FG(q7^pHd;)3P}WTxG-iY zi8VR(-bPF8WTZ2|FO7p_Yc6iP{`dzV@KdtvAyQuySI9pksHuKDQ{m zKq6$-5DS(wq(6!A%*ZFf%G{$@z#LaYlz1)gG9`cLP6RG14HZpN)i`{11^cgJ2FJjv zSZLHN{+?Y3TGF8%OW6+v=q_i9JCZufhNjjA?_Q2>+#vO(@OfyectI!$d=ulG>Ab^`hh&FY)k{=*%)KXsJT~$(vSqF|x zho${KPnU37q6(t*j8ls0dI9(;Kau_8gB%8cK?w3~*S%!tsJEJw-CEJ2)L@-&BN)%Y zhHx5idAT{1R_Nf%(#G3vQVEh~MK|-MWyq-DClLl`>tZ==M@{S1QqKZk_bDNKnJ3|U zDyxUPr9TYvrV3<9FxNCXExBA>@Q?q}E|MBp+B)5vb_vt8=)JT4iV8r2u6v!yOfVQdhwkU$(G?bnZ}Av!3!R%!TO6yCv7~SZ&XV4>!>YH1d9AM zPa(vg71M(h-1bh0rYF-XWcont&@FN1Zg}**glHj2g^eZ|!FvkMp_dmoF3gV%bAMib z!Mr$Ndx{MpE{%?g2xdybhWrNwyj#oB;-*Q7l(SS!$i)IHBTPfgqQERYA-sx}D>91p zH6n=hwC0ywdN+kf#K;z_ncADl4gmD0o)OuLN8in(usF;-RrRcCp+5kMfo?}jaG8Ts zwh$x__eG-@5*$-)wM0+KIIvc=`BZiCrg9~OQ5{~t#_HuPX19_DH>XNCU|@ONZ8sDR zv>OAjcnJn68YLWL)MH><2IQb?w-&vwJ*<`)q(@CKs%iaZnT8$%1H3*MQY~`VJnOX2 za<0Jzs^Jk1Hxo}y&@Z{yk4PPWj&?MFB5+7#x59pF%Srm*Nf~i;Si|Z!B1kBDonAPI zod#&jy<2$lU@f0Z0c5oPKNE{^VjWppx?V~JHFZ65366uhfThZ0LZcsCRe7R~yF?Be zLJd1C63k(EYO~dF9aGR0b@4aMQQuc^%TVwn;w3M;9%Dn$q4)q;`XS*^bO^x18C>9~ zA*8I~dwnmF!-_lk0#RP)tf7-FSq5B*cS$)>SSDORRY`#mvp7EA1+&A=Dq%gU2lUHc zve8i5tFoT-&x7WEzZq4-o#y_2Kv@h7pfq1ryZ_YN|I?Z~+5e>ZmuLyEJWG0imF}3J z)43pnH$u;&_1%^AE&%Oh`|Z+|9rP7n!2Mwf*)R2xo)%#=PPiEl+5J2d9x7R5XVIeM zpZkP+-;E4JIt3aa3ro64htwAXKSR1eo_S6y+MG)KjUL<=+J6pb?WNi%WKGf#aHw?< zY?Wk-^^3^v1*61^5eyhcKg#IN>AVL{es4Saa)e zGLiwyn6YzUngpKM zRWzdZx!^8Gs$N<-+Xw~jF3TxNFp=gYL~jL4AU;$OOe#JF3K|2c6+Nm>Ca6OM=x(wy zofaKSKAHxOl!`X|%(v?nSvCR&4MY-0$5g9&9b_CC_@)U~Icy}86RzP+`k#1?6O+^F zpu`V$&cLrL4Sd&jRmvj>~lWubFz)r7pwpO!DEE@C2xc zOmx;8g24o4UNSki1PTfBetBeaG#EIkLx|@vSc+!=tb`a5q|-3+FIlOt7MA*e&N`wF zf#v!D2gSawga8MjK5vJB_dy6G3E1%<2xFE27UVuYlmG`%p*F8P5ncrbd@4*tEXmsl z5QD^iwS(UZf0jX&lN6{VsnE#K#*xPdVIY+t+94E(M2Xz|(fk<^(4>%~_)=0xumqJO z4E!`BcFIXoFOsRoqK~fsYE4AZY?|Ton2+A<&^u zsBI%p$12X8u&I!Gb0+D^Du^C8yiDQFp7||u@@x?mj2|ROT) zZ&ps6d4@1Rii@%F#}xTo@N7Uhhxj;veo}#l8bb^C|3*wJnpP4imT+W2^%)<}Ur&w- zqzh$0bNR5%efN}!iMp9ptK+-%w=b_LrpGoxqZi<<7wRGZqx8>*mx782u8=m73Kif@ zx7=;SQ=)VKw64=_WFi4H#b>sa0lg|I2(Ax~arS!~R*JeQTv~gF`j%U; z5S*ftNsyOPTU!V(PKRM$wDpcrpGJAu@g4eaVy2#)7mxIg*Kl{DN!L}U1{M-d(Z{xID86GBQM?yhs(qbRhnaJNHzO5gl$#mtBAXT=boA(sQPxf)y|G@ zfH72Ee`FL zcj{rLsMqUNKu*2>M&GwrtGd}U)E^=g1w0|*2b^_+#!%B_Dcud!s8?b(nW(FTQqC)Q zX1k7Mfm5gT4P*eVFl^PJY92j zN?bd*zJi{6?9|DYuT9XTV-d5pDu{m}`_%Uwh}5@e<|qewS?+WDRMM2lJ6GwZQ-Ig4 zj#}lNCC`m}(xFx6rHX?y)W&CT<(pM1C;V3L7|pf)XI9-mMxvJ_i|^=32s~NsDU~0b zpqgI07p#RSFC$RoYXgR4IMQt~o9x$49zaq(oK67a5gl<`-U(+R4TTe0+K7qQP+!gMCi(+8yUe}h37j>&K45c|%sxOAb{e!n8g`pF>R5oy=b!(0?F=#_hrALeq>T#q(G zrYrevh~_!946KB-Tlb%1t}b6tGweLu@6DQp$Qz>15e=FzyW+D2e>v~Y+>$sb+O`Hx zgH%3Mue!Xji4rkA@Ot7a0V=? zF*SmFDWDpTp^ToSoTPlb9~)I}nmNBuAtis1Ms`l-Nn*@Btli$6GA$yFc#_m@SsxY} z4d5y2)m~2l7zJY9K5TkiwN`yep}}Bz&`ztpwMUrYu@6m5Tf(u&R>Om(Cuy0W#f_0S zXJ!|y1sw{XU&9LwS>`0Wc<{$me-*eyFyH8xG^O^NIxiUT-?}JpZKgtpBlr#sqP( z=xErKVN!qZPMyqiKOJ15IfwA^pBwladZNl8yjZslFK@H6@x@1pJ2|xg3>J>)yHmaw zsM#nt+-!BIrOja^Sd!(f>5XLdN4j|+@I=z~$AX)Wqdk9KZ;Ewq$7|-OviNR{%{;c# zCkui)*Ezc=iCfDZ7)Js82OuZz8ZzQ~&n%2)oQe1LrIg#Nd5w*m-$r_SZ>(FeK8oo- zB=}Jnp&>zO-Pkh&TcT)J_0Od0fYVq~FyFNcQ$5;=vZ>Rw--UuFW&pEFmAACjN< z>^?H-z}(2_Zx3AJ3Cr#}`dT*|-X(Nl=J2TCPiX=4C6&0>8wT^k0_onj{!{l>K{>p~ zn$Acvt*TQBEM2Q6*XcJuIjf-SB3b7Az3`+Ao8WOiZ?RPA;7ZTd-{r(U35<;i-&yvT zGfA&U>1}*^b_o|KghgAe7Af|VNIqhQw(tbg!Q#I-+is}ZdW4&9k(OR_>CKk~M6^eH z6eojrCQ1ivLndcBV2j6;Mj^mhzWMp9m{ zM+=p@&YLb&5q1q}X`m{EU%@z?TODr%Ukci?{ky=Tn3fB<)DL1o-mH{8&K^hfZh#q?Ovc8UAO4!d2t8cr7Q52)EAn(=JY$$!tZ&(V) zUH}zeeZHvT+1a`bB_kOGJ=t5kf7A zJZ>0K6b+};dpRcTu~`*1PtQStZm#cieti)PzH)}Ftu;=rt8u<#VB;@MY3(%$~&QYDwChFglMV=M#oV%cT!~Si?ig+e2-ge&; zSo*x(Juct*HR;WO(LTwae5tXZ#}hLj)&stzwUrY@E^;2WYshN=aO}cBYQjR zciqez*|W-Bd;t$tBwI%cpf?{nHmoSG6Xyv z4&fMQ_VUvCWs8EBF5Z_9<3JHGP>836< zOUU;dK3UL54ojCgvx|B_}K{nDV9{28^2@Flsj3r<%0PqUL_Tk84H+b9mrF1wcAG zrq7c$3?)tMgkv!5YlvNxe+zVxPf7rsvaNhFG04pm;pW1|hk!IbI6yL_)X=Ffrh84# z;Pi>@6*hp9clA8KoitSm3~i|?5~o`y?CegYv9~j?zRxVX;{mf2CE7_pO6+nrey@gVo+^!IT{{j@|zYKFtNVi z1w_w~OI<2wl7z53jR$-k*(G^Tsl<=;K~%s62kqWp%=j+N6v%LJ7fBOCk_NfZDKK(N zR+vxN&(3S}>KxojrUbWX8kCI;rd7u~7_cw5Zty7AhK~JsEaE8f=vN6Ww>n8FlL@A8 zN8<#G4=A7Mll&na?2&T!n+OTay}x5Wt8Zn$uQg9dg3@hOaV0xUNVSqM9d0iBbL>_! zxZ349W2Xj!P-7>jpPxxvIVtDt5LU@g_qw#vXUDMhK+K@({hM^eWc#8=8cn!{Nb-iT zvup>`?&Bd7Zu6^B3KP?Hor_<~c0a2!WH!rvZPGIrK@rVHSWbVxX8F{Z3v1xoNC%f-STO|235fp=@ zmH4F`?Iii|imf*`;Y$xUP=R6PSX4uDAV(&q6Rmez_Uo5Os4dm>kwGyV<13a7gmDBZTeHX6NJn?!~QYw5grgH#|E`&Yn;ZhfiOgvaU?v} z1uand3$YN4!%A59e*|56@5^EUo4lNcW`GNtrotUR=D8>UslRbWom4yZmw1NV&r8?o?si|^ zbe*a|$f&XKve2qnUSu{#njR+b*NS=!uR}6_vnqRgN^zc=bQRJzKi8l~DT5^NFR=@( z{u7dn&2SgcHCWVRI1Je|u7r3Z%iNVKnf^3iK}9@xmm#4tr3+5*Kxf>S22KZ@y1B6U zDMz_w^B*A2|8Pt0GLw&WKlu?%czo{GC(&)`I=e&Zv1I@m?uK5%8?@t0<-0VAsyNc| zhirq;BanFd#0j8uqi8l*h%{h%!WQ!YIU*NsSRE^SSRrhx6l%&2RzSv~r*#bGN&z-u zATLlrXH=kEJGsrK>|rVQQ&_1hC#8^HP_~Ns(g>U&a%I;Y;QIMO<#UfF%oX>HB-% zRhlIBtwKe?3Mr}R1W&XDkG`Kt)vmqG_yY}(a(hFcA8G50L0F)nhhB)}?G6?gQEJo( zo}$-pyVb__o};f#t+azF2KKTf6ZCuRO~6PDPO_}VG)eQiFr9|TDdMcPz@|jJ3Khql zHZpAVa9Yze#@)j)nt7}7WzmY*FdH0u%+4^g7He#O40`e`ic=?1J1z_g0a@`tzh+I& z&UZ5FN}9PYuPSX(HtFVu2GR`W-^mb^G@S-^W^Be@g2WE=QluLj+Pr^YBscn5Ozf`c z%c3jkF*o$J@F((;W}op}wnZlJBzWC?=3`8db>i@bdp2(enOuNkS+R+uSy{8=6UZ4I z^}!CY1l+46sg&eO{jR146C}%C2I9>XG4}!vm8Q+0C6M8xBt&OC$Dwphir~=?+0pjH zwyyk4lMqUpW{P&844B2RL@Nos{e{~myK}WkCn$wpW;8;mR5`Uka^XjQS)Ry>e0r!` zpfE-bFv2`!T~iWfZKx?cF8*5#atIr49SyBOND^5WnE4}}t>_N>@(-aEgM9(iL_jJZ zU_n2XjsMCS(YwZ?brlt@7&?u?_%iLRZh9%dT}nlHxY96x1(HRc zp8U*a^A3)jU4sy7>W~`&w$sd%F2gZrL~Sq)@fEJb_yzSC4)E!c-X>?xp&g~Jxce54 zpvJ}be*c7vk02-|Mp7Np66*a@rAvdHO_xa4Y7+l1oPrb0(x4dvR>&pRm?S| zkQZdhF)b$awx6Ze0+zD$9~xE&@oQBi{9*$~zgm*s{ZbDg^-v~*0!-07Q|XSw$ zd16+?J3f@q7KpWXy1n%Kj1F~8yoX+KBYz#~fn>6cjPRjEh#cHUlUP@9t)~4ZH(kUi zY4LX15s;pT^6@&XMrod5j5$Jnb#+2NbG5par1~gONgO8i{5GtzT5HW`k!9RCi zhft1-9WUQ$yAx35jG-kGchlz>^|d*;nxm%@G4sjb#6wezEPowSbWf#X4t2QK&89~S zn~yc%Mu?*c^who}JJ*o{-cMuAJt8$3Y+g~4_NcsuX)peq8`AUvcXU)G?vY4z(%2XU zN0DtyD+nG#%!RV7 zF3A7nb*aT#>C37$U`YAgZRyFl{IwI!bU=SfqxXsN*vQ=5cYVtgw|PwN$sbR4!MMT>$fq#cv+?#b>Wzh+<7R}H=W-fjtMau{ojSD!H zE5tThu_8c@xhUz3JFY9U6RI&zKf0$Iy;G!vwr!8%PwINdf?S!e)K98VvGr(wdYpNf zIRBc)j8F9u{n&mJ`mhry{pxrIejQi-3;H0OJJp&|HRFg|0-NB0fjoqFI)FYGi_^;= zpHazq+~KS@0=(r)E(D+FX_sL{WRlAuUJ1NEu9Fi&_$-GP3EY56yoTAl^6K7YgUl$C*<*N#ucSLvt zxQkO}hAi{V6G$VD5{`5W1}n6#t3Riz?<=pfJUARYcU;;(^oqNczg%pe*Sl<8KTYLj#{J1%Z{;Kx@ z=2z^xwC4Kz_G5T|T%H%&KA*os+r~US`9}uzHNI0sj_!l9j6sfGO%3;5t*x)F^K5u` zeI4B(cs==92ir`Lj=OAcvdWN8Fm3vEAhi(TTb-DoUBrSGLkkrB&QC?-a93|`n>*MH zUGKCc#cc9W=kS!QJWil8d%ogB*iNR`pTAjskk07#^j*)@NP&{6WS7_`S1w(|g+9iH zoVwV&RG;S{BBYl`CymZxTDAL)s*v_}nMtZ5(L)08{q1cIcdwdBB}PAbkO8PioawdR zjOMb8p)})@@5VUnA~pHLBU`Q!z0SZPA^O-gk&j4zc6G&HhDDq*RNL+bSWQwBmtfIoSKn1 z3>z^Ol~X4SJ@Dzt^88{wB_hW4f6WJoA^0 zz}qJPqbYa$!_r!{ZKA4PE!uAqfFnzG=pGQ@2DQ3BD^ImCuCTf&12^=3HIi#?Is{J4 zl9Jp;U0yz#Av9fpSG4*n*pFQ;5ia@X@>A&5F7O}+h5)TU$@M9zvIb}pM$e+ri^VIw z?IChB`tJ&(X72_(3;x9yT&ya7=Nc4=-*#g6=Aq-^lqOp-yU1;xHBX)~%mkBbuGbW= z${z&TF7+rP{x*iVHM(WN{Kk|Z^*skTFEiL%pt{mYV#aIUNrMz zGAC?=Dz;}4e7rqv0$=3J*@uiMNW)O&9Th9K1Y=>y7Rz1n1n1wCG$XmyqKjd$Q?}_j zb!IWE6a``NRBj1e1oJcWbV(EX$LzF?sG2-d2hJm-js%X>P;3|wDv^5y%ki7X&4#Bn;T@=*u5s98_fKJyPsv)k2XuCrJ*cy7My5#7BnZ z#>Ps1*0o2m)%!{#t5_9Lu!fP&uP$LjE?UE2ysJjFS<|8CoQ>fpn`kn=CC5kO>T$1* zFo3YfgHObUA*bX88`yNPFipcU0=+X>gr`8rSP*preR$#8(ir}Da&-Ros{hQwjE5spi8CZUYmOu8@-!COpd|AZn zRrxCu1P0-FuSLxyTe;Gqm;BZlbea#+aui%qIq<3QbTcF+J4hC_>D&jWKW~yBPgbbb{EDIBl`5OHpq73D zg1jyiKZ(x;N~g;$amP1+Kqe2bA^C^3 z`9z#(dV*ocO@cuLg|2dvVI*|vG4LpK8vBGIs{Sve7tx*lsQDGAV-9qp3KnbY4gS6h z*N~W_H*D@v;*bP1WT2(He;=|uTVioUMKfEu`_(~&%<6d57OWv!Tx{1*#?=k3?IX1j zf$-L(M5sTxyTb7$SX>Fz32YIsGF~yqH@gUGw$luSyjhZuzC^(?a}*BmOhVKDbdkX_ zWjE;Ijk^Ekw?6jQEp~WO?QQXlF#n3r59&2w-}Mx{9vq%ek{OlWjq- zYU}@KK!g&lfWIrF2FY_0MP)8@fSKi;MFnl>;a63MsM{zDNR{2T_&*OVhL@QSV+6EG zkRv|HyAFdokUQ?L|_e4{J;cum!BmD=f4iD?oZ2hHJM~CBzJPQ_+Kh<%?uD zfUM?;uJI0Vk-VV z$JcrRA1+mIv5SE=WSR}knzBkG~eQunlSi0f&L>U(g3t+>yO9JQW<5l2|aX0 zj;<4MYu6Z@v^C8>mB@-_RiSnSXU7V`Ig1SsIGVMPbt=jqjGZw~xvl@0+mVH5KC)F} z3=TcaOd9=&*~#r}X=GHXHFdJ4faqfj*fO9pCc#7a5Y|i+pGw}Hh-sfj5Nc>#S?>l@L%3pH@B z{TJiyLd_+i88a-7-f$BRV<|L21aE-zG|&b5{_mIuNs?&``L|P{BKwtO zNf7}Jouizc?Q8L>)X-|!u`5lh89+HP8Pm$Ro&*k5M`rWx(wuOTD2?h{Xm*D{yBEdl zncOptPt=h{)8GuP(A`j#YJ*AhHEw$Y)s!!JlPgRK;s}^F!@H$3-Ll1Z4rG4o;I6N+5{NIiTflB-G5}7Ltl%`8+sFP zwsGH!UJkK;Uecn3SuNH{jFzdgcfgd*f`X_Nzg#`b0(vLGBQKaD$-I#Db%j@PP6xi8$d zdI57T;_iatR{t__pBT4b|K7OZC^2Pp%xB%-blT`^i-4;#eBInopv@DOh_kt+{mSS)k zV=5TyxryxbTW(S$oE@uKJTOPx$Q=@`NweqXePk%UL5Zh!GobTE_rkv?Z9{!5D7gIu zQ5y3E>{1RVu_!NzERUrnc^zPzuO9caymYC78aHI(JauNGTwjtCoJmn)Zk)h&%z`|| zJ;oZ{+&FY^lB)+*Q#@WEoIie&^7`f~pL?+Hpq>4A@<|}qQ;N|K^iFDt*i~o0Y8}oN zTRrfrH8-uGBp2qGBu~gxb*n6f3~f_Or&9`|iBGc(?84c?A8qwnZ61N)y!sMZJeFO|_2G!QYAtpgf!o#?8(i{aH*sGLM@9mOrLU(_egbf5ON{_KNihDRMQq2V){$}_I|ON z0-Me1Hf`rU2#L=*d^)*&I#z{%Zm5kdK3E;@CXB%ykN9eoC$yK21wqNL%aL8L*$?oI zq5S$y2KNVyPN4HOKVNW9x@hx<{(M-pTXtw!QsasQjYL78h*1Fnc+8d7uMPi3hL!MA z^-G9032tgu08AFKYFJ1j77;gEa+$@$;%_$bXV-16{(<=BtnJlu z;spC2A4`7%{#;nSO=IF{)?4~#?4V{=-ADCO{M*amuz@P14* z2~;0doKm)Ei(23YM}JjCi29av?4-|u#+>+vZ$dV`zYES&6pDY^#AnerJ{}mXJD`}j zqN~fgtjU+H3H;hT;4EzCwF$FtiWEzg37URZ?VtRxUwg9qY@&iaZ0s-|gyjr`=f~7l zTO2gyR>Bdj;Xm}IUPhKB%_^9dx!iJs8x1-eRe1)6$Q7-`e@ozjS2e0wMDf+A=$9ze z+lyio{Nw=oPtDz`4VYVn87Y}Y9pj{nkGH(4kRm38(G6{i0NQ=-)KTQX|48C_(*`L0 z;UX{6pIIXAQre%%xxCr$AG`ui!jjSYO2JMBP}?cqwK1EdqbxebW6(O`HCXLACj&Ti zS)UcQf&pk+`^N1j5cN=H>K({U>`r-un%A}6>qk(#ln#T5LmTw4N(TB9(5$iZSgbn< zhynX+m(7kX#+^!uuwx@PU+u%`${15H9D95F_mK8%oPpXYk`#2Pm7Q{J3Zx}xp8;;^ zbrl#y{a`H`Ld)0*vm_?J3zX7s%x>7nR#JFTi*%S|i-Tq|$}J@zkIWL5&a^Ft0QN^` zk`u_$?i~n5czCW$5Ncq9cZ!OY=;}fcUz%zBA}n@xtsR+^6Jjl?#gId5E@n?WLp^tk z04Sh4L;Wau+sVcxdSRV#?3lc2g!T#Z*k@5ms^qySPpXTHn*fJ#$L6Xgdo6aHn}zn8 z#<6VK(l4}-zljO2#8CWeLu^Y5zr%nEb2qVytn`QZIcvYXf3}EVlXm7obPB@_WI41I zfrZ7r-?>Twc9N0=Inwq)+m1%!>=Nq{I8*haY=!?!6^b_&S`n!=D}x~;(@4eoA3+Hn z=8EBtGQPI8EiC<^bA@Ab9Jx4_zD}8%W(vWJQ!VQscBt+h&CeJ9#E55T=`Hn4xlvy8rwNAdwm_aUe;)@KOhJ?l7m#dg36c?`TOJb|PDttK1D!1g~xS1Y{X` zro5UlsX*ZsKqA#iJ-7ndHDDYM^Ln(5-oZ57RxusS++9p20oN_WiIsmUswyJGF zPGv{L)Y=oY)Y{3&oSnkY%!pMdAkAr;GlYvV1c-qM0^4VF5#p}>qW??MqeFnS@wL7_ zv--ui=H2zZ!uw$N@lvCD-%tXkaBsCvM`ui>268ZSm;L+)({xSAe(CGMZY}K{i5?dP z$bg^SW0Z6d4<1~t~nT?#U} zq^YtObs1R%%(O_qlR{KTN0AO$0+=a|fv^w$*TLTQ+RXm6I9W(xE99 z0e%DiD-l-o-YpuY+Qr8=H;k>|KWjgb^VG=@w&n$Om;mqpWnTz{mR6-MIjN$}Rh~?_a|Y-|U_*=a zcLf&IQ3+vDcwFl#nw{s91e$6Pm6Su=+mckx;GS-g*Sg`HRa){H4|}(Vl`Q{o^gvKf zxUk+aCxyo)714^(`=!SDc=7`&QF92H-_AdPKI_e|`GIe7-cYrAvN-%WY409?Vb7^} z_421cYod@Rr~UerRJE8yq7xu`&<5L#kfQJ?R0^u+C85jfCRsIL@>o~a(_RHQPZelS zChkEZTD8HO2HyfxVHm8uc$FSpv~$0$ce2=${nk?J>iXaf)BO@qFCL$jWUsq%YmC6A zR5grQ(Q>-QEGx>x%P)SWlx$E%^B_U(+UOJeGtx@`H}jf*N2m<$if(9ZE6y)N%Mk|n zCJ#+>kyz}Zu>x%xeGMY(hM^05;8+c~m8BV$(8g>Cpqn@3mkzc=p9t{h(oJ@9oXDwm zCxa?N@r_gY6&)SrY~nSIQ)pDjLv_RZ-HmqX)9&&w%0BSZ%~bKn?RdGiC@|FQ!d?`} z2MsZ1rW%8EBHg>^ozWN+k?r*slq~lukFC3_gS(a>=PS6A&54ipV4Sf|W?p+eg*C>k z>n^*?A=fmQ%?P_=Po1QhojB2Q-;NGT66+{12|QPPu*GtrkLtB;^qv0JZTqvd*U!29 za6GaGGV%-CGb}@)g+cQ5jBwU~oK+VW!vIctR}scp)jUl7rC<{bzF4}4YeGwD6?k3( zzwush`4~7P%O|X5Bn9t9_%#d_WpN!n$5tGnVbbox$v^M{Ingaejj&qw-ZaFABApNH z&M&7H`98!efq?GfNa`Y=um}IxK;RzYl>*8RRe+_yYqIkxT*W!Pl7+&gD>;F-nz&Rr zo`xeSUw&A$49pH$@U6XXc~Jfdj0$k z%P*|G?Kr1vJo3AOa(8IB>^Scs<+s$xR07g6#-u!Pw=IhAoXg+_7?bD1&hm5WZn6`b zq_CUE!usiSXNRc${tuoJ00dz57#Usl0 z=n0nM!cR9oO#aie5e#@a+x z^~@K_dlo(&T&f?9LnLPFd*TpiE6&A z2_9q~1d42^EDH6N#Q7V)5-Z18M)XDZYGhXLvZ2JNsBChl?1sz5P>&BBrs`MY+mbxfImd%HmO%VC~mq%N_!@ zZBE=Xtu7qyo;SHssl29z%Vl*CQAZjAmBn&lr8HbBOj#CiN{)sN)?UdqTzV&TzlZ| z+?O&@E(AkQHpq*9dHKH(Bz(amfCuFNy9fKb+4KLsqx~oO|JV2l`M>IPu`fNbHmxkw zS$Uff_k`0cya+C0JRJr+9R~dJhXGj&6DnXZ>^Grc)7fA}tQ9 z8|`DVxiW&8jFF}tZlssX;h~kCt9!=J0GM?q5@TDOG;PvRK33K6mK*`=CJc?dbsL{6 z#jauBlrqp(*$4%`0`*f+VP@xxJGScv%|8<_XR%NM>BGgt8Ya^Q$GHL>l< z0LG)L%~AXxA7%9uqWt)5Zi*{Y&}fWaoWp~C!;y=tRF3}RGcz6&)&~TW3;z<*xr%XZ zf+`hs_CE~3PLPcNpR z%@A5@g^&3|#-^9smfkg8h=;fIZrAj`8sc+Pq^hzYrIR zw9s6Gd`2RSUPg2m&AE)|aT17Mt1YMJOIH45Mc52kkiL;&za}n!?MWQp6)&%Zk~<6{40-?Zp;5UTo>7=e9{q z|3Z;vRrZQ0<7ZN@q+Ivp<==|jUYL2P2wMLVO5y0@(8WF~Nl~}yUX8PF zI%Aj0r$QEx81}nv&uwaW(=kaTUShRk0jMa~i@uM@j zDU483>6_x@AJt$t#kDEL{_$CT1=*jm&$C3NkF(45OUq@x)-Nyrqch7dssa4K{hxz_ zy{!K4(e9J}@7MVW`Je3cjQG#c`K85@(1O3Q_759DEvy(%^%)j^iy=+rcPa-jSNr!k=Br3C2I3y~;K#Us0C|nX|~}Ubu*s7jhf5 zh@xx9Q@WS@V|$CNgZ6ypPlKhmn2@&DbH~5&QO(6)(qZTY4)qu{vS0(Y&Lk6KEyQFM zCLBHFwxI?yevoThT_Oyo_yPuO-gtQGL~68oTKXOyIgn`xdG|2(7oHeQm;>peg+!6O zg|Zc)6A}gChf24kRU*-?-6lSjW{4CWfHeDEe6d~26bU%`JZKvdMF5@kd+kwU_}LH` z0|!9GE~nf~-^yt=RZ@1?O*p8=opN#(lcbb{|_>**qH1=HPQnb#{Ru)ShL< z3#)_QNhofZ5@_mVlK3kHB}GGMR|UWeV5qP=N$!@gFH&$;;+@`Q;matT6laJb#hGGA zF5{JWUVyA~DQGAjPB5WV#(C^bC$r!(ND~Pz0Iep|WP;C{_&~Tc5DGK7xI>Z5R9Qz4 zi%`Qt)D@Kms+)ucq6Yma%~)1agyAjbdXC}Niip(DLKl&SL4g|ISkN=6FM&t&_o;#W zr&Dq*!YR1!;3x$|2h}-bnav^_x*a;{OrdfwnPm(8MYRMJf&aH+{|oqkzQy_K3+91L z{%c_9%ijNnU+(?yJ>dTjzhD_kfB)wEe`)_C&z>f;FR>4NVE^~};2>-N;q~GElm5q7 z`KcA*xZ$=(Zp*X)V1R!78}PZ;)|FZ<84;r(67)3`WDP+SQh`m5b9gqHqiq!Lef?<|yKL5CbE?W~$X~XQJpBgEUr! zS``<{sjbXBC`Q+akSkIi{Ty0MrQhj|w&-sudPidu@_o4HWKcq)+XgGGrp-rn&6pxW z2|ko)6hWk#6F6J6BdLAtcUmuW*=qFgZeTR+xsJ4^SSrrBj$~R=*jk&>xi2aDg7Q?+ zbs1}9aBE>^YD8Nv>|Bj_)>+Qhno>~wl`;Nxx(k&qV4K;j4W)AIX8{eij0OOo!ht=F ztUna)e`~rmcDF1ng~Y>vOK!&g?QfmB8Ku)RqWrH;!OmN@0_UyTB$K(q5(8Z4u0rzJ z8wkAGB!xp0Sm4yG*!kRzNdIf3vGsFa6p#i#(9Q=|XMbuN5rX4zH`RCHCGCU%Fhq*^JK zw;e7nWht_0XKO8eWU9PmX42J_&i6+?t)jZBDs~>OVL`==`nZp&PGKz=Sufz61ePqw zCg6zipoT+Gkdj^sIVGzUYDn<7tysy zS(Eu)dAp;4xt1hGt`w!THBY?D2`iWOezKaW+M|go53PqNCSw)T%v_R8!3-i@%!bK$ zn)`4&e{4@im^!<3+8V{c$s*~5Xr+`TRi5IN>gYf==+QwQ1Ns6HxCc#y;$@5zJI|(; zL#8q@vT#1I>WV^~i&8vnx071C+-RrT`Tn1`8&)d+fe(s+{^9bUz545;dOa`yIeL=+ ze2t%J{|`sKDgQA*KSBO8QwIGok;b5-t^V$DBw<_mU+&~1zeYNt19 z4myL$sNIG56l|yZY44Drx>m=H^VVed^`X%&1gh6}jrL&B{=wwXs5}D?cPnpf(Ejdj zrG8|?jsUiwO%ERmKgy=}24nAKlH5B0=-y!_(F4RitY?yajmbjAGYNl-McCUt$fR69 zz@!g$zs;mw{}z*Z1D{Og-W*W%;A;mQ9({lszCOyPzxU=t<>(N|Shjr+shs=u-Pf5c z4qsDIkM^K!cF4I)L!~ZcjJj)^CzIA_*m8&F@CM*;=(M|L)_Dytx~k10W% zwJ@V0P1ovb46Gj=cSbm=tnLOfzy&vI4KQq~iiOo`pi&8BdSF7`QGY-8x8fo9kfSS~(tjus?&MO5xGD@d_uPX)7-xy_6!1|F{Fa!L_DwU|+1SWF5 z0D4#{z}?$52L{)-*YCCM4qY| zBYe`f)jmEyr9_RpT~2e@Zj6AbeGlK3g|nB%k;Lv(g+z^V@KO5k(mJeyQdtxLSv&;^~%qqs{vO_t~{k?oJjJ58$+xgfwXBC9P z%G_*s?GcM$8dmmj1#qj~ZI5j71W*_}?kKZb^oiWM_MAfC5NbcNmmF%t{s3l_y|e)Q zBQQWGpY55}I~&jq%8=(2ZvQNeozGP_3eI-eqi~Gnz1%pz7hzD~;d#%T-neP*TMZ7N;U~m2DFwpB zDq-b4`gC&M?b?KG*gvJ?yk@^Q>h#XrCIhL$cv#f)AxK5drB=fKaNcQ~GzU#qA2*sG zU?n;4eVE`gT<&{|TU8i94BCyei97C$n(xh8^#`AMPM$P6-APA`G`A213NdO7VU_6G z^Uy^dGnjAhQQh7#*W=dtpxbF8^=x+gFd*Fi`LNk`3{G2PxDa{LXd-!Z9K-54WqsBd zpkA8}cbwhZIqdr8c|0N?j&qO?p}AX_Ha(_pmh0?%)c#~-iQLj0x0x9X7ogmX(Yy9}((%lVFUJ=)l6uCY@kIw?DB4<9;CqY^(a`y%u5A3o&4Q zQ7D;QP?>RZ{CQ*zbro<1u^X`aIIzR8r*P^PMpS_^awf+NQ6X54UJ8{pC_mpt}t?(hkFh@ZLiffnQgv+4aJkO-ehC-+GC_YZog|SNc^B4MCd%Lfw)mj=eZA3M^{PcB}6?*7_+++(!{ct3TEX z8U~%DwuU|Prx6e8^OKYI(8)2IQ0+Vi+USlOpUu9<#hQsRZXot;xWLwpFoHFWsHlpe zhboizZsU~cA9AVv^V9bgtz%Mv%9a5J0~mC$vD|-sP=B*`P=E(5!u6y)_mAGZ-uN zM#XjT9OXS{co(4wV}Aee@Zey-sIY^++xcXm){kC80qRAirT!SUi4$YS7DnE;uVGhS zh73(MY~#udEqm|=HtBjSbce9}b}Rtwyp5#{SZKsJGy#ZVt|=qjW;=BoV!k5+0OG%# zH)ci*(whPpMzrpXfTMM6Sr2d;Eno?TE)c#?z{udr-tM^_LNzjOx|97q*bh#QJH5v6 zvq60^2qu{fu;cVyXlfaBXax;`LlFV{b^!I52s*HWaJGv8-3Gw1&@KTM@gcG;lWx0r zI(qNab$;)OI#K7Ho+DKR=J{JI0U3-zZ*=8a{U+@CPx?T+(1}whA0|Tf3Szlvx%_-U zw_{9_Zy~6(YsC@&o-4&xNlK4RCzr|)x*LY_S^p!lghu0X$Vul@yJd8f#s?*j-rad&YobI8Lp8A9lbUlkQR<5g(F|r^6_tqDUx7%JPg9 zfQ*8(Ul1Vb$OKl8CqAJgLeS~G2a-85@-stWT#edI*kD1MFkv%i?+AGk+~;!?M{J^N zz!3BAXv;ztQh_q;LmQhpnKEQUQ&R5gMZv*y4iTiPpt&VHg?<01L2O{F)4&IVkp~&^ z(?vNX?nx8LB4rP!d`>;IfF^_56I2vsXWOeeh=g=s=5?D4{?0 zd(ft>f~jN$BhTDw3{Ae;3U4(&ck$Mv**<2t7+o-jPQ*{oGnbbfVwu~-!ne%%>6WiZ z5GMIa*kmIsh>}5^_y;D=03X(JN3{29c3oqggg};i!P0?yavD@eX7I;;7fU7)kOEqA ziPN+8nIMh3HW27&J3~kX95;8?zWNjo-3>11^gZlgj*jejtyY`(U7M5Tpbl_W!xrau zn2CpjZfNty1n>1ptkxWvH5MTvL1%w28v=`eqlX9LMG20mVwO~kLdweh$M&#~kBwV( zH!1|#6r^TTs-phD$0(YxvmIG`Jlsy7yDaP4H319s7qkDY#3q6_}N zo<+x_0N%HETxhvd+I4CCTv3U2B;Hpe<%EgU=4>Z<6u2EUiV3x93QmIalYs7ME zg?E(4v$|g)zUgK$fqj6{&__;HAk|;zQtNixr?53avB2=WX_c|w%BR>9GC-Vb6LlP+ zqU;q^i;D|G8kt%fJ6AcpS`Et*N@ZM1zKxSW;=gHT@lU$_2A&WIF#v2xaAT$;320s1zikiAg0#UJB3+vQo)Y znxgs@&6vu4)2SellWu+zRqmZ)WrKGt*j17G>P&^+x-q`jbSVFHzqiOQ|dQoEYc0F(Ql0#i1xc z=rr5Li3yG`apFDbHk$fW#XKOEICMVV=;E%~Y)2K|YIlL9fX?aQlsWGAN5&LYSk}>u zF$wSn;@SBbZ!!DF|J`nmT(eVUxHu!6@G#iDeXUt-BdWEHCAi+i?ph;{0*m*j6x8XH zh@;z9ENV%*`BZTTwF@OXgY)4jDpWL%@%4{-20j$s zzA?;0mvsdW@(6fXWMC8|;kMf!IB>5hP#s|rNA z>d-iEL2J9`tTIth1xCQ`I3HRo0;eqx-f3{t;i5RvG$lqERAB2-odMX2HXciv=eZe7 zl5Mk&nq!^k7U8`I+IWui-aOMSOz<;s{h5Q^Y;A_8=OjBJUf&inWl-^qXWVJQN_Ez7 zKUl=I{gJmN=3E3A&Q7zXCoOkqwk$xP}CAtVLNG_GAsW{*py+VK&= zXErO7O0R!9;80BBxc|vIvczyaK1FJ&5bU+kRZ5I?3wGAQK}i97R)Cmg=27DN^HHlm zM%H)O9$6=onl)^HYB$eeI`D!#EX0wTUjiA4q;*_SfXQ5tL7@5ed1KT+6FYVlB3S|o ztJUzcW!(PeSy(agQ8^5CZ1P06*B4rChPGs@mD7jD!6<;{DeCZp02*zGYPdN~IamvX zcCeXIuYIVrr;U?>abH0V9gO24-6nwl77VWm?C;tzRD3_m!04I){;{BZBj6wdr5geG z$AXgT|F^kxN%Non+HlhRr@wZ2N%NonTJS?ic(+1-Z8)j%)89;6u;xE~GBri` zZ8?)YI~SoEAx2dt7l2H>G0FwB-Qa+|Y=8?Ro(_~Kct0CVTz`+Wr!f2=8{X~oJ{Tv# z0tyTv5I&jcQ8rlcH=UOAIvXUFGbrMlTwyuzm{?U)`+*cDg$$=Lf`#h%9M5#K7{s-A z@DSiVDS}w5y}-dK-heexwTyL~YomyIcG{NO2kKp(;9-LMzCRW!NcE!N&L8cwVi}-B z$wi40(?}O4jP}vNKytgf1?opxl;L>~7ZtZTY`1&PelB}bsp|Jm+U*uLy18Up7(kUI zin%}PoTR| zTY$s`bvqQ5QG_`^9`1WqIEzEia65=6zl?6Q%6qBoDfkFuET6f^+)eEBUH}4vhd>*X zZe9S?+^D(4kWm8WjU}N%gy)1#(Tyw-{sBm48^-YMUKs}KvKmIIbj?RYC5vixToQB? zhqikx94ZWy7n)2015ExsNt>a$q|LyGk{PrGeP%S|jXjb6X^`K*8LIyKjyuHzuR zYlKmFw~W@wZ+=rZRbgb5P7AkY>eN)l>&*Nx4d%g=Ouv>zK11bzelHt$x$@&A3h#@G zx{9ZncrAZHhDJ*xVGFcBjgT&(8rG@o-#lg;s3(a*NTpaFvF7pIKlFv-L~o==rShJo<3qDVVdPE~$+Ju>|&_1tCyxo~uhZLRnw%`6O%~ir;w-q8#$??+TD;ve zph@idAz1^?q(1tD=s~#l`{Ac(KF?(F$@F(Z%iE6QC~jVPu?g(07YoxrOp}80G%lhz z?T3_tRr>XEdAIkr{u)38*$n*z&0ozV;8PTKgQfP(=j_FM7S8cqN`piCxiO{BO{3MZ zwq%S+Vd=GZJ~#cUdI}KP;Ww%9+9j>yn1as7!2_TCD8Yjdq<$xzQ*+9Tf|JkLd<3Ek z(@X=5hQMLwIJ4=6K^g}9>QwBmFGi4GK}df-PyDnfipZGcB%7%O1EKN$RR0Us220EZ z#!6{laov#5$BNNx+YG$vwV!t7OfZ4Ej*=drsk30}pLxl(0X14y!Opzf(d{4B{@S;J z!y+I~JOhF?%(Rn$HoX}Ngy_04v2$L4NI9!lPrO! z`3i}Ee5I%gD}P!qfbGf7tZ--IC^b3~yGM2-x{EteUP9L+bm)7t4jPcZ@fJwNqqQDP z7&eMh6>zp*q`_(tXnLMQkuP{E1YRHRPb7z-Vr*I+}9)P7e8z;ab99 z24qCVD1p&<%c z#=sBCqFn67juyAf~|)(n_(tOb!gwfI>f`&Wd4v=cg)$!6o)|T z5MQl=gerwpK+SkSt(1~CepE_Pwo3V$!kDs5Fh1W=&V}l71hxF+8n|Br zG78d#$<=-`+@DRjAXh3ZsGGZ6!_#7amNOzPtUvAFfrwSaLfk9#y9=4;kW|JnQd?lyAdP#oTW_+BB62AhOtAv8;`9%Xug&toV5T2&j?Xj4E~ z#R23VxV>Rj*8Q7*!Kc@3C+k$qUd$h6PoG!oIcwj- zWDnaHX_->mWm-fgkb96ZBP)y4`#CdD^?==jM@aYbmVDcP{;3)Bbx3yG_oDtRc2auFmtv=ZAz^lf9#*Z`uXD zxl6{$Hs}c1SK8C+$8t}3VsA#jy7QmsOFA+0X_S0 zR5$Ql@DUmpe$hC<{j>wBJSnO2#->Ww|jAS^E1Yx zQz}y%tS!Ph9bhy8(3YGXz%VYKE6Kod)lDly6tT5-p!LDkI)#x90+e20{n5eME(LbU zt#PmSUeUt9HMDc4G^&eEvI_L7EwcP!AMPSEM^-!SA4<>nkF?4DP@5<_|0AhLzZG(y7_t^EWZjf1WM; zG=&F~OB*@ z2OwqsslpPdNwo5V4bY(6SpOeu@u{1fRc%Ko4P zps@(;SeAI_7-I{Jf7W)VX#Z>N-!ub282=RS+WRlf)dTd)c7Cr{7Y7+XhA?}KK}TJd zuuI3ygH8S=QO%4lZNEhBt8$xwk7TNU%kM%r0QtWruxvU zrTb`M-D@CG!>GBHS8?!Z@EFOEa z#pAK{G(UBJ(Sgq?K1cVXdhF~aStmR%y>cTme>pfey(Xq-(Ufep>O}xO-%jbdJs<50 z8h$KZ6RBxDO0$T|yX9)55hFk}JRR%&sy3t}S_I(9{3lZkKs1s^X7x0GlvMB;F9#3X zMDGdvXpuH)JbQ2B!y_6AmZSOlVWE7#k57_z+AXqIIE@W0Wio4ip5Og+JYfFdMRVAJ zQ9m>iO%2AuP1etbohAk*A9SFR0~;m;pHMg*Xf*u`3xYb8l$So?%`Zrpyk_us2qWl-tVuH1ph-&Ds$$wHs?(bDyaDVw_4j=R50qpF=+A=6;U5Msu z%^w#p%oam+0ta%?)lHUTyRzLAhg!BpiX+~tCYDuF@hZxle}CR=N2{Oau{wC|I@Z5zVC(;I{MI}TB>&4Ho8TvGj61GFzBhJ#}1t?R&97a~>aj{*@mY{1E zAo8)T_KF9_-W!i@DZJ$=YC3`~hy07=UYC?jUT4d1lKRo~1v zxbpzL_*kwwKK|pk7vYmB|7o#F`$dPI)AUgA*z);_ycxQyPwBB$pPJ!dlDHFw8yR^D zc}UV!;SCs%^|Z9Z?$oGWA&G*dI+uY`#IgAk%|B6+`g`jzpFepV)_Ww2@M-Zle!7P) z2Yr9_yuO=TNvbE*-V9FYMW$fmd9l35T~n*sU@{uMb|7*wx*HSbh;{_tNb0B3{r4~u zUb(wzG+~0^X6SyfcydhRs+ah?e4GnHt_t5p>G5v9?5s?v;uv%?TaX_*ws~EGxSY?{ z$ejkL6F=?2AqNUOK#jJo-H~IN4x6n4bWdaJ&n@3wZ}I2MVW zj+ccl`Z%A!<6u>QEXr`<^85@NXyw^3TD2D+VARA!O>_11jl{K^hRqV0U{LvVD-|FH zIs58U4!7b?>mrF5og$W8So*;P?LE%zvbXwquFS2;!~Ed^zBm+1bI`k|ZybnjPzrc_ zf4V&Vc!D^a`S$qu{^T?{{)qo9PfmE2Kh4)Gm*vExg83lFDGQguswXPzA}6>Siu$^^ zF_yk8%_6uu$r=W1M-_%CZ4vcSd4ZY()NicA-KALLSrLe1nV0wOi!;Z@+IJ9%jj%Ww zxyC9&G(oW*kt}T4x6-qe#^ewhTC8^EC(&Kt=dF+DkRRjdv|C`g-3tX82>YzJM( z;lDBA-t6gV@yOSxeI)J5SKb?p@Z>uPPs%CZ&er#M_w~?WyNkxJ8?~JkE^Es<8Vm-j z_13gARDnwf^k$3YX1UrPK4kU~dchbeqx8I;f899~cXm5v-#H0)cW$U;989m?~?scepv zq&i*V)TkGh5_1EOI{WUb5}&!{6ZZv`ngq3)yu4QFX1tlNJ#GJgBd)3X`CE+t4i?6y z<`8r#bA{%RH6wmS(CD!SXO{rB4$EZ{kF3+`pIu_l(kT;tf{vDd>g-R@8O@&X-t~4t zHt2{cWmjV~J$ps9U*#Gck7mA1a64PCVkENzA3;*E1n&l%!g1hEAI(+1*EMjb*p?!cnYLT=_59Ofvz;p=M?sdfxM`v_-)z^bZ-*~` zzNtX<3~FW+heOVxJ!YnIYeH+Wq4BD2DK9>(XX|fh%G#J?+z|gRZnN+aVJztwH=~uc zj!y2MVFmU>_eV-$b4R8c;C>UOyT8}por%OL%lnD{PaBgGzayGpV9I?i|40c zya4u6oJfjd2lGOjI6z}H^xPf}A``3D3+bRwi>Qw0IB`(^$qV!U$MbACSc9zoYL1>_ z78^qI5yT>%t!Eor!;gcB=hNEU0UFvw zqy!PMj+N5@XSh{dOQf91mHxeQXD!z?!Lh0G$()=CuD9ogkc+rIps zHGbkcLV2s)yMo@eEGCv&OWaXVWEU{I7S?n(U%Ai4qfSfH53jup*K#ii@)=CME${EBQ>n z-@U%FJSkpuv#YHcoc?(lX6UW%pMm)gC!)xQ6M=-we1`&m!F+v!?IZ1F;VypJjKJgDn{M7nQ4>*~g~@MUCt-f{eG~^H2sB!c$Ech6)^k*f?H~zj$!_8? zsiU(+FXo*{Pd+3AYa1$>DQ$mGxuazX=EPt!&q%LsDl8@Hjn1(lHf01Vb6qgFD&meq zM&%CFBD{E%9&5I!dc=_?$8p}dLw9Djb1@3b>WbO$GM98$D8XCZ&mYw7s6)_UL_VRT zxpM_`0ruiKkTyHD5B*#;o^ei*beU6%5GE?q6JBVW->!v)(*y9G5h^0d9KOB7iM99dlkU$o33G+2k;`YcCfe*)(gqtA z#Nd^Y)1q`YH4{+8pcxs;Fkp1y=V+lLUHGlmH;vqk<7bTfr(BR-94{V_f3f+Ar0vt} z&L79oUwcUS!}@z@Fb#JwmRCCVeD5X9s`p~bp15zV7eCLr2;YIiH%GqA4pjs*n)YL+ z4t25*cTzT%8S2~FdVxmALw4ZtoTdA3uU|}HKQn9hECB{x9@LZyI2odXbah;Q z<#gWwvNjXTAsf&=`e#W|IGNq9h>3eEW9YQS#K!NQgjAlFOLNc9b2wmkDuPXnm(zD7 z5ceSbO$+2z!-MO?d-(NczJ8o9y~B{eO8+Z6Pu)Odiay`nARMh-)N7u7Dj>A_geG&6 zx1|~YN3!yBx8f7Y66ii*p2tr?2k(}nJjHhs=Ip3l0Cf3dN8mraD%9hv#OqZqj z{JgzieR-reBIa8(Pwx?zIwL9&n?v=!-727_sNdDFr<%7D>Vgna#aG1z1koc7K@4@Z z{s{(aG2e#j><&q`Lxk-@j|#1LgZD_Oy_rfCnzC#M3W0qT4x9F2f6z-H_s+{YW}|cq zzFQ4nml1Ric5Uv~i>K|%JRo$qZ>@RFtaPY{Wwd5@B?aiqHfRuktv?PSNH=`Ts@!QY zQhv9Dw3Ol>C3Z+v@-L6*Id(u*_L3@I$flrepI7Vc3)Ov*r*wLh-bUt>7Wd}qx%oPM z-hN(b?I|j!0b4PCIRB65#d>~!JjTE?SXKnJc>W+Mx|&h8a%{45no96v9Yn>KG@dDN zyV5e8Yw=FxiA0VXf{X3FHiMLiOXUF}?mr>NBOx3@WUJC>Y`?06O`5%k85bFYggID! znXk2IiH2k=DMlLn=Z?J{M#TF}=G<6|$<7r~dk>oxS-L*zUnOb-WnFC| ze#ZxHV3B~3&S58x<_}M9hbz|-tz<>De4Z~{NOaB;ofh-r?A~WwFnIe;Q42$-VyLIT8ocv6s*#Hmqa^64^ugc`I06C1swOCEo~^XvfO_|UCf@Sl-YZ*tUs+D zh1IJh7GR{h=uH~2mnrYi;M_Rw&hF8~dk{1blRc+-266vMp3y|(s-=c1Yjs|Ls!~9W zOOD?x^2A4;M3CuSNyeY(2KMEqmw;}`uJ#b~i#Mf}F1|TX`uo_v`1d4-sRFC@;k*3kZoW#ouj@%j*<6{F~A=e6hKk zp#jOdc7!zc_zX%UZr>A2p2qshiV7Pa7PaxKj!Wct%TN1l;_cj ze-~Kc;EM*Vq9KC1`)w5m9_6#F+~Hh}3=PyXC_0V_U+q74)M5PiQFMx!!y02L8xljA zz}#Xe5pH-G_NndJ#+fJWg;-E$mrpMJBuS2C!ax4ryyuhrkKZMVXVXE}Z{bZuSv;CD zG}B`DYWa9TR5PhOcWSAi5+YqiibjRt970rmDk9XZG@v}ZINP?&vTCqXkVpFBKMfC!6c@xtiA9Q`>?-w7F zWBoz_{0pP`_rFWdzMj?3YA5KT*PqYtH%Wg~KTV23Em^ITCA4wlm`hrks)YE;Nb9A2Bq10o_)O| z=jLO4-p}68RQE%G@dMeZWw{5d1;W(jxz~EK>gi8`B+WbPdnw$X&QI@7lK({^UG-(W z9ktfgKA})3>aV%|>+a;Fto5z=-Fi;@P)(qePca7V=FKjql(NImv_1W~oC{&|x3<5*Rv+P5{gnK zchIoPB!NzMa;*3a65uC}8pR@2vy^j2y(~faiLRQIMKy@7`X-lumpJ^_iv{Pi>!;W? z2r~=m>AFuO?Z2F`y{^$TA@#(o)~D5@3iZK*?{a&~uCrI0-C8o_uR|!TetLdN@9t0^ ziy2gve#EUj#y*2O6W+$1j*GoiBWL1*?&Nz2gY;Z2Q+qc#Q6~yod%DAv8Oh8zrgN9yf$*}!GWZ;hxk%vL zSiZ=p(m92f^%6GSceAaVVtVnD{?!_b%_OrPF;hGtJv@08j^Zp1LUI!AS7=j+8CIrf-3hOxE= zUM_YQbMFFKo_GH;8M8}asLV(>(-N#OU}Q{QIP7q?@4}DG7&hQ~&!E8lj5qsF^?x26 zx~Tk3U0U|S7@MWy_Z#?P>XL&^G0Jbpr#wlc{9wfT;EOuTv+Z2mk5B9pYVHL&k6nN43nTm(Bktf?Z5X}nfJ z9vwpSumW_z%mYb_XlLaCofxVJ>E!Py!U9-8yu<3xBHu;Z;8)88*A8l>X6=rud9mjX ztDYBWE?Pxy!pWbvPtRMjUrFD`eRyRm&|p6QDTrGhi#@hO?;or-dpsd`Y=nhXX0V>4 z3HhK9MOL8E(=UmwyZ4ICuAKK6QUGJ?#h$L=7OMS1b_dN+!8n}i^HN9Cj~^-xp4Xo! zN>dP>iE|bDX8nx?65Q{2D03Wi&4{uL=4(Z^CslA^6$MgL0?pv76 zuix{W>>GpTv3Z=!w+r(5Fq|zmcrr16+FEC9F)Hs?poy#Z<@_sgXwA019ZGZCOkz{T z$-9`(@9Dlr(!x@M=NSS`nWrSL&F>wgCcmB(-vmS?#g0c0Om4RgkfBh26|?k$qT}z& z5Hkk^5FLggAouDIkvuUqLe_LS#|KMsS&h$WjbRrqdw{K?vqlbkFfQ%SVW|GySY->s zaQ?JfZ?(RqizdGD@q&9=A=0tD*U`-zqc?d0y~z%OoB7t0i9$HwCA0^5`#T^(?`W*( zAU@_1s9t|pj+xQB1>6=Gzl7^ZlwU3ow!ip&+~WI#(|Ba|JR(!W^cP{=li27lVgXM|2?n7~N{JpAxub-4hX(E_$(}vl3)4*uV^>&* zc+O+>%u2kO)r;*fsE1$V!p&tQR}mEy{vElrgX* z@`GwNR?yJ~!pLAyj@4TnEGv^C00Pec~w*z)a zx#gDvl_><(kT}y`d>`;&I(shj9ZaYECg0w+$$MjNaGH}H#Q8FNNwv5H;yvBH1LiX{d81+zDLw@GnC-*1X2 z;Wq5r97AYpkFJ9X@@_>%&T<0O0|W}QFDCXCo-zp+yOpFG9KD$o?AD84bvNk*&trGI zr0xnCKYpe;aR9PFO}}p~ETAi(^0O;{Sl8#Lz?4dAi zsYjVGNxjx8o%i5-`9W8)`1Cl_T1onNkL5%k*JKWHOCbG0I%?5N3WVMrM zNza?7`QyF6dlvM+EVg%_cfCJpFl1arfnlW-^I{96+i7W}a-M(m=i+I8hvA=j45;V~ zIpvpO#fL}VJhkq}oQtTb7FEWZi}HW8+$fi~2-5&YUU$(`bO7RwH}p=4I-ml)5b&t! zWVD_=Zf22(O7}cGvcsfDBp()PZ~A%WW(@otpng02(F*SNyhFS=p)$yEVh(-lfO7eJ zxnrNpx65b2V~o)ORAxI}KZ6SJ`NV?;4t?sTRH;kf`0+t_VZ{2k&3@!`kJV@z%MR}X75tY%7|Grpb=a)&E8ESG{nStyI60ZjZbc1=Z?Fq z@H}x-b@{l_d1)pGIm&T&6cf)x&b2%EudqORZDE#08XnyM%3Qme9=~L)^V6x0aScAz z_YS9xw17<=7sh*OxEdTzEYcqB_FK*^T#M=bY-W5qK=xs_Hf)sK6VBa1D{G8zrl9b! zo3)~SI#cg?xm`Rh_3qhhC)En5D)3sKpC3TPF6?DwqAR|pRlr8oP};eMMeuzQ8PR?) zSIOg>m4f`Azv_CKIVNtjlhmS?jr4Vs$)qK$^XY;c;!72QTqbqe^ zWlx;9a{abEd+D*m0TgzJRXVU5dm}3yUYqZTqE<@iz&L6VTCwxR^5exAf%4wnpJCtL zMP%90fqS#<8aPrCU{(Mxif{c!Pq0%rD-TvO6J91G-m0(&{<>ro1rxU4Eh zgZb?M(l5^YWN7nGi$|%Y#nM=Y=fx5|a~@jFhWLo1K()>JTUolxh>r|fVJ*KH(sDjq z+jfaBhGY-7T8r5d@w^0%`t%KjvHc?iWnbB!3@o384<4#7Lqu}Hi}D^aHA%en?jfiu zyZ6!~VC~8md86DzHV=gR?}dA4=Ip?KhTBI&Zv^o|wuivF*n6bfL)1djdkZ;^q#pZ? zJ^<`xu)Yw%bG9C$Fy2HTbM>A+wLVV4+o=rEydTP+61Cvq(ZytPYp5|KMem{B6|K6u{4n(@RNup$}IfNk07BO6*@RflIZ3^ z5Ah*TB0U^UEz4y5E=rO`HtE9WtF3+B-ACuBSfqYvQh_F;hQOVg`!%fgHic_mjc?1d1PhFCLPQXYu3YMPui=3_PNp7vIi9vYLh$ zEY3p{t78zF%|(6@5l8$0BaM;C>aK(aAn0y(ztn=GcQQ+EYI>RcifExl~=N@M(ci{x0+TOa`Yy#-^mh!roL-MauMJ`ua<5 zc3u&(1mw*d|00e><5xQ5{SJl_Tuz8ySYR2%1%cqg07JAc{ldMU`9K-pckTwyU8KYw z!1v7-i2fcR=6B6AgnNLf12xYQ)2K@voOw1+qYnLqePpXq``)=6k$J25&MWQ&SsEP5 ztPQ~dYUD`OB8y`e?-0fzm7X^2I*8brT}`R-^MgH^QFSag_4}D)HQrg(NF8P6=F81I zX24Fr$AF#w8UuFvpKHKQT~=wpc7UA*Y=(B20h?tgGhoM24lrQ5j5`e245{3J&5-sP zusNz{zz#vefX%?W4cMiKF$1=b92l^D1kZpS1D6`GedH1YwvSd~zz)!S1GbM)YQXjp zqXz5}q;dncpP|%%?IZ3rV7m-0`c-Pc=70N z+hr{^U^5iofGt7aVZe?M2o2aJNZ)0^mb9V<>^Mqbz-DOW25g4(5(Bo&R${;w2xSIr zfmCk5_R&gh(E;KimTsBp00Xwj5Gt>+M44r$0lOSEYQUE0Q3JL>iF9Q=xg^sb1GXq@ zp8-2SE;C^7pc*$|%M3dV*aGoz1Gbl~+<+|*Ut($&8Fv}8BZ%cDa)Er90eeT5eFp6P zSr0H^?;^6(fW1584gb()A(a}iqsVaswm{u&z?P_`25gD8*MKe1cNwq)MBjid z5Ml;wfe<%fOO%5Q*dogz25gq0+<@&Pwc`eCA8n@r+ad2XU^}!D19lX_H(+z5z<|wx zdkxqn$T0)9kNQFbc4_u919oYKas#%@;u)|#fHPnR0B6AVK+b?20Gt6^f|vo@0RjVd z2oeTt2Y!J8+s|~M0o%`ZfC1aj@*)E^%Y29dTcUdg>1r9f6$&Y=>5Az~(3i8L)YVod#@<7&Tx!gs1_VgLfLRCE@`FY>^?{14QG8 z@GOTLutm0g2J8U2%z!Nr%MI8LZKna-p&ekrcE~#n*bM1=4A{G~?=fKS%e>Qo9c12T zz%I#9X24F(dpPEoa?GAi@1B;=8~pFpFA@b`{K02{8flSDZ}GvD-~9LdZ13)V`(^Q1 ztNwQJc(;7MpX1l;X@S4y7=+`8&%e5iGx)iv*YS7d^8AedhQBK37iX8hshm~M>lgL& zvr6qZ0KGiF{7rK9H)!A9pXUu|Ug zZ|&F@X$u_BH~n#QI!%86yV|S2e_GEzJ40LB*Bof8AiO+^5 zXI%^E=Tn05G=<#hzfHTH))eCr(v|#*k3nZK{d_cS=i`1Wsrv9iI=W@>nhzi4`Lvhz z-%s;FMpx;xBB}dGDOGve%KDwGm7JH=Qb)792(k~eemWfu)8ZDgU;1FIUDnUXH@8!D z9WS{mE1}WNn{Se9AKXY=K;dm?nD={Gf0R@LMk0o~+?P}W9vbSZnMoyJqCvm|v!oL6 zFdvWdwyt_5V4lr9?7YpAO2ED5cnJI%OKjO-iL_*%#^ zT|#5rZf8RZjFGiqqSXR6sR=sG@^(@SIG}-82*{gmH>m||pkX*34D#U!-8xR6zkIpP)43?5y1Uwr+-;MsL zIDQeZ45oE4$n!4zo5H-m2<1CwpEfaiN4E=|auH)*Ux|)xhTV1%@XxSUiusFxkJu9A z_2~TosuHl#@QJ$kB4DHK1%wyLMZidlP@ojP2pDO``5+w^xQ;}I-ydllU^@oMWx&i~ z1~S%W4_HY{DUG2bxeAB_i;;FOeUl|uVP2U3(@wRXT*X!g6g( zC^|QNsNGfRB0B&ax;1$fbbvz{0*f)G&Q-WhKnHPIcNKI43^{z>Z(4M7WJJ&ntebl2 z;5Nq=Rn7u_ff&L796j5%e1Z+DoP`n+kU9m%tOjVnSza9W@HoT%shkCTwyXGvV(JWs z%0Rf*I zLyDO+=nOD>z-Fb7!LY*I5rswxd%POn?&cFf3B|3I~iF#--x(#{BrYTkCbEl?~0CtxnYh>VUWfDH=Rs}xeRDwuu` z^`Cxr1A5EbOzCcwhzbPh)4Xq$*H8h1>Hmkk)7N7RFhcGs4D8@g148LBZWPr0wW#iB z^Tt(cn>k>os#Z?F0UofDvLXWg0T=-r4F!!*4~M5Ap~|R-N;arHX8TYNc&GLS8XE8o zS3FYS^BfBgbtetadV>+}Ucz-p^Okm!fDo=ay6-eR;2`ZlNpq{z!;PJxZhF2RF8dTz z3%8Frc0#4o%sUE_0t0%C8^BQcwChN3{0`?xHUw!GDx!84gBoCWjG;zKGni;nWT{H1 zl-lw}%?6efE-O}{ZgJto6|vOOJ|*%(?Nm2GKV%OW0Xuu?JFG{mz%5i0xBrz;|D^4YS?WT?QH`BY z-BU_0+c#A%gMLa!d9Tx?5(;noQn@T$!HVn#c{1&fdktI+LT%7sf+E%d763}nbffoZ zjj|GIhSs{%O>bOTk0_4)J z>|ysn_ZOW%Vda8Z*m~dZcKR^Cp1>A_r14?5) zfZseDU&#s4ylcL@K(=rcFULRJAZ&$-`=>W)>ElBH-!Y=MApqrvksC>?4^#(-u{yGTF@3ILQ5&P27rs$Q1L0YKEMbM-P9 zo>&vPDpkXU1QBSj3czxs$sos7rW%Ty0WJzK_7$r_8PkLRclfrWR=#aRO#+QG^>7hN zhn>+a%uHBq?WXiR97Z$}-6%Q_)pf$?($GLLd>*Roz*1?dx(?+(Y@dfJ5OLa2oV^Z( zea2;~Jn4qB<{sLgA(vpC4d-t=Lgx2d9&`-(05Xxql z1KuX?tlTVuN(LEf0#=RtFjw-MKCF-}y+cL3s1SE6_*p2uaViweVV3n#3=)ypIR(Xv zMqo^9Z8Z=QQ&rz&@6mb`Qv*k6EJ0wvMg*c@M_`P9BeI1dG+^8?yMaMCd_P6*KvyZ_ zRlq%qW`qSG1+243FrbX0dlot$0$#T=oJgot7ugWa0I(w%_i2V#&cfZA z)1nC3JT!o~;RaaaXyc$W^_+$KHiL`9@Kz6uaFsGxxE7LUg0VEAXW{dp^r?wZM`s9YoA% zh|G^{0WCujmlP*Ji`vJtpgX(S(5wZRE9fm3jv16eofi>9D~9Q)uz{r=Rt&Ocrwz-M z64QVhwYK3hW0nxWDeouS1Jqc=4HpHC3)3@q#@(~XQHQA`?&wf|!0{CBfc^1Ar{jQF z+Dm#H)}{%mmyGZr#9*79>se%9El2yb`-W;*K9d}GoahP_uSQO~u|5o;p{Fn-n_@lg zGBgnrpA=?jhaV5R9kfZiJY>!|i>PD$79Q2~vQ{TWqkF(`l*!0LXv9bMaC)4qb_yXb2|?a{^z99c*NFN?XdR6GOrND4Ty}r+p z!VU27kJ^A1IY6N;7HL3Oenbbr)d{ATT~Q;aC!oO&2B6rqNVsrARpbmsBP(}?=KF33 zWWo?J1Daam zbWv1cEHbQ6u;e{{R2QDLFdrzCQrXbBLRBIMF0j=rIyjqJASac~kDR*nRK#d#?v3_} ziX6OPy$AV3iBRCl+ia9m8zRRP9;$6_cwk{SrD$5i-Uv@Ea!@WOF#dJ;eZUDV`_KSA zRB|K|YKaBNSlW}Q=SwgH;su2baXVt5r8}e+os@>!AWX2dDDq~c`CZ z`jpa4i@1jgo;540NyG~0nQp2fubBH@wH_`>N;NYypc#Y~(b7rs8`E1oTxzrr2#K4B z5z-Za68|l+Bw~NmJ1rx(c338FhWU7)&y>Tp(4MKo7Jod_Bcu{BO^Q=6 zgH^h%YUMqsyg@5H1k(zW!7H6P+QkTQ%Fk48$qiIt?e%Ukh^1R7Z5J_kr4}oV*UAby z`;VyP1sRc>F!+FT%23vCgT_es5l_HgPO7BJM$RG5MhOZ}5<{J?=77FXBZ!=Ex4n{gy~RDzc$%P@~f( zQJ{u9T31nPYO03oB||g2&WO3(IJTjMD+PtJLEH(K%G5< zeWZxlNEs{a*0LH}LU|({T6k!ZjZjgjhRzF&0I71um#G^1F~F7--4yVZE9k1xu%rFW ztD!@KLY=&UMc2cP9SNXWjNC}H=@_uW)yb{{N`a$>Mm!yut-<)egdPtx$i|~voXt%= z&O*Njb$osUl3}W<9^?L~(;s8^g-#Eq#<(p2nSrKL#4B~nRtp}rK4Pz<^C0K^2P$8v zedRsXa5d8rCniSzIL=3DK^uH)T&jgDDkzO0=ty!HNk-Gg$pg(f{m>WbywJQllol?ms(|C&HGwYFAyo}xI1p%TFgSTCAtwMOlZzq5Z`F) zuZ2skh0-9n&AQkT<*Tjkd~NEeg$pkAy)p3AVy0+SE5t*Dpcjbij6#h0M8R}VWcx`< zA8MNhCtN)>4te=8ynx@`6oqN4M_yXt5~{WlYz#;I_h6i(^Fh`UcoAcZ0!rCe3l~#o zcx)wWg z?q^OUg^Q-!364AD1VpQzLJpm(2q$}Yn~n`mxjH#+kd)8y#a+ZKRVmYE7vbf`_zsn{ z!;ynO>x-ySZ>vuKHUl)Z52YewTWH$aGmeI9p~j&LFAT3#N5>X2K7{Kbx*CkoZH5kn zn66q2S4FWYnWiHcm5ni3hic&hNv#&*RlB~{!u68GD{Z_|7&7mB`Iu-%cfwQ!_J}MZ z#vR8(@d*j&Nh`i36G&Hs^0F_ z!V@U-3cFBY;vR?WeR1OqR*T(?8EJW_PiYV@esUlpPnybQ{7R=fy%H@wGo@c%|zeET~03WSFH3A1W;Wf|h1ll{golXjJUO}XoB0}Z^jDI|V|Fnit54V|`b$NT5k8ZP}^%tp! z`^?*Xgg!MfGe$kK)x;tL_wahevxyLWmxg-8%ZU)trAJko$dzl1{Z{r4F-kk6)5L9t z;dHpm#LXxk0kuG&=QoaExC%mz8~MAb@Gk_!m;jhSm*I5>Joz2M(nLG!dbsgyb~}Sc zj)=yXk7#9m;#{h9e}vmm-O)kJW&44n!B;5(T_cokXFKj)izZZxEe6xtrhiaw;?E zikoiUfMqD}ci$5}B1NuAjcKtWf^@WB5BH?1G+L}du~8=RdblgK3RQzKKYIA7wzx3b zNw;etTDUE3kXXTcyrZ;HjPd~v%y4UpXAHyqz20a<1V_ZeOHOur5TFD`tmx{fEAlPgPb)OkxGTs&BVr)0JQQ;smg7?Ls*d=Q-9iPb^Jm@m*aeZ+g1K^hT#ce*pvvAhn=w?=pfnip_R3T$>J>1GdlLvU-6~zv^ zq#QMrRQd1?x-_9104X4d6`Co5ASpx^C2|ynI}W;ErH>=(;YOCU5p@0+;w;?G(s3uQ zK~f7lkK9K$n6%j^hcUzp4T*-Bx;cFwxe_DGG=56wT)`O*n$v=9!c>5cj=m>%$*ZSO zm4Wh2M|q$z%t{$ihEw%%@T{uP(Gd8JxAH3Dm(GQF^*v1)k2^%~ybLevw+1bn-Ksm$!ZiLk;%79rDE~^2r32vOBE~^2X8GPF66ODk^_H0@2(=V$5yT^Syk(I+D zh;6#^8t_wKs?M(kjB-&Oa0Jy#nbgoTr50li$id-zea3WIE0qOw^ABn}O5Y(~WFWc< zd$<9oQ1FmPmN`zotOX;_dHk|*SC8;Xjej(s8?)PGJs5d-g&F&>pix!yQd|};>*3H- zlF^xDF6#kTxm-3fs2*?@m2JFBVJ3!BATH|xgZ2ERogeaKjGj@K_0pNHT528XFY6(D z1*W#=U)D?IE#iUpg=g(}{BT(hI)hXE6DwP&E`yO+I>?{lQm8A0K_X?44RK9@X^S{j zAIIPDU7klo?dVo@6&`@)s0du1M^-#@ugZ+@^U@KH$G}>SAYRY`#tlH*I1wizZpWJc^Fmev@fcc3K z!UJvte2fmw%FFliGT<^GI4|JKOOM0v>@dOJ=+HuVS@m&>f(#^j4X{yy5Vy7)7q%J0 zk#-TgysSr%VGly?9-8Nfb{?atyQG!&Qc`^{FE1l#I;IeF_qe>gijh;}0D}wBT4@YV zmzUQ8gRpkP47Qm$^*A71o%u*~4~_P=z68ArINo?a%Cv73m+n^q+tEHyjK&Qe1M;#w zngf|~O&Foe(2g#yTk2a7mk}F!4&8>g@47{*&HacM+mb50BJH^&n#<6DPFR^eX0#_h zmk~p{MjdAARzz{z8So6@?Rlz!!?+HHKJ~1)?{FEK(m^A0XC(Gc&t+&*H@*qhf8jE; zs#CN#6&DiMN17=%%++ORU8hKT+0aCta>q;7(sUWx+0E*vC0KZa*dhq(h#I*|!%+31 zCP||3cCkBz##nD7eF}l7r5?mURr?5Bl^+6_TB-%_D%>3#gdn&{`7waWVyzoj z|kvt>BHQpufpxD(WO~H06+_OwJ?gEpt}lpvwSln zwCJmFQ%hTDDA3Hea6e1h?7-epy$W};v>{UdoM>Q2oIs6&ZgrOk)xu61Gyw9(F^UvHm&~Ze}S~X9QC+zFmhR4XsJTe4>uI$!%8Cyog;| zG|lR~%euybSUn3n%|(esaA}w60~U2EQjJ8?z=%RNk~#~<5{aily0jVtK5l60?sf(P z6Y@u(mManz&$pNNJFu!JwMd&iJw>~})FRDSk%PSm@wG_v3kqwcG_F?OM4T{kg2I7a z(jW2$V#EjR)G96!4XPGtxM*-ZPcWFFKi!rusYjS(LZiUs(ZUh)AZo}ZT*sT_$&c{J zjBdg>YrYu|5FB1q#Vv`0M^?KgokNkPgiClm!i1rYD`vt%)kUKVyyK2ujP~t-5Tr%B z1;AR^=_0^*1YCun0yvImqqPtOVzY!;t(shh02iMlgyE(wiKKT%?W7(iw>rguwu@EQ zN^Cd!x*X&4gU_3jkj;XX2>1A>u2cCkDJA($N7D- zTs?kbh5SCLRg&NR&SShIrHi2ue8+2~v_AQVv#)LVaYzMSJ13MoM7ax53?0K3MGOA@ z{qHLmh+g^l@uN@CA`?~kH;!y*n>H}owF;s8ge|5c9AIK(?5QSwygB`NdMDT(uoSxB zpMl6<1HeZBK(#}_-3k22@~C>QH2VCTm6e=C2J;9s#Zdw+KT|(pk6|Q1nkdI#p-x}_ zMKIwjat-rQcmMTRPAyfLv#(d0_{qsXokhk3me3y&c}Dx|$zQ!{GH&5pig&B~`SItq zV^o4)4re&uJTJHH_3A;PZbT0z`0bDf>($fjlX_MG(Hv zP=MV`xI*}bT)L8N9EDa z)h;b09ZcVLGV)m@dyvV(Z3Z$+_72n&vz@i*l^8m?Z|R5&%I(I^(Ygq(hBG=jR#Fas zx@|>H7P;ml_j7lV*P+!zw2=uuW|7V#wA|#Y zOYx*I8r`)2#=$RrI89;n^>R2@0S@lRZ?X}p^>2)%M9k|bCfZ&`xv~m5+|^0CNRfhM86@dt;Nl@LRBIENLCF6Fv7=)&5f zJqiqNB^YPO8R&Nyjjno?V7T>jqs3bsHrQHkrzWCuHgcTf2W^DXdaL5E>&PA!@7%*H zMmKn3G445(ivT4Z(HV)wxb!f(%3s*RuRQqZeUJ4UKV~B^ZmP9Oz~ZDqds4h_!Y~>; zTdXWK7P;vmgGzvMRa=iN8XGGu=z`WTANcZ1#1LahT!>ZpII%dMB#RT0;w(-`2?lo} zzNcn-2Oi5%iDrn5d=c!7KzDZRNF(rXq@ z(1sL^3)ezHQlQU_a4#+q8>G$ zfM1D#fL8-ffOHeT2HY=4BZwN*eFAwQ0s{D2MmmXB06HHpOL2Y9S>S5Q^^D|Sax9@2&#M)LlJep zY6lp8r6WYVT1SXrwNYg)cGtypEK_bP+#dp#ReS~nUk3Brc70ZYCfax1j$-+3EFtE# zlM~YllUm5e{Z=jnZhBUNnde;<0@-3#Vwke2acZKSX{2g?BV%N|7IHGQXYi}iI13O& zJsLg%zY+lfuLcdVkt9X4au!shc^1bKb!kRP`4x(j@@f?)MH{mMLwWabU$M7#4tp?W z*p+?Q?HjYm8zYms*bsYaM0o0*DvMYtMJ(7TX;ourba=>i zDwS5Plv=Z!7fzD2SkLv|1Psm2Jh0$p))r8ojb3JtgI;DE(Xp5I$7#3wzPt|Rx-i8I z?etw^vWka^xA}Cq28UGjkhuS+MXGs7+K=19eYW*;xuvRP=N^V$wJ4rq!L{=2BESSK zh}`K$nKj_X3@nxGGN{G~EfBITR}mySK(!dxepl#+2%PB+u~H8U&)*w#F_0o5SiDA1 zUI!;Q8+BPTK=Jnem8=z@42D^|!}=ie#|5kmUYy(5NF_U<9OiA`swjqeTW0o$xtG}+ z=54=ZwEDA9Yo%4tyVoeLZ`H*9!m!%I9!v*y58UEbeOv@94}XVL^N>K*^-=16{RRVQ zN?Q!1_IZe;?5tzf`)%J^Psb;nK1Q{*IKGL#)$NAG`G$E-2*cl69N#2QRw&&`8M@o*3Hs_lL<`5I1!0Nna$W5 z9yLP6N9d(ZX_wN7+!W_*Hu!6wT}K%(9ahZtLN#w?^pLL#%TTxsylAyA$A==hEil}` z>+Q2~!e|fkKhdfjZnW*D%g~#8qPBb&hSe}OXpL2gVC5Q%eAC>9Oy`gWb+u8FJDeRm zD(!IIqHPn9pE&eNIbChw(uk}APQgd}ds9?2Em3*N^Do2a(u}bwRFP@*A7-sFKADCO zh-TfkQv|9WV$bo@TW5>uZKvme=N@qE2939<7E^7%kJ$vzg0<8MN^|XxuP0Y>-VidK zK+!3%MezkMqTo@WIHS6frzC`ELql5(U-oK0+3?8gN*p(T?a_^YLCT9W5u!4kE%Sxk`3%OJB(k=04*I3)AyZ1$7ZmItyr1V z3CiExB4(vsr7p6iU5DF_5k;r!%(0CRJlhAO6hoi!qsyusd*oZ5>H9LHJXbex6y}w9 zB1>b!XvX!7LTXsFs{oDMu=z0&qFo1Q=Cv*TkekJ92AJJWBXW*{xUERxuqxw&(`;N_ zopEnzjrd2{v~}8@jN+YRxJT{(XS0M2)3aH5`dYlOWu&p;-xyQCA*KOhrk+msrYN8` z0@SqE=-iC+als}ZAco9BxDBIj@nVefhdQ8T0UD^LZCF`x5QWujhl43?sb@HO)2|v~ z@hA~t%t50p7B{h&(#>^ZSIMhpbYNn~aHOzm5g~Wg>GZ{W73h+K;zZ*4XPM=W7XtJC0fG$ z!D@1;GI#|@zfKcv;oNntCYK^XRJfqk!|0>~Rrom`KMOwUIGNYt{VTO+pwuE&Kv4f$Ly&FOO z_2GS&E-PAOZ|c*vYs(IlU}sf7j8LX7x(%~Gu!&revXkK{8w1CyhIk;|bGn5Hn^jWz z9Cj^+jVO5Sy3 zrNZ0&u)uY6_& z^>0D0%^&Xef{dlc6IWP$-`{%n0%hk?&s^|<6=2aKCafu_VYZM;2=q08~^In(PX{Y zZs(85hi^&x2$-9szgjP6_-FFZvq$y!|L^nsq58wqY_pktnm_)qng1Sgjy^9oiZ1+q znyt6V>SHoXKCb8UWV!gTo~^%yCH`PC8VvaJezDoE7ayLt^ZNv9jQF2dPjmQVwoMk> z0_c93 zt=F^1?Ki07tD_!hU7$gZ(gxi$O`wwP&Zv*pbJ%4kX+lqilcg^ijEAs!%%I*d#s7Zs z5g79^F*nkuw^o4gqy=D1Z~EirbejDBcePi4|FoWcdYC0Q&1SOsw%N`frm9uSn+q@x1tXwwyn1H$NnA=JO|LBJgkX?eXsOdiA*Y z^Zfo*k`NQ%pU21T51)TXRJApw`{U_!adCAqot`BB@DIuVu&KRi=iSwXyT_&zk_)^Y zJYPxz=Pw{|9wShH0fBmqKLz-^M_4!G{y1~5FH6^NmKmQ8yZnIcDV%Z^D zF&d7WBOi~dF6YtR)AD(P|D7CM8ZkHlZnE6OF9!I&1`8q{Clyf6pb6-6c@OB8SH7G% zk^26YkyOf%5tRo}^#Jrq=WiGu;Hw3+#=YKq0wV0_xdc!>dajm$YDdqt5>Wl8(osGtiffiEo*97JIfkb*21#pF>&jU0W*Ng zhn9h;@3LW_pfnCPWsqvJsg}WN$)@Iafh@5sXK87rMRCEZCEZj#mT6PWr>3AjF?x+= zq$ObF>SlWn8UjgGE^8rwkao9vlxZJkoB8(J(?+JwzurA@9`sZ@W*=X`6pgrGy`KctsFuU>5*Yi&$ z$i>^HkG%Q$jv-rY3X(GIW+}cSiP2NjKFfEvdU&{BdL4TQ>*`u2-QUlHgomYq%C z{JUA*{RDFk^z=ss9hNd!QZ1{rqV?zXN^w{)hjCT5mE~&S9|P zE&*007jeVssjyf2?BZ(6}8@Sg5b)jC66_d5t@S<>Du`TQF!3n=gn3 zTHELOdY;TS$rtFeQ$)vI6m7BYW{>b6^6mLiR|fVJ4f^le2UIZuquqJe%l-*A zw_DRn9A=F??<&p^12)MFwwjnoOoTlr6iqnCi^uKBDULH_8>6t;nylOP>iNUc@)%f$ zyJ5XQwmh4C+`_((c4>xd*kqzeB|CxfQghNS`;QiMzuLyI+x}Clo>wn@`_JY1`Tw*3 z{8#)$S372&a4X=8?GtuF*=@@!+}NxilfP^JUGf(@Wp!zjJ_dx%Mj+S70r`qKRbqx5fEOjgulJC zXs7RNskIXR-sTN1Xlf<=Ep9t+Q`d%C*$iy-(k?@b@VANK0Aa+XH+s&XCjy~4mjx5i z-FbpkLZEsE6!}#Rfx}E)DZz-pF=&%Q=SEAUr%KKPkb0u6|DJ`O6(DqdjZ~9h6qGnp zO#Ig!=v5qUTrTYpYU`f>eT+|&8m7_pV=c(>C#;%9AEmHL58axCKVfARIzB$o zOuII+mqrg+snCl~1N{)$@TZ@!sR}(Ejqs9QOQKgomTUBGH*r75<$U;SX`_9JsliD} zk+!#V4X<>I0(88y(oNq}7uxIZJF!%#^vD?ENXk(uGL{4qdY489KF1;7{jl3awJ~CT zWGZkR{pwwEu@j4Ko?Y&*bK2?w2g1=I*rcCfd7oVG#2XE>j0cd0n&QQRY&d$44lniz z42z%#j1Jd>3zT{Vr3^t!k!k=(f4!V8Jk$di=_oo_-&Fur5eJjXMF7Dl3Mxi>QVUBQ zW^HvH>mn@CJY17hs$qd@G85VAd049Usn+ibomXVZt?muSue0B*zC zt8kVaL%CF%DD&{QC<_%7s)>1DAbU43sT`4>${{B{{S<=v=1AnerLUaGrxo<8X+E-w zALhO0VBCCtWD11g9(2G@aadp~pr5b^$f{(Hu5Rc|^%WiaP=!n5$mY(2dNEYj1ODVV z#zEmAmTF&N?cx_aWTVo(QDelieJw*La5SZGf>`0TkcmFe)Y~(XVU*@0>RU<@QziOC z*ap`?Jwd)_!s2dt?Nh^wl#s$TlBfE`I9-xGA8yhFyXg%)+Vd++m%!0_9-zxLZe)@jB{DKeD0{eyv>23{Nq)oZyW<7A0?M}O3i1xW$?W58LSDE_5frS* zP-p2nW=}Zsrn=6wFz^w`0l{=Mo}sSICdrdy*mKk;MxtAx=0hT7una84M+8182UO7k zloVm7d$`$dI>dMg;jz(dUTKu086Pc=jb*LAim|NHd}Mqz3LjKektAFOk?v>e<~Qin z4~vz{VAFhL6#<`9pYj*VT=mC&d}F3ayXsx9PQRU-=d742*UR-AsT{#AnJ|thz18hj zE?7pJ4jVD-f_ebaPu&dVUTdH#%d0Rz$wMQ>6+0MAwRTC3EQC_f#Aru3nn#-HuoZyt zrZ-4&Pg_7p(ak3mZ=vo1TJM1auw}S%ro3Nz8diC?-e!l+k)i1n`r?0yM{{7>w7ES(!EtNup5^2c^L)M0^+VH;l`) z$H)2IcCmU42gi(#od>h+XW(@}9V-?j?yuEE)hfyXA(n!AO%AKrBv!EqyY#B5MoP(G zH3QBF#J5mas1k#ym#$bs^Yd&yyW7s!i_La%$04_~$NMExrSC8O`PLKTgZ1JOG77P= z2L8}c7uD60*d@5;jX?)EhD{!**vacbyMIGwAzbWHD@{+1LD)c^Q|jka#6CGR^Mo=_ zRPM+b4m34V;92U~iCjF=RvmRX_=JD(g{FojtTB zj+UrWS=HFcGuwN z7x3m5Xl(OsdVlYxWO^K9AGCB|#!1k9`u72Ot5~W~vf`b$m(E1enUwb1K1#LJ^#9+W zTD3`p*o*4coIT#nmyuq=VSHE?*FT5nsoHV~`6W4Bar?5~Kw*_j(jdtYcX4{KB+eCs2^-*?o^%w zGx#M`s8PP6e_-B8B=6*~ic+~!8$K}O#Lrk#V*WIL%pRW~(qqMT{%M_X!I@AUgK< zQrOJbFB4Fh<3*wg@)(6wwKEhw2W6btjE58n|9)Amf9gDbT&*8wo*Wj+=nF{jb{|H= zj3Tcd-jtx8>JCi%u$Hf1LUOX73RS9A3=LvgTd|cJpApeCxr9vrc5*olFLT~|7n^?ZQ2x8GbshY( z>;9j*a{cSeK)2)4`+v1cy?PPc|GPN5{D1fV{wscB*Y5Sa5jXMw({KMZr>#!f&2N%k z`UW2|OGkO{ScOY>F7EBLJ33+>t8H{98s^<2=O)wE4~UJ9oC{04xb3t@N6vMn{kAh4 zy~*AmIR}_@)Siwyy$mDJ_r3JIpSRoXENeB=<{L&AVfHz=qdHzH?#;g872wr}&1yN{ z&VQiG!;8mcJ-)bbeT5YQMMo%4j^ec>v5 zA=;3`06MzlNw-h|ypYMd3{qQJV|;UTEvVjR-R@CEG_RcxGj#Uvw>mB0c%@QO;b8{D zq#A4c6lvCiI#RM|WiNeq zgB10$0&rW@q=A>}K+DeGBcv`Nbe8}!`BiDc_Tde-evq};=ph&eP1KM}34yjX^Ik87 za;`i`HfrN_LN=P3FtsJaAw|6y${N;0*X2=4`=w5E#99WB;(hlGYZ0WhI-ILmL zRB9CuESn(OJs8peqX!p{&MPq(zP5ODc_He5)9U1nKd4-n7gr&OGJ%4^hWZ=W2YOQ& zl3WI%5~z%Z^0;4lN34`TMpOQomS zx@rH0cNc>Cu;=V{wJ@#9Y&2DddLMtp@726f``m8UzZu=K`%66>L%7=Ubq5k}hUt4q ztMD{@*M~5xJXQC5ou@T#Gkna6HL8bmu|IC4!v;v2H~c1w0b%;lg`lHG;xL_vwg6y| z55@z|nI1MCFJ_GL;Sp&W0z|J_$`+3Mrj{aEKSOv_Kf9LHLH0r|fp+yw5{I4`Kyuwn zhWRe~r-!rs=63XlF$|RU`$!I2xQYy4nNm#cUSS4DK62G-j5#o;O+``W_?%!h2%uLosr}5e}3aI!EE^+!o*C;Lc^g#F@$Jvl8 zZkX2Yj*DCLr)J{{)B8EL_(&Fj?>cCWhu?l8I(WgV)4m-;rdrh_rM1HjXqY3!;1{tP z1x9%6!jd$|`}npy8zlrAsJE0r7brw^C>t!AZ$|l`I64yb>0u|108Z0rNCv1QS!O>Q zDS%*7Z~FFKtKd8u=J;+|F;d*a%Rs=wN~K!6sMT0Q>A7@smky-E2%qLSI#$PvCtM9B zO!JCZ1eGc6EqX8NTb@ezt<4{O0CY{#kRuAIfJ=$T9g`O+b!A5;dBqhtwDa?lt4MrJbH=43!O$z=*E$gtz> z;0<=JW*Asx88#q#qXl{mW;<&ej8g0kwN9UT$)H*C-LXnkkMObrR5Dl9SX{~Wl%D&e zx4_dTT?eMk6B~I-9_n2Nt)ul4pt_*QiZ)>LzIVoT1OvqKLeqhP`kUxlNL_Bh*^D*_ zc#%p)z$hXO193NM-s&%*tQZV>P0SMDO7(=jetZ6^?^+8V5K2X)3LRl6zedrQ)7 zSKNK{Gb?2`J~9Yq^In}@UHKS=tyMh$S)De>HA)-!zHf{Zqg&YDi+&T(PSI-KK@w%ofrhg8hm?)G%zA-%m~ILA-$qyZWxxz3U!Ip7r$0 zd~$u_-Q4cH%f#|1pl{P*hb-qcS+jy3X5^|2CgwvqG%;}uqR_NK48lxunpaSR-iDo! z*(q1yX*4MWY0Emkf6UmNNCZ*Xg?3uFQx|(|1dQ>PbrROy@ivi+2bc{9!S`*2QaJiu z{l<`hUnb@gaY zyrdEACGb-A+1D8zj0z|SAic&G!eW9j>^5`0K@YcigQl=+Oxo?-aCwQ4+kE(^L?Yve zSEyByP9rHsLn{rek65ZIdS6~>Sy{1&aWm`;IF}10sblCgZCq~^X4y@c#Tyg5sn$za zz$cSVafk%Ek_?irN~6t=7`gyrd!K|^)e$nnuwAO)%2f!V{@^V&0M#y0S2VjSN>_d| zwLlb%>phFLRj7XEU9VF5If|Fb5I6?Q8i)4t0Y0t#PK?09&JaG)3N{IV%smHysOn;$ zD#l4!QH1i!B%vkLAK7NHNGhUZigEu<<_R%Kp4{RS&BU+kAf3!C0v#893~Rv;VIY~_ zGDo|l4g1Dl0miOxWnJ3p6dDCZiaN>`5vQi-9X11y>r3 zR1h8>NlO6-1G!`N;OZgUtmR1$4MbCN(NPa!>MbNX7`z(@-vN!wJE0yHq`E;_dXmT< z4RBy{&DrchDVm6Rlat~CTv{Raz}@uLX@CzlyES%wkscuc0zmpQi(y86){ph ze9&G8NE1U%L6Ozz2y|Z9H)h;{g2D9>f|&gZO7=gNoy)dXmogIyx900~+y!u(BP7HA zqm}V(BPN1S!^N#G5^c~*zr=J1bLy?wt6?%7rWLTgysBJF2%Sq|#cNlxi0oanJ1!J0 ze%{_v-ZF3b&JWUHaqD)Q!czlM$#_xcDYTOp)H;1*47uRR#sqq-$^2Dk#@{MKal-NY zO+wY#5Q}6aJAY^mr^B>UWG#%H#CMMfQM!nNR3mvX#{Q5W>)AXCawQ;&PEDjKJg%!b z>fD@V33G)8=bphm_FD2+ua+k=mnL@XweqiC3%p!PnT_WvFRL-`4dV5Smegpgg{8t% z$kxsilqjw9ByEek^70X}WA*o6HSrS((p--a+Zo9mG??f0*u=B%U|C2ZUj1FH?17*p z)3Pwdwx<|$-d}SeIc?#lB(Q+Cjrp(cCHL}v?pp<0Z6}f{B9)BoRgt8PRyC2RrCgmS z+LIm%igb(LPAf5pGJD4$s+d{~1PXd1N2B_A3~Fo^d_@YOiacMQ5J&Z= z;>=kLM8FYIHY_brd&& zpVuxpw4dX)L5|9iHDDc8&+4LCiqoP*wp*&yDrc7hSU_?&qvNld0GNYN(Ul{0sKgV@ z!BN0H<=0pd)uw2mxL6D8%cL>w6fLMkuOoF!0QkG=hHfFVk~PTk%a9;No#ybA=BRtb z&8s-}ZrPN`AW4tuT_Eq&ii12oO@Kz|wHXEZ9VTF-R#{;IJ>|`+sxDZ8eJfTHo#w3~ zI@RO1PL1$<0782_kSxVCB3tuQy@g4q`il}Ik8a1khIKru2O!vl!(wvI(_x-#ZQ@GQ z8;j(2cFpQbZxEmW5@|TZnNz5`#bfUQA1_XlV~Un>VtfRTkJYcm$;nAszKPB^DbJ`c zFuiN9=ku$JV!r+vZz1Uy5|iObdnfsnkI@T_VUbDD$GJLT?*)d%a1+qbEDZq>=FK)# zOGGtN20Z@02dZ-lCZ8HX2ez~*T21kI38-|9ZnOJ_A7wO+8!%-^ zq?QE0TYUgsm4(t)O+H>ir)W@OO{6JnDkKZX3)ozwZ!>hYPK0^`fVa9p!M{!~3(f*= znv*FSQj_CZ28adzo+bFa?NL z<}Hm&NUulI3#z3L0kv=pG6nKnNC-+*daL00AHDjKGZ;3?%b_n5BBZXK*gd01gJCTg zea81$H_7Jt>1nl@-|LrORp$HT!?$Gnd7eD2SD)6ihva#qUwwUCZ4J&V{TS5Zkx=Ol z_UvhqsB5&FACjc=|NT5qmh+EW%t`Ofeq62b`sg#p`BpdOpPtuP{^kcFhs%*(4m)T$ zC3}9tuBAS$=d6lr6HDT5_3*S<&euOAd_`j#9X7U*SCyxBi^ zJ9wam%WV`DH4PCp$Y%#NKWsgoS>aTfKBBv;l(9BQ5*_A|{fi zT=PjQt^L9yZG4!j9^p1omY4VJR-`Tx%WqVU+?7gEFaVqvk6#9v5vj%AeZP^ox#+vp zA>7`*O#Hi-Ixk&d(2fsXnN_ie=dm_L&h&O+?q>S86`c`|c|&2czS-*0R##g+)X3dM zOtv?CJQ|S;kT;VlM#;rn#B6ZsRJ{DlN`zE$Xkh+a8j)@-hg9*#G8@E@O5Mmk+9vdX z9rym4Xfr1Fahrhd4OvUl%`FB#Jpg2`MsQ~{ok2rdA&9wV)O{HDW1HB!6YMERS07DA z`1I)lQtl)-nd*ZK?g^$4&9JEm-q6Oz7G0@$4NiDcuc3U$a4{1@q(KXu6@q-KDG-;Q z=pN$3jSP&zlg;qO8{a;X%o;ffwm`QI$De*1V#7oucXaWO8snr%R@Z^ZXQT z(*C8~Z+OSx?zCu%CR{_)P2{?qGA>-P6q>+jfhM`h;)0>jE$+g}_pVPE%+kJpRWEFH<>8Ew#!iQW^y)UpWvJ zLeE%%Ibx}_5Rje+45)Y+N?*6Q9+Q|ml+5KqQXQLvifnsp}8O91NS(JP7TrTvjE z%Vlpdm_bsxu6O`-&!BpK&eLymyoVr`yg%X*F`{1bB*Nke%DMO=ND6Lv832W$sPg1N ziZA%qWEu7arl9kuE-!%$G<*?2f zb#)zz8@w}g7DDI>KqXAa3yzqj8iHUHaE6*>ke9seCfT*}JOWfU&x=TnLCMMtQvxLa{k|N&{VX_$}bxA~zu5*d3Q!ga0xiIfnnr>gjAn$FC zE1Ax6c#yYrzRY(~Si-GJtw_GSQ#&HbmiKy_Br)}oK*eW@PL@o0Ph-4t?zPg!Xc5<` zs5uPeao|nb|3gQQ^@?aKtvdq@x6&6AQ?bGHt=D4HxmD3<3U|omJERqpbfA~Js%SNq zIDDJ6Dty+nblkbb(rZceB9>lHs@`~jZEaHZ`jyhWUL~t*%^&NOSP3!JaH)A68%=%B z@Vy?7reclBr6H;LBf$c^(a_4rjc(TL0>m2(400I`S6upVzgfEqN3DekKH*@*E7^4R z*i$Ey96reOiDZ$~<)~;h3uA+-O9nAz2yzK#6c{TjOX{ASpld~SPfV!9i-4D=A@$3E zn-+BC^>B~oZQYv(I{DlmBt0X}&i#?nqXBg84+x#?_dD=b0U{DW0YsD2;gCX}ori7K zhN$zf$p+%J7^J@%TIXJyE#TrT$f0RnRDvu9A{yS$MyPKk7wq=$(3n%GeHXIf-7M|X ziTQ;$c3Z>rCb{qitx6QtM~hd1DqN9V`qel7xyhwpeFu>;tcy0j<}F@$Ebo zd+FhQDOy3Jdvcp)T_avEMK8X?aJ}Qyi0n(zneRQI#|IDUuU--=JGPhiJ0pBS`${mT z0D)wpijkcsxvE4=G5;J`Vu&VenLEvb+8~TB9C%gp?Ih`N!Y&Umb;ALa(X1jMWa7ON zN!l-;DIq#l<*$ika=NICq)7SNTqn}T{P1C%ccv;rTScVNaeP%I(P>6aBvB0NqQf6b zcXNUiGgdZ0(3Q4%JIuv3Mo3qvRhcw+uL2(A!y8E-K`I6!g046S!*jNQzPj9f;e*(P zH*xJ>LCxi7d5d4cdg-9nqG}die1)O8#@1;R8HE&JYsP0qV9Ly|WlZWva(OswkPO=jvCJ zEzP?v*IFjn4UDzyq8>n5Juj*O6b8V!sn{42HfJITJrAKbj&Lo28V?JEhI#*#=RG1T zdFpCYzm5PD+x#rHj`hnJL}ikEVO2k`#2_kD6r{RUHpz}_SvSUm^I8m|iiv_$F|tL5 zYxS!jSy5uOY7Wi$ojk@zfbzSM=lGaTZZ`4^ACr|=jXb@_beR3}+#VA(D=zrx#v&=& z1bS`+*yLP8&NLwieQC&dCIC%To_d(4Ai#M5K*tzzgz=a}iB}?#yR(q{ii38VxZ)2e zhKt~9rx|mPz+^mH^Vtf?jg+Vhu6CLfq1opvBzyi49HI{a4NU=5r+}t%0>sayOu-fb zPXiEvwl5gGw>(oqRaCEcRG~@~gjx_ON7YiW(119Q)FsM%RSqA^GeTY~ zx}r$=Yw^+*22i+&SAaBa)K0H>v{;UjHj2DE9%Y`YFzDGw30PMTdL}G%MPk11WL@qW zfF~+b8;Uqdj_IA?le4cM;pfCdBc0ZuR6Hn*Tzwj*5in+~hlAE}}fZw4`ei0{Xcsp;q;h zRUyI;SOH`)Y>Xk;mU0!gqL0SkiY!Nk<3$KRJV%HLw1~k#xu&ZsVL@UyJIa-}feOGa z%%lKnbo1sLVN!)ez2dR`S%<>Q3KLqVP1j~P!48E1=eAWyQKo{5Nb|#4|3F_)AgKs=Nq&fwxE<_B>!!wVQR+QrrfVQKNc z-&8fC-jE*mxAgjfeTsp;boFaK626Ah>3hMmGz_0t7|WwX4bjZI@YBgXA?-6Oy9TJ@ zO^x{0Rv_q2AL}du){m`7|Eoa<8=)ej=#cfoFs0%Bj@AS&gS?F_;|F&pH8^-s>3Snh zr@Y9aBHFy3kedR++LgAukx4b1zaqL=5RTO2vu zwxr-U!%pi4X7{+84m+dw!mh6{@Mw=N#NxullzI&&_YiHIsRwmK=%_R5W}pSpHL_a3 zJc~kM)v5sr6TYvN;oYBV&?N?r*H?vAPlAg-#^p%z*jks*!1ZK*J!I)?Wn- zR0cxyJ%cH5SpvrEH@b{UFoYb6DWwwB1APY5F0tVv7y`^tdmd6JfO^^cBBTrB@6CI~ z-eByE@|&Bk=6z78p0Q*ZqKj_VAxb`clLBYN2?2n}^)MfH{sbdG?V4kRN-aRbOUIq2 zL#fL8qfAk6T!=$LfH;;8hvPnNiLT|CECNAT3E)l;)_fQV!fKEjoVBX-KoDM^g($_F zK{`SWOq>Wh=meCPK{^2X)iAd{sDjSK_6Y4kV!Y9zPiv(#-q3>^;)G8l__8|SC}L>( zmrFfJRyJX!vi57Gz~Yzx40#_yb3@<{s*lR@;|6{DF5rFC`$eZ zBs}>aj6^B_gO+*nKj0k>M>Wrr>k#NI4gqKV#o;O-5m_7p7Ke*Nz$G1GGMcOpKPSMx zTEHH*d<3-@%SVtiTt0$H#m{R4&iiXi(6hnX63~}xOTgQ3Z3%|wL4q){00q3_3sAr+ zz5s>P`2rNuWeZTiLcRb6g}T*66xr5WPZ(3`6h;DZCjos1|I<%iRYQ0H310g2VD@!T z9vzdOcJj<5m}oX@7qL{#0u$u7uakD?T`&7B9eey!lCBk2``usYUdJh3auYQaarSxw<|V$;F#yLm33=9PW~7JpfiN#QL2R zE^aLheW1CjOMt;>Jha=}b2d{EO3BRz{O;gUY{dh@ns;_B!KI>|id>hT-H3t=7bvetP37-m%Ob6IcY z)~DQ+s$Q{!_poMO`)TAKd?{O~!`+HB?W0D1aA(&s5csZR14&z9wXN>9nWah7&(^!+8iglbZ_t}Q`k0~dk|8z>OQ{qKtHc|>DtHe(o0s)-Qv*(*G3gg`QO$e zsrpq+*uRxXaII*5mlQWjsutzv7croc=W<}sb&e~Uq_}Z;C5af9#LHMR8>m;Jo75FE z+xIoWdRS>kIwno^vg$+BY0u?VES+8?0-#4u@1gX#kV}OJrI-B*v12$m5Mvkar4_ai_nDhFD2WqB86I3?PI4eFx$>;NW-2)hrbS@E>~Q9JxS^Lkmt;U z;EPRAHJO~H#aJ(b9wW$k3?=#1m7lJjGX;n!yl>XbbE$54Cx$8o*W+`k67-wSc3MYy@BM1gc3=#lMt zWUu33MfNfZB(hf?$lkB1TzD}kj4Rb3*uIP$PK zd!!2(m6w;Y=CnuEYsU3O2%;6^TIyi5HBF?rrZjg(doGv7!4MgAd0hz-bquD81Ud`SY zYQ>Nu5R-8eVVYS9fM$p1Q**lsDU1PR6$dH&6a;k#DWOMAWQ|mn&{Cl5B-aRaxv(nt z9AoGT;H{uQjw#{@R3{qlNqO-Ws%AFIqOa|>6e+ge2D+Y=)2WO@i zU;k24D%8tJL{%@mt}=@btU6Ky!&SA_#RyEXyrEWP%Zz z)3Bg!mcFIeL(&?$#P1DGKo!G1{3wMv&*GS5qbY+;C-k=T@t3FBdiHRV93O8!uh!d> z+YY^iXVOo6w|Vj!?w}=)Y1|Fk$SD_Oe%)WCt4FD-Y#OO_6&R?>1X@F_1Da07OE+{b zy>vsT7Np~C_$pJC8+}!I5lsdXO+Sk?<))H|-0Zw4Ye{?^j;6}f+%D*nCu^lhBvEK@ zncFUX7d+JlzNyJnO@TjFIZazF9o(l@6#!-8v9P*;b#M(n=SgjlP6k=LEXg3*I}ja7 ztuAQcsKD2#(F4>^ht(cqMlcJ40-&8{khOF$ZSotbF;!3?sjjcpYjLnTHmkAiqynRH zP8ELUL$t&GxC2zH9?+e=5*oJl+C#wwL&cz~`3**pIYg}c<#rpSa@4ARLlvN#p=+XF zn0nj`sQE>W@&Ufn{tiHbyJ#W6y(rG3+IdZaU@08gP8Ri}c-Xprf|Yo+h@zeoGim~+ z_MMhsO~P#V*Xka?>$<83c3l@hc-MJViFDohnTNu39yLL+_kLVEG#!Ie<$!7UrDJLr96MTwjS~P%!aE4!WdOnce`PtT!0F$2^TO z#uZMgX9C>rjWB*V268>)>Es9n3$}g&o1U7jGRwO{K`SAeh?&J#0o>H6R%!tZXjQI# zT9~YaV&%$*_0l0If7rIF524unkfrVc%;U96_pbPjBl%gmyz-K93RN!s;`J5tYoCaX zqEC@hs%L@=js+EVL`r~uhMlEqc2@CWYI0Prf=tF5d|mS)TKBG83HHEfaOG44gNE6l z3nQDFdo3WAR3%J>4M>LFBg!w>Fu3vnr93EjpH_T`>CvgWN;>lZY8?1f?7O(tGoJ?va+2lnJ=9AHf86@FBdaY@8A zYXIO?VYOT5J;~&XcpP-45D2-tQJokZ0DZ38R^{UM8LB>^|`k7y#T|et* z*Ab9jKkJpt2v9u^eCD@MFRk^eUmaD+N|>q|#^39-AS?$jf%>_WVsq^`$Esb|bsu8a z^=naKu3goubqV6y)sq=#d#Wm{+W$Rp|~%|&urAlA_@gD}m|H~_2dT*2 z$<%(Flq&8>t&-Iks&e0Cy?-Z(Nk_fank=g@)PiI~?IH>=QT(}=rQXc*!kACf$Q?%4 zxEJ4unI3A~1#IN(!8PvoJz_S78uv#Y#f%1+Y7S>)qBa}UM5=Z%VDB3Bw4;BgW$cg~ zRv6f^2L4YT%#PF=bLqoku+cQYm?+Q?VwWSq%|rtVRFUCKmN*rTqy2rAlblG$!KwjO z0l@gB?^*LPjieYGj+l0v7IeOTE>kh-LL^!1wn)7hcj$VlSGs=eLKcr>6_k4rlYCCJ zn(xBfmzda0o42B`n(y@S5n6Y}L)uMxa(ZB?i)T?4%wEj85+J;|gS;J$hJK~+R+g%m z)>XW>z5#_Ed~IdJ8*$$YA#@oH0~#PqJedVRdl}8Ve{G>Ry%z8ZSD>8S2MQiR8DV35 zMO4RlcI;}uX;0I)X{YNAZ%n62BjdGVvhzq5Zhr_;hc|ju)gz!n1;)FO<>Yuu*V89I zR{{oH#JH*QROzu|8}v5h^a^!H{TAjms~4U&D9`{*d%nTYTDM zJ-?ejZWB=D?pJr4AGoiNCKBO|g1ENSJ&5zt6|E_X5^@E;UuxZRy*wj)5S1=8RAnk| z=L#QH`?>K21C#rCUxX4@x57izn+WOziW(Pq*|#oJV+1B~0_0jR>I#YGjMJqezsD`K zoLCoMep#lhJ9Z4!qI{?p$F!zS6R%-r#l9j((q@Dysk+UCPjIiw)$cq(!40 zEgF@#XjI-J1UWx$ImwiN(6o5d8CaoQ4Zu!$j^s60gjm17ePd4M*aLfzs883}t9g*9 zG*b3t9;EexXLBJD#{_#14^lvtKDrjP(7*VoBIv6aLPr%*z?-z69v!jWETk2;owj)J z6$$ExIN4qktA~&ORzy_>DG0HnimXjK=m5`-s)93F0qJ-SS80gSQI+QpRwB`1Cm$Zw zM9tB|=BOqZll5CiHPMvYya%*IOX%&unrOy&a8whG(2p02M$qGjb+u?5HkUQ1sJ50b}*3E?S{>wnuf*5M=~8s*9$mhm1v2@JbZ0^jxrXs1ut! z5u=G2Or!dzGL0J0kZII{rc9$Iv}78!A(Ls;2#;--^Z>C;!)9Db z##OK#SCVs8Y{!*kT@~ALC3#oHc3es3Rk0mcl6zHb$CW=SaR&nF*HV6{r%fSQRI{rD z@Y&Z?U=MAw#5STC08-vFfM{Nq#5Sag1`bWCXd>FAvjV+}0F((3Y_w3SwB2JZ84JaOy9Xdh#OC% z9nHH73QV*=q^C6c<-}{R&_FsQMr>A@fsKm;R1B zqwr*Pli*6i=-D1R6S=5i4AImIZfhB=TXo%IAc#(m1; zN_pdAj|w>f>8qas&|3+i<_z)v?uhj38ys$uis!o8@AT6D>1bg7tr*Uxt3Ik1ButTz110Cb~?cp@-7ac|m zlg9lH4c975RcoopJEfY4hkDF4y>M_@h?1t0pKoTsYK^822rHg8Zc7v5aqNQ@esYD|87V9d;&w1%Ya*RxuL?7f(KJ>N5%Vs ztNHIBlOx!RVFBUHJPaMat7$muAB#Hio!*Zu8CZFRaFlkUJ7*e z8VhfC-uMG~o?MGQ#v9^Q-bh*_*@knZkq1aw7rt{*=+9c1^E9wwlNSaa2VL#AL6)$y<ke)h& zVOxc?j;tp`vSe$?Qk7Zsd-fucUA?{X3NT?7FGM;9;u8@DJFT?enW{@uUZNiSeroVg z(PYpz0~5Cb;ebN~73;+w`Lg)GE%nZUHSXkXwN*C*a zjh$g8%1fu_j;ToWeGu|ip%KMQ!({y+Y*i#$%eEvDK1_?LsxTh!x8+`|tx3X$4-}$7 zC_A9X<|DFn>Q!8GQL%ZQfUqtb+1Faz!Sa7i$qz6(I5|Is5w2OSTuvF-J{+NM8t(S=?m=)&&rs zGG@SY0aOD9(=SB2(RC1VDIm8Da^*1qFMX+faQp09z+ew%XJrv_9x0Pl)n3^R1VQ4yQn*vDAog>nIcp zLI_NFKFw@~u8Kod4?!mWvIl}XXot8f34og6eIvbeaIY7Hj{6c`^D0BnoNL%cq&E7T zyy_LI*CeiQP`WYf$>(aL#)nC2-vpGYfsYfUkpoNM3c?<0zB6fYtShGdQ`j#?#i%9h? zv_>&!U%jbwbO`W4F8q{AhE&%{wiY zldfp{dFh`P-X>rfy&_R9RPN0>cdMxjJ6$|(S-!4%l9y$@&GR=Z6JVBB)GH4%4A2OM z8B<-^?w|=(I8`@44$C@mStl>eo4s=dyS)1tB`LV_Cp$<0Ul;|{g~inlsD`Qm@=yPF zc_UW!>&F5nV^HJUG|uM5`XG zES++yDvcWV-lFjokquJSNiWId`X4$6D{FRB5VdL|9N(gBh$Ocr1ICKYcKv*}O}4X781A^6{N>eA z<2~#pKE7S7w?Do*qFeGm&A*vH?;h@deDzC0$fvJ?v-n3DITt+{$YPz7yAQ?U&vPI~ zl~3-!w3o9_8~eQ&Egt6i^R`#a?@Te4$Z4X>vnkPXO;l#mH-mCvf+UOH;xT<(Jj}Lp zDum~tHt~d587jUL46Sh!c6v}ocYtfb(ekOeo&(hZ#uUI-*%#!GK6f5B+u7qC)`0?O z9ewW2AD{6HI`ruCm&bd^HGkZyIv(A9Gk<*5f0zXP?&kfQqs{i)63Hpi4TW$1+@C#o zDb3|Ze#DG1O|mPva{orI-MUR3HNEVZny_Q4A(hJ*qL+T>$z^}Lzu z@{-S!$NThdyZCvoi;}rcRbetQS{@lKdAqPcC9aM>PZp2&t1o)Y;9Ndh+_x9&&9?b@ zu_Rd(=BJ{A)M(i*;HoQ{N@;GFBS8PreRf)c)7$xjtr7g)X;tiC!|&E?JF7^9YJgB> zlO`|>BlU?T^Zci;2QndAB*n8T zZqq@A<)MWAdb`>dPb)pClW+3VOzp%>cBsx|alifi%o5AAi zd`Y!*MG|M+XS9M7P&r19BYMe9mc#kxdATLIff_=xBmss?o%;S_z7^9R=9|szlN^&vXYE@p4>lX8OtVDVw9G8Ey2I|%Ie)JjS^!<;10?Fv*5@p8T3Q~8i z?rF}8a-dS)cULCFYieTf%ITNL>6e)4M;~f7aqh6mn3%bxDk#ZQ9sQ(kkoM!NzkgcK zK0VBmr`g?4$4}3j&!^QBzxtN1WfLS zXTv@eD+K=^bU}nsHDyx3&x0$ZM8N%G`;y90mAvYNRk>TiSmKzp<_J{D+tpLRSR5BR zw(<9j3j2kN)9R6@6kF2yf`J43lB3V9Cj3P=wAXh!T~8A}qC~}r4PJ_u5bLFgN;;Z- z=*}NMp$t?B-TB9DZ?^ulcr+=)#i!3MiD*18RHoK?_T|x3k38CN(iWzAE+sYxDNGYv zc##+PpnmH$KU>de&DWe6%oe1qDIiGD?P@)@-<`+1@zcFxGKuZ=rw@QLU;jM6|JPde z->{CXJggx5jMc7J+)%BYAoOLVFQI%1raE!EAPrI7K7ZO`MSwI`fPUe>LGg6ZVPvRo z;2n)9MH82~jat`K!Z(+ot!v5W4-dWB<|mobTrF3mpqT=o0_M*c6Z*Z|)=;payP02!an_a%!vB8OPX4obJMnot*~QyQz}x7sWuZ29 zGZv@qW6vsLkG5LuM`DDk_!_$EpK z@zXQRab=fNIn`DwRhtI>-IWP{OO8xJmP`)f$>hJ3DHD$=6Q3zjNsJ+RlxKCjo8A;` zxApjWzFvs!CT%5u3=WWfNjxI4a@Z@8L06O)bPO)YnaT`eLiuTx?WneQYJ#q zp>qmUjN)m|W-%T6j#gnhu5U8w{)>?Tl}K8Z+F|NL=Uw(IYFF{z@GKjIjn(>oz7}jP z?$)d2GLm#VM?0Nep_ObFcsk7@vH`0>YJ6y_4>1}xHAck(IUQ8@1qn=u<;HZKk<)~& z#PcRh?d@ zy=Xa7r@@2OdMlE3g0fXMX3zISwkusARP0k1?ogT4gZ57Db9b#@wvc(%p8PHAJ(2Z} zbK8a3I)L3;G`0)W1hbDH=Xcw9s?)FSUoJ;k|If%AqTa}4U>^D9w zk*tZiF(RO?Znq>~zP?{P&gcx7bB&nHzV~qXfZ_3f7ndi06E;sgHpd6Ed$9R0&f6f) zWuR`ciMIWUQD(0_A3)h*M`;aVlS8UO_EsBEb`w-vHQK9@ZHHmpu6~}cM+>C`dxWu7 zUQ)C=gPz(Rg#%MtV6v}w%V%}4W08rt`G}FF^7H|kcW6eR^!80xeBIiH=>s$2fnW&2 zF3(t)4E||)C*{s zGZ!h#oMQF7z7sO2SUft(`=$NhDrf!MOy{=Nt0x9Ua~JFgoEt~(e5v?HmwmaaDk^B| z9OT{i(N56ed=Mvf%gKWobISPq)0_FXc6>aAIV&qP(5h=0P z8k^?gzm5X{ElfAiB*43(42ptBW3 zYm;goe4$G}tMyxTdhhmIhArZ&%RXZ)!T3v^{$M~f>V(N^%|(T^FEDDP3c1f%*>4)HZWkTl{d*Zd|I{RZO|#P6%^pR*k-Dodngab50a^<7OCsUs zjNtf(1P#{np9zG2I8ZNrlc{a+@$&RDzBa7yo)Q4o2ueN?_!EIY*^6)P6q^F{{m+sd zwD{wTPWb!y>GWxH0t)2+dX*%{PbWWo{arW5v2^_USdFRIC;tE#KU#!uzf%t-M-YCI zW#}Rb$OW}hf4fRiVW&h9D);L4O&4WFI_M;1GzWPLn~x8x+4{aa`?h-C9s>s5ay|L+ z6)6M;`~KgbH(Mo)hV#4avA#{L?!qGGo($R7FpIr2E;2rT8?2t5pN`Q3#)rX(Q(8=V zOgav`>#yuWr5Pr%3=@@uB%aBk&SlYQW1&}q4c-0qDQ~y4yU*qt&l7M?wM#Gr@BEq! zjrpg=V{85qkI;}R=!3`V*7$9!DUit1-`x0SUiw}Q8t6`?mxmQ73#OLK)#E3Jvzp!C z%{JTO+Xi%GeNLsT3R`aa9lZ?COF~bS-sV$#vE0tr$KGRjsHo^3!I>zLTZ_%pa`vs5Z@18ioAh|l%HCpd)YQ(2y_qI9(+X#ct);lShw|5A@tW^IGhOcp?k?O607kl;(@LS)F+2%j*YI>2&%WVlF@xbL z+cCfUskQv1Hh@ZIpuE%*%%cjpI4{xI;V)(}x`;cR-7i+L47;;ZHosCX%n2D3EdFA7 zuS6$ah8nEw+C{3!0ob@wSo~;}X!|u?YuOzjtTs+k$5af$Xw5f2 zZE;1#&?7Mf)r6Q{z`(fsTM!4yxfBp_+ivhyPv6qJyZLgy#=YEV_F*{(Ij!P*=U4%UIntec?iI+#znsPK}>$x7r`lbXQ{vKyl4$WKRN6e=T z{Woahjeq@%v_2SHl7=33sSUcL{*|hM2|qI^GN?yq^d6rc8Fm`uQC93EJ8@xoCW7$f zAi~xPq-ZW?%hjj!`19%G>6g=wCnA{+A}#Ec#YE#+lO35S`!aVP?-y$rTv*CBBx1m} zCfh@ZO%5P7;lzY!D=*#+3V9`4>8CpInbS=VqB{9oQH|9RhsSqN@#-|$K}HB3qN7ER zKYj2rv-(FV;P~fj{&zVwTw#Xu4IO444~Rx&?|DFGSfS$CeeqX9%XHkay=xrhWUtjx z3x^Z{vLy4Ll1+@=r5$9+`U2pEgy~E{QU(pf%IXkI+jx#6=bmZn?DWIw-Rb@59Ol%g z)6b`i(|Msa~9=W(g=QW8%sPHSrgh zLTRyrw1y(I*?sHFUTRX~-9ygX$hYPnK^<0BfP;7cF4JU3CT@%I%rFQ#wHx+;y=J=` zl-dTFH)oZ7NsVpZ$-cZc7VZ2a8dfmR@!jdu>GBB;k)F*(N1uEB`Bb5tM2bdNAk@QO z&Ssu-7q7#d+`RLB`F54Z6}Z+MpYtWLvwM>SYSDJR3e;(>O~;XyUKrUn7`U%tM{tCW z9f7;5$Ki7CVMhlo!;KY)rv)e|PpHJ$G`+@a09S)7%A_pYWM?*~hlSZaE$9$3v08X) z4)n_WiOH+A z{M1^k(di=Pv1L8^8O<;ep=1xqLCzmE&R)R z6tC7<-y`_hJ(?n1T-#DH54hyhLbeD-IEIIdvi4X!l(rJ*fNQm}m}u9CXzTJ(#SlDI z-Y;c^;o8uctz(8K1k<&cl#0-FMDXHx+~S>6z!07MN}_y50?iSbv~eK>+di;tbsAp$8bdeh;7*pa4MMA)&Wf1H**K0h!!u@)j;L~OUV@xxon>KhZI ze0hG*RbYy_bkPeH43G zYj512(;dCYtP?qrFej++ir2X0h&cFh)Jce1M%6BqUZDG^3dM3oiomc-!Nv=-jAomk zOqYEI?epnGCDZx80jN#;iGl~blemgu6Bil2yt_=67a;4cI52!7gQ6drapGkx8_@sp zJX>lbzrVm+_I+J!O%v9qcPBgn*28S_ZraUn@^%|ldO=*^Iqk!wz<(>Dut{OImx zzEwA8bp`a&RNUsn5y#nld%Sxy|3-Siag+?|ZqMtvp}<8lL1EL}SS}uaLMOu53TTjU z@rj@8AqHNcLZ`dP&dEg_+>wvEy)-Ajj8UF9w%2lD{&p6+Gb_HP;pyHccX##pDdo#; zDb|Ezv7uvdF!r3kmng>!HW4S%UB=)}R-n$5Xaj_Ur?x}8g-|L}aIB~>)ryVY+sC0U z$5GUxt{SAZukr>3c_t^KmGz;f6#cQC+c zHI1_Gr<-$gn&>gXh*(_NFxBJ^Vu+)R3bW083`&JPe3i_EeI~`cYT4R&1uZ`*<<*S` zPYP&^j?n|@Oq7mNw9Jd+>z#tzN4lOX&oJQ`CgnL+&!8SdH{A)z|k7IKj5U>6Ei zMiAYTQ6Z#C_M4J#W@AdO8oP+n^loW-(KW$hsa4z+Ome`B;<-EfWKZ_UnryPWHAy%) zY6%@_m>LI%@JYou^!zQ2(O^$5&);(5WeXak&9^F!_D(Z^L!XqP2V;-W?LCL`K}UGF zfN6|4p&jBC53fLU-+&Z-a!UwThT|DVvk!4}v+vNTS}=dcod+bbPoHr9G=H=!yOif1 zrg}NY%v;%^gY{yyUNDo7Qa?!Zcx|1OJQWCcq*g;S`;ZutRnD3*A4Nd=)skWzZhUh!Ysj8u@^%_s~=}5RjUihskzHKP{iV?!< zYG4R&te-cZH4^K80QXk+GwmCGe3BgZ$KCEpSQYIZuVry$7silavfdfjeZRgiC_l{a zmC;6q}P)|A;j*jV!sz--6uj;+}cL z2f*cG%T6!7eO08f&<#tor0Uf)UT){Hpxc}3(qiOfQ3WZB-v=$f6zXz?mqNXpq48|k z(Af61xoiI_v&Xit&0YJ~4y=po4X`Y7rJ}^6q4W6jY`O5YmnK(VO3?QyFn|he+2c^r z+0Z@p<P1hZul+&`XbqGcsYT^@?KmI z_26>fnEpIlEXgl1Hj_5Wcx#OTx{qOtzZ-KRF}Vl>OmiVkze-ZJSa&w+mUK)ibT*}K zj2-gCA-9Nxkhea%C+Hs7s?pwwz{A1LV3H`EXe0GhVrM?>cN#j?{#X}PxEgd z?x*vgQEzk?6qvuWN9)aExkM8PbJsZWuPSv{vwP-?x(Uy!_GXEkG|{G6J@vveH5S{4 z*;BlPGVBuK@-7sjE2St-ybK#}Ti{~JuIcW@aq6yCKRrLusSrIO*rLX+ z*5C9!qtLien#0~rA|+ynD_?K+q?Ull-j&OLz{4l#pJz)L7y6JjqUj1WJXv?@6AZ82 z$dkj7C!zw3A%JBZ)*y8wd^5yNVxC7UU*1J!rHRG74)ki-n9rXg=h6nse3AK$pj{cH z8TZtianUSUc`2viAs^4Tqp+Ph-OTmg*V&h0;$`r4S=bycK7Mehg_c+3;4Y%{F~{vIT8VA5OoVE>8%cjH4E&t@{S0gvMkC zjY&X5R36afE^F^aG?r!8-8C+&Fv}mG7be?rIIts4KQM?>q``;g+;$#?k7sPD9M138 zvoBm=T31ChBIvHAxP~^zr^RMFUz0PL(GIO2-|Jo26Ayc`6B}1fiJ!gOO&`}xKL?e; z^%R#wZrI%x<^XKIiIMD7=(j6$M3IqUV(OT|*VacjH+NJ;;FecpIiGFjo`)w}{xyO= zk2wv6#c=)rOKHi4Ou6k*sQVAY9bRxAE=zt|elv5)#OsqNDy9r9J>;#pE4GX>hhsC@ z1s=};r^b5J+0Q(c6e<*<5sz_~XEP3e2NWK2>p)wo_K}m4%#N$zI_}QglYP16WnN~= zJye3SEaox9(yXUN)^DZ7`+k#b+p$G0LatOWmyj!O6PkBut6fIWEpvl|sg+mnMbr+x zI*nQSt1W5SFYYLjapy&Rb~IdgF6a^G(!#lyQ!<^F`o;S`<`MOyU_RzfX%w1r5%s*L zQ?Fg9lK?e_DULnOzDtU=BIXNys*i<3u6Rz!hIi5wR+v-Dl1u3YcS3f2;nvOq{fIw2 ze0`4_eRXWMZ~!`juv-h z^^lxzQOqP>l)7)02(km5I3pRv!EdwV;X8UJ z2OO2@H*h!!&x5f_BPtfi>o8ob-5u_*OvJT<5%p>w03YZA>xUXBSLf1aCT5qEP8 zsC!K`ZjMp@N=G)*lJumQ?DlDM6jt1d?wdP9({vH_aO=sKf^rXem0!j2vdS7 zCK~~Y7uN3SHp)hLG5dI4?0_<93z*(+wG@MHh?b%~e}E%W||>9v;X%@#6T5R_W$$vEYrRqs8vP8VaKs%M*|(z%lW8gD`pI=g*L)NAm1_PANf0Ji4l zx(WHK9C-F*nnW{sl~uWVtq#lp%3JPD7>meq2k7v{BB@g0UOl`AzK4;8}HjJaQW--*dh#^XeBB+m&lU&cDvStvW|bjnueY68&NEJ!RP=$T@{_(_+Bnm(Wg2nK*o$1zauLRry*Bww zR_Qp3@&qs@U#`FdPWE+v=XuYFdMqAMqm{ckn&Ht}D{OB^C(zwQew%#RJgwpTqYDR1 zti*_RjlsXszr`!NT(R-wtsiqMdl3{~0yI7kZ%Mhgp%2ht16Y zp4hjn>=~E+i{4STf7?HQ46;CZ>~Ee8zu1TOGM=%kh_BPv@`A0)wsUja%z;s9F`9@kdd`!5yFBQ_*ULu3P7_LHADDxEx(xli-|Tkq@obaJ zPrkS(b8=Ci#nV6jOF#}S_JU5yyEt*Ewm7%bLy8}1lW6ME&>eSl9Nc@GjS1M z_)Hu_iacWxf7`-~?j2@|Kk(p(`Bxi7?>&U*TLAKjf}PI=#NQCunT58MJA(R0Gl!X? z$TrS<5cfSAB3;HykD}lRl3~fCXxiW%jRnr5SL-0%JYF{k+lbgQJT^z+@u!1$)EtpX z1Q|p+3_Z+3AeYA_jzlUhM^^n+5NKr>-QS%6UiL>q_;`x$_cv_j;cKEetsnPxUjIP(a?NK;y@d{&#?=t_jF54@u2n7L7%K-5u4$zq88m zaE#e#AROR_kBEkp;2EN)Mde`y;^7#APz)t88^RzCk=yXPKbT=Xj-;-nN3W^#4DL3# zcQ-twD(~x--s5!{?G0Og+17&HWlw(FGy=xqEfg66nCPA)0h*gK<9Y75RCh0)Fm{QLHlFITr>r`aDt4uMe?(Lr(G3M?Mk}5`5tf_ zP3S4U`xHkcUKhUZQ06#N?okqVSqR(}Vo0b81da|NDjolLpJiw;qJuO45Y;d-rd-6% zeB%efHj6l`^-gXbQsgWyen4llc&AFiDU(IC$0_V!B?JO*`00#A&_@yWNWuclS%N!M zaG;+p>}LlQA-xVT^E-c+Qe%1?B`~Htv^{2ihq%+s|DRE_J!bwiu-T{IW9CnPjhR3F zJ~MxMn3+HQ^=AI`nq|nSC0hXKjcOdUF^GCA9%={c}rS^T)uR znO{W2jhp%7D1n(jL<`LPAxdE8_fQTs^NVcdW`2QosF~l-RAS~AXuHh(0bGQJ3Xcd1&S!A%Ys3`Ad+>&HN%mnVCOA^)NF(%NR5B zJ8;y@9|K3s{0uE_=8qzjoB4h8z|8L>1ZIAYu+z-%5cit-C2C;im*Bw6FTuiYAIrJp z1i+&t&HNI$*UT@`g_%DDm74h_YGCGPCWLY`e+g1(=4Xg8Gk*;1nfYTVJIwqHJ!a;2 z;E0(&0u0Uk3@L8rmk4{z{LHQsH}f-uU1olX7BTZnggs_{hrGkgUxE~x`D2I&nfb$v z2blSJrihuJ-+DX1%rDU+X8tI`E;D~LL%Eq>qVF;Diz|I`GrvG7H}ea$U1olP$j$r$ z@G>)h$<4$=uP=rdA4AlbnZFDzV&;#ahGu?-bf}r%W!YioXGn*d`CXPhW`2hlG4n@& z(#-D=JTt!o1ZI8)3eEhfxq51T>ASVlyQk&z2LF5Yi$qC&`;aKL6@6&fw>wUdP{+%kwk- z8~;43o>zW@|JE<+=Vz7LZvc8(z5Gpb_BUwX-k;~q7Sx60HxEC}7ytg}`ML~mAN>E& zADDcPH2WH9k&WIDis`MLyCQ9YGxVlEZceAk?|)Z&_4iNf*{6qDa?@-k8IBRiT-H{1I=ShPc&w+!j-etsuV(m`i84ZJzEhrp3-!L5$1Bnf-y)8p-l z%d*{ptm@zC4UQOL+3+Yjm9X87jO{9`_}j7!@v2ABZDrnumEV)WuYQQWz*i1F&hF+% zo9+7fZcBq$!S0XQpgBqY;UAL!VF1leA8OuCo7qWN@bSaR(a<l$3Hic?dI3F<7L_ z8(}-kH5d=Gqu-r5mEg8hOvTp`-cx+_+t;sP@Xxle$NTWSolmF7$9JoTscrYkNwU}^ zs}Gyi60{NE2cN=8?N##WfBw(p=PjOoY?9e}o;;$7Kkxk`P@>zB#?w~T?54wPYT13fIB{LJw_W9QrpJrZ4=*8= z{8RGu{9(DcOFno)XHOkpQVFjVt=;g##30jy>o^=HuOA}gQV*}~9(){Fa#S7J8Yiz$ z;;;qM=l zUy{X-jKZ!w`ZuEQK-=4iu{QYaY-Bf`zQb_KR=>qkomGC)nj%@`MvNDW@0V2_^c z)c^5$zW&y+6Z4oC-Z@EzS-aC|sfZb`PiQFrCqT+=;#4C zj`2u6sF|Vy%%MM`bvrJ8T0F%wM$w0J(7q3;P;j?ThfjdmfPIQ{+K zkDw=C@lBXkbO zzr0G|=lOB7_=I%mopFp~Sou)`HlJ7PEkUZKkeUa%LlYqa>i>H6Z$G~JCBYI;U&9bn ze{=`<`$yh#(MYutQtQXOA$CI^YaLP`2&X&t$O`06hxyb{O0!$=H2Nez9GTuxshuEA zO`?DRBzqL7w03XA)990sJ%H?_IYxE_B^h6hoo<~|&hzu)e!8U=m*hmhH>B%^mhKV9 zU?&xmQn8ps<)S8)sOTd2=Ra^*$AUT@MDa++gu}o8!4sb$<=5)(Qu+~iP>RKo0yks{ z2XsmRMA1R4;pNfv^|Z*E7>3OqRtB=OFcpSCY{fj0SDIxO9FMi>9 zH{O@c1!e{*7qD6oE8geV)f48CJ|I(jQ`yc#*&ixx$|MuGdF6x(O zzWuL$R{MYUzyFFKyV6cNeb^&$>z_+`x$Q4z>vN{P6W5d*2xYSkDFi@T`DAg;Vh)s@&B z4ZG9kltRNLXEK>CGiXr7%hAn?OoOTt)Xi`5c3Z>FC9Jp|k6QVpuc5AWSs(Ym(=G~O zdNY_&)v&C2n`>CzhtYk6qR3hrq2eQ`=%5;Uxc1^r1f6)r232!hm@-`To9UqF=FK-#(35zV zXZ>3Y+t!*w&64W5%P{QR+>WMccLYtQ2D2J>v$h0Py=>IK23VK*1k6>Wxb3uAS*{|m z-!m0wqg;h$HUKur+rzv!rGhHO2-r6ofpiF)K=th9AxbqusftrjqQwfV4Fj~R2wHt~ z8`SH<8x6huEzDh4-Bv!vvDNH$ns1nBQOJ|qEbEeF3HGQMbdKT|gD^XK#u$S5#}Ngi zOLS;SbT9c45-E*>Tk4cw68#5-tV@lmyuq!gC4BmNVE_IxD8J~X-R=|v^>!C~3UE9ODFcySB*C^!XF`994bxB_9C)$QnSZ78cz)$SE z2|gFBD8veDE>h&c4{zq*TB|Rnjmekc{AoVhHdoJ&Tbt%Qy_ztD{bckB(CIH9^w0V) z6{+!_!g#M&SQNQ)BiDkx5O>vrjb1!!pBe zjI2|pdbV~n*pgpjYg!pux3)QQ6sHnv|L`z-yzks2$p8;;U-@YvdA3Sg`iUBS=7kKT z9-@V$NK;^4LYyQ%jsR1Pz+lLuqatGBNQ`u_3*Czd<(yVi8eIhEYvi?~8E}!}@)~f2 z3)FOj@Jpiq`X%A51Qzp87_2cxb`D-9ZZ5GQHjv`DEp zH1sP9k!7?rdyk$j*BN)$M00dcefZ#t)+$`t{1Cm4*l4j;uXXbWJ$K>C7c&7_$wPzaZq-o56bGexBV%R2e~tl!ykpTe(dd5JL7(dN1A=pIHYlxO@c*d1c1oYI8V z>ibAJCcB-5%CD(7-F6?T$#;`d&qPFIhpnBmBs&7HBPpsBeMVwx5IjLrR@CHgUzC+f z>fJf9;+DOw#oaI0yLYMN?s!$sr9i23Zfc%>6DmB;+UV9Op_#-G6sXyG$C`+8PCJM-Puuwu0;{@Wjk+L}a5P39vEUIc!{NP9$m54?8j zD*AD@cE_n113bZB-5Q``! z9+Oe;^~ss=prh;OVdAQO7wF!j{$M%m?WAmv$Y{Cinx# zb1hV-I{sCTr`g?4^LzC0GacyP%`ypoPMv&m5)6Tm#LH>iiThvbGq{F=iLvs%%rDH1 z>6@qd9V1|pj^`&nnR$dnNZ~*NV!WASIKczIRj%9B1bCWlfTQMX>V4X8O+{X=fe=8`yV!+CeqSW z)GtM)a>2=TbE?Ub)k9}mauI?c~}*b zsIufLV$53j+jK+FD7wvq!;xRC32VTw*AU&;1JhDfbU;{LAd=krxLnP)NxPe;%uR|u zfu5I)b;45cO<^pBs>s>?njT($P46$WP|SFi`C6Sqy;i4D4oE!+sVF*JYD?#7nM__E zquK{xvIqkdf3r(Kq>yTqrom}SB&@EerR5Sr=-JWNgRySTm@uKs)t)l>XMF|i_ijk4 z!)F@VEGjgsTg8-e1Zdjdg@RnZgaDDUx+RXV7&FUIW+ z2+@>{CzDPSG)Pw1>LUPB79Xa1>h`A9ftmE9y=SS=j@7%&Ct-S{GwP*-7+^RqZX@Z< zyqgb;K}v5A`#^dF*H66Z4r9ssMRh+p>)(P@OWU1ptble-M?-!x#@>!3zscU8a6xsu z`hqg)Go7HJ%-YOt7hMGy5YE*QN^>cwNhjlECbrY0Iena}HYOIVJdVHjzPx0#k{t5}8 zYf^;n4py@#rd`N%orcY6jdA$-xdv%B8;xT023f3&)O*oEY7reW>WD31TN)im>Q(Cq zBcTbgvC=(}a_tuR!rKmGEV)(Zq`r)$Ndc>_q;RbD{@3kvNNq{RWtgEkf@>RdoOXscxbyP*vU+d?;%Zl&*it@X< z0$o#sZmbGjTZe9}67;sVt;APT(l;!GV5jsimZd&{n*L*8AUY*VAKm{f`8!MhjtW5F zDgJ}x=>y~K)9-;!R^R1SFPu~JSL@X5YG0UY7PgwjkN0S2UPxp)eeEV;;c6oUg z-2bXwp8Y@j?|;P)w|s&^;n{z6%73E$*I7rPED(QA^Y2WDHw|`I3KP276}xGoQtIqt z38a9Q)9z&5R*}?r@*f7-4ZB(bDFc|)?%q_lJ;m$dICc4zFH9bHyB5T*!!*-rKf6gs zowxk98l-mfn<*?Pu*9?bB%N+|j4OU0HPE-6W`>Gr3JU4bSqvv-Bw2DJPO*7ZixzZ# z#_q%k!1>X66mW5VbP)wyo*!Mt0PQNfSI5%Pa*gK)?~Vj=40SZ_-xQ;)&oR?zCDQj@ zyj;W)o6$;j$2q9`P0*tD7Z38a8K(&2Z+esVdg&BEN7eJQvlu9ScXREyOE z$|&>2P6QxPIg4X7x@q$bk=Ox+{B@q4bd+h@`U7P={zo8w5(BDo9i(}y#%4e5W&BDQ z0NVMm=O=@3Xy&~^I%1;?()7Tl`EtbponCsA9f|xsQ0Vw&tPa}pdTEypXh=&3g9hks zAS3vtz}|3ro24z7W-@V*ci%U%KXpKLuLgjdyw7NxRJ;($8X>8SayD6bj#199R%(DH zcNqmi`TSxeK#FXn?jK-Kf_F#PabP~Y$*{M4=-W;utr_%mS7dC6nq%QfBb%C`- zmL&D6$ARXE@+5VSHFzz-Wc08M{@AVc&PJgLVTZh^tv(GWa$ z>SRT7e&+Wih;Ebnyy5|2@-S%C8=RwdH_ux*ZoL5G%eASOW8zJ9w=Eh zaL~P>)L_`RI#2>gDW&8jS7)(u6jE|k@vE*T6!w@iJE4`cst;-4Vv)5hf;Y8L{lWz@9RZ97=pg&9ihysR4%XU z7uRRJ{|5y_z#vQKwevH!04WkylQ}y3T4hytP~;f^dF>5QD|!U21yEGl2viS2SvPGI z1Pm+0bwNV82vDTrM@W|e5~**u=@5PmQ^L85z% zfdesuHv>4++zF#qieYGE5<@ATvKnoVh*0$aqt131jEGm4ia#hkostN7V?zlY%I%E{ zr2`Yh8y23fOJu#l5$L;wodK`B44Xsr)r4^p!2HNm1+$J$aU49 z+;)Niv{Cgs(d@0yzSgSs5JWp-gn8YU!O$5Xg8+^mW@6f`^mW?n4Rg^)BrKaE#T?f{bjV zjg7BW{5dmn-8-v=5*pT8Qh@+`UkgMu+f@+ty5B2Y{l^~lIyCKfdT#H5?5~Bg8lh_M zffO#o;o?TqdF?6~7oq}{n%BM1J~xQ#X8}-*;}7*pfM9k{P9MQy>hb9S_yGM_uLZrp zMaX&GYX#qTBK416J;e?V3%HEKWgXksQLLsv=UG<1VT|Q`mF~ z!|I^jnqtg!Jb6fC>7*AZvvx&5dmuAlWAwDSJ(^0Mi$8hE`pz;D?hFKyv9^lfAdqW-!kAv_<`kO948$swz*3X8W z=2WSq{CEVR{fwN~)F9@u(JZid4=w3U-9Xn*!bm0-lXQT}z%4AV7O5ITYUYFY2BGdD zn7WdG3cIRur^o+T?ydDuzuU zMVe9tc$HpwK+W}94O+wE&beIm`dN*2e+#r{T7*$F;@OFlTZ5E=Qs~5MPS1iaE&z1F zL1~{BOkir0FF3=SjMj71SsG{6st40GZ$cfKDJO>j*djHXIM6u2P|GrC>jkg3rq#x= zS>XVarQJA7SySooNAtT4xtKL+SXDC6II2`+%81E)m0;T9WgVGXU-{|(fA;>gy^-Tc6ouz2 z`d8F=?(vX4REt=+wA$9W1)xBd383IAfM`m`4_*)`lCVI4#?tJzrTg38h+HF=0@y8i znK|N&)u@Qb%*e>d$jB{HvQe=R?~{~qcTC|-wA7LTOc3gUw9&!t1Ku+3376S0e}RfQp{a?^qG6oQ2F#OR-Y zh%=pr7-BY{4%!6w*1&005K!C&%>T+2os3Kq8lV#bH+qj4Vm@FGDT-3f(3QVH6*v z33`GOP39*Fcrpr3jL9F8%dk#_q1*F1j{3N(o<*eAWGWFV=IPqES*?Ip%P1m1+3^4rjF@=v>VJB|iuo)to z90n#D{P4Jy^>5k|T{h6eh(&hhD5F4(iH(yl80H1KYM>iXaqJ8NSu;yz3dw{_GB`14 z!n8yAIyI1NN|xfxPN2^WbSG|#IO2#qH*oJSX`SAhOw-A?C8@A`V?j_8;=Uy@E^oGs z39eQK)8`vYaDsw2ttB;q)9PdiPT+fSqYsn)ux-hVwI+xj(p5Z&q~0GeJpp{xgU_Jb zqyk?nPEW~v<#W8%VjP8znblStQBS&&)leJ}y$>%g_>9f$*dQpJ%RR#tR-$y_{5d+?J{~GiS#L$E#7dq(rPP#=cuX=#iUsCVd_b8 z6?lu|?x)o#0*B6~)ha5#cGGGWfnh$O)gm$x`i*vb2wa!#9GWeGmShA4jaYy8m>FR& zEnzSWUPr-W2>nY-ARPN1eqs}xxHvFS&8UlU*iT&~YaEsOtbjmgaqi<8j56-A+Ip)j zV;6P4;>U6ANQOmL6;U-minlbQIN3#E)!R;g3GHRoT#+!``3}w*fz@5P6LOJ;O&FZP zHij3rkuoXpz?E&LObT3Z@s2Et;xb9UvuzZoNW)&-hm1VZHkb; zqX0t~&%&uFAs9x@3&$QC6#jY=f-FW8$jy#hT|y{c6yStrz3UhcT626>faKhs7hoBu zZwrtHmzH_ZR0fNdrNCid+H_R7uwffdO2JJI^uKB$Nj-UQJnLZN#n~svf>0W1=3Ng( zQs84Kc;GuqEwNG}F>0Q>1WCOe|8Wqh8ow3fbumZdb$~ad^O2<_9h$g1sCIWAI$YKi~~GF zME7t2{)agGLkLw3#I}*aGG86Th221G6jAgLeBeR%A`qKHo|G`sG-aV?skrhZi!?BN zX)y3?I9)>3&_}=sOk`aKz>PG?=#mV8kdT8M_CTmeP%Y8`RME=~bY{s2+FO`Xt?d;$XVQ2arb6!;>TA$QA&bDNN*3y77d-upctU zV6p)ACTf-{CVqhXD5Ti{7Ij+eR#O|MytpiE;JSlO8iA4xa787f8*zwbhYH_P5Wk67 zDx0u&)WoeUnAS8{MQRk?3E$(bi!R-uLooDy4mPNvmjR3)Lo6Hh=!HF$d&gW}l!(lf zJ%_Qoj}&ZQ;cAR9+8augYDTjGPKG#EP&T3X2wgh~n?`8>&jxiofmHKT%XQkoC|Vxn zC?8wu!7uET%5PuVjQiB06LtqJZ~_M@Ug0z(f|F#hbd>RW$Zn1Rgg|@04thA%q-(Dl z!<{ojI0}akml@(wn3QjaxhRwqD~wtQ11k!woSgabywH<#Kb990MmXujY59^kBq_kCWAQg zl8t1Li{Rj^O1XAcJFlMB&JKMk*nJRuv$01CBY5ba99#8aI|J|t_@S2!yuY*RS*?8T zXAQ4!;9+6(&Vl>$vy)?TH377pEh$H71E1U*#u*hMVilNdA2%=cX;W%mE*iZ?JIsW; znw=|%(Gt|h9d%fa|GU={12ZM6b61p1^HjmL6CM3jD#5^L|J%pwdB zgoI}vUTvClm!_9S?38`GpBnop4gu&L-4@XJBHv%k z5*#SZ!dnO2q|*mhxQYq6t&Wc7ppVgtE!D zH04G{*@DA3z^3*U3*Nv(&LM3^aW0?_wz5N&ps(wHLZMh9gX$*1WhoW_MJGp(oq-s36qm!;2w&w0Tlzt?-`aY7}%lHT3{q^#?nC1ae^WEA^L#M!~m{uzZw%U zz<@_kIaW^_8z`v-#v{Rvk&r3riU`!VAuGqVa}Nqw3yi5AvKw8qTaDIO1DK>YYQC3j zSp!XD07}S&N?)>W@I4h8He%F>!F|ETqCmX0TrsHl-DV0BS8%8)0VrO1HJ(^*@JVUY z3`)W11me`lmRZag`+C`AU0=nf!p6x4R~}-%oO%L8US%QmYU6wXEeL&$nNte*IfdI* zYx}C!E~;9)sA}TEMA+ulFxB1P2QJuXTt2SUO!$lYMxjm>_L?1ifTOZLIv^(dRx9k$ z*&W>}yp9B0r)HOO`dQB@wbzh0oaj-6h7s1oSg&cYxb2x?9{{Lh1Q=kPzQ}A0Hh{OT zH5KmREF9+R-z9O=B(`;{=hLlTk#6-0b<0;5c1x1!8aX$|nnoRzB9h`5zN<%S4&a6Y z8~HTS(c5EEX%52UA*6l)%vz)OqZ^z__Gl#$6N+6fT1O7YYF;3Jm2(TzV7Fk5mIOqk zvN9w9@(M@H;Wj!Ezy|_uSZFLE;c#PY0C+0s4YLjKYnlIP_1q{xISAFt*{N9sd%YdI zu(^^7(~42E-k>HLLE^};GX)v3c?_Pl)ZyYBKfqOZd2GH!-uD~zxXR0bDC6C8cHGmgscvF#?)Erbz zqD~ytxkR0sD7vmhC-#6FbT9cXo1wEE5y2{E-HgJ+<~4>trTd_r4qk7}61>I^%70D~ zmoZ+C!cC?V6U-$?Y7S7H#~B5;6PZWN1dBWjPS5}ojuA2hSBgjkKp2IM9lm5Yv`dmm zk%V=&m`&H_@g6=qV`&T-(feLIZp3|a*y<)QDQSlo496Hp^!!EpUhPzjsUPpepMi_J z*Dwk<6`g?;=So>x`)ZZERYt-e)Ac`dqCh$nEb!?+!qdeQHTH5RHCJO~?K z6CtziD^yegCVH=dWWNlgi0_XxFo{XnC)An=+<|gvc_cXwJ+@fGwUje6IfBlu#0b+u zWH%7_!CmesmQB=kmI!0;a&K18R$iYC8_!K z2~CF=V7dwVnntG*7y&QaaQk)*UX~BDh))M<1~}>WlMeM>!V%19&9vgc#wms2vb;%^ zT4xs#q!+^tKP7}Z4SG!sTw)capk)eWrv8A`;=dGE|3wo0mr3P+aw?7avUo~#$9 zZ27_LWJ#BGA_8XLNtYkgq?fnaNt$$ds5r9c9=2P3w2#E}hwrUuc4WPUBk(pFP7$bE zCsF*0ImcEVtfxGQ0{@>SqONE>!aI@j-iU($=6c~pV>0o^1b>*jGg1YA|#} zzCK5HpaE&D!qI)@PD|`Y(S2LYE$XtBL%K)71lGG@yHa#dS;mIIo#JGWHX>sOo>_j} zSf%^0J(xrEFVkdjaY?}!Xp`CE_{9y~n$_^cL;y=-iH7df3Md|9D3NtuBMKbdzUAv6 zt;E>AO~avxqQF8LR1EQ4V-OF#HOd--tmi5m8*n+61efA20zX_p-B4(uh)a;2YN))m zQP{YAOTR?JHsT7mN>w!^fB`LdtJ96BsFz7aDbYBMG9%&6m#Q@%a|%mNf533bFH^AH z^AZW#K~V7pzQk0bAv=-*JF^tGAv>eGTw?~^xSy43hKjSY(>aCY{YM_B??3PLsLP|sleqeKU_#cBw5hs(SJsb zey3EUmyB^0PeP6QW00qj3Jr;9!z7IGA+-y({LAk+BZV2@kQ714khZjN*UB+?T2V>8x47s;@V@Cya67;v_& z!i7zSYL=4@w?pLB!w3Lr#KMj>?S1lII{HIWM|XZeZ*%f(I}xEByC3o7+!KU#apKP) z;`22N76N+_J?R8MF|-hOq@MBh381V|ppJk@d=UfQqyC7_`~3Ym@kxvnh@zVh*$799 zI=knEm;FgK5h*$&BFa8QqjPgbs)v}1&Zs`fViv@rY-3>Z+Ph@N+s3d!;PiN@xY3K= zB0pVbITjj2opF8?P2Nhw(9Vu^9;Q6TWxYd|hz%G~$s+3Rndi2&fD@YLKW8PG_OX>KT|*{04X#WYT+`)OdR)cZ6rHR^gAm{aO|nwS&neNq%CM%5Jp!<W&A3Cg7AN{ihY!0-$>pf-7x#9{drBjb&ss<~*0m+r{sYhDi9r)mQ@xnX<-GLdhXW&NY0HbC) zP>dCl7=igX9NatO`5q4K#LZ^gI3v%&VRwKbiYzenu&52*xiNwZgh*nu9u8pqJF|c| z7c@_@ayT2JTb;f!elzCrN);lE;ag$A;Rzco9*AA*1~~jYR-auLoXN;lAG-k?Xgx~^m=AorW7I(TnFbP8@lbo5P#s-IfkgfMiA?YZ^A?+x3Tap6E=&^0y~ zV4J3V56}R!10U_M5t)36#eb8Qg*h{*dLZJSaUrE69`i7C6(gyMAeM^2LW`VKo)nFN zdvtQ-!p6#%v=rk8fxaPQOab(rm!RT++fnzzh;|?m{G6pxJ0@0R^Qj}QCdR9CG#{1fN%5_CG$iH;QIZf$34K#6Y7}VpoVf$3qwc{Yx+$9B&`` zXm(W5Y^U4kWg5lzH;oRbk>a*n)sJLTW}{nbq{l4dc1wnD0@z(15i;b2%?MXXacR@y z!&eBCn7S5j6vI(^Z>?dP8IHbaCs}r5l*AF9vbgwN;R<*o!Ie_eqH_$s3~dx4;Anzj zYHEm7pxCZ3hI<^a%V{Srh4htAOCBC2^2`|ZE#$djPA%kHWB3=*zC{P znMWXtobh?om2lb)(l2*E7f*lqXBki!;=2NqO=m>z)-N*cbUl4##M;o+PEq`VPoNHv^8wx32h7;c}knZMxGhX zVPnsY2C=bkjRtXqaBQ}UgD;!ziG#104d>virmy1QYnIF65S&=9iz1L=*2|U$;}BFF zKgJ=cI?jwkQgd7yhvdZdYaE(W*R^qI&RoyNp*eT`8;9nt$IEfWckFR?T&l9i<#DMh zo|CRFRaNt~i>wxS0<^niCxIt4d)UBZDolx}`3P@VpwWJt8d(nH^E)!F=&9q5=j`EQ z_MUQzr|GYgtEg$e13n7t4SWI|-+Uk6PQrJuN&|e+9Ddi|DR2WH1P4ld1RVZxUK7V$ zS};XqFQM}vkm?R|(_eMtOJ>O+B475~_f)w!Un|~0FWo-&f#jX~8qTJh2mN`OlSkhr zy8daCuK_m1w@hvyd-L&ve%EK4b#L}DpJTG#HSUdYAhOAeKYHDhKic9~F|Umzjrdk4 za^2*mOtRTub5-U?~7HQFDM|*r^ua3ZI`!vI`nW*@o~Ue#|xoa zj9d_RqVa`L?+l^drTIEveaNR}7gQmMlDj*zb#+NvmK5fIe08(Cg_b`a^>K5a17j7&X=q8_vJsCEsj~4?ad(;pjbB%%S+d)ITKRkU1nzXsF|gjGfOpR zS~XREjpgIhDqpW>%f&mhl=yLcPl|fq%jfG}zUt%~CIbP!vA`zyly8wQ(9zedh=7~;$dF^f%tse7g#_c!0MaX`@p zlUe@p(_i1e^8jyr!0)h1JSQxX|0*s`n<`N{&xN;z0g}yS0C|(j0(oY-SZT?u!gbfV zt{Hvjx@LBs>zdVju4`8JxvshW=el-X^L8O#n%Rf0YyM7jT`TBCkhk597>M*E4F@rH z#_Jy_h>6h#q8M#hIDdK=+rUO9EV$8nfQS~;rzN-?Yoo03)(D#;y7Ieyu;_`F#60TYx&m;6;Aa z2xtu^YYky-VZpE^EKr)?<*R%#$?J0%Gd=L(!)${L;VbZcKs1(%&1$^f5Kw)Ey$Sly z+Moklc((BVmU(C+v#|Gv?<iJ1C;)BUD|g7(iRId_Kk6tskJ10w7t<^2KJn z;W?u8P93b#`0;F(^8xH-FQ3SWXtVpVwAB0A^&kZ zp3gR)jP%elH2L;v&U8rvZeWmH&bL-A`u*g|0zppm@kTkIAduziQMQ2G7a;O)FYlR0 zza}zdZhpS%F+X1d(MC!!P?)mY64;!rpXTFFvYXi8RsNSPDDfwP!lmwf^RS$nuz0b_ z7c}QiKAnxJU(2%HJmf127&jW7@nU;7o@}-&ZPEn>lyr`I4*G~kGecBx{agLqrQ}0q z9nhlus^$M&Etie(tD5go^C405p;q&uZ$!s)$BHe!1Od42TD3@R+x6+sFHSiJXVE(lJYjZil z_P3zPcJs8|*ra3VDO8kq&s?&=hA4^&OZ+ZmXy{{T=w)c=V`%tthK7V8Z<9qGy@nFZ z3`JRR=6=H0$f4okzXchvv+`lembx&%{1J7Eg*t8rPn&rI^pvRCA{|d>TU36&V3lW^ z@oEz;?wQe$u;)B~5-`SrEQE6+zlu1rnZdgP?O-*T*Owm+-dNcN1pH)Kq$&-5@PGP= zg1}Gs!2;cI82<@BdU3=d@WXW(NAJL+XWjOaDEefZ02jZ%olv39}@#LkvP#epVQ@&$|GA%R2KX!xZ=ZnL$pybvEvF6h z+idfRX{F+Fek(^KR;&5#<#;oBz+z--Yy7g{&Ux ztL>W4jYVPeTOj~X7D8!V1Z5hk*luJnr@ZM!E}T7@*umQn1>)pU*znbkP+OV#WS!0K z7h@cJ-VvboXb2rQkCFw1sR^#Z0AkdLXiR+p;Y@uIXit3=%$WKrs92g}ZUewtvw6Ni zzX9Ve;Ekt02^}C+7MegHd&M;TA0npVXUJ*j$f;xP&{Jo%&@h(863Y-`{LE~sQ z(9oR>=xaBu-}LtMMrz3{Ge!*-`C7{LbHkh&6>xZ<^>C0otAl4KmEHRXS3{Le*;hax z+ak^bJ}Q5smJFV9y)+CT#@5MGPIp$Ga^ZRZ6wsWw5vJe9XF{e<_k~bxiu{V zNO$`fEjBAY12VV=WN$o2Kn|BmRHNStF8?B>D zw?Rb$iMo35Ts|%2@X5R@29a|lJ)iKjxxXY1b*$O(Isr-PSDgYeEsL!I}l9sPJ3!x%he^kfvK$*YZX6t#JucRe-N?Ju_ zzHhV#%?Pikx?Y8k+qbRp<81y(jAk5^ z<*V79R4xu0%854r?5&o#+RnQo2a)AYk;`Va{2{*{uV!O|Fa+P!$h)0yU;=|as{(aq z)A?+nN#4te{!ilh$bue%3(le1YoFhl+v)Q=V|!zM7p*7br~HwR*8*m)*~oOX`tTiZ z#`D=ke-9SZd__105LAEmL!N9&DqJPcasmKsZrWPEVtWU$mP@M=2)|YVJAAIC0eTBqm2{mi zrpr}4{XS~rNz`sLNk>kBjqO~x)x5JJtT$dP*L<}>*B;Fl{c6+C-I5y;$qh}(@h00N zIz{x~RCYr{c0*HkMIJte8fC+Bi-qUp6Vjo7m>0sN5(ieE)kx*bNe);(Tyb+!wSLdT_qb0#!@n`2GhuLH;#3U9oKg!J`@%>4D%W6ZeoBZQOi%}MCc^I>EIN8vBxsLjsyV%1H%0ck zQpK9c-^B?6y=*mg7p)fdlGWta;0KkBee=>;mPO@ZV7OnT>Nu{ogY{qMd=^kF3{j$x zhWILAPrn7^w-JIDR+3qaPRR?>-vvd*UG{9kmx#h&QI(;bs>x5>$OysED3tsv;7kN$ zEil)jG)~0x6TjgXkMA12=WzK|P!2}5{GYd*!G_qEZ*K_J#3?Y&8$A*x$}~W{Py@tD zb%>x4n@WLLD~cu%&BZ^8T8muoy zor0HVfC>ugwJ%%@K+wMx>y!9b8NG@8s_ z(MDqCk{i(REiOr|wE>lR3pT{p9!AQiFJ?vQONOkhU&0EWJ?&|M64|%4?2YPDNsDiTRf<;-T~mtY zpH@ZP^bBTH*X98sJ4En#ZNBI&=bs!E;2&eeu`|{}D+@Kl)ec)j96b<#7gXe>?deu! zy{9Ufr`3He@3y|DeHCa&mHxhSDL!`a`QVz&t;S+Oked+1OUS-&)*PojBT zWw|>gT1c&kFs6*ua&v`%iVMX+qfP5*5EI5M&FACI>_e`L;It}x{#lf@dTXkvy*|<@ zM`O8K0#p9Mv+yZ+a4G-Q!5-^2fVs`IhCeI%~$VyV795zHrnVQjehipi)8 zmr(u^t4&LwMOENS952|$=bTyOqAVKIT8?6 zE~TK5om}ki8H5L;BN(8%p(JmY!L8B|H;cEIS^Ig9ili=#<>^OEf1aKDAF)p7 zGs;}bN=#}CKz#3(D>s|}lZFtZDgBL3CB_9{2#te$a^o+x*n2zttiMEw^Zn`*KG-t| z8mB+uBkDFaMt;Cg^46F*ZAJj_38N2KTaqgUz$ZT3NwE4;j4SANU1%Rne&bhot>!J_ zH=DtPZFkZ{VY{96cHDC}#oRSoliKjqB}{sAc#DWQckEM*&jwO{ixC5+m$)fqkQhJ? zN|Rni;n@fOX+E^1C@iq{DcLjBhL_19tiADlkGRp1%`ZNEkwCn0II!8w2pqxVMx1mL zUpzPgz1;V>vG>y+HzvNjA>lVWDWo%-&u3cFhIrVi4GQq}MApG!5}P))G*?sF?5k;OyO0;< z1O(dmQ8<4(1JSthqfNfNHh{Bc7w&IL(N3gXBRQ#Rae@5eAA7b3i^HIVFl7#wOr?4A ziM$CV=1e|)`RYf8)B((3W5zRr?{GcQCj;Rdo8185^@-JDJa0qCinVAnj?megc8KFT`N*54Jt9d2G#A>kXEsL3mKu zgosWlfOrw0XCSf8NjExrmuxx|{&Z(o-s_+fFahCjbr!(Xgk zL#tjMMP)Bj%SW{TCUU!fWIuqJvw}vPI;cs%#29q;W-1x2|EY7sXn^`;}<^42zewqmPS5Zd9Xmi zs*tedlwghT`H1fcSan?)LGPA!M$1>nxwEUD)#bN3mRp%lHi&|Qp_z$Rl{hwLu3_$xTZuG+q+*sA z8R2862mnE#{B8$@u_NIQp}0_h`tNEu47omF+XH<;hZ*kdFvDLv%hzj=ol`Z~Cl8-LN`bl#3aJ2=>`n~ zOcEC5(V$@vi)b?0KAJ=bv6*B*moc8&W`#lB(wq6y=D~nun|v{u&CSHyk9~U zQlY5$rCDd~ZTifJjKiMO=j+*ec0124Xmk9i4wQm!_?jPY@%!OzKcZ;m4FePRVty`! zO~)Vg@tWwP-c{khFJ+S8q0^FUZ!!zH;3mKQcUtivjT;*?m|L+i0nk|Aig`T?kxAiT zqVW!NJ{7?;t!&wSPz%zwL2l3&9ty@?;I8@BfxFT0*JZbV?PWK)I0EbnBgoA(_vx4~ zAptn!G<}-|iuqm$^QXXUZcs2A(6%5x?KdcXUCjGeUCjHt>CMpAo1vpO!Gyw2^i_4EjI%JW2L}5&t~@ycaY6qrH$SXouY_9FE8q2Tk>}t$zErh6Wv9oPfZI6A-*0PC!s_*B$qebUAzr zNq_I*%eaLfxVP~4F{X(2ayGO$^Phdzc%hGfADL++o1yLE8~Cs|FHmuV;^)fs7h~QQ zdr_ysnQQC4UQA>G6xpv&d~U(;Oyl`a?*E;CaGu^MBJl(1Il2FY7g&@mOM}A1(Lh<8%0L&XK)$&f=3~AzqvK2xG4WSrdirDc zD!7&9{o@^740nKPIb31vMRA27tKv4ySr(UEdthxB=yl7(nhb1XfG;x8((w5O^Sf;VAc#(1j_0Y}E%-Uu%Fun@uh6dfRkkz=+ zArfGlynCxh(hM=p(3|MPayF%@F7RrLYC-l zHxmQ?qj?Mu_yYD$qTzv9Z?=oUEue5Uk%o@_kM~jT7_k33iDqDP^WJ!lK>-gg<%wFR z6zo5|kqB;*%Tp2pn1nIXhqmTqXL8y3|I-$5I1aDPPzhV(y7(`*#ctFG_RG#k<` zADRDf8OR~?wLh&g*GKlhM)Kk7qAE3GQWe@z`t=d%i}5yhh+a$Qz}Ku8U3-iHVHd1{ z4=yj-Nj+?TMv~s0Gj+8^0a%d%$MgYBJGc`H~pL#SuV8e!#lr6-C0me-Z`+k z%6IfMWc)KsMf`cD!cMMLuUOBtl94v>N=HgXNmEc24GyLW;oX&G9$9^=m+QVqCFvt{ z2OFSz?d_@<=j48gN1_EWn@_yn*}XAMQ9AyyH;WXwd#N=Mv_4DX(&9<(g3Js2VxACV zqM$`IXBD(}oBzBxli`8UdF_7-)FNBXXH%{eq_Js<%^Vbs4D|=Z9q^KRU388zoL%Cm zd5JaUPBMP=>_A-GF}+!Shw9dG)|Dexa4rLK;nQ=K4_>fpjGxB0v-xZ@%h$FQ5u*27 zl0A93Rz>7iU|9?q^ft?OPYg+{Yq%4Z=4$-RgOD4O9j|_|5p|vWW<_SE(PFA6()@!65w9P5qc zuNS3{K5_KWvV~PqC*H)Fb(*?zX^8T_N&yCr!m1|Ky<63JGf1J#>(;P$br_6@!?Q}fB z;Ax6O&^>q5aWT>wprel)J(yF^&YBb&Q1;s%yj4zVevdN)V`@)Ri)%-(ZH70+65&5R zHt6G~HD4~Lcy8NBCr2nbjWG-2N4J?UrDXi;7C?&!#gpwOG_n^X0-X!c6*lxW3UeCn z%xSnkE3B-42@)|%J!GbQEcX!7sw*P1ppR_4PgeKQN2^)b0Akb6(Q_gf2hs5nJLnL#AYqg+UaEE?B%C+J}E z`00nkK(3jyuR}`K@saV*Z@&%BP2!tf#JJ8*iLZ7MS89Z~(Yd)gm>fMGeL7;KdW~Ey z_D}R;zkoa*7A*RIl8gQh<_E-J$p)XP;FCznB)D)0Br8Dp?YEYU>Mr#}N{8q)P}0y~ z9t}hacBn1I=TtxyH~0>*=qz}K1L)a7Bu&p(BXDOA>)vSB;&6ZYPY;qhoIXWSc=CSiYW zrXS?ZZs^@-5V^5>RV%JU3Y$!%aHX(2#pjmrx%qn=wzs2Ebt=0kmCEcNIEdGmA4v!B zlF-4%f=wh zlGIGG2CE^4Gb_7h!`InO!KnGAa%(;LFdF{U=J@eR@0Pjds2SIpJo>oaV6|R)QUBv0 zY`%7Rh`Djawh^Y1w7HnR>7`}0EbZCgf!vH`+nu{XCNW(^vuZ`CNSqaG<4NzkzchoP zH-o(_@R&Q^v__zootcOQK@lFtn;G3B-kld+FQFNUU5uh#PTPp${1IP$I8eKdG6!Q* z)|X6ON?Y75MK`p`_#wUR1`n6JHqW@CPD|w;C*IQbu}m{{4dV+lHG2b%mh5+6^u#wL zqVmm+4C0|dEY!@d5Z1UyrIenmed z*SbkR_gy1@NfyJMSq$AQY|H8%!EsEhDHb_*R!g)!obiaE+0&xT{92o(R*vR^wu@iR zKjEyr*yN<+HE7uEulb6(3Z5&zo>dkjmW*C!;Bgc-QdGHmuh6jOvu4U&H?8?l~)P5!e3pNKYOekk~pI;=-^qhLDv~JV3_y{Y^g!C5tbVEYt zIhrUa4I^uWK-)<_bm)gJ{q-z=#_PejBy26u6i~ikVPiN0YxKN7OHSv@(CU{!NC$MU z8_kS2{`7W>;c_*f>N9b?G`3)FHcpI}Mb~o0x_J4YW*;v;DU{znM-Ytk?Cz6Cn(h{alkx-9rEqbZv;mJK zLYES}11=|1yFPvaaUxfDcdxGVRJMBVP6ICaVwVztyHV5#>bw@&;z94EzZCmBu1fc2 z-re9mn%bL>KkeMo)!Vl_lJQ`wLg{GqO|Aph6%Ef44Cd$G9^64#SSk%&>M!kH3f?%Y z;_VJ*7qD{z|E-??b(XK(+eechq{T%iS zSuxKB6{PfYMz=x>3pRESWpWXsrl?3`pU_M*^riuqP4>xRqtn}nU?rCEqN7@xkLTd$ zo5$#ACOG(v@ovHkMj)g$8S{5!q@%1AQ9XjKF1TQ^o6tBRr;pL${ksjG2i9UPIMXL6 zhc2aa$OcHM0O|bCrQ9r6;s}&aeDc`XE|Y2wKH2z#|40>kUCZ^VoT1<660x+l^YpTm zYL{KjYF(DSJMr$Mjnk1ubiEK@AA01ZM2C-5Gaz?%`5S(vXT?t_9qCJk4xP2RC@MoY z3^VVBAwAFSh-k-_p(9*-;*}X&hXt!L8Qnwl^!d!QkJu>MNX(p##NGZ!=HFZ4eaPBh zvAa@cZ?7B`A1BOSzEP3w-l&jARD9bN*}mc4b*FMf=ul zGiO28l1Si+gsjH8Rj?Lf`9(do9Bb*|{*^-iWj&7#aMl2e4%KANY9ON)1r_bo_;R=| zD$W#_y|(Dr5P3G5IxhtSoL<-SBHeX6zrph@yvg2Uks7OS{*LTlf-6|F&8)?;9c_hl ze*m*NyPHkMbky;Sv3Pth7@a?R2Aa96DEo@oKV2=bR`%+OZLN;$Su5?{#SnXLZj``sA>-4YS-4;rhmzp6GnfS8 z4wr9U14S)=$T0wyc@WX1DMCJjhr|P9c(C3BmwJiRPd&7$hXv%Q2XnkENEW+$>N><_ zh%f1|g9g5u4;CvvLvn5s7*y=cEx%;!sUJtfcn4FXtNc@FoVqpc|L;gOv{DTVk_~6m z!ULJl_jA0c+JLDN2oWy}rs!AWf2AjZACz3&vlI!$?uw6w#XBK{o~8g=d0~Vw;3MKU zGjs?QqpihCt1t42hdX`HMwTj$&yeY!K?d_FK|wkjr{D~^8$h&^N$ZaG0B03u4mj%w zr_)uwUi&ArK-L-mkPBYK#K$WoF?FXrDQ4Vh4fgq5 zDduY_`usGxpFw{Q6#>01Vup{=brOp%@&^>GeyMOLnp@yP)ldJ%2hqq!n|$e{#`_=S z!+K+b1i*1a&^sVs$Zl`MZk?@;SuKAVZAXr`n4hBcd@oB|p&yM;JG`Y6-LfDX47z6l zNHfrohvdVGj^|B)85^HYNIk7#R%jI`)QUbFZw7*J0z(*t29<|ILSe%UODyMm$t~`hQ5t#p)8h)`0-sH-F2^2C3kNw`Ytmna{CIKd%LcXH2Ubf z0Oyde$t5)dNiLE(7t1uEy1Ya0@fdeQoCE0v$J7fGxd-WOQuB;?!O3$wkvJG`pA+|z z8GMtI*j{4uTsS46DsLULEg&Q3Vt1UFHExiQvzN|UOiHNR(>f4oT&y7n7@Y%+l+ZYD z=pH~ct^pAdcl1QBw!qoa0q^iyYs#$i_#$^P{A_nI{Ds`baKF14+U{cb+3sTa zGu*}S%iP8A7j+lIeePoTW$t45OSy~Ti`>QV^WDYpmvR@irtNVTO+v4`NJwmV(MIib z7j0t8UG$-MxQjM9aTje=fxBpveWtsplfTGa)Z}~J#bQ#gyXcY=chN-da2E-o&s_}Z zn77a6@)Mg^_rAnEbP^T2pT(p*+*?22j{9kl6}yW?WG`|Tjl{d$MT4-&T{MVxxr+wj zZg8Vc$qL*>P4FUjk&+wk zqDJg+7YUK=E^3tJE^5RccTp3*z+Lna?{F7^Jcl9TPW{7I9Y>?d(|o(e|GoOjBKfzU z`L~%&zJ8u9s+F&23l_Enzs659{AV#=zj^q%1;8H${5`GJ@Za*;$ua#G{!Yr3v+BQ< zk1Hp&)7r^#x%zK_tyPZyEja!K%HI38U4v=_!M{EJkk9`7*L+n(w-5i{^bb^Q!E|gG zcf0Lubg49!KxU|e7u`W)Gzz}`eN{cPbJ1u7Yqp_3dSJI>rB?bhH)qc)1;1(hCit7C zo5}#y??>$@Y~lnd3rgjRfoVpq5WIMtH#y>ewa( zvJuP(!bT5>Y6V1bJM3Nz!i%U>wo#cvIXq-h_d;QhKbAqk9g?tKPorz3>V}=DRCNft zVL!f(6hX~lt&t4yEK2FbNh&d?KE@=H@#V74`Dy?KEB35_FGX(6Zoi$~bm~dFRB`pQlXQg)vZz<8xQYS%cRE6*0Rb5H;xdK*QIX1%^fpe7; znpfalVV27$Z%Z{-n3XER-Oh~v?KZ;{ACBY|aIHqt!)Hmtwxs2Bb%(AMrx`TZP0|`h z(G{m^_^FT}Y28FJv!+K|n3*e=YHkAyT%}a=*bk1YmTIm65x82Z<{A)zJ1Ny%<1KKf zrJ8G%1@5d=b2XlubX^m-xeSU*>BMa~gQ8kGDH_mJ-A;;z7FEL&S84{uY3an3ok4L{ zI&me)>=Li(i7P{eg<85&R9L8?D@TQe+PN}R*pt$!D?f!jEuDIeEytdfP75q8V$Vyb zUMtJ7Z%e1HytFiqOQ*YpRW68_@62rgi{@?V%xwi*hR3Bdw=HawxFFy;UrG%KCE zqa{*Az4{GXNH3kcLn4+yvv5a7q##*1VmI#Pm(E>@$60b(eJj2A;M^5AP*lsOr_!Mg z-nxRk$@)=8PJ8&2#xt8q2}O-ibioH10gnmPGtB5rhG4Ejr~?kZrza=GLm(90q|2pH z@nN|mnUQG|rPKHs6JcDD;re|eZ zaYi!e^-PkALxQd{M%}0XoUuu$bA4waeHGtVn+!#Tn;UmxwFxl0PJH0lzIZ<=exCBM!BC2?4`)SyW zxpzg0YZftX;EcjH&kyIXwvLp)9F$Fj^p%5(3CD?e*zT)L1Fb_aKaaav zABv2cBs&0S(C|Y;ql>N#m8l(x^(S+GKmA%Bkuo0#qzW!Nrk)Uv$xXZ976bmWpaYJNkFbH}BBeKr) zj3VnW2wZ90ImKns1>Wh?*tZlryaZL`VkfH$fJpk6&?%w;ScY~`Hbl}*`e6@DO9SuM zQ>Cqr#2A5gsZ8O`IBcX~U>a10)zLL*MH}a>R7O>)yyq0A3@lZJsr=>>Ed=%B$#&Bj1y!o1FG#2~}20;ton z2Lte$UC4J)S`Xttgx%onTPwGEc$tPVAkM5rb$n@k075xCaS#{rpkwp{0mqO_C&w07 z(81zs;OgY9jYz}q;&x!ms-6zIQ9Np5=~>tgJHe^L+n{|BrcBUpO-uuNDDE zJ%ajMEPw|By@d8d22I*Yr;aS2*$5c%0GL2$zens)%*nBxC{17r0xX?d^=W(u>ImcG zv8_T~ZjUVTCiYP%p*u>W-k=UW*=9Ow48kVb^S72*qKlgzj2%`%Q5z;&?Q5Ro*iMr5 z6Ru^J$Xa2PCNM3*y$7@gZ_h1!+(itufQ?AQF4*|0RnSG0q!&=o+qWk+0xU-NCa760 zd67mD=3~|7VgT+_2h;-UVzGP)c59G^8DMG-=3;b(m-f$3>_meusM1YPwVE?-M52CH zUU9dH)hIhqaNIKNlvV*SY(Vcix9QXHkHK5pti-7-)RJDDrD4>DPHJZk4k++$iS7?! zCqx}B+u$CsVsr9`ByA#xHs4p_ci|PNdpEE;!By0~L9fQ*{c11_!3BDIYPD}W>|Zkl zv&wBpU@H?W*ha*4%)fkYgP|MsBk;K+FjqAvQU7wlZSR?-G3~+o2uArqdI55^DhYmW zH~^)nI^d|u`^EWN8`TbPSUX$Aba0$b0;dF+=>XX74xJ=T8UU}9E&6VR?hx;E)v}En zj=qaRrXsfLpveFSWq|#{Y5|xR4@2l+Ry!sg*6fy;d*M~gTK#RsMsz`~AonvH&WgPO zb7YkZuK6H1vFgwRiyQZPIPnWkEur)hR<)YV63mqb7vKU_oy=04LWaS))p>h^DD5X` zs1v&r{1Lo6@J#JNHAQLQ&}p?QjzIvn>YRmxX3Sk^Fa@Vp=^2c+Om(cHaS|OuWne;P zNh)h6*C7lA6*~pMxf5X5FiQsg%Td^3V^PIsk0Gz1BoK|&jNmjw_o-Ud&xR3kS6Q%?Aq)WZv>Df@$N zoH3`$PB}<%73QtgmV+>YhPN^qT%r2|HR+{TL>W`rB1?LtEHxYP<&;nLY-^HDJSRaB@P1`1H zv#qbV+Xu&bKvzr<1&(o>EeTf46u4iNv|3pN9%uI=3d{^a(L=thMrT!s&?_@1CPJ;u zoSJaCWkkh7;1xPWBk(GnV-k4Hm}3&ei7~?@h|{24@gmNGvQ=wylPf6KcAzUk`D6#W zYD_X6G*shk2O27Kz5@+adbNKdF7NE`yqi3MbgUWdU>TOVYTU6y^!__o#Wn(BdaTQ}CWa6sExUXA)2)gRk9wP3l zSAU4mt6mKvqOW>&h%`Xet3{+4s$M-JjZr(^NpNnA9v*_X#`>X8P{+os)<;n`Y_yM} zVobJt6jfsg1PYjiTqH2ibuELb;G;oi8BOkHo6L$)(d3U0&?ZNh@gLIIGLASxT6Xa= z0=|cqQPe!)nhYLTxwOoqrr^teww2WQ_ux>E@N8L}UD_toq7o%h^9h3j`1e_ctQ(R; zMD)i2_;MCCbRAJ<2M$pir|Ty+2K^C~HZ-UTPaH<|2Gq+q4Co&E%W#uN zW#*pz6UX!h^{gNF2iT~b(6hZ9!d!|4G-qs)OEkEbq-%d}BHH~F_iWf2`KgIY`)!G` zwvD3qpp#9QP+zc}<}3)H&pyL4BuFFRv^x@;8G_yb8sz#ou6saNoDUAZejV6q7rg%Zl{~Z@fN=n) zID`J8?xf9^i~9im+flEdzLOcfQfbl#u4*S&QB&VmWO3};Y-j781qH?mz;V+C@}8ri zEF#GPkhbe#<0^Q~9RF4_Quief4`fKbmnIovlHsm2uLC_PaF~v|U*8&*~v|nwJ!W#<$h!e@;1el9%*EJI&|xL^th= zdt&gKokae;`q@cn{Zyj$X0@Gcg3;t@wzyjce|uG8F&jJMk9fr}oBcI^_o~D$xi|B> z@pjH`9)53K;rNrJY3Ji<{nIA@-njh%=%0cHe{$}1yT^aMD_|l27y=hCI0h~w2z>!B zimZ?wq~MXB28-EbIn7Ci?{wh}z+j+34r25Y)Ez(aYzl@Af$WvW=bB+ zpPKn(_Bftr`4a*5AC}wocroQro_&5l-poGa$!eOfB#^%Ysev+mLok?qdc0lES>42i z1n4)S9SLA(4ToP|!=bl|!=GEn;R`A`v@7Xp#>MvWHedY{8}X-rJDaLe^ydz4|9K5U z_#K-3f^=!*z{c|NX}rp_%?e5m510?3!e{E2h)A@~qQpZhF?q*`M(;!-ou0jFBP>FD ziJ|FPE>`3{yqVts++sRjVT8}{!0~#ISmA64I}+~oo=k>LCc~Fy(qw@bFy!(&Ja7j6 zBQ1s9X@^eQ;qJ6N%CR(xP`2yYyfp35P3wQaSf}N!1Etzd+so1o?R3TE^=FS-zK+we zTSg@9&`E2_mnd>;IiJcd;L(1s^6NCi1E10powr_^g1KnHE59(3VE|hZ1C@_!MO4wp z@Ic4(JtE_Maf+co#qiL6JWN__E=!+X5P?L=*z~$cQciweQ{iMdd~Hh6%u)9wgFBuJ zKkJU||61}}%$v?>xHqRE&#I6suI=1LvAp;Kz>d;&ilLRFu#herU-mVP9-($M49#mt zv*_XD^-k4h=Zy=Ln|Bs`_Op1L@jnZzQx3zIur$C>;@m@e1C$ zS#M-=u5o~KjGYwn5eP5g^>{v;$|3Q<6S`QC5WmDXcC;Iv@zXy4$t!A-a+i*I({?~g zGpu5Ni7~-(Hf7m%Zw^*0{bF zIM^6T!n2XE%lAWr;91f9d?ymEgJ*g3vmHrf$g{BXVrLTh@GS1U#G#bWt+VL|`gi^X zSJ@8T5mSmwM&$IM+B{j4m8zAQXa z+dcH?43*8@VVzxSpEac7JD|cjd`EUz+zyF*EOy9qvUOv0AqOxlB#qwt_807JHkGm6 zygFZdLgYe*#y%VEY7U^76!`UYR7GyjSsVbVnzv^a?Q0mxe41Xo#h{XURMNYNpjJfG z1VjBI0W9_OgZ$QbIuoEDMh=w5_#~k!mFud1(mV*BeCWWE#v+HcSr)B48C;(^pmO9nJ&fZIP>@G!?O9wWlf8zaJ(juGMKj1l3>$B1H5?-&uj ze2fUcY>WuMe2fS`cZ>*~F(TYKMuhvui0}ntM7Vd12=|N;;b)H#;mgN}@N>rqUxLCh zB7Er>5$+x%!hK^z_&H-l_>wUqe90IQzI2QTUphvFFBv1kePcxUk})FuMaGEmv&M+< zXN(cy&ln@Z7mpF)OU4L^7jp^|s1Ig|BVNjPM!F# z$JJlszy2fsX#CeSy0GHE3dr9r{;MqO@+!I+HQHg8McF7#l78vn0AYtZn(LuO%zT4B z3xnhkmn~xE0pWF0JcjL1S1fAGGIOY^7F93eQ5L$5XapW$=p?8WaNJ0`t@y$rKe5Q0 zH(h_erTDA@elA?--sPjFYh1-`~5VoW8@I05hxk-qy8w1`j!k#q6`n&$Nd|q;;ysNVWWXJ zNIGG5g_&ew$2mmvVLadFBYffj&(QFLIv?^8124vpcqEXwsRV)_Ui$EtFMgAVT<-fT$BS`cF(!F^0M?JY%UR=sh zl`^Eo41d{jtWpXp&)@X5MYV&@%(jT|8aqfByd+OXx-VCpIUtiFN2g^9Qw+@n!~H3g z7SKY(o6|iX3?DPcC7K;M`na&O9KJkHF5P`xs+@6qyii|Me*1ZRS%xie+#ZTe0DFMt zQZ1$NqY=^Qfe8N~uT!BBkHb(KBhNP_OrA215L+<`m>zM0b+loj9ljen-E^|JRd2#}oHC=LWfSL`|>MOA>vw zU1Un8d{5I6bxBwQ+MXpP6Al^m4?SqkjdtE_5><@$ohXTDW9n&8v>0jWpzA?%9`uM# zN$6PUjExSVIr0<@NKP_UNn)}6M4VM)fS`oh23r={B$DRSGNzPB*ga|j4YcUNMsM~J zaE6KDphT*VnjO}9lvj-ZKf7OsU)C?f&+C`r{(k8var$Mrzh8PteEl-q-7kG;t6w@K zZodq7_sej1zx1K4ei^>BU%G@Z>X&XZProc6a{FcYl71P!q+f=+`(?PVUwR4bei`oX zm;Z#<4}bmJwg0#NF!=}U|5Yp1vitsHx%}(?-#_Ay?*C=i4Qu~TK>qIge_51X$Bif( zg$)e`gKZ+WXVA!nhqZeZ{oKvw1$$vl!n27{?~u*B7poXicZ)KFQSw^zrlB5O2;4XpugPts2WMP8#Vgmtrv=9 zdwe5N7xJD9p~2H$z$YQA`N;6$0rCVS!TfO$rEIJ9iiP7GWb{cyLf1)}xD8cL615jf zVjqdZF|-lis45u`j!1OYPkOzmNvo?cVcH+{a2F6?A@rtH=&FNG2i-1WY7Pc??Z@3g zq!OPvB)t$r7)ku8AKxTTY)S;SZ?DgI^HfP-dG3-8Pt{~DmxF#Y8PY9KC#N**aPeXY zhw~!3Zq%>G-KL~0yEPJomtoo*hH2DG6I_B*S$i5*vViY{MAxAHf$?`*$aDrhAWpiP zZShARcA#yQCha1DN;H$GN01V)WbNvSB#FEIC{2?Ke817JGmH<>Bp#j7yclf~xU!a% zqE*6XlMBFACyO$TI>~k9ZD@-!>azDL0Tt<82b zLc@bc4Lt44tfH?2V-N9lQ`6Y^x+T$kZy%Hol*M>}M6`nO*oqRk8sLHhjLF;tUEt5~ zWby<>^GBaFfAq@mN1x<=+$FCc4JrLdMf0Oy9zS}7@Z+wEyCWD3G#Mn9Z@saD<5}iY z5LPR-aEtK?ndTM|qN6fMxgIB7JSpNtJ)vp~TJ<-1@?rWcT$(;R|Dd4!9PlRFj5h{& zx!A0hb8xdJ`O_w!64Vf<6w$}o1`j~LbMnug^2zLOHt|q29`eZ#z2$7Nq1laRn@a}z zDKMGG5K$(?4f0~*m8kzaRa=32t0j1x>v-zs-kOi^*RF(QeOYW7KT3-%Uu+*iU=2xt z*I`jm8X}Ug?S3+nNkz)`J{8nm-9?botRA6-;Ob zvyky80kt}SY#wOnEt8q5qt!6t#uIyHybbmSN7r{bmZdT5T*?v|24!!cdWRtIrnW)u-Ng z^I$b7F2S*QRP6LW$*4cRXSPNM<$8jtd%l>=^7T7MO&BY?bmgbOTS=6a7x6M74Syja z4GX0-e6g5@1#%kh5R^|9{gN6MNoub;k%>9csk?aHUQT|K$Ha&8rSj{Hhu4ngIaNCy*pq&tWw-&xtiBZ50RjeD} z?e*bjCLikLLo2=Q!t`;{HNuGLH@nTWmrYHGHjKIoG+*jcQTU6v+HG_F)qfFN!veOT zt(sAz4Rgm4Keu%N?gRftws zJ_-c8fS~@sgFNyOr4gS2OQN!$2p1)FP8BcFpv&H7#kZ1>sLCBy!lg%I5-(h7LR_L_ zQmNF;VE}kXvpnJo%Rh=6!r};YH^zzkgsmy$7{*>mo%jKrCz9+E8^6_!J zP;-mY1Xs|P3mn089bQ8dug40b8`$Q7HnNR-aZQH1YBKayW%zff%Wy|sFia;se$P*r z3X2Br#og>a)JDlT%VeCbQvdj&=Ha+K1rGNWXq}uZg4-wS_7q!jE2?bPzN9Y8{-k&- zL8QEd_MPX3!8b^`YbS_3*_(zPQtM$tX2Fh2h#Y9;%w};#>}$gv4ZFAOp;@-kJUdD^ z=ytcVB|Lt-!;zgYwv}*oH)`9>BWmxA+H;2YCHea_#XB2*S^hFxKD#UGsxPm?OG_&1 zqc5+_OH0CInYt{xykZs1j{C}wqJKRW$XDd>mn_nwpcnyw7fI$#-Y#k!#NL~Qzo!jf zkjYj4vv?56UsAqsR8@3BnD)quj5p)k@w&Lj@*5C!7%#cq<;`^rYo`Y+sVhCq19o*-@&(F}h$i;%G;&b2A+7&2ad68G1)o zxBu+V$7eu4D<7tCj=9`5@qcMebaJ#1yB9ObgVFIsZ+k1?b9!|+UT*XbVPr>BMpiON67JJ^1wC5w?6dZ42J#; zhC4FwSuCGZFj&m}V~YX=3R{w_b}1UwAC@X84(7 zS@?6tvhbH4%j^t)k+CfNCC9Sxi^j6>3&yhW3&*nXXN+ax-(@TdzkDnUKX)t(KX)wK znZQ4mg)bS)!Y>)i!p|Gac99p2W#N~MWxhm(V_Eo;u`Jv-mW7`;mhB?$9hW@j!QvJ95+jal%L%#Y4-2Xd1tDT%U z_x~!t#{c|>{L%Y=*HLQS{}YhE`~AOb7=2;z<%fXN{s_v&%Ni6fK%AsZG4#BBP(D63 za&5(c01x%S zg~=O0dufzL?Fe0sij4~UjmwAzyOc@d>#z^G#qB1!%)yZ;0Qg^&rdZum3!C+#MjW};}J_St0hpARj01l?x2XM^+kC>xn!9cy5$uNU5 z$|j=M0a(R`L5Wpw27sv96(X7Qs+Ef zmH=qj>rq(%q}gs$NgyP>rg8vCE9ufmp9s2s-y{)I5rT7-xG`$Sb#h${5EVZw6)XqU z5U;nGJaN=jbW=~lv}tn3aqH$*?!*ccT7f(xeyJ7#^Eol!lo{SPXR? zH84tS#e)L76S1RhR9M){v+Od29^Nuz`T`CE34^7JFq*6ZN7A@EFzpP$>w{LSpCn+m zK%0o*V@#8zjY!CfW{0>Y@Ye*()sK?4(a>>g1XAzWtO2+aLn&a>Eb1(6U=~K%pbD)P zstRo$0cKBiTo}epV7REv+=pr0$BTn~dP@xvS|Id(8e)<`KWSyXun`$I(h$XOqFu)< zS~3gj^CbouxZ3X0iT!ORtnRC z7Jz`N=QX!tov4#wSmnyusjqBctO+d=1g9q_Re$kevzhf>+aFuXq-=e0{9tjqZ!^AU zWBhxr(QFW>XZC0J3z*`p%oF>N@;YCw*)dWDZq4SofOaxJyiMV~)p80P_>!2Yww)Wh zPt_T(fAGOASYju(t{NaH+um+mD8BRHR0M&@&rg9ZwRf*Lo!IXJ-dnT96w`$C47%sP zJ@Hhr`h8fO*U&hS?*B*TH{6wBya4xlK7R>+4zIhjdkKpkhV4u*@(s}(4Dgf9{+i2R z#%go@1!+_?`3NoP|6Gy zztbEqteWu}*ACKfpDe?di7EUtG3`p`>oG4CQ~1KV{~B&;=laiL^NTG1>|Xz=RLdu) zHGBQ10_b1YfBpe~bo~dWBj)lC2YmkO&)2Vm&1$?@&%uphWFX@Ed=v1j*TH5Pbh04- z%XanwAH~|N-vn2A{uFE;W^2fDF?m=m7hoTzc>m^kwt0a6ET+rn^_zz`;&CXE*YsdC znw_4Xjz)*UZ+{#7yMlH`@%wY~REhuur|7Qcb2EdJ&&c4!mqG0_GN}17sD4HURhEIY zS%FP&W&)5A$pSy^(mSIN54%|j8H^_705@^3*RYZTgeJsKH(4irkFWYzRgQZZP0GGK zX;06utdszu3GwrD7bAg=o50|Apl&%{4u13St@m{lO}Ss82bchC%sRUUtG^NEpp@u^) z%r^cwdd>ga9Wqz@wQ!wZvwuhnC0&@xiwyA4BumNvk!M|B^M9>o1*j;EC&990Q9PBW zAXN@eBgh+!Qi-e2#OgGR1vZ`juV23kUI*Qz5B;l;y=9ZHH*1ML3Z5TklZOD{AkVuT zs(l{*#u>YR3Oc}tE`-trYNih*8!BXD@K{LTNXPKjo)LEcg00#5Za=QY)miMdi zBUsoV-u&k}z-ONz=V@@aU9hX2P~q*I8KlL1&XO*-8_a95+{`99Z&;;=ti}g_ISktW z@gIM&Y^_HAMK%4)d0Stc z!aq{Ctus95?CCJ5p{KshYw;8m{?A=eV7goC#Cl{P7?0(6YP1=pP zNx}$lV9$hd!mxXRK;?{Zk6J6%Wq8fviIGKY7GCTkWp5Y0AJyZ2#+JC{SOj&U#Qd8N zl=vUV%N&ONM$%~rNAo}-oKhIxQ~0;Phw_6%KhOG5hN#-tszk?U*Xa&}AAkH}Rt}Yj zW#v(|O!ZRZuq0tk#A!_XJY8;Y=ef$_$RISDUXlo1HVahA086rP(F0YIaA-_IRmdRg zYPIobNxaxpD<7+s{_?bTFh06H3=R%t;=_aS;cN1Bd#GD);7h33<0;7}O&X&lvxoV- zvz%5d-n75_oiD{|Y^0!Ue*3LA!Hyzi3iB*M*v;ZmchGJJ|M`E8|C2b$%oK7=o1vtn zaWD;VZ88eG&=%s?JMB%2EV_MMxEzhvn<@GOWEOz8Og8H&P6HGhyC;Wcaz26MWZlHL;8NIi0l{+nsHyJt2lTV zcRCuc_kol8AEHJdTJ{o~04YjTPN0oYsno#h%)1Gmqwa+mnbII3c0)juZu^Fz$Yvo- zD4Qx7JM>~ibLPs~8pyz%jC~|45xXSL)7lhtFP3j*mY9086DVzk!c9mSJ+mbGi^j4& z-%&Gcl!U6=sALGTDG9x96Pb4#mub?4_9}@(FBDr4eH2JrhO)baVY6g!m)b;(vAtB$ z`=~K^0Uc;8*1+NmPye*yhDp?dKU?0A?wbAU<7*iGYR&v=y;FG(fCbS?PzqqlnQimX2#l(coCObUfzJD}C97 z%^yvz`O(MzkF-T-nFXb>%DKfc@Q;?d{pc0Pk49_$Xe-?83t`8R zcvmm`FkAo?A4(o}u^L;lz%s=_$j(?(T*gfpf1U2A@Z6d?eNy3x4X{;C(S#}J^|h~@edGjP8gHQUQ zm`~ZV&IUc`m0&1I&l9A!ycMa@`!f3>3Y)f*^jSdpG~|yDIK5wR8E3S!a-XUoQ#n0o zW_nh}{G%W!NFn;6j3BS)p>_&vrY4?=kHU`1U8XRPcgG217@ysR_7iWru;&m+Gn+)8 zJ<3ZWnQdYeF?vO&fiALs`I!*C1yMI^?c_kGd;GBH7tHXvA9!>W_HD+SUX zBo|qYwgYiV} znnX_f*n2eKwxwB6J`sBy{blg9%0J*<&HZE&OqP#NGrV;8JYFquf8i*&U5zI{v$fdb7zaUyiwx@i>?j=cFB2TTj)MH2?Ryjv1mo^@KF?;;aJzX} zVyvCu_rc#(I2~N$8(~_N;HP)S?!^wu(%+7c)c^hDrhvh)-7HR0_9SU1jc`XP6;Be@ z-EsY`C{fju2wE2hQ_x?3nwl?7-%oquqeWq*ag!{LSz;+basd<|WmVaV%|0T2=NgI1 zE>SZM+r?OMjf9~qF1n8Q78tVXBH29{akU&tYQ8#N;O(?##t2Sa0(rR|(WiwEu#tqyKGR&1zl^rUWD}`b%DI+~6%b{x7ij8r662-QAf0N}r;y{1-L%!&(W*=Z2xX*t>pE(+Z8Q#1Eo;xt# z_2dw)ac2$^KaN+Qc4fq(ZSYGiW)65azLP&LSDy+}LMKS^<|X%w%*63x0##V&f7~uN zz+-Fj3t(mzgT;C|pG{_)d>SvFwwr=nI$`4y_aCHIu**F%kIs1V0CeGG zvfM6;a_BeeX371@Z2_saca&a+q$|olyb??1*=5|biW>irvv(HO53{Gj7D9(6jq$#) z)k5QG6Vl|XB6ijDS9&(Dm}ZAdd#mLgB;1+4A9uWI@pMB$LM#!6*X~7IdDUhPqTCGJ zm3c1Sd?{8lcEuGtXyOWAYFZus2RSTvG=y~XVVbDq5tv=BH@?qz2t?)p&UM(0x_w`- z?d7Y-@ggr&H(@=D!t3DJZHw9;!|Nxh)db>&>7s@cPa;~)CLTpENW^Yfn<<+4?e@ON z0{`V5LM>Z%s_rQ-zF8Oe^k6%&mnoJ6C08C2k7}R7OVzJ!AI(f46UX}2jJCkjMWs4G=VuhM_FwFK4ZNA(@w5K zZ1S?zNMXCKSg@KY8%9l0DXX3Omtl-xtBLx9^hzYK8fcI<2h7>F+O6A6pmlih6{~#) zS1CA<0%tW*9drRCB#>3Nu8~Y=wG)mX5@oeiJM3QzjMYr-xPLj2QmR;esTHOf3Zr5* z({&v6*)lZSZnl~uOgoB0yFtE-QkI|98Zhp|gc}i7V}REeHC3f7!H2Chz6wJ&hp9T| zAxVWgSDi{lX~J2rT8atgsfqkm-`Z@nL)_l4T1s&he#aEAdS`1_cp0}br<&dH-_@CQ zs#)#Y2cwB|hg!{62Cy1DC%f|vx_WllVx@5krn)}gE*_5VKyVRrslLXuzbmQwuGEP3txdlh$u_WS4kHb z!9*u#c6QykH(<(kV$~J=)g~+GB?dfjNds zB=|~{pyCkl5f~%@J{bQ9{W%H3I1T@}GpFd{rq?$IW{aX7*O`Wp0otMn+c5TWMox-o zV49i0M9mzxEt>uS##WxsSrJVl#`yChf}048jX9>HfCN&4XALt&3y@vrZ5@| zyV3P)ity3!01G(&>?ou^CrOyaon9N)mYcgXyiB?m&|xq9>Zfx9g9na9>;a^*Z+}J^f9Rfq41JKu?d8H2oC3pC&u;=IL~j zs)vJUuZJz}?|G8&ySP&i>%++3`LwU@HYdmJRtZ4^4F)}e6S>VQh_YdvW&U;*6z#$L zs8fe2*@eG(1z86=UXcOSb04=t9H;qkt0O2tLHlW8bp(;gtXn5Z7Q^hVA9Z2s&&`Tk zEj^9#FfEX~xR!%6`qkW?duZgW$5Vvi=X&tWZQ=jTibh#ZQ%?uoD2ACSPGf|l<6(xo z47=D>bFNW6x#|>|Sxwcwf!|qy-7)53o@_K8DiD4bw+q!>Otf~55t4)sHLebkd9}y) z;mA=ZdLK6mS&>9ZGfE3IRnlAx!hVD;`Fp1qi0 zxiU3+|A#m$M2a(Obe|dV(#5OC7bkXFiR-0}UJ-6jwvd!=T^l7Py`+=061sbhcs{O- zuCj(*roa>wDMrU0C?IB@T-gL_O|VFinxGFOEUIYRErhRhm=1dZjWDD-i%xijOOF?E z^Wf=deONkxKXz2{V10P_yWf?M4}TQjPltzQss^N)LmGLb>=4t+Un&pG`H*zK#pRW|L!&}*vy~teKIo3p+!pHIa(4>;PCsG?o>(Hf!BhLbYm643+`=V^zEV#tv%7$w0 zeHn@G!y{@Obhcrmtqx3(K1ji%W=3{OD5gxdU?{v2_;ad~XrL5cBl&l56QAHnR(MI) zKpCm<(tin0mQs2FJiDWm?DlraI)nO@( zb<`aFf6doY=ulQg&3QJ*r}yoO9`>&4%FC2hv#L(2d*ua|=CBu@5G8Is<(uqP8ko9^EqG$y~Dn77zjjY!i zwc5Dh!TfVPmeNb32JZ(^nuh(5R>mQYIs+KtF@QBC!b8G%VI+DlkM1V}4B%U#M4iri zc7rM%@Yg{`;dL1EK)+Q=hhc|0$#v8LqjXxU<3-0S(i4D!HxlZfks*me3`Flcow%sH zQ%YEEf}Dyd&nRWu>}L&1NeIu4Duj{RgVo+N9u811KRk$e}Wi8xzC1jA4u$~KH9&`_gZ8?Ue0yV;DY z4=o2?Sk$eONe{A>0eP$PjMEMq0Il*ZKpMk!8tu((en7Np#; zxRiz$hAvhEFMQkgN*Sp<^xF?Fct z+oL7*yKWEv>tM+}E#gsJMK|IcHuymU+Te)6)7KncG2o)cFr;IEa?;d@#HXgXHVAx1 z8XO7uc@4@w$+I1IuV||xiuW@vP&1LdiN|ncqZo1QUZM{{j(NifcYI8C=F;e5G`vjO zcoXiLT^0djY8>E3iZlXc!AT=tW2+b_=soT5yBlbN0nG1e1}^D|4#+R*5C@!K@ocdw z)=N>ql)w@(TC52Iapp*zB=WPEz_84-I5*Jk=pt+jq7vEZ=SPZtZ?6)C;zv!qM4Hhi z`cqySGK(&x(cG%j^>VPys8TUQEp>-pA0cqAKLv@1`9HPn|HXiX>p!t_?IuFy$~L?a zg1s`rpW{f1@$uunaUsaKEQmBhlPFEarfEi2PS({xo)3REgV3DYG|W6Y?3gs-ISq>) zlcs}LZJWjSoMgSss-HVF{RGT7`b!2oCJn#ii?MMoOC%Tw#?EkAWc#Zd z{{~jHyJFKoO11M`^*8ifdoy%sgdD^}&3(K*lrdM~)IoRn;BKC4(b zuAe#!vMQmgr+y^KTb7K)eh~JDjm6YMAe-?p5m9$!*lLwolI~h*r z@V7AY-@HCNKK$xiI^AbY$wZRymk~xVI5(rTL=OLO8gWY;T%Qc@0LIuch*2j*yfv76 z!JzcYpQge)#UmJeNp3YSowxx(3D13m=&|F?Cl;gt*GP=pSA?)yLAPHVzc%h*5h8x3 zRFy~#o*@r#fmuz{0Xk(#2T#iM%nNdaz6&mjNom}?CY18-I(-U)ve#~xjE5iy4#zEV zdw^Y^H=cti7T9H6GT(+Er1Gq~nD&*t${~qjm|~ZzRWEOnCdKD*O4SoDV~VK8iFUG- zGLulMp6=v{P3lV3^PO3-yBxhnspiNWp9Z22MxBJUrbUuu6@#R9Qj2zxjM{>#VNqSb zZ`v8zBrsK`6exh&$%!ohb}57}pN=k@7-{MvZZI2qYf+*$7LcCVrUEZGhkeySD5Gy{ zc5_1iu19#JUWHmfdiMJ8U&bh`IwPmcj*=&gsyUutvhe6I z(Ulo$nnNfEMrwTNfK$D}hY^xHE2%w>o4pJtoISQCyN4|9FfzL>Y%=L{IL+Y}E7nz< zCb211WD2_@+Jva%OvRlxv?-ZgDmez+qCzK;-IaFQ+orr|Cv_M-`l;h}*p&TtR(iXK zhFyu`uTPhp{_Ip5pCePPv#)vL5Qv0hE1cCEX>v-hA}&r72D`eWenpdhb4Zh@H%KocwvuSi5ly=CX+3t|$1-W~)*{X*oroD`iKy#rLFl}IO04lQ zAI_am+H@63SJ_QhlXTVHbmx+;wwn$lA_z}*6IK<6r@IMH6^my@gxK<3W-La@b*t@} zsG7oV##sZ^fHZI+EemrLvgbM7d8|u{v(u($QfpH3H~oCGTa(UMKiowq789MwdM1@z zsB{(v1lbLa<09_5JCXx7tY=A^g%+b>fHa<);)Aa$J|wqF738`dJNO~M1R`fAx|hZ)90Lf1{@R4PzzPF%<^M~8!cf~&m^FUz95_fRDa z&+B8Elkj(1ckrA>7cqNh)Ym#@F?fiy!9mu3ZtU%q&Y9F`G#{UD~8<B{=x6tszct+e!U9C7m zGSS_-BOpbPMHl6YW5o!%;a|z26!6=%TeJeep|d)Vcy|71r-b+krKoiowp(5qNdh*M z`=rDO{?LJ`WHa?PlPV&1beE#riKDOzeSxzdZzC{tJI1I>?#QDEc1l@N6iS&80F%zx zV39yIoiV`{Bq&U^P!_!~20{8{!OtP>Y)?+Y#0eg&uQrO}kAu+PqMU-s92Cn}7fvC? z?yHHSFyCr-3&Drpy)7#aU8PK~d@aifF3|cmU++!{V{wc#U~*c~x9-&qdl&&p zP#>^!iOb)*SsecR?~m=30h(y}TYeFfxNK`#=hhw7 z`^*5cz5Et|YjE}02A3JU;lL{l-a0n2&n{bZ#S=*Rv0T!i8GE!(1zr!cMjV@SDT_iJ z9nqAhg`{jvBu+U46H=9ZR4C;w%-Lr3(2>hQ6bo?);HPWoo1)$={n zOeHw&X}Ly-WxQLk_+1#VcyvhP_#DTRLr{{a;t+++uxGA%s&KkdBe}q+*Qrc>?$8Lt zftRHpiy8T`u#iKijA7iZRxm7{JlkuYJfuYYRTN29b!*GWG`mjLKkmrS<%|X|mW5Is zm2`Z~yxq16{?TfKA5E$LxT6@CmwEy!!@UhxQ{Z1A0 zil#?__(ONl&yzIrFvZdQWfu=qa*xZsBoyv&Mn9)>bP{zzmR&`5b!j})irO_WP4dOXCMAXLla>80uH{F*JR-XFl zy8a2?QNuQ+CQ?^aqK(s&EJALZownkusn&S_9ZWpRpxJtTcHOTljdo=>r6;8JF0!)O z=6FsWY|w?e^hLvS?xr;LL!$>cOTciP>VUH2MQUQaR)dF`yAjfc_F-pU4ZK`xyjcLE zxrQmNj4<5H=lT5@4=<^-q6#~c#g9+TDYfu!z>&hhTVP@E3RTcg2a!w0H)J$b zD{N<)jK`oB9=2%Ea|;XetwE-P0~pUbPy*IJGvj3lidI6+j0Yw-i8?P{V&}!lHC92u z0%woJ#d7*O21Bcjijtjk(c6I>OW&ig*=A?kOLkrP4J`S_%Bh7Vj~?0y$y0~9W~13| zt5D0$s2^frBQG-SGi2F7%EvG`uHwUqOtqD5)-Oil!3%k(pkg4^8zdqNewG61ss(g% z1XYAJr!;UtM-5GI;w7jy~9h0(8Gf+1?W>BI*UNzyLhH;)an4ynV+c7vpCOD}JM#H&mM$qI%GUuEiA;XnBz9LjBB1t1W70T7gJ|#%V@JS@n6|dZ*f)=sv zbyx0jK|>|`hCrO7fK({#NiwDxp2K)lJov&kx`^!U4bNdbi-AU`r}ff3k7tNWyfs&+ zm(0AR?1=85OV3|AwpHjUK6A%fQc!tSg1u9L`8BRIrB_?IB_*9mk$bfkCBXDrwg4wC z@2r)`UQt)P)S_k%oaDU(O1qnvxU^U%baso3n@K4=iEEwD|KugC$K3(ikBO6MI-tMq{{Bk-Fg?ot%(KU9E<9^ks6|wbF?^Kh~^3l8(rhV3U zG{zdkD>sMISoT(&Vj=`(yAaVNHiC;&VQptqG`r1{Xfu_}Vuv_ZWgmt+WsXxGI=-|R zjI2!L=u@#XaJ^+Q`dEXGXl(5h<2yY)unmadt9)z1ii?%EuLx%zqAqn@*;7D$JZXHz zX644LLms-!*6XJn&j~pG_rE{Tharvg)W7?k+##Yj%Cc6Y`=VUrG0%c*!t~}v*|2lj z1$p$t3t8dc|GxNW@Q*)w3Di;F0=ztqOG?BS!dilDnB{#pDx7Q`?!Q zJATZw?P|5WhlC_m#Z6`M&jU=dFiJRBM?h;tc%y|}kLR-~%lzMYC)ttL;ctJ-w0x&9 z4-47ix1`x?4&AGr&0Ca1hdr{#I;i$VInOclG{thSR4M+Sd; zRoX7_K}5)BzFgb~L36wrm){Za`eC`+FmS~Wu2S&iVZ7p*)V@Fe)4Nwc1y~N$42+TZ z)$ZYscZyB10oP{y1b^I)r@irN^Ud40Z-bv+{YSo-&hD_zrVyZ-PK7Y;8a|~FVg&pP ztQ(Q0HUQ)4J1=Iqnr(7FD*BjDwnfNrK4`cyc{`#|+h zf41i1`!#%Xb(!RNRT~S`iG3N%H?xx=o+<-pgNZ{G$8UIB73z%FKLCg;W;UB<8)yh# zl$~8+k#hc9RNOK@Tdo>`b zvqiEmVMXd6GZ@M3pYzE^Xefiki-#P0&eTBd)gjH$k+OO&Zl9X{%T&wZN7u?h?NQ}_ zew_-~IkGhWB{gCS`ma+XiygZs?N+=tG1Bui|1ew6mJ4a9v)jLxwUM54Bdu(91E1NI z-#}X7s?%m#()Jdn_UnzHet(m-Gg$a3C`#bZ8eLj{wgKf{oN zGGS-^?$s+8yj$`6PV`MMo=$_u}~juO%=Bo9)^F!6d`@ zj$lT!O78B!n>JxtJ_qx%Tq!7exE3LT2px+sp62(n^(J41t9<;Psr~v`F;DOf6tz1X$?}EDVu0*5N2!HOwmV}{!a6$ zY_9e9JG7C_YD8neEGD1B{6x&f4%kHxw{J*8Q*Q6;=@pkknw*-8vOD{^Cx46}P}nWa z((T@QXzL)T-gLRWo##R8iRqdCDjQ!FEn>>|GrphK)6_cxqB_oroipf>QwFRWZ4$m|Rs%t|}&1RgepKm4jeeZak5l?_MnBH!$6KRNlLdo^vcW{z;G%4>Q8xG} z8;q0)&ntv#}w+J!4DIn$73mSJfaEkg+BpV@*KDnt+To@ViESpOD|DBYmbZrVhaXw*lE!U~9fipzb~<-TfiA1^l7$2O$zLY!3niUX-SkeUNI zaUiD-&b?MPU)djdgzoMI;DqB>7gr)a|iO)Z3|EH zI2@&8m&j#uV?!>S>Sqq*yL`1Y_3DW^7aEW)?=}vwHPfR|Z~c-HskX}_&n`b6vL%TA zL%z;~@hT5C4>_Q3xA(zv72Lwi?1x|_9sgjtVEF8^>f2+m9ByTLgP=ZMg;)<3HV(el z=I0~-mp(3BC#*x9bh#VLa0fc01dwd8vF!31CI8fV#weU}wL7@n>&ZpO;{3PElIl znvQo42Z?OHek>~O5Ie;>M`?n9=^o(=#8UeiVyXQMvDEg8#qgJk%PsQ6ewIiH#^mEr z>{+s2B#c(jT8$ss3mXW8zBOA1cMJqSw(EQvY?jb-aAkBH%x90dq8&V~mXmzF1{*aI zxy%+ohRO~Zu`UX>YpQ!3^w(9;=ndAv^TTZN5Il@O>u^{BKopt;$Qv^lE4#4DC(G587mAqpPN#vYakLW0 zcpZ!vP~WHRCU_d7q`){IVTy&!8Y`QRp_*8k8JO**H%GzX95TKA1pF|rMHbHwOBfPZ z)v)AszBvkJ8~iz5ueXobEDz%i|BqFQ$iY(>7$hdH*;HcR6jWB^0ma?s*gR4Z9+#j# z$m@nR@PDplLLq?VV*ZIUC33KMk3Ma~^ zc>oWRag$vXwP18@a{8ZZTb#hgDqlY>p&x-FCB>A=EBAAI$kR%SC4V56WVmfG98eNa>oBA78 z8SRv$A#gqo(((y&V93dj4PoslxP|UA*6o6YuV>SIh1O)e+R!e7omNR}4A2#-)WV&lCOgRR28FKhO2g zx18Nh6Vqw9r0>@82t9P6jD1B2};R)nr*gsci&go@{%>yHql#Gi}UZeHzSkE zMN9d$o$C)sv;Mw(`X_dlD)1Hjk<##iTl_<&6xN&q10Ws#J-uZ9%4@(~7`Atbeif9r zVhGt>zNCeY9M5x)D_7`JIjMK7guS3_bjd#3C$pGyoVCLpE|=(2%I{+H2N*{3kK@T^ zj)U#vcD|WC&2wz3@+mkA8}N6agU$2B{pR6~&v|>m5e0f3j4Qpu0g{XNzrq6jY2PIK)Da-JnZ0hS3&=JYFI?Jz=i_nmC_9 zsh^HyUR7`Ul{bU@<0NMfeFW3l`f0qut@wMH5!4v6SfR53Y@yAm8CeUH!)WGE^SKzr zg9-eXWhydSEw>xo;-`|!gZcOqz-4#PZWHkJxJJG~o*O82j9|sK7@>=uRj-vE&!5Mi z*5F6O#2*BYbt!0*+wE+w{4ubXV`13DQ42xF78?Hk1}AcHSAUg_uZr+U{+h3r%%@*& z_-t93BVr}w9+z5xRNvu-eqA3MUuA>Rz=bBRVtiHUSKmn2H`4WubbT{j&G$=jf>q`Gutt)xAuZ;aGobncLV1;St?>g6n z`~x}F^lr%%&L}bEmu?MMX)9kcAJo&nztbxAD}4LfF*OKfm@hUpEcMT@Gc5g=8yS}T z=U5n)!IzsCmi%*V%V$Y_hizeb{A|Nwi12f)imJxXwJLwt#cCy_!pX$H-eRu&&<7Ft z**38tIWgBJt;M}{4*$i2-obCS3+YJd4LGzfzme;L(%49|@VX~{9ldV%RIav3(!td* ztZUlTS1uyC9Mf1%_3a7;l?NUQGkUE^Q>I5i+hb4LDR?-Yf`aN(6W#6OZNBPBjas{f z#%w``t>=8N3zUbV*+WnfuFSHN7dA&nuX{FVmpsI!c6OM;Nf>x4Cj~F`S0X4QGEajQ z4QzX$n#Jt`yAFTTNR42Bdll$Y&^VNd|91$fMRy`IC-TyPm9OPvV|X0#5C%xX5@3 z^Z7Zu5#-4mZ!7wsZ68>3n=iJHgjZiYTwq%A7A}^HPmjy(`bfj#DLBO7LrmC!KoK;4 zE`gJ9yrd?ck~NnohA8Z6YUy>zu)3p8(u}AGyaYQM>5qf3jsN0nfILvPZY#O);7AkLr?8Po`8>MG`q_!t-FiW73bO}Zy&SJxIU>^ zHNSKY`(ueTW0Xlcw#0YM!I7%^m z_ho{`s%yH}I63=Xy`vu%7A@xmTHP&%DFFKBBrq{^6m73CuW zr1R2Le&AI+j#r;p1$4Fst;*hj?kGmYa^K3XGaqXsKW$=@xFYKWDRi4l2CWbp5eSDg&7_vWm%vGOZT(Z1Ge2C8<Gp1Mn_i$M#-Z{VuOq;w5KBt)>ONZ5G}v{ z(pid;LrFwOZlL~#H==}@lDssb4bcwl4o^)JtD(Fg+{TXl$uxlWc>W>!DYtnUGj_uM z3B%{f7$sN$jy-VO0T<69XhHJmfLKGOo7iNs^Kd(OB>R=<&-|O!<47c;W{0DR0Y4(6 z#F5f}nbg&DLB9dW8hV*1FU_HSW|K`m1wUXdQ)l^l%{rk{GN)$F3t^7WP<%mQpXFntSvtW ziyttla9|`)!V{FAu73V;ko55x+D_chc)tVN+7EhTFb2Kla^A*+`|lLIyId5ZI zar-!2u5eC}GCLD#t0#21t> zXd3wZ+_p-~Mer#_hsEi_6fOdD^2v<(5rk}+{Tbz04BJ`Cg-8ObH+Hh@G^~0*cX4dgCc> zi4bU-{m23O~1MBgO3m5*^JXx&~u zyFgqH)X*sD567zoRN}kkLPg#y6p|FK54S_sEYP(jYqL`~#!ur3o9tPLG)EK3h0Iwd z@{m4>t*3gm`vnsE-#}3m*=#OiTV zfra@|7(DE`Tp0FCM9ES!C^G?<{7*p(=o=U$^G7#SicNxH`xE6lfss!>JFqytLm| zFKXgUmCbY5Jtd_b!Upgzh_@k@tNM8I11|l;3}l*rB+U4-3tl&1K%Py;^DLKsC1JY9 zk0Z2EhHaRk>0NttOx-OoTq@CHzUWF%<5kWMoc$CO*9b&WjC`4Bm{r&zGj^j3PZ?kx z*;x&!mRb|xQ-aBMwI(&-57Oa09tJyp_gO zJf~p*+$Kmee18X82MsteKGSEw=DUs1@jgfvyE zx!7t@fXUOAelFJr`3EccB`L)U=|thw;A8spb7DH1PFWr0|ctHvSF+BYGUVxFgrV# z+Sp_;+}fb&Y~=yjdEKF)Y`VKu?l3ZYe0n64I}NgP1SlR^b(_f&-4q65gqwt`e7+o; z#VkDao!t7M2(ybBZ#PRU$}AiGz8UxXEa;p#KCC(mP$myo2%mzhw=lsE`B-Y0>Sn-I z6^zfH48rFba=W~{^FTQdgs%_m?1KhOfB3+6)@%y^L!k}w9j|-QAwQlGTMV|$ONYlz zC;lIsc!~Lf?(67Gg1?o+)cH}XdJp6O^N`N(4)5FxqXgVu59=c ztM)L#MI|TfFfdF39Dx&C&W5Wt%p7wvGI9)#S2m_e1ZbS?=Ad{1lfCgAeovdUn{ey^ zW;uSmkV10D=6$S96%H3!tim|R$RUOiDmT_+gaWZBad_2TA#m%0LWNL34r1|iai4u! zZ}LZ7ZBBv$*+YW4FjjnNy$DQ^ZEx3wC3=wN%&crT!Xq_=9LANLOq3pSm|QaJ#;If> z640E_ovvWynBj;jSn#15%SXPIXR-0*PlFgMNqdPrn-e_Qqtg%La52TCi1YR|RFCFt z#bVcg`ks??2c3G9;+wCMj4edO5kK|s?Ki5|S@5E6mnNP6ySg3+)rk?icv=}Ro;3J3 z3pSxh*hxk$b&uGT_i9e*p2n+(=}H40XE3bH zmxSbT{LzA}*W@?NdaXNUKAIUA{d;~lHdt7GSSz|6rqq*leosHS7pvLRj-<*zzc&HeF;@^f4diM9 zzzsHQ?Uny&z^6_<3wmI_(dt8 zmcIDIr!_A1YoFHib;T;pPcXi%^^|UhBMjsG_}Lh1l)GPy$mKTN+C{>ciU+rDiHa+a z!boSJ%v92WDwrpjvQ({Lf`8`d#h>=%FI~ze;717Y1xwa!Y;j6%%^+Ti6)E27@Ai`I z$U~!GGW^wJIU$^7#Acd+)$PT{?Gg{dEWB*Be8#70WDP3=_Y3^d#(cb1)<+69+0Hj^$Z+tU$bwW>%oxY_a*v7#$`Fd!162+DP6LIuqG;NS?5{*-{pCg} zv)1OqA_{fzoez!2vRd1P+$_Taj8B*QCQOVMY)z64`j{eIt;U}?cdf}HWZNd9X+B7i z{1kxf-x*>n>h(;-To2Gdz4ORgZH(;dRlB;CJ24R&rc_Jl6MK$|OXH_N?J7$3(JG-- zNP~*(Un6PBT2i;LXc0lw_`|rrY|U2d4aYch6rb79i3~Lm6FP;&C+IB4n<3ldVjM|m zSVk)$$4PN{YOdtw!4-~cQ9Eg zpjUdNE)%PxhC;=X9tjobXF3}7Fth9Yg0YMp70?V?nJ6wT_|F_F+Hp7HvtDz!C=_K; zO@1=Y0#NOh71Bkix@gePlz5mnF7aenC&J9UjtUER%D-`$P^^)%Z`{v~o8M~!cEZ|# z;3Y;rXmTq9EheT!>^oXaxvwP-8tmXo+Z`Xas0T&w@l7`0LSfM|jJ+PJmy>*}NcK8{ z813~8-Z5Wt)NvPIFfBU{#lf%D5&}))AXO?4JXuX~&P?0@TOLZPHlj$Nafi{>ZRmC*FBORfjNIhKm z@w;o#O44DNf;obLruBu~)4l1!ye&2joM!REayC8a_QPJRc2@e}b2P$syB;>K4iDJD z%Ol3*5&L~u*b5<@$B435lU28|Cy!v=J-D8=Kq^N_4~N8@HOBKf9+9(0e~jFTq0#ow zAdM;j)o@wIZDLJ=U#3ymmY}C6~ZXA@CR$m{d++oXhgjrGZ zGd4=Gp70HOM~uSbH8<+tFvL&HuJaK~f|n~ZRxs}B)2V9G$(D~%yu2ZdLA@}WU5s&xmvAOX zM+47^>X)*m^6;{xu>0A;9WbTwUUi|n%+fG`>)WGShOTAzl;B}i;ffe-Ct(xsvbN%j zf1Ia#F<;(-^MQ-ojd@O<2_=Y(9P_jeEQ@Pg$is3=4uj@=w-VopXA?U-y}N!`&ZiCu zTP{L6O2V%a;1S>6D!-e3G!HI_+g|!gfze=MZq~^kp|iT>ibK`7qiSxR%61j6%k5|r zJ%RIK3-xf&?Z=&H)Ead8VyC5w^&I>_dv2`9UL_S3AB~3&S}BD1HWz+Z%lY!2=Ax9= z%Z}DtFS_s;2YbHbAEva%-5c&e_;+phFOaJ}JhKLRBhQ3;Zj$yA>vF_)4pxP^RI1#` zEvlWNrjzM2==WHky8!?T(5C^ny!F00*ARTVhUM1< zS#5xzBJPU%6l(<-TRh#$4^8g4%<0~HK@WLZ&&crZAYQcMm9Tbv>HZs^$+IJ{ z`;xO%TzCe^b0DVhfLZhrZzJYYwoqYcGP~KK+#>^JG`QXa@`!|N1$nT$;@0t41C5T1 zi#6&d%}4|)0X|mvYzk`W?Z!TE`lE+-6v*aU^SCB|eIKm$?r`sR( z<2t?hMgynfvsr2Aj}a?wj&UD>9X=CAfIwtm2?5&PivBRW-96{x^sU*gayz6GrbcYf zBu-ouUER($tMTd+u0M-``JJwwsPOA7pWmVF;NM^-_z%yeG&CHUaJ1`#R*P;^;brRa zYMuAT>VS%Z88?>{O5N+)QGGg<6bbRD;AXbjZgM>*epiUs`+^eRgQ?KQpH!h}DmIDg zjW-YV?cH6zVnb<(?_S<6=d%f(lN0si6z~4E`R?HU7So2ET=Q6Z%zLmhVE6216Far5 zhCc-!jlsjq9&oX?U0^`2Us~lZcyL!ie8FS9+B?y1?Tad}Yie^#t83$m>&yZu+c(1Z zS8%Xks3}zi&6<-b<;_99Q%^oai#A|nQ_Na7>WokO_L_5f?VUdxyj*1g?5q&tTrQID z7J4%ce<|L=FXoNET1+2G9E~ozgT`od`05q6(ii!rv0bh5#fDk=16+(ge5aAh_Djs} zboocH@{3?Jnl0u~;Aj-=Ab-UJIpgow7*L-FaUPAv>qkiVVL6A%|2z*4SnzuI`_1F> z!@Tsr{@305o8yn=s|{2Pf1f^UM~{C@SD-~jSD#9+^O;`A8j+ke$N-eg*#p8HqFu z$kTv>!agB)B>GBcOo$E-jjW+-0xf^u>2CHh7zel8`}PnOo;pWOc5{trC=1N(pZ`0T{# z|EJYo`~N@UkM@61O{@QNhyr!lGhl2uhQ4*Im-l?V~@b7{PsY0`QyW{zU64vnHM>K z6KlHU4{+V)ldFID1n*5Ab!X?{3l$8cFXajV~_y;28-z7Bn0mxLB^f37X@@;!}`8<`2Q| zruZ>hjn?=%s(=dpzn{hr%jKKN^3CF}->QPx^Ls4jc7U6m_ype)7v7)>=&9l;AYSNw z+TPA*6Br{fgzKB&X1NU>$Ddd(Ky@Uif{9}t_!Kb9V;J`@@u|VEdlL-txqxo}=1ma7z$?DuC_4(G_q{aAvLH!= zxYKLLQ8PekUPftDzhU__0v_ z@`}xoUr}!Z7Y)Z+bK66i77o!@j@9=Vw9v5Wi<#|fB-Kqc-$dUrqo^NF`$jx@f_y7 z_uDb{7vWt(KfV*$plJaLuqmsjo>tG+M22v?{>H1)=NX0@a|wji-AIBeGR8>Kz ziiG~oHiFsXx9SzyqO$4KA~>K+k@V5V0Ol27a~u2(f>9@Iq)B#2%0%m{OU-xLVQIv{ zfS->#aW^;stABnNPz2}^$5bn4r{{+h1scLpm2&N@c3wTLodsV7WrGG99%+E+ZKYDJ zo>h*kr{^cNv$K=)<1-i>8NJ0w_&z9C&TJ+CiY%Pj8~|LGZx;rza;>mrU@($rvfp)+%pnZ%@xEZ`}lfN1Z_a;fx)Umd|Uo)3aLb z_^f(%{PyGoJnR!h;i#-z+|aXK=Fn{OQ9BAV(ehFST)a>Kr3x;E&;z9rE``tnr4O&X zY=9tSWBA$N1pJqu4Nk#-`PtwU{FkW(l#hYK$iU`g;IcBXc^SCO3~X)&gdN?aRobL? zFBs{prfuzR+19>>ZS8B<*4}1q?QYf9zD8~BYtz>LCT;C&(boP3ZS8N**1qPf(dL}( z8TiEU66P^n`MHzh}54WkNQVGT2C?nJ7aN>l2;P4_LIA zVlL!rq+c!yYY0Z6v-n~Z_LENBC`eBUin91FawIFKPJAhqjfHHNc)i5gC0kQvI}*Be zHRZ7lgS-z8#5(NZS7o;0Ook_vg;?qPn$72)(f?wzM&+|`&k4K>DBxlUT#k;A5+|3I zF9}qgELd$}a`~9QqJkcx&RYyJkX?7R<@y4@#^cuT$){8W=tG_HWVPfzx732kaUv7{KG`KADP5JHHw?V&Aen&8`N*XoB)d3b~ z4JI~hEoA+WPmjb*g zawG7S_3cRv-P1|TyX;riw3jQZYf?c=O6LM{X5y_V)?#_os&K0 z#Z3&1&5tkuvyu2H_%L40aHau2ak=tNMo*E8|I8=BS21w}dm69!I0^$?2mFBNYK2`D z8sF!Vo^152zu{Xy%%n|&+fRU;gU`~-+1%xK6a4yrZ)dCNo4f6s+4{|Td_Vqb`(`|O z^XI2;KX-@e*A1e7+6K}8BVQ5zCcy2C|A)cwRcYMpyUpiwbl*5sZ6%$2eO&vxd=`|e z-;`_LRNgW?-&msiO6|Blx*QoBO9F&LXb3W8lID@6Wu>`8hf4c~`~L#`JB*5Z|BTz8 z+W#1h@KDK!A3d?5Vpe5?@#u_VGsU;hu9GWJMO~6Scl9lq?r1`>Qil>r@h%olk*)KmM2I zk2zknwtIg4p1e6Xcr^ko-6plcT6y8b6Q0&HG=|G>Q6yP{5RZdP# zU<>cyxZvo0p8-YLCD2XW4YR6XZt@Z>_Z^EC$Gv~k_)YLPYq^0N<~)B~g8}*hPh&x& zeaIKH9Hwh90i5J~S~meRk*l^>qY|HFLO%C6ae~>_J>K31WyOXV&K4c8;lTmU#_(|^7)fMlBu~ihzl;tk-#fqU&@s1Btan%trgVIWvWTGxHpwW5#ngKuXjU$|2uQp-| zDHdOXsp>7k_;&e$NKGgvZ=_Ck-AMbWlDa^y*`v|ZXvB)PZc%UsUQ?0}7KyNol zS__s&Q;dpaSD#RP;1r%(nVEQNX68bf_c6+9B9`JrP%XX-8w8YDi-I#PNc`OD)Hahk z(JSLhL;-V@gh-$F_YhYx<%|%z!-TDiJiIXn_fCD(7^HmFH*i$-KLU{hp#%Km?P#)H zVI+Hg2GbD{C4uS(Qp^ix-ZZOw^Jk*iUxpBKpyc5cr0371B(YJ4(&}W)Dz2#w%vY-g zTL_k(JdVoG;75rQ1gdWjhPV{HWddc1h>CN7yc>r)Um7uxx_~2w1O_aXKuo4E z(P#?etuLWMU|LPZmp8C(0}#G6fy{EDscN>{M@&p(G`9CF{*7HPtq6SZ6@4*1SxCzw>9F>S=Gh{8rc}!Q5PrFC?J`2rpD?S$41~yB>Qvxm z)uucoT3*y&16Pqn*}?uoDFxN^qQc1Xz9krCbnL8U!Il7;CPP+>sf z#?_z_0h-bfz!wO^H?Wsz9^e1zo#vP8m8W!?f(qv|G>e<@Bnv+9KoiWVU2i83dO>>s zEXeKHkLwSU)#l^JH|W7)IYPd4I})V~l3T7nIMAK3&=M|lU*gTv8keYychXTI?;|8q z-b=be%$he>x`ZE(Pz@$LvNTHmj7f(PNFfMJ!!n-Z{jK{4<}-|*?jP~m_zYLHcvLO) zIawq&cDMmXlJQ;6Y??gDD^?5S+7$O8c|He+=%U}}xSGqB74?Km)0iHzVgdg|HN z{<#{cVDcn9A8VvD2YrPoTK`hx7r*YO=RRQ{XzLiKD(Vl?E>Mg&Vgmq@9voooD_pOY zZKN03beMsn%*eW&5tU%N+}_Uf(s;AHD;=;Am`fA11v@jqXEq!cH4!oQB^W(Jia;RL z)JdcY5Igr_B_Hd}YO|ag86OFSI(%oIx*0*;Msb!jqW66^85Zid-fVBze5O0z%qHla zvL*WbnHJ=60QrSCa>c6?HN`Oz|8AD&~y(!$mq|sVI*_DV@KpnIv{)|7E#z z5uqOQ7G~XL&H(uH@SU6jPG=uR8|Ep^#m`kP0+wx8`I>JXvJ-Tyi=!(A;O(5B(1j$J z7Bj-+a@&}1oCqYt1mmYC5G-3B#7*ku>IWH)Wc~>}S3J?Dx8=UNTP(kNnoPdpjC>^u z7iTEhts1!*uC|8d=Dg13QJiDIG-A`(xTYlo!ZCsVWxE8KukuGQS6nDg{I>7 zaBEB~2QaN2-6EM`M2-T>q;SGD9teSQ9`P*2fq|Kuc}THv?9Sf*3k-d@eD?OOo(-^l zYf-&m6hY|)g<}y-xuMA?4bmSBl$-b_@DHzM?qVbU@Kp&$P*&pu0nsBSGCEo=*uFie zdMDF6)^FG%Jhy^;10GDt_;xm*Z9Z`Zr1}bjAu|HoEQW;Ol>$lRfu;(i85uooeFjsu zFq%t12bN3Z_(zzXu)w2y@&Q=l?#@vlI}9JKwV@u}y^QSMB{QsgY4kY$A!i2^4!rEW ze%1vmDn|yQ_-9Y?P9l=(nfoV}Pb>UCTr}AF(Of&9Rflw( z;vy$mq-A?a&$6dD4(6AB6VB|84G!kPiKa?d_UiOXO zyH*Yg+%k`Erku06^uw4ddZ6f!bkai|*^-RdI_Eh$&pKr=`ZHUCkTc)WpM!6I9~=k& z8xX-a!B>EO_YbiH#&t-XW?L*5U*YvE;(~iU#GMiiMib^N z3Y`<%3^W6W*H-CP7`Ul4UtX7ZR`#iu!-(^voMX3iLB?5d9K2BXSTfY8W3NLBB%WSQb=b!z)-jjCQ@%nH(31aL2O!CLaKGFvzhc)da1oua_2L|t_r2L#mis(r z3+hwsP>;+3-#o0?5sLgHR@mIk|jGh z#$$;esE})8=*6Hu+s8x3onC)dMNC-CUC?+8ADrWp1tO<#{`4?L^+I=I!vYfE7Q1mx zDH#2s-j2FK`IJJ~+f?8+>1f3Q2C^K1NWSN({`8JEkurB8ECDw}{B!}kog%g^)+#b_ zE+We@;bS%!>5Cg>#v?!7$ea2=6iv>Ul{o6)aODz+2 zx_TxH4Iai*b$tx;SX={d2b_1r-R5{%21Sii5WGb8?}ub1UnrYm)m@hR*?yVql>amR zvVYW{>;H*k1HWJyyZygP75-=Web2L~`6y+0)*|@n}tC3S&)RT_F7)GEai>$&U-+)Qf#UAlx8}`od~U=7v1?u?3~!2>FzhTA)u;8>ERX{)_eEFQS@f^M zi|(I$sogiWPpyz;B~Qq*k`c1(rQUSlcc%+aNhm~%KWU*3bjkM;%#&iHJNep$5|5qG zDl!-i0p4T}`e`Ehl;1PtF`bS#;}O0nh|aAlu*4U~_)}CRY}wJK#Q&YJ>Fzspj=m~0 z>(UDQ+^X>dOKW+l%S^`)FMocz=N0r@!HASVY0VxOW-!rCr4nw=e2)+I;>Hd(;-6Sy z7(PJi$QleRXd@Q%(>nlWK$*W+4l@k-D?~v;L>CkZxb5ee^#OlR(9DFj2Rzs%yf--|zI%ScM{Mtc1MG&LU3x8dMOjR; zRy4)i{-hz-3lF_KWm%l=!(OJv>tT|WpKqQgf&l`4+A^?6bre|m?Lwq;2*|ZJ@9hJ2e84_8z>eHWF)AqrYbnQI zVOJvv`0|{rj=DC>c6Kp8U%TwgQDlfuFb9Epjc&ZUH!d_7?Tz_CMv@hzB?koE15|;w zNKEi+sxr)ONij0*z((+xeXA|JEf@q0j2pc2khwO7R?#{u+3M`eWM<@L#!AYH;{a3z zmL5%{- aDf(6Zk`$Uj_AftnR4_952R$-AY#yJ$7cqrGu(?3*t%Dd9RyjMj`XYKp z{)n+;Z0Sl7V$GgjBt*V;$mrSWUQdJ3drrpXHF^)DVDK?8*7(zm)2Pv>15hXipy><` zlkhtUX-sE{|bsLvv%80zjC1q)kKln?N_|>Byzh8WoAgKII zlpT02q|%cM;p)IYxcrOR({|2w<3&kmMGcw(MY;V(8D%W@eG$_N_E9}PrG=JhhtE-!j{7a)kw+BDsE zHs$3G*7@q2pfmo2H)dhVHoKcm#(XoT+ZUXuRQEE~#cH{I`X*@3Hc(Z@tdhry354^? zLV4vZRPzBgF-(FMIA@)+$v}=e0mN#-EHd zWK$N%4%}a`Yhy0OwI$rBS>UAk(8}ylW!AyPyBV%>&G=maLN!rT zY{MFNj3gDzBc*=)svf_phetjB|LnbKW7|fOFg#z4Ux7Gli?k`4qz=oL?HO5;9qq`H z9vyMAnJizB1SP~I!4Ra5NwmNHt*bAfK~Z*+nSGvcCNc?hS6|iDRn>Kr3f?wZLBWod zCp=rBU=Kecln4bSTont)?pJs~@AM;HaQ7K5uKVO%Juxj$Ow*!VQA=QJWAtR_9u9pE zyXN7o7Ey~PX;wJUE$``OKQCGnSBQNuC8}CPwLNZ8w@N3NViv40*V+w1bO2MIHp5;y z!(XX&oLd|USTg#Y3HVqt17A6>cETKkbh`Ip*VHOFS3G;d3MBjHdzwnb;KD?)S{hqW zgMneHgH?tpgPRU*E(#Svb|J=tTnVVjJJZ94@oNTA;ERg0CaO(z-|f4V%B5sa_s!(H z(`YeQ_6stCw&s5SaC>XtybXQ0M?@z#sUdo8O!3yrrY93dfxedgOlb*T4QX1b+Q1MfNHUR{uWm zYkxyWo_XL^{}#%4^uMMIA{dHQP-*95uUC09>F;* zDwQ92mCCxHN2~lGuT%~V9kg-J@0Vi&S9<+&PPM1UB+k;oC5w5>1B^R0UT+9ifoOM= z&ca?gTAFguW_eFhr~t*_E#6Cvdg)ar7g9z5tWjm)8}aOqqbwQRglT7rA$^mnlFrz@ ziVX<}T0go>@rp;iiAU$KmFl)zD=I-ScmfvOGY}6i|}Dg=!_tXtVj4H9A^eRKsV>{)eyv!cFAfX(W%05yD^Wx)VNYvYkD*EJjhu&-p8D=#8ts^1Ti6%2GKcROR30L(-@_kjJF=` zqc-3${kX!#*IS8Pc4)Jq#DgFPY5IwPrW417j?H_%!MHQNjl`nIl(kXOz58vqq@Q03iSFJRz-@&Kq z(S9*D7VJSa*T?JVSb`SnlpFuW`XVO_m$mVeP-SK91jrH%Mzf)jne@}~MO1v6b(5s< zv zQ{gEYkrtlL#$ylM>s;5AZ1Mo4XX%Mx!>0X8fazBPZUFR%-(B)8U0yGB-ovh_hY=Sih3LWz0P_7rm1~`dJfhe*@0R?RcLLz=J;YN@m zRx91=kAU&|Aa{c#{|5AfRU@857ueAZPhA=A1Ekgb)IP1a6j5~f{y>#-qjIT}?SV{G zE|}|Y=D(`B+kdSRrYQfjP1PSL|HF^1F6 zAcuPKVh_&__P)bpz~g9|a6nLF5`JD%+g0NJF-1$4Opq=-A-qiyGi)hnteEh%8LbzNDwYrFnkz>(!NhH; zNT6cnr?N~D5S%A(E6QUV%4Flw+zx4I;*mq6p=)Mx&p;|0jnEK`W8Gg(FtX9aq`P|1 zHg$7hTum)A99s-)mF z{dDJIU-u`&yCTGwh-;{Amdc<}ikQm<^`MGHJxk?S{q^LIg*1gc#AuXvetE zt;`>)FP@4_9r87~qxq-0s~$MCeeUdlM>|iZY_u9(W0-UowUQdiqE-9~Ccp6|N7qe= z;nY#JPJf+mdCjw_qJS z)9yFllcFu6z3OIaV7BiE88*cID!`UqY~}ITTV!TRg94Rrsyj|XL7G6>MKjOT=6#Wn zuvIKxW4S~Gha}4<;j!=gA1GM#1@W$fz+?rU44muC8(ISoe zFqSIQ$yLC;vf_07m37b$Dqo6@LkmRdAwZk3Xq`HL(@VYNeie-6! z;5CL;p8!op&B%P5r*Nz{!0cU$zPF7moT+?pZAK!T| zwo}VkclFIHXWhlA`We+Zd}^Leb#vQrYMr}zR!>?QL#9vZ9)xsanq+gR$*E)rM8fP` zht!n;jH1f-JJEc^`hK+fb4YawrT!8^eLp%qk4!H_rM*OYZh9g2EnDidqN~&b|1+~k zh#vCa)zrRt{}aK4Po{t1{cmgSd9!%`yY}b(&mZv-`){@AP6S{MOHOaXVbqqR`bNHo$PR5^w>G>|fzvXbp^gi?*H|iBTYh@hIwGj1!{;5*;j@;((A8 zxSJw=MkYuD2jHf*trP^jw^jaS$`Js_K*_bO5dUrI`5Zf?xkC5#$;n$lX%nYuLT*Hu{BP;<|Pl zEzR0(-8>!Mv}y{`^6Q=F1@82^BVIsb<-ZdzP(1&Ywa#zX#vSMX8YX)xod3-~&;LK- zBj>+b^jro2ZQaFwV3HArv;eTT?&VQNgO z0XX=iG{%F9`e;2C=;SVVB-8n*ASBQysH`ESu=guN4kiVaC)Gc>l0UhUe>GRKzxQG9 z^u+OJGmm}~o0NAZO1o@dh4yUBDIv*ehaDd69`KJzY=?K3ia22~$$wP=Ug!$f?7$2! z_MH?)Ym62Oqv_zr<}XxMsiUpaZ>TnmxV7G3-Acp(;o+I- zzy!Uc)Mh|H2WR_r8Ru!7P5dqAI zW#Nan?R^^Chs>)@TNX8_V^eO42W+oMP70p0890Nv7 z07w=O`VuY>5cxr6=^xh{jivBa*r>WA#&PHo}Q{D=BAm;2JRi462J$o=IZm+jg|G)=k7ab9~ME1aV7~h>8ftyx-Xvv zyFuPnxsIHCbIj0ITF=*?=N=Oxs1j}`bUp6Hf<3^P73_`e#Ind-ls*;BB`&@oG}Wg3 zXgVVg#o}3C4Lg8W8i*O#{^7xUMom4#`$6t4jZYPH$ET~CSw4gMme(vu3gNavO!9_| z(2+I^mrQ^TSo)OH%JWuZWqo69_4)I)jmC2{ z%qx~P!<#ck4Ytz4AhA!}#=@szlc*Cg28ZGHi)+!b=zQk7SzW`apMSr1;C9gJj0WKL zD=(p(SZYv2q}(#FX4H)&qR+HHt@;0Vev0xR8+-qe{y(jiqWypK`JeLNAMttiS(1{% z5g=LPOeL1o#zo4TKzQ4_BGM(d(2REv?EF>20sN~c=l_9^&;O^_Nz=h^NC58K|IJ2z z|F>5E^#A!oK9&>3&fCMo{q{F@sATm>xRmV|FG9o(%&=&uZNp~|+Hc{nel(rT;s-ha zN!SM-E`HE(;+|>nfAS9hx)1LE|mBjGCLV!E{;ru1S1>-%fHPh2;RjJ<_pPQ2Ikpvc=BOu zfB!2|cXomJNV6oR#Mf~bm7LqG&y01KDYX&2j)vm_Cddm=k(703m>oR(1TrnaeYbUT z`c(*0&nZSZa92@ALDMjF+0uEp3s9C18%xxSvjdW&c6YuCw`e(fHy{OaoKteO!ZCLw zauf%^9o*Ez)9r0ilM$cAS#u{>$bj`{gMp&gI8}or8g*l?fS`c6>!!0wrj*sEPl}A1(CiFlWSDqks6w#^BQAx zoMLQv+qqZqYZFk$uZ9Ztcvqx({$fmNf%!i?}-Wi*D~ zy=47a)a!*yUw`#%mQ9|KTh+5pGJ1ydu{@cLmcob?XB21}TBWENX`kZ@tM1mEL11oT z={~DUMe#PIJ63`K6R?wZXG0Zp_GOUU7|m+9hqp0<0mr1JbU4Whpy+-wnq7w%DRjMp zDF0C+CQtB|gqb`1I*jYn>uEK>c**r=-E`DX&S9tF&tddQ|4X_<{UhNfgW&BAs!=eJ zO^s0_Q}6iJz@4pnV6_k~FJHuiF{OsMqDv)uF2fj$^I#CPaD>xI+MChsbP#-`OI?@~ z4oN`w5f}pP(t?-+atW3UD4H5;Leuj}gw~{32Te+$StM&p z%T6NDD;ORp*LC(?!qKX)Fi}YqW=IGznk(cq|HrK$ryNKqH_Y+3>*bP?Sn*!W zSSBM~hT?%BOAxG7!(B#_EC>iqUWQphzo!~~D%iI)yh+>*W>FJLI+|Q3l;9tWumn5GQW0rc9YWLtG>>?48LnO)jp|*-^O_OSbay@ zfYaZPy3?Q&a|*3IqS88bVx-TsbH2jn*08xHYhssjr@%RGBLxC_2snvVO3y5HVqrER zx)-EVM<^?t(sH0057xm4&D>tM6`MrbtdpWe9Jed^*`mhfAbH@ zfAC*7?f2{5->HrH^55EOb0shTt*p2H)c^h=AJ+ed+lTMoG4})VNpB#rWswr$Yc7(G zZzgofThB<0ro8>6U2KCM$69CuTpMvZXZz{e4Xr^ny0{wcH zQY>7taY?2Yy#m>4s4w+Pi5J#Z^b5{yGN#EcjMw@*?8=FBC47hC3{l<9FitQ@I@VWa zNG;Wx0IVT1Q(+EuB5Z9n#PbA`Ug}gk^^#e*pAin-H_=Nbqg-Fhutdl8<-#0nk_A{6FMW(Z(q zrBMSRH=AO~4_jf_Xf>P7WuRZr!|?26D{xG99uiT#cxd#bAGW?bIN3fp30rGxl+q9$ z?0q=<5FVU;c)NQX9=;1tcDGOW4xxzpSQo)i8ZS@Uuw47QVUx*cum#Ki&CYR{wsHSn z^d_7w@$d-YZ0(1YtvZyblJ!pb&FgIt#l$bSnf>}fb@azgr}OQ1X9wFS z)N!LZ zupSWO*=_exScsjA3VB#%+X=jeamU^?{@Mbf(4Y$s| z!wH|;k4B@Hq^WgOb3lG90hiWprBpN!on1_C}mh1r&-4^l*GD5|jz3qm)s1Js%(bv9)K z`gpc|dUm`UIv*f)&akp6v;@7$(DV=g?PL}rB(?BBie{%N@A2?;*w_ph39vH!wznhB z;lnz z(_{#pq}jvLltl9}XU+xAdpPz~0p1C|;AnX~a>8-cD|x21(NMDLfx+n(pw;VUb9IGk z@*|*d-Eea&d>pb)PRBDa$W zxfYJ2UXPV5?>>f|-sGkTwWpvWydqTc;)w=ytwI~)VTk{~qpKYS6m~-q=4|AHngd&a zNz{Cd80kG4InfsU4#(5_J=O=O4HNNBreK6@5Y8cm~i5<;TXZq~k6DeYeq%{}?A@M&Q?a_IuyhAPWVMM5ZK z96V_PGakMIR%Q9kNYk$j9zK0qg|qU3I#HnL;~X=Z0Jrr(okKVc07C(wm%#%}Ia*-F zRFx_DO%r63^cyP-Z+6#=u2v#&J**Eqi zsSU4>SlCr~3phyAG3=oUU5nvuP!Bz{hGcU@t0R3DN8YtYttLp8fqMY*76NUXn9^nOy4gVBX3| zYnmSxsgs`Ke&YrEeOAsQb$|TQIg@|{nFX^4Wpr9ryO*{(aE13Uw-&sc&OidZfO(?3 zKptx<3$IJjbui!GilPcvtrJhL;&`MiR%kZqNT$RGawn}}0E8 zKw3LNfe&Og5K?c3HTnw-Yfsjgq-?FI@hitLLG2*QrtLe*2}m~=F4e(9y%rLTaTmma zu4>)V7NOdc_}1))y@T!jvz^`c$?4Yi-`gj9|Fx@NlXQ&*6BIiEBw7j(T%71OAe9Gl zhRJiEj5j@OjalirI}3mVq7Waag`NH=%hrGFK$8 zDK97cl^QPX7vcDB@K?pGcNGP@oUo5xL#8|;Liie%*Qr(URZ~fdLl014!K!M8S!-(z z7I;@Qi@+YfQtdL8%dV0su(kLKwtE|uVElrR{D}!Q!9olgr+V4Bws%?OxrH1L z9#}eMo-`~^+vC9lTXU>ms%5A+JzUnSvN|bqgk6NaKeETTB2I81aB?8kYyw}o8plYfmnLE zRHY6e7JW4qyuqqtk)`yq*3_wKG~6|W#r5qfbY&rvFu#^P!L-Za8~{{+15hCt>(+*#!x6`upJ&d_G#$q!p4$%-!Y8nNAwMb&yz;7Y6@hl~>;0hW0+zxGw*8CUNwMst7T%85gvv zap=$qBC4W9chCqaWr#d)c^`EbAiX&2+FkkXyYF6-_1;(92`0=mUGB+JGwV~;07~|r zkDXWB&zTb44cqWBbEe}h9^x-e&v@T1wrAbViXdRx+Sry&>8-_m6&6_r*}z_GU}7g5 z%d_Nq6ub5)a*e)`{bn95FBj%XA;;kYXHiI*Wu4P=nvInn~!bKzG&5S}enRZHh7#)6XNES-LQ z0DU5~lma4z6jcCFZY~QaxD3tm?T1zY*nB)krcTOaJph+QA4n48=>P@$c$MA2fQZNfxAJF2!KkD{OCVI0_P85+|@mo={ z$EHRtTsMdFZ>y5XGnI3N{ohO;|6K+0e?!rFp3HoQg!;hjR(FZ>dzLQIc?DHOR)hPr zrlt4_ZH{`^W@&vUKekv|g3b+*x98&TA0~7ER>HGApVYfajG-1s-B^`ahy+*!Cbx39 zbb{@^S#>l5#SObKT@fDUfz4Q!(-`-hxSzhFu&95u+MxBP-r)Z#y+P}KiUYxPhf8*@ z%G3mFHXA1fnL30ivH(;7VL$AWx$y%rEDodDHIfK^^7bA6?)3TBF8zw}7x9PiuePit zzVCrO)gv++rjjE@F#4*fsB86#JeXP`pMF$b*IR@!j8ElPufq-D3B?-9tzQe(`IXxe2q`~z%elEjdSf^CMo`i9 zvJlPzUr;Kz%EJ>*d&@AUX$ll{avncqDraQC%30PpVcDzzfB zkt=UzqkuP0U%O+)6NL2opOP^Jvw#zNFo24PP1fEs>%yx{2RKl!RbCa5?;|ZC%dS*I zRpt;)jj&Ar#J*W6CF#~vz$8m9VAw<{0iXb$m^ka0TtC&weR+;)E zX|xER;O(dI&1(T?AQ7?1erT<&|ESO5Yz&Av?N_o|_>g6G8bdc4Els)Ss@E^WN7+M- z9u7KZRYi66V!l&jJ%I8-aV>ein4hIuIpe|N`W6f&i!1%%@2B4%?N(0Pdk3eraObrB zZu_7XHthdb{m8KU-Kh^3nsaf1$BRl?8Z*?uxx>eDAk?SPxxy&*NX!?lJ71t*%g%gQ zrN!9=D!5mwpMJDUi31Fj8o{nyrwN^Yntrm1kUK{nyXB>4P`rrsPT!&w1-khV-aoV_ z^mkp{vTeM5@EfmOr(YLuAZzX5A^X|5&y@cUJhgA?_3~gf?GTi&Do#Oq+4QTj#p?9S zmnyzvsbc?9Ie6$@tT6odUamMdU;IcfmSy9hS4CB6x^>t)%JXc+^K8|#K5=1vMtEwj z=gtc`7p4^dh=!DGf|oz_;I@&RIo_ zXufD;cg+$7ro!MY96e_cb>cxO=>4s?yZgda%qQ_h`q28UJ%0D8*|=^wkInJuJT~W{ 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

ZI3tc4V)oa*@ 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

9zp0AX`4jgAl*#<~-0|S1%7= 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�q%p$*FCi4xKc+1H9L4IKnTY?L4bek8~Z! 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 literal 0 HcmV?d00001 diff --git a/eo/contrib/mathsym/test/test.o b/eo/contrib/mathsym/test/test.o new file mode 100644 index 0000000000000000000000000000000000000000..fc16e3ae34df04bb3ff2f80aa8f4e10a19818622 GIT binary patch literal 1768 zcma)6zfTlF6n=AiCo9LVJ4iIa;!Gq$kUb6lh-ZQ*D$x)+8Vk+txo`*U-eqqwU`#L} z25haYZ7lo;C{466v9PqX(9T4yE%1A@^Sq%j`jXlAzW3gI^XAR$Y~NhCrIaEOMGkcl z(Pl1-oY!icMyNzf&%W+_b9cV{*k|X&JFVWoB~?;GN6Pp*?x;KF4i|}X9$oEo+*CGvXNV@wH2!%kY|k5_NEsoH2oVKrI{o2!q)q}one zt6@FuR3krabhaXzUtFrpO-@#(y=m`aW&B1MH2t`8uBP$Sr3uRCROB~fQffQnCtgS` zIn6kwe1R?i<>(~))USbFe05J0SCAE>>(C_@biIS$b3I5K!juDuBK6qq%jfryG6J6n zFLQ0ceVV)8Utl}i>n^MYhOP;kPGFceFw`Qg&|rRUu2vbxJ}3UZN%GK()DNK3B-0JC z(r_~+?}4BCI zue>wJ(Wh+)n2*;Mk=P6zVsq>X2A{5o#A%kDdd$45=OqvDYy@^O)?!sa7y#XKJZRTUY@U>vueCq&wMj{eh zgTvFLRh<7oft15sC3{Yx8}w>gz{L_@2X-IZW}&23G8)WlP=|8%AVW z30Uq5hdvM9cl=CzXKB9%^H~H+IIsgCw literal 0 HcmV?d00001 diff --git a/eo/contrib/mathsym/test/test_compile.cpp b/eo/contrib/mathsym/test/test_compile.cpp new file mode 100644 index 00000000..03efbb0b --- /dev/null +++ b/eo/contrib/mathsym/test/test_compile.cpp @@ -0,0 +1,185 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#include "FunDef.h" +#include "sym_compile.h" + +#include "Dataset.h" +#include "ErrorMeasure.h" +#include "LanguageTable.h" +#include "BoundsCheck.h" +#include "TreeBuilder.h" + +#include + +using namespace std; + +void test_xover(); + +int main() { + Dataset dataset; + dataset.load_data("problem4.dat"); + + cout << "Records/Fields " << dataset.n_records() << ' ' << dataset.n_fields() << endl; + + LanguageTable table; + table.add_function(sum_token, 2); + table.add_function(prod_token, 2); + table.add_function(sum_token, 0); + table.add_function(prod_token, 0); + table.add_function(inv_token, 1); + table.add_function(min_token, 1); + + for (unsigned i = 0; i < dataset.n_fields(); ++i) { + table.add_function( SymVar(i).token(), 0); + } + + TreeBuilder builder(table); + + IntervalBoundsCheck bounds(dataset.input_minima(), dataset.input_maxima() ); + ErrorMeasure measure(dataset, 1.0); + + + unsigned n = 1000; + unsigned k = 0; + + vector pop; + double sumsize = 0; + for (unsigned i = 0; i < n; ++i) { + + Sym sym = builder.build_tree(6, i%2); + pop.push_back(sym); + sumsize += sym.size(); + } + + cout << "Size " << sumsize/pop.size() << endl; + + // shuffle + for (unsigned gen = 0; gen < 10; ++gen) { + random_shuffle(pop.begin(), pop.end()); + for (unsigned i = 0; i < pop.size(); i+=2) { + + unsigned p1 = rng.random(pop[i].size()); + unsigned p2 = rng.random(pop[i+1].size()); + + Sym a = insert_subtree(pop[i], p1, get_subtree(pop[i+1], p2)); + Sym b = insert_subtree(pop[i+1], p2, get_subtree(pop[i], p1)); + + pop[i] = a; + pop[i+1] = b; + + } + cout << gen << ' ' << Sym::get_dag().size() << endl; + } + + vector oldpop; + swap(pop,oldpop); + for (unsigned i = 0; i < oldpop.size(); ++i) { + Sym sym = oldpop[i]; + if (!bounds.in_bounds(sym)) { + k++; + continue; + } + pop.push_back(sym); + } + + cout << "Done" << endl; + + // full compilation + + time_t start_time = time(0); + time_t compile_time; + { + multi_function f = compile(pop); + compile_time = time(0); + vector out(pop.size()); + + for (unsigned j = 0; j < dataset.n_records(); ++j) { + f(&dataset.get_inputs(j)[0], &out[0]); + } + } + + time_t end_time = time(0); + + cout << "Evaluated " << n-k << " syms in " << end_time - start_time << " seconds, compile took " << compile_time - start_time << " seconds" << endl; + + start_time = time(0); + vector funcs; + compile(pop, funcs); + compile_time = time(0); + for (unsigned i = 0; i < pop.size(); ++i) { + + single_function f = funcs[i]; + for (unsigned j = 0; j < dataset.n_records(); ++j) { + f(&dataset.get_inputs(j)[0]); + } + + } + + end_time = time(0); + + cout << "Evaluated " << n-k << " syms in " << end_time - start_time << " seconds, compile took " << compile_time - start_time << " seconds" << endl; + return 0; // skip the 'slow' one-by-one method + start_time = time(0); + for (unsigned i = 0; i < pop.size(); ++i) { + + single_function f = compile(pop[i]); + for (unsigned j = 0; j < dataset.n_records(); ++j) { + f(&dataset.get_inputs(j)[0]); + } + + } + + end_time = time(0); + + cout << "Evaluated " << n-k << " syms in " << end_time - start_time << " seconds" << endl; + +} + +void test_xover() { + Sym c = SymVar(0); + Sym x = c + c * c + c; + + cout << c << endl; + cout << x << endl; + + vector pop; + for (unsigned i = 0; i < x.size(); ++i) { + for (unsigned j = 0; j < x.size(); ++j) { + + Sym s = insert_subtree(x, i, get_subtree(x, j)); + pop.push_back(s); + cout << i << ' ' << j << ' ' << s << endl; + } + } + + x = Sym(); + c = Sym(); + + SymMap& dag = Sym::get_dag(); + + for (SymMap::iterator it = dag.begin(); it != dag.end(); ++it) { + Sym s(it); + cout << s << ' ' << s.refcount() << endl; + } + + + +} + diff --git a/eo/contrib/mathsym/test/test_compile.o b/eo/contrib/mathsym/test/test_compile.o new file mode 100644 index 0000000000000000000000000000000000000000..fab3f3cb2ecf260d4296d6dd0592283e779986ce GIT binary patch literal 380656 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

IQ)@CzyWe-l^w>-}Cyvvv_q5m^{p1E0`&De(h zIgB$oj~lt2=XjY3x`y0je4V*jmX+C@Z8?C$Ih}L3o`-mX4;ZUk$j``Pe2)#-l^=5n zS8z4gaXa_%7_aaKlYSKPUtvYoVheWTC!ET!xSD%;gZG)dd&qf#HQ9o_IFyq(l|OJh zWAzCA67eNw^pZIhzZ(j$3$^ z4;i~x$WO~mEW>8($^M+g>D?QnMjHU?&dX z5Pr=SJi)(tov{am{!j50=4WHJV^{X!WKQFc{GBIwp4XUoV8~6zY%I#^tjA{T%YmHE zW!%I+c!1Y=o6igi`LFU#mSlCl&$jHx$y~|(yvl@wL;s8{%-ZbCo}9p`T*);nkL zSVKZi8fIh>mSQ8eV1EwdOwQv*Zs$2(W`d#4A75u~R%8u!U^jloNnFI`+{WEJ&nt{O zEaWF6wKkSf0(L<&f_Nj$;V7TGUU9*JS@qwY{u^Vl9&02$woO|%)^2#!cuI+z8uEUoWhx0 z%(dLW6THc%Mu$0)G7Z!79oFOrY|p+N%<-JU1^kZdxt;rXlK=1?u?kzU z1BY@Xck?e^;vGIUF7!{t%q+s%{E#!boE!NE|KwTT;RB`|AM$drBpa|fdvO3KaXOcC zH4pF@Z}I`3pAd4>umFp&E*tY>4&;}d&DC7bL%hfbj59IhCSz*8!Cb7!=IqJw{DMpQ z1OMPYUgUKq`8?!5$JdyP@3K1Evn$8&bAHDkxtE7|o%fh%Qpiuv>a53R?7*HJ%rX3m zv$&Rf8GCZbNyO*)GGF7HEXpdZ!Hyinhm1QV^iRx`Ovh||hs9W*oj8b}atgoXD(>bP zUgSf@`oeK#N@isa7G*hBV*|EkHxA$^PT?G`j)V9K=Wro6a|i$7 z(=$VER_0`BR%BDQWgXLM3E!m#KIfnE39e?LuUg2#f z|0d+Wz#PoSvaG}!Jj}m%iFX)lZs?nYFE9(Uu`J)`*PO>?T*EEg%j3Mj`}~ioz72C^ zXKglOD|TUDj^G5&=C|C)LySK!;yDO++NKj$X?!2>+Se|VR17Kb@f@I}7Ka_r1r9K_L_ z!r5HHwcNlHyveFdLVmrdv14KyvW4|79LTYp!F@c<8;rFy^i9sRd^2h!rywh_8e2tu zIVPsRdN9Xx66bIpf8lx_h#Kj0Reh6BeHZc*F)cH&K-9?dYN%_oBfD@YKjD}BnoIaS z*KrdM@hH#o0`Kx6Q!fj1r(<^JW>J>pd#uN1{D9rqlhZhZi@A*3xs%6uig%($j@z@} zhdEO+J9D!rOR_#2vjaPGaMVcOsp_w|j4Qd5dwG#p7;kx)D#_kmu`361 zC?{|-7jOxGs39lXrzOt2!%n}q3^iFufxrC5&dvk_ad9ec4aXYw1a;41En8aWRa z)R*~?kNM2XuwBilk^8(3+pq(Bvp+|39OrNzmvJRGatqJ#BL8EoAHp0j^A+aen=HXH zY|57G${zfbV>p@9IG>BTlY4oN7x~nWVa`NM%M8rPyez{CY{Ay-&HfzCah$_>+{i6F z!V|pA>x{c9%$tB2nT2n$2rIHGoACn<A@_OAy-GRN? zpOZM1^SFrX`5X7~5U)m!-bIib3S%f86 zi*?zJJvp9}xH4*F?w#tryu_=Fy*|wG6jSg;W@AnkW^vYK1GZ&H4&+cy;AAf6kKDrp zyu_=Fy}`Up6E(7*`P7A2mhZA5o3azTawI?Fd@klXZsJ}Z7GVj# z&qi#|4>_2_IhGSSi*vb!zw;0d1Qb>3!zZDIZ-e4eS8h1pn4`jz4b9L}ZO%&W}0FFda@`)~}WaV@v;6t6Jr{?Mly zyKyXk;%+`>>I3HH`y9cQJk5j$!}i%(o}D>^3%H(t@Ho%&CLb~3q0m1yGcgy-vMO7# z3qRpRF63h-`ZM&;z&BWuqxm_%;(V^)uiVZfJi&)db~xk}VHs9oJ+@#ce#}ofh6}is zX^({d8JQ(&)aTdSl z58TEbJj#>2!W)eDSC~H`pJhsBVpdjWb+%@Ee$0Lx&XN3r)AB!7GPyoXJa;J zdw$4%9K>0i%eCCV{rr>Xd5Mo0`)rsqF_SSZGq429uqNxU9Xqif2XPXoavm3PHP>x_5N{7l32%*R43%Xit3P1%+m*@pu-lizSTf8_7n#nU{`+q}>Cm%{vsnTc7M zpKq}WYp^{(WIqn#SWe_zF5oJz;V$muF`nX8-eih@!u&5XGhb&BmS8p3VrPED!5q#n zIGqc*lpDC2ySR^k@f_n{cD$L2X_=e(SdJChge};G-T4Vea}uX=9v5*3_wXdo@D}ee z;g!hzk)I2_#9C~}L7dMO+{0Upb2aoy%v4OvLafB@?9b60$HiRFe|U?ruZ6s)_zLs0 zF$CC0=FX>me^4%d#{w^b2AU|0v|BRozVYTzQ~tZh;`V6ZTKUyF_vO=zQEqAar~U~xQHwH6SwepUgb?DejMgY#;kmUMOl*d*pThmi9V}3_TV^v&N-aNpZE(8@hI=` z0TV>NnT}p>N%%5fVJ^POvV4~{S%)pzhM#f_zvS0k!Bza7yLgrt_%CB(hq+(oE6l|= zS%PI)hxOTp9XNnPIGW=)gR{AbTX~R2c$GI9J5HGUDW+#8=4Am^Vl}pAdwvo%@_I6v zbGVGZa5qozAKqu8xS>y4W@AB?W&^fm4-Vm2&gT!@$b&q~8+^>yGOWNFtj!i|%~4UGjfok{DN!T$!8crCeHGVQ->?3Y*LaKZ6NSEsnT6R{ zh=o~|HQAIc*@pu-jWf7}-*X#x@F-96Ht#cjV)HUv)W~tj&$?{RfgHsjxr0Y}fk~2t zei>Pfz4=+x=VD?eaGLe`++zKAp0IvfeV@sm4t<_uX1>lctiU>~&yMWE0UW|wJqvSU+lHKZfvYZsR?sOdhsN$3iT{#vH`e{EbI>nwO%ci2U6i?^=KU znUIr{`B*sW^D!~SS>AeWHe+{=iW=E|EWhPKuI5_q;Q^lE-@L;IeEQkY{~5l-m-z;B zu_o)VEjzL=2Xb=M$az^DHS#{Pj2o~AM@GgLcjFP!FO1Jb=ZB{G z=RZ~ah>`0oXVl1jx;1L#{o~aH5hL$ojiW~1Z>L9%ybte=8u?tjD{;igaepT!V*Z$z z54o26qZWvXxvYL1F?PY2nAc*3?b~r+)W~*Us+UBJZnsAr`Ss_M{*jm6C)-7K=Sf{4 zVsyK?QQwb=*=9XfX`EBhT9sH8T8>sPD$aJo0#g$T5rkO62t` zV)S`gqDK0Zi>^nWS3hd~$oHYvzl<8$ZiRYR^zq1cN#aF}^nWI5gP52Xqc)6*N$Ggx zc6^GfYdAhxqed1>ThAM{sk?ZK1 z`c~A)^_4t&UL*M_qDHQ}T zpOL5j|8b49 zN&UZ^$Wxxw>G{9?ev%h?{u|bx`*?^)d6H*%jkkD@|1$F9m~cNZ z@@>?UI`Z-Oi7zq@(=!vZ@(t$Vn=HmsEXRth%9^ah`fL?7N#yvm6T7lM2Xi<_a&pwj L>%cV5;B5XMfA1?< literal 0 HcmV?d00001 diff --git a/eo/contrib/mathsym/test/testeo.cpp b/eo/contrib/mathsym/test/testeo.cpp new file mode 100644 index 00000000..ef6dd3dd --- /dev/null +++ b/eo/contrib/mathsym/test/testeo.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2005 Maarten Keijzer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "LanguageTable.h" +#include "TreeBuilder.h" +#include "FunDef.h" +#include "Dataset.h" + +#include "eoSymInit.h" +#include "eoSym.h" +#include "eoPop.h" +#include "eoSymMutate.h" +#include "eoSymCrossover.h" +#include "eoSymEval.h" + +typedef EoSym EoType; + +int main() { + + LanguageTable table; + table.add_function(sum_token, 2); + table.add_function(prod_token, 2); + table.add_function(inv_token, 1); + table.add_function(min_token, 1); + table.add_function( SymVar(0).token(), 0); + + table.add_function(tan_token, 1); + + table.add_function(sum_token, 0); + table.add_function(prod_token, 0); + + TreeBuilder builder(table); + + eoSymInit init(builder); + + eoPop pop(10, init); + + for (unsigned i = 0; i < pop.size(); ++i) { + // write out pretty printed + cout << (Sym) pop[i] << endl; + } + + BiasedNodeSelector node_selector; + eoSymSubtreeMutate mutate1(builder, node_selector); + eoSymNodeMutate mutate2(table); + + cout << "****** MUTATION ************" << endl; + + for (unsigned i = 0; i < pop.size(); ++i) { + + cout << "Before " << (Sym) pop[i] << endl; + mutate1(pop[i]); + cout << "After 1 " << (Sym) pop[i] << endl; + mutate2(pop[i]); + cout << "After 2 " << (Sym) pop[i] << endl; + } + + cout << "****** CROSSOVER ***********" << endl; + + eoQuadSubtreeCrossover quad(node_selector); + eoBinSubtreeCrossover bin(node_selector); + eoBinHomologousCrossover hom; + + for (unsigned i = 0; i < pop.size()-1; ++i) { + cout << "Before " << (Sym) pop[i] << endl; + cout << "Before " << (Sym) pop[i+1] << endl; + + hom(pop[i], pop[i+1]); + + cout << "After hom " << (Sym) pop[i] << endl; + cout << "After hom " << (Sym) pop[i+1] << endl; + + + quad(pop[i], pop[i+1]); + + cout << "After quad " << (Sym) pop[i] << endl; + cout << "After quad " << (Sym) pop[i+1] << endl; + + bin(pop[i], pop[i+1]); + + cout << "After bin " << (Sym) pop[i] << endl; + cout << "After bin " << (Sym) pop[i+1] << endl; + + cout << endl; + } + + cout << "****** Evaluation **********" << endl; + + Dataset dataset; + dataset.load_data("problem4.dat"); + IntervalBoundsCheck check(dataset.input_minima(), dataset.input_maxima()); + ErrorMeasure measure(dataset, 0.90, ErrorMeasure::mean_squared_scaled); + + eoSymPopEval evaluator(check, measure); + + eoPop dummy; + evaluator(pop, dummy); + + for (unsigned i = 0; i < pop.size(); ++i) { + cout << pop[i] << endl; + } + +} + diff --git a/eo/contrib/mathsym/test/testeo.o b/eo/contrib/mathsym/test/testeo.o new file mode 100644 index 0000000000000000000000000000000000000000..c60cf5dd539f739b407d86ed46bbabc4de09cc71 GIT binary patch literal 706724 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�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

7ea&7=ZGRhbRXp@4)1r;RW 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

v5gdgtTaOUzhR`GT^ zcqc1ft>C>Yco!<(xvT8YdABRQ1<oX#tq2#upm=Y79ppVv|dJ(bv%N8E+`wIPkb#_*C#tI6R&oSAvHw zLwIm}XDYp0p!ag96{X7z=*fJWgmBM*9+k@u$awaHn-p)^_w0UkqvEXwkIP#}!P}&G zkAr9HKR>Q`>qWYB61==4;_0#jJS1s&aJqb|cpC+;v*4Yhcn98M??0ajJ(+%+1h0$W z-KcmY!Rr@V7v;xwinj$kZWp==UiX4{d~3lYf8m4U+gK3SOGED%R>GO}YN03Nu}#Ed zKN0RdiuWz>P?dxS^VUL7^0o`!0fM*3k#YMT0B>4Ii|qSE@pg!GIY{tMRJ_jLx3|-m zD81g$!=rO}a6FbmPsXETZB#D1i*Pq9-bnC{3u#e2HYr|L!8=&+3Xh7X%UtmKTX=n; zC++Jdc!vnyJjJ^iJllKh*^1Xg@OlW|HpP1wyi$vOFDqV8@VGuWT=2T1GYT=Br_l8W z_V^wMJsIB-!oC8*o2qytz_ayFuUC3wpobzD9v#eI*QjvEiExh=;r?9lW`SqxU;R|^ zCJEj#g7=}~EphO6C|9>35If zRS6!=748TNsQ!9Q@tyk!FwsEOfl-_jc+4AiL74C8oZjlK0KoowNF6V(Yir4ivd%oSSc$2{6e$#Nldr9#I zfM=^upI5wc!5blX$A3AVezU-{mGdt{Pp01t!5b-fH!9u|@ND^eo#Isq-YCJ_r&rv* zTfno`YkNUY+E*)hV+3!C;%xxW)?b^bcxk~KCwSjfyzSuG%F)*qZ;9ZI7rai##pB!M zc6)!V1N3BkmkZtm!7Ej~!Qk2Ip;Hxa1$f+FJ5})htaw%6bw)YjgUj1A3>M(Fu)eB= z-auBune|GcC*!e7#AC7u_g2Nb1w5NyeNXXL3*HpL+pc&U!L#Mtn~Jwq@JB?y&p8ROre0 zcCC-<(;0$ywc^!+XY+&06|bA%ohx{+Dc;rK+5G+`#p@w>GX-x53agCo!{BwXq~Enl z?{Vna{NO6+$#m%{!mSkHKBRbm125ka?ng>*2lUXT2@m$af2eT#h;V0%a7UaFkMF^E z+Mj2JLQlq{Nbu$g-dx4&1K!Zky2zia6mNv!%@e#oDqa}o z0X-RyaU$G05$?r`cO!Uv_g^E`zcrAkWw&HCE&-UK$4aG}?w?C4Z`iTn# zZ{dJ=d<*W*_YR;+&m5c|&CrwaT@GFWIK*2lcz;&B0r%P4)sd)7a9ikC!=Y#M=i$(k z;jV6s@@GJ0P)SxXT>j{#%8+R)l+z2={!&dk{QZ{w{!?jK?~`yIAmE zQoLutv(DnTs>$?@`c`_H7ir%LMOI#T)q(d%j(yc$)-| z)^L)GQGe@W#ajU0sTTV_P`oYR6+n;t?<&Eo861!A2Jmd@R}DQG-yOm}T8ql|-LH7B zJ9zgh-cG^0R`B`_iQCt8oqhc845c>!dIwq3r5t)P9v#n%%Et{N+`ANSJb1S9cDv$r z6}%e-uNQ8H7?$6q4qi{_N&C79-b%r{)9~0I9|W(fh%e;_9k(f75AY7g@8kzJ3Ene` z_cC~B0>Y!f{Ix~#iooOk-_3&8VOS7fwy)s+e2*D~;=li`cr%23-x9pxiZ{x^8w@>} zerds5C3p>rHxoQt`ps9o6@vF&!MjWGY8|}W6>qiR-6D9eE8Zdp?^VTHFL*x?yq?43 z`LW!=D}bI%zb%5dTJWYR-VNZ%@dK#($13I*t`}eH(ccnK9dOd@n z{QtAwaVN&(TLnGYzi0c-QhK*Qj~N8yzpqnz8=!X}DVT$K>y+M8(Cf}hIJ4f1O7BhR zahWA`{=4^xcs#Z{^v*YWolIEoLa);NO(!mg3!o?ScRTWz$~n~s_rN#`m)e>86tDcJ zcHZ5J*P|)o-6wc&E8c?+-W!THN$}PQ-q9xo>B8~t@u1zlBcLbayF~CF5WF)LZy9)B zz;!-2{Z3cBwcuR|B}%^s1@9)syXj~7-W?3XnRz!VUQu(j&iWz2+oX7-9p`mZ-d~SuXvAwH^E}x z0>xV;?0ZD;?p3^fe{Nrw`Xj|#2VO6eej5ev&x*GIJX?8tMe(+R$K{Ro+~D$d@X7J~ zcn&<t{DB z-b(QHN4ONdkef~hT+V-(TcYgJodk* z1#g?;o%?XUS8L(Dtaw|&CEY@b(=SkMA-EuM6~Ke0K=mHo+UNcx%8TzvqL~Z?NJO zEr`nR>w;IQcpJdOBYSuhn7>krHwnBmaE;RMO~JcN@w{Kzc^50*YQcL;@K!6{Q1GZ8 z;)CORi{kABkITn)!TY`9O?B{ot9U&ZM!dfX-ai#@E_gP7eoyfxfmeV?Q2MXmzzFHZ#ndA?N+1GyBd0j6UZFQtA(EQzgpPG_2~{_-wlel2E1b!hBNb4 zDBcpm`={XDuXs;_S8d_lt9UEG8wx#2zYhiPImIh_#6BMJwBl_9kJ6cV{}Q}^Dc%I| zPPf?iPsQ5=9=De}1@Ex&@%;TRco@P94^F=?K~Lt#Ho^P1;EhqdryTJesdzg@d@0iq zZ9o3cE8gqi?GsuTn3>l zg115O#({UN#lH25*AqPUgFOZB!U^&C&I2!P;Vp)qjBg+CdO?r;YA?b2sp7o|9_jJH z@%@S7m5cc9EqGfMuhT|5?-|9b61;r`Z;z6AeEWfC8>jw6@zNsw_7l9`iZ{Yx-?7k> z>9<7KcYxrPDP9$LwsJH@@m7Gxhp^Bp?Dhw?@NOBzT%An&z8UMDBdQ)J5=xvL*!5`h2yNH;K}h9sQSm3 zptqO#n@(EYW6+F)0BLr`W;;jJB<}ZsBZ-?L=DR_4(-UbKn zHpT0@II{0(!FxvWb~t!j6tAb?9V2+1CdTul*Q56Mc7UGDj}e0RWx*>_ycyu(RY!P0 z)j#?xUO9N&k2p^7&QZJ@!K({tQ9E;{;#Gmi&r!z<-sOttJ!XF{yF~F;g2(-czJhm` z;-$gsVzKXb#oGj4XXsIVe}drsQSp|7XY=PjDBc$E*q;jpFK<#je{XZd_fy5&F5){- z@CGQ}A&=YR+YfruUwWP&#dnb4%~rgg;Mty&XDMDE@Hjt)2;SEf?`DU6Usb#+Vc#&p z`;FrLz+vC76|Yvcs(b_^LM0!R{%YkAL|6~WWk%N zc(Wb6Ns6~o@J0*X62-d?JZpWbcw4|@e;zA%cPic^;MvN@ZHl*D@QMZRdBuARJe&Xh zN%1;f5c%IJg12{RJU`BT!d^c1gr3Zg5#VusP$GDv6mKqgHv2{>-Z)|3M8RuRysZxV zY87vZuy3;9{ZR2@O+7t5CeNz_aK|7r-V(uU7QE*a?@92Ew%GTy;w=}v7Qs8IJf1G^frqRN54LX@ z^kjTjfXDf}Q1Ip|-nh+<`c(1O3Hufc-pz_v3f`E|y6E|1rQ)pzkL#BU1n*JByTM`K zBZ{|0*mt4eeWZBb0*}4*UbKNN2(c>CiDJ%3yzc=ut@Qu^s5;58ctotSqw^kjZ) z2ans2iv@3s;tl?TJwG-pUeBeGKVK?%A1mG{@ND*dpm=@2WBV=>yu+r)to?{gr1D=R>4~( zctaKMY4G}4ctwi04Lq*bzAJe5D_+Mfc0cWWc03+kp?8oa+>X$b@z^2a@qH2QX^K|> z-fQB;qw z5%E}ZPCVSD;0?9#7C}$)x(eQ%g7=o4|gVbCx*1BoR5Q^wBNcAB$d7d*+|y^qHpQz4&*slBD_&ag)(hVF zS@C$>2A<8I$3Rcow*)-)=Z6Jvz2f}~Je!|BsCX*{Z-d|ssEpe;;ZOGVw;%MReQQO0 z9}&E?;>`ok<}Zzkw@&aj3f`THw+cL4J$YzVJRU!Qo~^$BBJ^ZD){Af-6X8x%ya&Lu zJ-?MI-bV1a{QgGpu2a0%!5eMy)2kJ43wQ<4qk8SPg4eY=9^YQi*weW)^kjT@2>X5~ zcuk6T7I^zw?AxUD=0eZr&yTBcJ1&d-d9w(&YIZyx>%l9rggX;@G9Eny?a<5>~zS##s@SO;Fcg*P2~G9KmNk>8X5Jui5#E8bDh+5P!d#aj+uf#JO%c&VDW zeO2Hsx7c?!^rU^Og?%px-b0G_CU`bKeL(THfXDUjD}wixd2#zjJa6~YGU!SBwhP{C zg7*)_yBxeDE%E)k;&r?@^3y*H-bwT0_N@WW=BLA;C++JB9{cGVg7+Q8+Xfz9WrYV+ z{o|X8*F)I%7s2~f@%nGg_bv@-Q9t5i#p?+k``_Dwm#U4&cO7`&xA4w}o{VofcoU#U z{`^5hT;{ynD5L?^ayLPI>+p;D&FC*+3StP ziZ@Bb_i({`Q}M=wS7@)CKYQE&^{~3vZ3myBvC5EPDA1MA+`f@-*vE&Cgr2l- z5_s${y##NS;#~>eEE7jMaeQx9ycysfY~tHn@b+IEx9=_RZ0Wp2>Ft0Xn$Ymza2G*O z#v?7#rLPG0Uy4`troFzJaDLprTIih|h8o3p9Q0(kD@FRzx1_oKy-D%bI>Ozi^wvS| zV@tR%t8iB%+?miLzZxjQ-S2{UJns36J)QT4o{UGw%c6R1kl>xDcn>*v4N7k#^!i%j zF<*t-RfIcKgu71h-gEH&qVx*h%J)vNg!^X|Za0L>et)6}_lry7={FTTo1Y#8J(+$z zMLbRtyzz>67I^s<`>t1dGod%sqIZo7w~q*Sln8g<3*+&)*}>}qJsFQ8!5brZH!9v{ z@ND(-b&5Aar1Lnz`$+LRyltRe#x^+?q7cRPdUX#qAsZH}tP8@vVoRw6DkIQGBNg-Uo_z#yj@>ExR}# z?ri8ygnfK)Jf=WThMPvX1yG`NE)(JYkK)}2-jxi)nR&ldyp`Zlc_ZHGf_KIxfqi`6 zh%cWEl|9z;BmWprr>>F@uoU>-%-3Bf_Jvy zZBo3M;F16FQDFXfT=BYI5#`4@g7>!K-QwWAp?G}+FC}>UTpG`h$H9~3oYQYF=*j$; z1Rm!{h2RZVyq6vJ4N$xp!oEtuo27UKf48UKxr(<$@Tvvxdc~XR;9aA5s|0V3;Qd_j zt_08Ke?L{c_29Ap)d=3-6z>-B*hk1!`0uwAZ;Rl~7reul$Mbgscs&SYjy=q|ROxMn z-l437GwWTb^ge)IH;dj6mEPX(VgC|~-jhnN0D3mwKb2k)^bWA_4!tZM-(u*=_Ko8) zOzBO5-kug-xzd{sy@M=z7bv|N=xVk!Byh<#zZ% ze_W$_caiXew^g`rf+y3N%lsRP*W=2l9y(v}j=Vgc&ffcW-eJ&__Kgs{C4zUF;vMYZ zO;)@ag11!gE>gVy4&DWdw?y!k3ErKGH^ITXP4QL<-X((fN5z{7o~$=GKmMS2>%rrC zce&v0RJ=xqeIF{`CSl*@f_KyvLH>3!ezqJu>G$k^heJ>1?{@IWcJjX~1#gPt-3;C_ zhD|5tO;o%cf_Jsx{Yvp32Jd(a?-z=f5S{hr0p1UKT&N0D6*_7V%gu zcxx2zO$Tqa;w=}v+XU|qinsqi?ay1kQ@oWTzH0<;r{WzBo-Mu~D&8t#-<^W@1s(9}@;`@l=RSDj&1#kMwxP3i8ia#H5Ie$~>^@H9(OFXtg zPsXEGr1Rq<-0okGhdax`I}m!3w_Na^5WI1UcawuRO7T_+-X_6oQM@M{yz>-qo!~tw zc(*Cuza6|EDBdQ)+bnp`D&By9+4JL%inmSho)WySH^uW~Hh2eF^0zbeWPa=fkNtj& z;GLm(=YyAT;jK}6%b;f~AFEZk9j}SP{gVjyuy4fU@m=r=E#ZC%dNLke!P_5tRDPco zyh{{sGkAE_5guGVmMUHk@Cu+syype)A;p{Yu{~W5yg43^X%4+QrFRDOhKANf?PU%0 zWPC@6^m|Fz_k!Zx0A87e_pIWL1MgrH-&X|hoNvbCu?;-(7d|-sexdZXL(kT({tS9D z9y3I^+eEmdzZDO6_)hyg!IPjTd1;X@uM6I_iZ=s1n_pd}cuNHDO~Lzv;#~*c5u7ME zbGrOa@s8Y9BY5X1-cE;oXF^Zfw@UE-E_mNiyrVv`$Mxxo{aB0!TUh)Rw~{a@P=A=Hz?kE!TU(?_Wf?$zL&wX)dyXmC+*t^ z9@hsS3*L_uujt?Q`M`H5-d4f;MDQkmFK*vb@NE890zGNp4iVo^1@9Y*cMEuvE$R0) z#oH-(d!Ww8e||mpFU9*Cc%v-5e=1(b6;b--3EsS0;_>bGsokGvLr=!H2YB30=L_D0 zidPPvE&bLhUQfZ>Q}Dj<{kVM#9QKtfy;TmqsnC=0=p(}IBEtP&#e2jNkKZd^k>GU| zyy_psKU%~sM;&s6c;;~+IbTEJZLGi|c$K_~$!8`NTxP7JI+4^gz zLr>Z_L)dqq;N7iwv%otpGB0e8?o_-g!Rsb?-B-u$TLIoc3-3VaN&9LAue;!_QM?Tf z-fG253*Nzkck&P8_U!;~ti`?)p(pKI0v`7h4-vd|iZ^tRPS$?xJ&LzN*w;hw{;GJ> z!Ly~`Ulebpuvmf_zE^|yh9$oHLr=zcHF%4lNB!6W!8=LunmTl{_J@WkUXN>| z^gBxM?ohnd;Qh{G-wze94|o%deLV%Q@b-9ooANq&GcCNn(39~^gI8d9#|qvr6z?hU z&am))rg$sCy{o^*pTQ7Kh z1aGtARXKQ@6mOH@^%J}g6mJ=Ly@Y)Q=I{3vZ!36ojr^~_;2m{GkbWHB4G!Mn(39!6 zQ}6}|-ekq|^6mDOC|-~2BKwL2?*hde<=`z;yb*#oSn%#ryk!pF?TR-;@P-QBD~h)U zysjn>=mb^&ctP=&fXDtkT=06_8PAV(;B__(Ix+8H=AeiSqlI39`TH`Zm)EINY=3X&{Z#242|bE0AFTJ9(i;Z7?yQ6}>+N$_JYA+h zPqx#nSETf2IrPp}dM(h~&l2uZrMDb<`&#r?E4`bcNBO}A=ix2Tllit<_`xY6-yS!- zP6n_BJehA?USCmqcSCP)4isnB+iz`%ONwz6bv(9*-W- zqx}7f;JvMQw}2<>1LnPnI&$@(7qtBTk0hR6@91n=*P*Jqzj9=eX< z!SVg8;&la&({Hxmop)~#U%qb(c%4I9)V|e0PsXb`hx-;Lr=!HO7Q9hZ>HkyaPVd*URv-P1#gw&?R4;N zR=nkc*Ccpb6tCmH_Wa$fcq;`jEqI-O5>LMZ@Ct;#@ZTep-YAD&qtcrRy`C1{8l`s& z^p3UYy{hzHhF%|w-cjpRJof7pTX(|os8o8Bp+|nt2UiW(7(H&!&xPJWtb{X{uPdM@ z{c1JRnaUfLqYFhk->Y~{;K_2yycd+-`Ow?f67I7q+_fUyWg^_Y?hn!>&oHh850}G( z|IUY=jK?~`yF~E186E>xfH!jhOHuu@zv8V2@0KHibXhKV#~2>RfBWc8-o`^Sc}FVV zjC;Cx%aDMS&X)_`KxN-O=XCPEa!17D{5?VOwmul;+m(WMisJ3L=bqkX(UE1|SjF20 z-UjHAeOC+KbjABq_dUH8qC?KS3Z+-sch4vi_>1+(QC>g05}(W@m51>7Msh#DVwWqw+$&B6%y{>FoXbTDl`Rn8z}oX7U zRq$(GECjj^BgByx>#@^yF0Fij=kQsP!rdd|e%V8!`(@9bGx3b;Yu!0@=;3esbpEhQh2@8_2ZP>Tgk^Oxv!E>P;#M?2P%1x zl7}c+zF{JJPgK`WQu4`49S1Wmrl53PaU&(b!Zcy@hN^Vwii;@>Ad9ji&Q1XRJzDUUzEBR6-U#8?Mlzf$v zuTiq7AaNznyIx)Ys*=B^uDf#ib`Di5{qvS6u`8XvXujIZ;K0(QaN*<`> zA|(%2@=zrYSMmrYk5uv~C67_^I3$9~%Qq?go0a@6C9hKQ zca?mLl7FD&)k?li$+s(cjgs$B@|{Y)OUY}M{G&atq!t3dHd@o;Zl(WYCEugu`;@#+ z$qy*`K_x$=B^Sjiid{D_h_D)~_*Kd$88DESE`Z&EUSsXjXLyv<6cFU3bkp0`EG zPb>KuB|oR+txA4T$uBGURV8mz^6N@|Q^{{BdApM7OV!bl=YMHh%I~S`?<;wSlK-jX z50(5cCGS-7zm*&tIzs=UgB(hNoTub`CGV-^y_CGSlJ`;aeo8(-$p{RmK1InTN}j0X$x5E0`64A>tmI3Te3_E3Q1VquzFNuGDEV3?U$5jF zluRSs(UIrTmtvwL&!aEBL`R-SUuubtJdeJ#5*>LSeJLe6@;v&|Np$3SwkpuzBCXWdETQ+eoV=~QSxt<{5vK8Udfx4Ogq;{ z2l^vQrk&%XBhPzA$BEijrSb@}HIbhLZoH}A)%F%)MQ}{1B&>vAU?N}Tgc%P(X+A%mf@;ut{H#+dX zNXfM0Zgk{%`ziSVCDYEf(UIrT&a}~i@fRi2&alye_eDykomrzJ&!e4Hqa)8NQ1Veq zK3d5=m3*v{dnviMlKUu`cI1qXJnsZ0)6SXEk>?Fi@<1gIQt}Wb(@v7nk>?Fp@`*}5 zNy#TGd6bgJD0!Tc$1C|1B~MUtiIPuM@+2kG&VA95=h4o4(UIp(Q*xP-Pgn9+luSF! zMMs`@wvx|La!Sb+O0HBg?Qj+yc^>Uh79DvW?JyP{c^>T$79DwBos#R7+@Rz}C7-9{ zCM7p3Ij!UtB`;9&LM7AAR?(5?(au!Sk>}CQQqhs;(auoOk>@Q_@+C@MuH?&=e5I1F zR`LoZU#H~jmHbsD->Br3O8&Z%zoBH>(Iz_Z{z}Q;QS$ec{Cy?=K*_6>e4CQjDEUq$ zuT}EhO1?+Q_bT}(O1@voKUMP2l>CsAf3D>9O8$kCf2rhODVcU~h>kpuc3_B(Jnu0j zKd$5_l)OpFPbzt{lAlsCt<;Z>Jnv~G|4GTuD*1UOzo6t7mHd*DUs3XFO5UdA*OmOH zlHXGDb|uq_<><)s-cj=3mHfVv|Dog$l>CvBKUVT5O8!*Iv|=ta}1xlus zVbPK2(aNsq$n$7rR&-##jgosSnN~JMN1jJ3lcFQfUs)t&S{W1_c^<9oiHEDEU++(~64d z!2BB}Pf_wzCDRIp=*aVEg+X-Wd9*?xIxrtc$uvVhI?#Vo@(d-Pqhy*HA02t#OeNFI z^ytX*Xl8kI@h?>gdSxXl8VDIO-p{hs?5a}c|DMv^S2&9oh69p8ciHImxP((!(v7utGh>8j}z=qgG#SV7;KeNy0 za=VvHL4AM!edYb+JM&E0*=ajFyJzJ^X|ppqa`-K?vp912t?5yEMwFfzrDsLy*-`rZ zC_N`in;o~2!*9)v((~fX4wau|zn9rrS8~6X+36ZN{Fd3N8ae#VPE)rwJ4GXh-`VNu z)|W>4FOSlf#XTG`cXkuLfHr&7YRiKn_YM)W+whYpd-o0q<6qmgB5$<&+ucUHpP(D< zegbav*@RD)zXP(LE&Rl|j-&fnqoU#uKap+V`1i9GbFhdKKF2d<@8bx$uhCnT|fe z`T_ruj&5W%bB%Z=y|HMs=R96^4bJ!IE>?Jknc##!$@zwk{OP=79I%>Lb-3cq9slK4 zxX0A^I$GftsQN7H3hY&PwjOrX7?YnDqx9}5eIQEPN15E{VZv97(hZ_?hbWyAr5B5qDIi}iXpBC=(RW+DJ^n4N(dg=q{~#+1t?{Q= z7opD<|9Gprbq(6=^bE)sMV~@zeur7R(ajzIA=c+;y`D9#DwV}Uj>hsYAa78#M0arX z7AqBPY|QzNMw^|~0og@68{Nv$PgpmjO??hn&sZ;@+d29lU=0Z_s)G zZFbfLq*Z@}E^u_3^&?vA@88y`)x<*%y}kk8Q1mI{7O;l%?PC zXv?Z4?Koh~@|}-1X7Sc7zH8BXJvUm9piRFJuViqrN9^Q@C^s=ot(3;*B-_PhYv6t&*oh0M7IW)ZjtB*(LT6rFQzI6k-iG+!_ zuJb*G*7QQw=V%>2i>z98Ozh$Kr&?V+dXkmt(KD=T&}}44ymgIlGurGF4p@&^+tGSH z5Bd(E%}&68wbfVKbkuTelz(FHYloiZ=qG%`(S05LjBgfN&;K#&8n5;}<oRvA7qkr)| zh}QJ~@@LL%R{$xSI6ZqfeE;16E^u5L)B=+BXrc=hMudhfZ?rf443}pXBJDeAl7d ziH^6v@ZFBq^Zm`Y1zq6S|7ksg*6W>a?e+MdW&em4b0@!bO~yD({u9u{hp!vj zq#v-3vInCdb@VRlLbRqo$iB{_$J!5|O|k*m55E_!<&$Fnj5g&PZ|(QhFcVifOkU!x z&wNeMVYhBkdUBM$9If%E*$<%gdhheSiPrL;WFJQB_^{9Nn}J^r9sl=RP0;H9fpxk^ ze{Oa0*dMTh9{(?_T(oIV0qdZ(06oFc-&h+w`aA12w8?`hgJ02Fem__>8X6xxjDK&m zw)aEU`RIY-7qEV|uJq_%t!?PRj{lF=VUPaGs%r*bIaXHr>qCjTE4mVALvSs|MONK(-7oP`xmX1XtmF? zccb-sC)nSiwLX2~tJGM-nrJZ@THDX-)lyUPmdXEnR;_sXLk{)-$ZC()>-CA1jyBl}SSS0=N4IhGH2Zo__-4N6Joc@8A9(Cf z@Wq*knJ95XSL!#D@5cD`%T+8+$??M7?=ndqz4 z%rVD)kgqpd?NfYf&}u)-_XAq{>o0wOqP6|{d?%QKk;6F4c;oAh9_r{izC5(%zlv`q zTF>uj-xjn%z-r_>!BiAE^!%#%E<@lVwf>#z+m0SCegW$|Uw6~7$f4yw z#+Q!P@*MBmfY$Py;5&fU^G)|1Z3;pTJ)e*-0j=@1@GV4}%NVdG`nI6;e1GsghSu^) z@co9?_?Fsw`|GJ6@iucKGnx1+T@*4giS?5Ft7G!tDpG`$t}OmuZ|3s_mc z`_NjSvweS{wY&=K_U1y$q4^u(F{V zAGSY1Yk6$7Pcau>4o&Y?dm>uPce3w7w1Lcb?QhU(|GeGLBrJ#KZ;tN{kDlwR-d_Fn ze9!l#pf&vqeOIE5m8rkCq4oUc`+kn{Kgx7m9LByLTJu}r>xMo~`~udA_E>axNAIw= zqcuO9?OGi*vTVn{m3<0Y>-)vNQRr@t|3cr*Xg%LWzN5__a-1vwq<#Cwqc!|8-!&e+ z+~@1;nA88P@EwoV{9o=Hj@J0E@IC3#SNcvrQ^Th?>Fu)bMdvvBUAx6u>aXYfzI_>b zf#d&y{T5ooe`t?8TkW;Jykc)bn_`#s82d%EUay^YjV@|`vE%=hJsQ2v(Fg6lXj6>? z*0*-cbJTvbqrbN|pf7jyk9Lc$>TmwvT+i-NdJ5WH&v@%D-vV?sN00VjA7#G{UEA^B z^ z=lE~--Qdx8`}U%>eZJuP7H#4SScmNTJ>(BL)c-}_8R$LY7O-CSrK63FxgOb3dOdoe zWB;n}1@vG?zvMfJ*8Xsp@3fxcA&0h)*M0Y(jhl)8QM5U~fb2(m!()HE{TaH@@vm%G z>m`54(OCY;eA3q%-Nw+pKR$^Ox3Ezci)%g|=n4ak1G7txa(eTqM=j|m+v|E~VkXl;MJ z{0Gt6U-$91@2mEe1OcnBe>hs(V{iW&j}G`hMQeOb{9TeYd}}BC3I2!BO&y)=e-WMR zGx4A6?_n;K9Gm1{ze1=; zbhNQD*MA9Gug56+7LOigKZ(}z7;S&x(If1?J@)Dd zx~>!cLjNyl4L`)LX9`9RwSUy#1FiOR{NvDSAG9y<*gxjK$74U+|GLLM)BYKKnxql1 zuJB(x+)0k|$hJR4YyRijOGl``mdDfn@6ek5Hhdn?*>+X3rxyTfSXYp#XSSJ)HKrdtZg z`x>{Rjg3kFF0{Gr3ds8!JJ4DlH`t$}TRZ-1?bI>yha6_U6Oi{gR-yI!?Dp?OS91Js zva63Z*5Uip_4Y`#hTr3V7_H~C$v$J_3b^N#3 zQ_!6p{g}NKt?@r$pDJ0|M6D_GM^I?`{7F=<^-_cm2nhj$aNR*IDO56h0 z`~ID1tzWhLjV3$h*w^(>Myvfk|J`V{|JeUKTIVJykf6(6x-PzGU`&XbfzF+-^(A^w=f83C%@`oH6{;0TR9$h8wFuIP|1gzR|9kU#B z?w`B)Z}#XO{@U5*&+{H=?yX&hWpD?&|or z@gHvt2>rkiSmCFeY%7VSe^Wp^Gr;Z^XDFZQM-! z1ETcEC_Obw&qXIn*no9h+@Bs@KW^SM6SL*)6O!v0_Y?X=O$U%-0Yf0{=>=^x_JyZm_`{kngJN5AafGo0*@pZom@Xf5B?alO!{`~uc3{!t!%n?DC#)$uJ=)aIfPA6*QM9S+@m8O>ooI7e1J-8$ zezf)%qvH;vclwO~n7Aqzy5k=lcM|$UC;W)Gj%aO@vk0t>O!^e>BLtv?rL-kN7s!rzdvsd^*AoN zJ<`$5#^?{cl1&*ltb`WqP2gS6So#^ z<`?nS`EfhZr#X6d+~4R^96c+p#d7&Wj;8W2-kKRV1l`2ZGvbOodV1WoXz_N==bk8S z6^055L%FTf^YX0Vc`1dRg2Bw(%$&?ZQSB0f!GglH!p!ubamh@}%A74KHz$~ulM&32 zfcZt~j&75gX$6CY=@Wx(B;0ue`z5B#%5GnnJ2jM(G(9Pyb1*n~Xi{qGs9^751AC?> z4;mN@S_8U|?4LX^sejVIKB;{r)IhPClv5N;pE)z3gGo3mn3tcK9SUY;78E8~!9M*5 z_2}L|7)%akr)B0?!C^TwG9?>BLj^_IAxquP8<>#TKP_icQQD+XYTAUXP|t*<>6RD- zoxGS-q6`w+re$OVCl=*6Cz3Q}ij|k2n}K;|&UF6D&de!}qJx~<@U;9XCN|HB8V7UY zy-cEoX^{{E6B1JML!ll;nOPa3e96<$eo@(Q&OekZfs>`AliMdbe`X{l8DmdqW7$5G zJ2*GbYc*wPhfuB)I3+r5EPrM=Vp)l8tv#yMoNwA<3nfm0^`RGs!ti zb5c&OQ-TsArLbLkZjq@VSp`E=a*e0DhH^5plG9TP6B5!Vr{xC=^V2d53zE~5l7@;~ z;)JvUsYtm}X+mk)$*IBAHo>Hn4kp5ZDY;n%NrQV!WGR~Ugibv&(+WZv19LM%DWNRq zB%Dhr#tEIAa!M(hATfmo6iEdQMNY6}felS)>yE~xmmmcwxi-$R!+R@{b9Pw;$rU@Z z^i(;o_QApZ(j{E#@N%-NHf7|;$>V`mpIY338CB` znK?%uuALLEZ*F#OR_>(SqJmPAG!-ayc-x9tt7Z8oqITux+Z0R3UTK9=OA5m^Ln?Q= zDG06B1@f0%grWT$XSaRltlTu|za(%{N`di6DR7#s`O8ER7X88rB(%-U$tx<9j%Q|O zcACat(o_1#uxCQ&93Bl^LrGhw=B5sh8J*J((!6!1yz!xD zTT`RkY6W(O4QE15Z_tD((tV4i6Pc+>gG2cRGNgxc!mg>qOVm9lH^oh&_#C9kIKx+m z{E#z%Iir&|&R(QcoOIYB((+0~hl!c}^fI%W+*!$ki;a?|rv_6JX`~5lgTtNCC@903 zYuE{AjF>XA20Kk>a*j-8O17+U@wj?};^e|HwVx20lqs_(Qxav_CCaF)R+0Hrc4qS6 zaAV9cJxt`>rPHuj7T2?SqdaN`vTad9?<_HPxGcqSm4CRM% z(nG<*S$QFIt$Ro-ADGf9m@K1rN_UB*oD1bSi%14zr5Y*m*tyNik_^Z+Q;Or?MU=tB zr(-C0KyJ<;&pawpdCYhl(@%oQkQ&R&Q-9>5NWDpjU2o|7!&NgO(V5VhPP@0vMBR;$ z3>8<8;^D0VjYF=Nre7SIif5){L7l+o&I+a#%`92nrJ@HXreziArI%8V5hi?!338tx zw*tkcWlbp~)irXJi?df;_oX5hgp%BM1Tm`VU^zQ!m@5+6sND=`UqEDpxQyxk7`Y zX<-#I4CkU>j26*3Ju9uCU|?D{ZLLBPnp{hE!)2d3Ij2*wf?3f?-;spSB0Pc+(YZ@5 ze{$^&ixQ%vo^>$ME^}E8!D; z#Y}W6iD71L zfpg2y&fLZ6BrcdykQ@tg>~;2t^!p zGu$J)F%L6U(rdlz;Rsn5noO2IZxiTU8UYnDlU8B4=JXAzaX@ z!(+rQ!BU4uN9~lybS1J+a(!~gAoW)lH z=~IjF&1X17IEH>&cRMl~X!jPm%_0Mx^NI>4OOKg8RqC0u%o8zjr{u9C!~GIGi<=1@ zXXNG=6bAD``4i1bhpcC4qGV)ZW?@dKpg_`bDr8jPHtA_u>A{d$gEck2xS+zBFi%rV zDY?Al#?8HcX%?%BvI?D^vD9ZToObw$OC+6gB0J&$;mZ(7A$%t0!j<$TV-b(?mcXR* zl5%2EurQ%hc)=_!D=RlW_Oe<32?+ml2wnCRav1gM~7fW|@acCOiEz+sFc0LYvqTS0u1E>~tqfu0c80f`)6& zuDG5_Nt#yWEZFH2gzy7{PQ?p$ayA|EWg?NA9ZXA4m%3a$%m)k8CKV41nS;%B8EQu9 z@Mu%sQd)UAYG;-~wKbJ7G7rk2dCzonUqra%%m6h4A9<=Kl`sh6 zCZ(`*cG}cX(3v(G{|Per(@7*xbET^46_mpF483x3T;(5Y$T!)O*=4NWLKjP&KB7ch z&nT^>XZ)iUUL2iwnLj)zIz1GFV(h%CrK>-4tUU|EQ_5Nx4)?Z9^Q1()IdNYW?J%7c zUQYtX#z~{N4=z0pW&_T=zGrTZ?&wIKB6%E~Didy5<<|=n-bg_HVy)uhBklX)Ab0sqgsk0_uI;Zdya4AD_Sr3Xz31WJ7 zbNb;)nX6rv6TtEGjMB|J|b_s*mTqBAJZ&z-UV3ya}CD@rOh) z0*4? zBMcKRnHD?GD9h`rB9Bx`i8WF;OEGYjwj|c6C`UG2=%%z#Mld}$Z&q@74~(3#IdXN~ z^ADLeN_&_7P9ECzFpoCP`A6!X(@2~$NOV6;l?PB%g@5uewY&2$wWB^v?aUAyNi$}h zk3I!g4s=d&q*Ew!Qf6W(&s|Ijgr`sCP7IyGh*VxzK3sD`xsox5bXRR+T#sF&Voe94 z!@7pS(q<6RLF9qufN=el6%QTaO57~y8CGPfpVX=N?t{oG5~@U?3KmuL?M@r#c1Pzs zB^!nFc-K{vD^#moT~UdKQR2z4>v6BEpp#t9wcIE6TGZi5hSbI4W>xW?u=F@0{kqOp zjipRSo$Xj=+mc!Fl8PGrNIX1Ii}85--_#ZFeW6S*OqGd|yvZfgxDrL4Gh>Rg!KA$F z8e@>t(+=-TsOXK>l+3|XhRS-8&Pz>hO^55O&&){6&nUO&jgb+v`I8Q}Q;)PN+XR)zOW#O!q3 zWg5M_B3q*zBsFWoB$udzXQN_+}#oNFUMXQByr1PIrlE^gkLHCTv+4Ww5 zIcD)J+I8+SXOy~YwkpZ$f&R#M z1C}#^%?Zgi#L|0$qzPs(VQD)M&1!T?PiGqbFXp1*p}(BIwv1fT=gK6fqGP2wW2ru7 zLM`|9#Y1LfZ>f&#vcTe8d^1%nIYd=x+7@Gci5^v>Cod&?E>}f~*_Fpigb^fGL^nJrU#va(r9#&^iKx!BTD06OjRr1twrU?J>7LicxN+!v;Q}ko>rJX`3O6S zsOa5=>RdQem`)P;p~A`exie6*kvMj8u^(p@uM))c=6TVPSGPz<6}h=|_n-7|B?r{< zdWl#OyNbqj^@=TZL}3Xx=0wufuNE&K$eNiBLjN*H*_pEZX!g>WLOil&ReT0VFbK6X zTUpDU8J8QgjB;k-1m7BqK z;cg`|{wB(cJ@PbMQZ}o;@}CrXX=@3Q_}$ad|LVpg5_|00A8YndO7Z^Nf|_C`EY6km zT$Dt4aOtUxvisS*8x{Q$L3zoS(Md)1{3S=3e=%epL9*rVfd3cgNJm_v8!K}er_|mi zMl}D`bvnWt8GW%_MP#Ofv0`&|!WEtp7RRIekn}NCIg`BNFs@F~m3HyXbz6D+I97)h z^`b<{PAkS$_!l)bR(9P3p=<|Ye&lpyB@#Cs*uUNX;9a6Dvu?UBbj)dFxu@g3FDh|5 zl6YCy<=-Y>vbQUd1LqdNy^WJOPU`T1vMbWOx1Kg3b9zEs`MV%9=)3^oyf-BsCgmo?S}RCHC7o(MGCzr2Khe;rP4vPwLw!o~@FpDdlW~ zb|Q(f(a^Z3l(iAiF{s#^0;$QRY#2yQDgTv;a0a7a+0yjeRp2#eJr&ucA-8oU->h}w zPbl^ME%7$(u)V(guJ682D4G~+18kBkK&J%r%$7H)Kk{~dX<=tbgq}C-XUImSSYgxT z_PhA9$Jnvw@(r&~covep;ln$?N^Zz*XEu?`zVG5Gi}N_iL}@kxJEvh@@Yi+jBYltF zyhSfX7=AVoBhMwbz{M~M=U&RLL#|$j;!RSKZDBF?B|FavQgZcm{)#RFMT$L=bD2(s zOIcPnVr4@tVr76{zIQMsNhhY6`LbEjS?$#4xFvShn>S8n8xecL^Z{2HTYjBAtIob( z_fphgS1CHP73U=~Q=7fpNnB>(^9yfhh@5;3BhNd$Wm>wPB*`8m`K&}vf!WAe?!8L6 zS7D$m&?FC*S}KnsOl1vMS$UXCcWUOqi9=-*J{KW5n9|qmJ}0Q$=oxU?38!689RY?&PmHuLU!y|_yyZ?qY5v(c^AzRI?HE6%)LS; zZyKB3iPPl>FOr$c^$%KSKbZF!h?nV!DT+wX)| zYTBB6<;)!O5dr5_X!DJz|C3(Nv{7@;=G~|N!$kE~L_RZ>pCNmX{_m4-Z|+dT$!BHe zgyeHenv4J7g3F*2^OBp*Q9AOKKHm*bv&yh=-tKdjpY!B{Ho@tc`GxZOm>I!hypR)) zFP4`R5ih95@^`=W9LrzB$9@5cj|j!O@!-8ceK9tsfji-t2Ba*Rir$CrI^PmrQRiF2 z-<@o%s0p7eH$9$Lr%cgDyM^;n!aW>G@pxoH7mM&alf2^-{T^hoUG%$|@|I`#?X{>k zO{3p!D=q|iC8-?W0_=m3pdQ>Is`g9I!Aer->P9`kq2$*y}V|UJR8lW64lc z;ziN~*Ndd)?Y!_yq^>tcW%d%jYbc&FJMSqZvA}lqF+xSDIwr4Ki;Xm-y&ln*#YNqD&X^3iFc_5>n*7!pxjWJ<{a;sc@S!qo(-) zkW_i&&ej2QSJbX3CoO+g@pmd?zj)j(>XoPIPP-}T8ooV`N-pfIJ&=20U0ozQ;nyL; zZz+rBR=A8Dy59VW&dY?DIh2>Fc>hK0JwsL4T}q_AyhU3|kw`1`rdje`B*wgw9u-T$ zxyvad4g6!Jf>+t;l>O?jl!}w_m{#sIV;Y20cC8ouA2vL>MIR8HFjbxx7Rjd~`bocO zG90;68tl4LOK9)zq;9@y?M>bJklqxDi)_neF}zZ2>X+9zBeNjS?CnY(Y(jWWE=j(x zoHt88UOUB1Hf3!mJCvO*-}^OPM9CfUo~B*mEFzQYNDt_|%rwQ!WlNs3X?rnVO)uk< zkY=aPK)F`VCn4n_uG5o65{ng^IkOT;>!YXe-kXYUwv-nW`b}|fv@ExKiUwV(~xebufEb5(+j^TGkj%2;NefSPLQuJnmEB&+F*vJvJwa8N= zrRGVwL{e+(+R5QQ#~3xoQ_ZA3m;}u$uX1SP*4+zHpOBQ)#Kmbb(yH9aNqhv9wviYt z@swUdO68NT*!h;J+0Yo8l$-DQpsSfsw=cHfGv)Hp;)IUHj^SWtio(MMS!Xo)ah-Wo zR?H5C(!avs6rt0wJ+&f6iAjf0qH#oT>y5r3bcBQl4R&JmBjfk zMt;KGXkmWlboo63*|aACq@uBcC>i^ny~j?hgwbNp&cW#Fg7v z>)`(oFL;$)*b9=W1&&C046?vSx-hfD^X|Fm|Lyq4}5-2HF)7gVZ7xf=#_X(9an zQp{J<+z+aB%yNBY!Oi8bn&4%F<|(U+3kx8(gI7oVgn{5@sjG%x>GkQ zQs=d9TUo-3^c^x?klZ^v9sa>1*j~;ox4X`ASqm(u^$+gn&P&XU=$tpa22#;EuPa*f zu3kHN(MT>_c(u^At`nv*B{;j4LOxOIlAbymROuouG4ma@i_+e&yyVa(Z${ z?o8>*yO6P?bU!3F-@@0Sx~Ew!c6!mso&Ud&-`OSN#9Ma5l(mf`{3dyH3zhCV)=O5N ztqpQD^kk)h>9sAd(#0-8SCjk~FT2E!yS%GYvDaNH5Vtfv^TLbyWdtb{=gODzMuxi# z!~2cpTc-c|m6r-+vUn*aTs_SsFV?%)?zmjTtjt@ZzL-%;J^A-lJyugHr9l6EVpB}d z>0CYUW$@hUy2ig)`_p7*UB0IAw?9$VRZ-pZ< zNp&c>bFTs=Q=$1|$(W00B(X|9gD(=s%u|^m^`TdI(Jsarl^Hs`XD!A2^pt)SDYJcH zC@X7{Dp|X0H!&}_K%V{ugV__zPwUBVW+bIg&*HNV`4#&zvix|C`#03&%gE6mMouXV zO^db1TxLM>k!87ak^s&(`(#6ptTQqKwy+ZTjFQzx14{>3;EH8Go$ zo$n*|ODX7>o|~N~4?WEfafz?9t3j8@Go4Mx+FQy^z4v{a@VZaAD?m5Z)C&{z_tmG>QCbzQt zR9`&MDapT`x@ODQcTA0r#FJI%-QgK?N?*~Pqq37dQx++M1vAXnnMfir=j^U)&r$CqnXJZq&8c|rkd&Xi1{D1Pc6rgr{iSxtsN^mt z<81b-dA{Q6Y-y19e!}~=Qd5e1WXImD7di1sK+nzr$1%pPxR|Lp+Y(Y!V(r}v+n3xq z5KbZ1n?~k5JRzh9PLNFsPMFg7N_rBD`7qy!AaYTQ3&V7P(ukb|%IlZ}oe+M9i5(V=BsD)M#R*q)J)p33407VT3?nCZovaU>~E z81d0C<~_L*n|s_9I((v@S{^Q(@II)HQd7IjSAzdPZ-k1qj`II!*P6^T%Ge%ZyxdR0 zWADx~k4NP(mFpKON`J=YedeyOE|j>LbthSRRG!CmGMV~EKbYa%y0bGTI8}a#W2mfr zNc(m_^8K%O$GDadU3c*Rzfam(Ds?^R{;$uvv{gpeuo+{MPU)9FdjE^`y=F&Gtfu8W zdM~A#S3CjPju@GH$kdDk|H(HYS4RwYImB8i?)R@xAZG4$tuVaERpGTl zcW#g58GAeLhB32}D&Mn`b({*XH2#muA+kOxzb)kXZ60U;wDwfa4Vi2+_3juo-G#pU z+0HzP=C)H^IvE%96UOSQjveKvD`@W$z?yv8n%^5(by zlPzCbq4ZO}-Zv4;dQkt5dz%s!%BfFs{~2Dnmb>QCesZaeyD~C=Fh3&eY_E03G~EnQ zkrx{)cC%parp&HpsqiuGNImOct_a#oBMlteMBLrL1arqV=w&myAcB zP?Qlw+I&<6DZ|+N@HaZB?6Ywdpj=G%GJlMq|JCk4ccPJ@!ClPdF5^^uFQ6;2axVWr zuFcZhIZIgPTMp*)xccQ7SHe+6Yr5^SAK-h#dTL4WZb4~jW~U_EmC9V#a$n|>Pa-_g zJ9VT(_>*0(e3T65n3hrR%PDSmrd+*dFbg=$UGkJ-ks72j4uD zUQ>V1W^(91S%E8FJT;$;@V+KpTz&F#^Me0Tax$cqmZE#DR8G=)8T>y=wX`I|OT%V> zP0N^4R8aU|oo8lgCn`y%^foKPsk$|;yeVd6ncLMMU5lWy-m4#5?DQXArLxOQ)<)gy zMp8}8YH8HkQff-cl_+DGTypO3)cLYr6?0OEj!u^$O>-$dC`*+wm*1SsNa*t3$OQYndYY~3v%Ui8<~Z(g45erax|2G_La8PTyL!n8xCAy>0l5TJGNW-5Z58WhA+$H{YLKFX4 zh7x}_<1X%JMMKHgNAMRz ziSNu~gc9FCp^0ypp~QEdahLeA3?;ro<1X>dFfX~((itH%>5Ma!bkdEx zq*G)l>0DskC7p#vOFHWeC7nm$E<;JDc2%LocZ$%&ce$CX_?EyM4JE!u;BKK$8skCq8P&vJ(&;HQ>6~jQ=?pUNl1`eTq?2jfC7o$TOFGL9 zC7s*gV}_E>UxpH2?PE2*28I&fNkS7}8$*e&lW~{$x*09;jWLw?ir@wKFEEtwON_hN zU2nAH^Jd&P7hm01xZH8NH>kY#PZ0l3wFX4VP`a#>OT3z^%ZJlbkRr((| z%J5;^%7;r0ACdZN_^55|HhfI_XT!&Bt5OYRQ`iOe6PolU8U2Lh-|$K4PYj>3tp|<& z)3)`B(b8@Y7)ts5WZdO^e>M6Usb4ik%Xw86n)7OD_^gy09Ao&LY0q%6;Y+r)7CvIQ!?t$8uMJg4D;aya5>xoKY*2`A29Z&|1i7_J^}xR$)-Jve-O@trhXgu z#n5l+mFTnJAed;%Q`~#Nb72UsudDt~z*pdV@GJNmtXxm+>%&uF2bcs?;m@$;aT;zG z+z20s2jDNT^YLmw9j=7c>Z^N0crr|Y{ozgUZuk(~2KU1y4K%)&Pf&gU>&isXlv{Jy z9qxob!Pbq`t_K`)lIjic0r&#+H&*}S;e5CmJ`E4UDoxaWFbu+_@CNuh+#j#@jRML+ zFdZI(Cp1<6fp7x6xtY4(0k^{E;hXRy_#ONURy#$*p8%V~4zK`T1n+^L!QbHh%{889 zVWSqR--eZ2s_qO2z!`8ZyaGNC-+^(hG<-GK7!HG(a2>n{?tz0(*YFR*uVLfX>YfPa zz-4e1yc>2qL+y*;-SAl$-$woafbA1hC&TsdK6rdv^}hgK3b(+h0A3 zOn3(z(_Y zWivP$=E808Rrogi1X|rRd?R=ooCq(3D`AiBYQF?N4bSbN?#tmWSfi)94}e2@slG8u z`3|htTlHYL4DNtc`>201d<*V_2jEZeZ`i1>hC2;Tgcrh`YLsfTzcfs3J)V*V>aw?n)?}jyosedmx z5`GB3f$_uDu00IGEO-;#0{6kMV3QFVz8#zn=fb7%DtHsT6Fv$L!O9~wzJ4$j2H_M~ z1n0ra;Y)BIJav@D*9M*id&41c49tSJ!AIax=V?6EVFTC{o&nE<=fVZ>8u&i^41N#) zfX9s1bZWx@90T*3o1|;J?chu}A6^QthBw2z;N$RTST#fAONC?MWLN+%giGMH z@D2DmY#!415?~KF8(s!?!oBbSjGw6C+rtasCGcvv6MhU&pQPbBz&>y;Tm|>Q{qTF( zVzP$s0xyP_!Zq+McmQ_F)NtM5P`DJXh5O*=@E6!-iiYn6m&4U?1N;E~2s=$BT{sjj zg=^v0@DMyYOT(Q5hr%1+t?)tk4Yad0+%Px}=E4o|QTQqR0iKbg;d{btI2&$-FT=yI zTCRrc2ZL}4yb*o^e}REK4c7@?09V4p@NZaUn%dWb^7>;g04h4319Kl}`yFkjPWx0Ne=ASgLl{ z!C&F1W$JzTu^``K_hyc2!^YpqecKJX&=5d0FhSgUr~@J{$SY<8piPlmU` z{qW?Q)PE|x3m$}LtW*E#@F95m&FUV6YvAXw{(AKv0`G)d;4XN~Eo#>gZo5tOm+bYo4O3fIHu;Wx0>{Tl8JI22~X`{B>9^A@$A4bOT&^#$-LXg#Rz-Qh)W z8?5q>`lrCv@Lkw=tNM?DYvG6R_J`H~8`$;{)rIg$c-*7v9)g?U@38x0>c0$r1QQ-t z_t|heJnIQ{zZ4#T=RB$I%i(@F^eJ^;3oAdZdJcROc6vtLuY_O1UeBugv#|GbXxM9; z>KEa_=T*M}Cu~>!2t4)$)q7yzMb*>c^RVtq>OLOc3yi!)}eqHru_$%!HhPpomUxc5+MsKQr z8+glZ)qD3Sv))$DgV)0Q;9Kyxchv4;_yFwjuDYkcryRRac`e)ve}>0>p#CFaK0N+o z;(=Q~QEh#yJROdN*Teha9@y|RwVwiSg73g@!tS4|-8nxf3*fe&RKE*ccJYby&q#|C8W+xDvh!Tl>{+0-O%##i{#Z_$)jOTOFnT>5WW8ii0HF#_#_3r^^!Oidk*s!wNjfB_0P4F++ULMGs=RO(m zD)>D76}G6Vb|c_&xDEae6RWA+WVjaYg;kGL|DLc2ZiMf`%Chm!c|Hzjz=iM`_zvt| zL+z)*+u$Bpxu*JegLlA>VclBl-y6<^o8UfJy*74m9^4AQho{z2yK(SZ_zFC_uKIU^ zS#T|U86H(n?aqXK;X=3u9(|nJb%fdQM)*3ca=hA|54XTi;qmp=KN(&C?}i`1<7ESf zxjsYS68H@K1)gz&+D(CL;T~97HddN=y1-nx2JVJc8>w9bI2`7{J+RV=YIhFIgX`hD zaNtR5w+L>9U&2O>)qgO&2;K+3giV{M-57Wk+yU))_3r|w!8_o4ux3E*dcZum5$=Ou z!xks2eRp^Vd>7Vgs{TFUbhsHdY^MIHa3OpM9)KsFqIQGeT=)?D9=14D?Iyr$;7(Yj zx%!_2XTXi{eORM~+I4}`;hpedco#m@Z{6fKNVgAx5BUC zNvEsbKzIp!3jP8UTC3e8xE8(*k3B>Ed&8M<6Wj-@wNbkyI2$g8+u-}KcY@l_fOo+U zVC}Z*e=d9m{tiz|RR3}Ca`+rP3{Po?9lQqaf|c8=e^)pi-U~m4Cv{M}!Egb55Pkwr z?5K7_;dr*VoDDa_&tZcuYBvDRg?GWvV8e6Nt_7S3FNB}N`d!s-Ae;y9hhM?5-PCS1+zx+* zt-7m!5Uzwz!(U-y54D>LZ-MW?T0PajKb!|2hF`(Pz0__9oC~+YgYb9QDM{@I!-wIQ zut{(A9|{-3$6>2J>Yo9xg4^M*@btcF7lbR|cIZo1|IRQU-VQ&2C!DKx1K}e0Fgyqw z_fxw8@Dlhad=VbqU+qqUi{MuH4Qw(%?NZ<}Xb)8PvtSln3wOb|L2B0lPK0aWURZOm z+9kue@Im-JY&Jyg#=*1I#lh(!YklS@O^j)j!RMd6>uB;8MaJS{|WFdSbdnf zcZJj7dbkHx9{*z68Iea1tyGCyL5Opd=dT(+l*4X5G;WAz!zY` zd1^NSUISl(f5P^o)$U&SC2TlG-3P$A@P7CytTz@rxClN8e}S#Xsa*)(1mA?m2GzeS zEP%JdH(<5#YS$eOf|tTu;IV0HcMdFsx52kztqE#32R;BlgZ0zZ|6F(>ya(=w4Kvhk zB)lBH2>*s1LTWb+-U|1@niJK(7n}}nf$ziGlhm#W91Dx!K3HS2+9kmm@DBJ99FeJZ zm&2#wkFePk^&bV7!AId?m^fAKvfyp-Jy<78{RhH};G^&$jL%lP6gVF~0>6cS!ZUN! zekgntehmY;>YoZ1!6#vxJoV3n*TI+JU$E^owab84!kw^MzWOJ@x$pt_H9WOI?MA~Z z;q&k}cv_*_od;LJ7vOGKr%3Hu!7Jf5_&Yp(y4sD0*TCavsCyHb1dHHu_%!S_Q|$-9 ze7GHc0PD_zHX*ehR;bf5PgsHT*enILw1D!#U@x-9mU3TnF!h55sM6H*7UW z!}o+^;m0uT0`<>?h46fM5nKYVg0H|2Vbu#Yo^#;@I1gS4Ux0tZ&T}Vl zPJr2PCR_|Zgoj|8`J5NL4L$)kT%`V=!Dbh$&VYRvs2&9~U@n{sAA&pK$I!P>!zaQF zcpcmUeV3?RN0<$7fqP)fMQV2z>0iS`p;ZN|`#Ts7{oCCMQZ(*w?YBve4 zhx=iJrRu*Ju7c0eD32%gVzz5({a0lECKZIYypP_v<=LPG-=CC`=fEU24;eGIX*y$RL?*h0LPP$gz z*TenrgzMCO7`z(~GpM!z*>OK-KhquA!V8>h4ZWg=h(33ZH|!;Ct{3_$zF&QR6)aj)Vp94)_sle23bP zhL^%^u;-oXKNP0HJU9z3fLFqg;qP$pCXFW(J^|<6rS6O2D!3kg0j>vG5^y+`a0a2Y14R`_%mk_!As0#BA;60D1-U_$FV;)ua zu5biA;c<0u4adUia6Y^gUJY-CcfqajS@+V zTJ7e;-(b-*>Yo0rGUYktqHW4!o>wl0M{UO+)_6hnHL$^ps^5jTzNEUr4&^FX_hr>r z!Ao9I{WUxUeXpu}Z8!&B4!_!|{&~BUv*1Fw8a94S{S)CCudD6^d%?kQ44e!L;XHUL zTmx&qq470?UEz7~EjZ*&wR;T?c}w*+*mJk)?t7Gj;A8MjICro5FNUk&TDTeh4ePwE z_UUjMd=S10--p+|qxS3JX7~iG{;v9WheP0p@Jo0I9`&BuXTf>!XL!{6>K}p^z{}w` z@TYxhH~RzS#c&0@3AWs?{^!8=KUDoS{2f;LNZsqelVEH3G<+N8f2{V)VAD@jU-T*N za5cOQp7ELb_krW#Y}od5^*;;thC|>OI0@#%3*ch73a*74;THHLd6{~PS#yl++ezEduMao?+62#@+f^(C;* zPpYqgwGXMj9M(9j`f6D3XVuTb!e3M$|EuyD*y}gdPr{VnRagB(`PiSzm*HFRLwFGW z1+V{0?eB*#z>napztz8{B|A>!dGu|tyL<$}=shssR$bGtybJb=Q~d?J=qT0oj!`y) zt>KxlHyi;E!DB0FxBxsGz6rA`tG{19AY}4)BkWLB_3Ln2HPtnaRc?m;tE>JTcB!Mf zHyi?|z#=#gE`zJ#I=Bfw2Y14E;n%QbJx%Y-H&EUJyUK@>%z3{D zt2a{J<3#1B@Y0i1e;!aSK3Unasqz&#y_xDJrzoF+%T85&UUOxO7RtZibuCq|J54$0 zbmebwb8FS_w^43NQ1)u48~{hcba+0z1g?ZPzzy&|_zaxVUgNz8-UPS6VI9=}Fub~> z>Mos>AHxl2s=fz43ZIAj-~sp({2Nv|OT*WL&EOmGD_Hq#wL1}ZfbYWvUDUtTIm$io z;;yPs@2xx&X2SXKa@fC*+6{x_;Z!&s&W9^u{k|IRG`K8T^_B2Ocn5p{J_UEdqH{Ie z68If#(ofw};eD`me|67>d*Ocg6Kpm>?MA}9L8@oL1#ktt4&DmyfsexH;cM_c_&NLm z{s}7$*7WMb1egl5;Uai5d=EAnqT$EDD`4B9>YfSL!QHT0iu(6}bKqm}C)hew?Lu%3 zd=pk1rv6XBpJ1!u>OLN>hHt=1Bh)_+z6;MBsqX9GJFwa)bsq+|!*1uP`(QX0u7?l7 zm*5^47_H$tz+^Za-V7gvU%->b5Dw;#Q@s}Mh2Oy{LG}M&yz(GynWnl291rKhPv8%* z#RRqQ0xyJ@!tL-~*eG4?Tfz{W1)qjHVU-NEKM78T)8V~v8>}2s`{UtII1z4wkHAB) z@ABc-~;dw^iNXzbKp>TJ=_RCfxo~mlQmpFcnQ1?egO}|giN(hf-B$}xEFp6 zyG~L20dO(A0e%1v!WL82z6+cWSHKFZAYYJ20WVjB-=d0Zn@J6@` zegdl(s9i(Y4+h~9xEj6!KZI2aHGF+|E*u9J!>iyc@IzR&i14s490ME6ZVB;;3aSsd4SW-R0c)SH;Tyvda4NhCu7`W!*YLPG8ontU3#Y;B z;YRp2JP41!K*KkKBViU?4R3+(!f#=N3pMV{KMrQYIdB=g65ay0!q?!p@YsbK-zl&w90{kvrSKN`F06Tph93^s zz>i?7Md}}fSHM@`F^knd30?#rgNNYhOVlm{u7c0N?_rarYBvlng-^ntV2fpHHx90X zFTg)x+e_6h6W#>(!0OA@KMBr(_rot?{AFr45}vq1^)PrDdx`<~j{`4*U@wbG^DZgy+B_ zxErS2pmw8S2Am6b!B61N@NZaYjfOuN=E95NYPc3|fX~3XYc+gxcoysl`@>1_VfYGs z4}JxIgZ>*e-a7D9*bR<@7r?9Gy>JKo6#flQxJlz33Kzqj@c4D=KNfC)@51UgtN*!h zA$$&+Z{3=De-)^$2Y3oVc6yl)!FcNc)})iZvi{PsqkXB20jE|gI~iLcWFHH z;7a%=`~tSxtagd;Y&Zhm4j+R%;U2gj{to-xt?`Y9IdD3h3$KG;L+c(5R|htPO<`BK z65a~8z-Qs>@Ll*7{2SK4SJUYLhrwL91g?jV!#(f^*z!J&XFS{hzlH7ZSO2;2e)t&- zY*GKQ@CNt}toMNW4}weKbMPnF^g*>tg$v*#@H=?QLuxk$UIAZ#f5CQJ)ou#B3GRh8 zA6Eaqa30(Wzk|&mQM>W*8n_Ey`>6WA4y!$;IvFm2T^}bsI0{}3?}WpjP`e<^gInMW zaORV0Hy>UBcf&8?<4>vG%kW+JCHxWkpH{m@a0I*#z7Lx`qju@=Hh2J@_N@Bn!u#MM z*y%a-&w)$eGw?OIA0B|e!YW%Q&4^>ZtZ^6zVsr%6%D+}OVpQvv1 zsnYj_vI=YnN5HAje?aZ(z>{Gom<*qUd*ER>=}QfN^;gPGa4UQfcK=%ahru=nRd<8Q z@I1H|eg~_3qxKiUzv0E-s(Y31l&fLjd)3#$+CQjX3hf_N{|smTr23mf%4vs{gML$v zhS$LDFz$Et?+oX|tKfU^5N!2_+E0a(|5QB#E`;0Q`|x`>|1Y(F7@qdG>JVHDzk%mi zey4w18m3S6D!3MIgj?W~@Fn;b+z-EkhoR5bc&owVVF0#;{a_AU1lPgGV0FL7HyJ(! ztH-JPVVHE3>Z{;Ku+7oxej(fiTOOnCv*F9IVI_5+3Lk-0Dyw^373EO44t@jAuB!g4 z;C`4MVlPJ;Ks z7vV?n517|T!_R^X;0kyhycOO9ABE4u*Wi2bbNB=N6IMD=)2j~?U@FXpi{Q=hGuZYd z4L=7y24^=`_ebHM@a!ho!^fZ%ukQWfW$<-aC!qer;A*%R-hQ(Be*s&_50sdB-ehgA5+y>*is(&|l zK70uN08j3wcByb7d=P#EPwB39pt-bcXu4~`&giQaE&li#{UiNWE*-vhhCuG-}zFd=6y{%<8IY91~ z-^hx!eEDj!o@_3=%Z>7gtXNy~$$GN6>@GLUqw={re!gDvJvmZNljr4cvdU|IzPfU) zJR&d23Uz(CsnY8Cc&9urFUec-p^R7GmrpI5$=-60{9YDq;LBf=cVy7e=ab5svaK8- zr^tDYefgzwo!lXh$m~sgxl(ep+$rsKKRva~Cts3dWw@CyH%;D?gPZ&OKAE(Ik88@c zG-S3>CTQuWe5y%g8q)AEYU-rDDz%f51oJSQ*7Ds6oE zda{*VEN{ugZGE|;zsOvJeYwK2jI1nQm5pUbxkB!eb%ywQ zn#i`YhkREKlau6MGWk$He@{7)CN-NPcPf8d<{9S8SCEV3A$f}?GrKGE5BKF8(B$~L zvT~{NYvgu$R6aGr&sSDflcVHhxt6BD^-BJv{B4#&&n(Eo-F;5pTD|XC|ApLqx|%uvXcB%{wd!W?aQ5) zSL7{eWBl}lGPTSm3&}FFntWS+DCf&<@{Y_i*4N)cPLX@$pK{nZU+xn*Uw$b!%f0f9 z%s$@FS5}UcbLAbm{$pS6D|tv>kkJ$T^pdisY%kBsOY(-iFXK$~^Cy+*WlmW{mX)!x zmTV&1${uo{oGLfVQ}Q?Y^e2A#v2uvqCI6JuCi!y5WTMGFt{{8KCGv{QHN}@}DksUq zGX7LQJx2DDd8TPTIYI7|q3M45^RkCLD=W|N)91=WGksi1_L5s<(OG_a;!nMqWG-1u z#>krTGr3Kkls9Fi*}lF>@|t{cj?Yh&H{{E6eSVI#c|L9+m&u;_6|Uj8nVto7yd z$g}dQye)%uzFZ=iQI3%diLl&0hTLq;9<^FJf&$hPt?8SjKImt1C)xn(g~QO=MnWS*0L{-Uy+tRid6*JWq9 zOnxPco$~dRm9esxY$Dsrx8*5$O^!b8>zO3y$fa_f+#!$4d}sW8G4i_nU53v3>4{`& znN=2*^W-|&6+NCOqfoUn0MhTjhRvQhqOgldaDC`FqPo7ku1O zz9nzV_}}{J&&f)%6U}7SO)gb_jodB|%G2_aydmv7Uw>IyQ{I)q_kMapnM!7n`DIzT zL~fO7F8cYi$o#UTd_h*1^<`VRM(&rxF8TV#%4u?eTp>5fgR<%me!ix1f}AB!&}g$W zvfE`}zKv7g_wiU*7xjpiKI}=a0$M4}IK7PL=0n=0E-P)^er1C!hbzPahz6$oLj< z3=YvALSa=!dg<_-DjZ^$HvEWd>%AGo}m~&+fy*FSw!Zc$QPGYXg;%QvYqn%XaTbUa=P+6 zX+g8SGFt+~h0Jov8Wi=nrG?Ep%3;cnmkVeSv&C|s@|S2)vma%ggucF{GCM71mRnX; zz9lVg)>aNtekOg^Y>wQn{6YCWEn#+928j@tG>ejXDb}YVEoBxf+bG{%4yL8?JY6nS zex=+^%b4w#muWe(pXF0eBgS%`k-2G%S$6wxKA$j8-&TDX%G?Dlzhv%+krK z6y@v6_B7V4vm8oaG8-uuQI!8u?xj`D4$2>Cb+c_HJFS8JBV(1XC0o;)X6@x5 zTFY#xoJ+CXO|*{LHhDq$xJi+J%`AZ|Oi{iGt!vgyj#hpRt#7tLUR6F#GUOYYWsub= z>S;|IqkVFi^5f+K+62d~+(}=@`5>=Q)RQl{cPMR&?J5t-ujOU=v%D|=l251b^Cy#q zDC)06-!Q8$-&KAAZHD&Aua&<;o16V1qo48hz?M$OUq-TrW4va}>+}oxX+7OJwSFKA%;Vp*^u*WMkz& zq`l0>$nWUeW3u!fX>Xk0vXb&OWlP!z{jmH%`K7e4*$R1D`A7!j-!Y3P3s9^_ zP1?__j_jlS2XYd9*KC?xr~Fac-|VEkt-NLQ^`@Zj;d3ZiT>01O0JG+DsPg0FeEPoG zA~_+GuP-Lr+d)o|`(;#SKfSaZB&X4VX0zlb+7Ml+M6)Pku{hnq884^ZNNp$O^KWY({69wUQ&0Uq(O0 zct@U5K5jnbXX82~8`3#uugkF%>o;94lq=;PI@j!g%#q)hkD>F-D#~`s_oMSMK9y4$0&8o_7%6~wYm<^NjlwU6Q($8_6%B#v}D1`h{v&^z9U1s*CTuZS&JLF+` zR{lzto86Y_3j6W}=@({2Wew%~&=qFy$~nrfp(`=&lO2ordV0%AbQP{2a=Y^1&@aut zm47Oqttj%Vai1frQ>;fbx(3Iod|&w`bgkKPc~bdsG33{o#g+Lf>M2jxo4qKTDgPGT zVAflXqZ`rR%NZ2&FOeJM*Ts?FWOhQHrzm$_K9tWq>+^+VMYE|yhtI-{1HRVXVTId3+)7srPzM6tcg z$)?J;knNQ3t+<~YsQg$tOD>alWT=d$vQw`~bS&>;oAp>&rha)5vVH6g^;8 zRxVe5lRQuHx3a&Nampb+gvSdq8O8cW%i7ATyaG<~f6MEM1BjodA-N_!s5 zJB;zSJV3GhGxCbOC7+7H^dn|Z%d!;ZYtpYV&Xifp`+Pz9oU9~k%2xC!#vAe%{{Bz}Uxk2ud-_SGYU*(IH5uY`yB0E#G z<0JZw*;v^(*5`-FadNs`C^yk_cy1v3Rq^x9l#ApJdLH+6GT}>zLuN^2eu{QfqPNUm zlC72RPj8zIlrxoIOYh)&aPo}ux9IQqKAvp!GGf#}M=p_TB*)4-vR)HkZj;RXx{rs*o3de3pZ`i0c*Doz#*|JhcU(YMDfov(e$UbtoyeZ>!^7B8CQJsC9QcjSc$%isd7hf)^OfPfFqOzhK zBB#iPUH$wmWM|o14w9qf44J8$pRcGKBPYv6@^_h_yDvXNPLdB~iXMJ?R=HZHf79pt z$?s(Kw|u_7>`udh^^{YU-$)~YZIxG)Ptz0msK7GFLlo!1DfyFZ*URVo$+&O(IElaxxh~ouzN`6bx{$FMAj*nN% zujCPVPTr#N1G_7Wzl->(z)H#T6!q4WZ^%^reLkBkEX&H~G(ljk9Bc0;Cq z&(~L&rV6aMd{y~YG<9I@rim+O^3MAHWNor?E5O&8crnRozVtXDCbKCqIq ziSpfOhQQvEW0hY-GX}O)?pOX>nkleLGW0%T)Sr?@2bNZrQ2u3_Ij~n`2j$1mEP;J2 z*DHTi+CWUt8dyY@qS*o~E9=tifi;x9DcUiX<_K(pT%r6X`8CZM*a`V7%@x>fnRpQ5 z+<_&R&r;M|pXLdyv3y_o*)(rp^W|~nf1&vT`%NbMz}J&O7N+^J|7C6EJJJGyb(N!( zpDaJ81q1s+?x%$UJ1l>ug#-Nl#+z_3MEg_8ytGJQ1!Z;R>&x!6DEb#UL;26-SF~7Q zyX93{9LKjzJOnY8my4DNET4Q?`PXDSS~9RsatJLQ*a$h7mI-X3+(}XI5%~ix8`w`W zG8A#Sz~ad)^!dPY$QLN)uP&R>n7~@eLCQ~~LnE3n$K6RjOs zH`$w_`~t;`KNR(wK!qkPmzKVM#22gkFlr+ioXT3~O=@yaiubpu;24=R6JUZ?fY zf6BxkB1Ze3qxA!OUVcOy1U6Q#p(uBXHVo_=X&)hOjDAceq$pQPHlVKu)%2Tu-&RZFOnvWC7 zjui9vmXqkaflZU!l|M=Q2XLx%;{L0(h-o=iRu(}xF^ zN{*yx_awQNjzB*kFDieRj>PpOu z;yq4ss2ndpqoV@*T%J?@XL(mX{Ta%Q4lJ4MO2^=QlglaAdz0KJZ_%;1FOn@6BOVu6 zTiKOjzW(wfIZtL>;-}}473p~Nlk!LUF`k>q+Z6RhKKCY7}oe)?v znSGfrUqn7H8_k1vXbE{u1$Y9A7dWMLl_B zDOpqYTaD>60vjNQQIy{-zm;*;AU_k=MOlcVTmw1_+gT1&ejfcau+QXS<z&*}R|WQ!+)uIGGx8^yVzbX@lCRJ&1FI!3D}PI-*n;V+14}K-QPle?T@%=Avb*ww z=~`@OIft$bY=K-xG5;p{oASTQhsr0~>dR%21t{t%B1B? z-Hh{C4woOv&nUMe-GcGByrBHgGHNHLZ^bxR7NnT(1-dP;%Cd#>3+Q${cbAux|C8>( zef2JHbBcPp$l-KnU?0hq%Ku1r;d&#}>_)sB_d_x}MLmP*UK}@a-X5R-LT-|K1U#CZLUo2}LMtm%=I$ zdWcOt1^N6v$!t@#Z4oTKlz9UT;vaWJCO@;4+$OSZY$QH{z6!o2> zX)x}Re<`2m0`h4?RzTLKDE}@^7qa)|0_8W*^dZ|K&(I7ZJ1_6ij3Ij{Q+56(`+HjCd(_|gJ#Emke8IdDU*GV z={fMZhipf&oPjiF$cD&e%I~4MLUur2S3d4Vz7dY+M4WC2-`=D~9%+4u)v zzMbqThsbF(FOFAvTKVfVU&wCCNtb;+^W+Nol{_pj)BGX(Sys5>=X*sql09jGkoA#A zmA@db%HT(oD~R_{$oUl8afRF@_sH|K5ca2>^b_L3A)6+{Kl}L;%XBh_EG#S0A|ZQ8 zu2g=D+%GTFqF7&9^{TJGzHBAC$sx2@$VSMYl>c2uuKD?&k$GwHkQJ04EB~onD!0h} z@_YI$j%S(ay07;|S|VgsWW8T}zNPFY`^j;%WXLAUT{nFBWAZ!sn~eV}rk4s?B6*c! zf8CRDZu&SgEgiD#a=h}httb_a1x$lj9uD3&u#zWlq7>&oV`lYCo#NXv(8 zjI4Lp&(}hBk;7<(kbNj$x~KYO3)w|}KwrRn!sQEp`0_PmW7$a#q!rOm$<4}Npf85( zqD*<;*OQl4!f`5NANYK2*;MwXl|$A~HhSpGeMn=m-g4cah^yd!Lhhv4o|k3#FCQ18 zFX8iR*b|G6Mzf=C2 zj2joz+v9pC3(yWBD2hKM#67S-?-@qkK{tRjlLDKowCQ%zMlSagq$E3(Vih&D!*0! zs*FmE=^unFzRX3@uA;IU9gOeQ$ll5ilGEvskbNo-QG8GMsN9_tG2Y2=onq{kBpECh zW%+1)vrZK6T=;^b&$&-Aw#uFy;@uL}XqK?GqOlPhKw~1do2Cxiue5B$Ql@|yQlV~Q;a1OrGprQR;C!^zC$qvUqa7E>@rS7K zviY=Zl%1nxqAYnP_*|4Vp!K6{Cao7`S83fSD-{i2i?R{4PLy4swWBOmW>_oAT2dSz zpU{X|Og0*^sx&HM>*M0LB{=R5QXHS(Q5?s&DUSE}@gUBV^c3e^X^Qi=3B`H+4n_Yk zilYD6NYTF>rs#hzQuI^5Q}k!?(H8b|=_vZY0u=pZd5ZqDHbsBinxbFsP0??Upy=19 zQ}p-CDXteg=_~ji0LAs_0mXGK@lz1jznm1;$I=wn&uSFc+mbR6!*_@pN6=qV1cy=YRb7fr(VQozJmFZy)Ij?+ZApQ8yezDNucU^(h$EIag(h=U@#e zo|AQ?c#hVe;yK$`isy8nQ#`-hN%36oG{tj6OA7IvF*C*U#}_D`Pd2A`&e@CN`R8zo z=cCgoo}VtGc)q%w;yLUIis!aJQ9Sp3Nby`aX)=iC#n~yICzqsn?));vbLsXJ&#n7W zJl7si@%(!}#q;v56wld@Q9OUYLh-!*KE?C?r;|f`j?j?ebBa!MOdWz5S3Q~N|SApVlz&dmWzNbj1 z<2gK?hR-4CRBU%T1Cur+ivzJEkV1$Lf(gy+)q!@#0a!IAji#>FCC8W6H|Oopava^&yVR4d_GPG z2R4j;5ZF|T?>Q``1MxWreLt|{bO4^m()V!O)BZT_Q^R+0+|z!6m7(w8`>wPvmP7ks zIkb0RL+IOhPEC6SwuJT!Yzuu0-{Ylk26mbD2<#8qJ+LHcU^jfffOZY+S=uGADztN8 zjc6x)4nRBN^IX~i$181*=hn0xKG&pe@i`)GgYPlY*7!aMZ53F;w6G<fP;`<)70X}!5_3?dgS}(AJv~FPE(bw=jB3cLE(@Y0z2UdvI z!sos8ReWAaYvTN-HSoP;`UKK}U&ir3s|2=}#^U>tv@$+Fp_TBt2d#+x zlpa>Vc|*(NyrD5TZ|L(lZ)iE3H?%CycUlI=A1#f3g_gu|K}+Dcpv7@q&|)|)Xi*#& zv`AoyGQh(4+=&(nEI%!X&xvUPe7}e053B{vhxMd+(T~wQfz713@wo}jh0j@OPV{3m z2l_FZ9m}KH&@W_!Sp$ovS+IUIGuDqrWBq6*tRKyY{YEpOU!du6e9(007ie01|BR-= z=V&xFwj)i2@0VnPDbZij1o%ESeJZeeG=5-RXgr)xG%n638VB2rMq#_r2(}vy<8w3` z!Y^;4VSw+EQv92f{$&{F!9UHa(T8R&>3y^J=smoTi{8b180hbK{}a7~_gc`~X1~!} zW^ppZ^JZ!2IkSB98?)!>S+iH^8PrctwpS z>DOkFEbs`HLl0v)^bp!h590UT^nlqsx*zSP`_OK>*DP^XxW_CD-ECH!?lOy|JMsP+ zir;H@qWE3+dlbL-9!IyKUb+?a(k-Z$ZpQYYoABNmy3s6UHn_noH(hU5hORSvg|0Pg zM%UoI0(7Csqw~$q(|Kk$Dc&Oyl>^Q(OHF5+<)xpRm7}xFYSNiz zE$9sFPdeRfIGtuTjZVe;km(e&opiFB^3 zShJpV4BqQNN1IKhqp%$M5q>vIKg9bz=t#3GbOg2+9ggjl3l78fqC>I0=n!l#I@qiM z{lKg%9fbWt2V%d__px8-0PGj~9`+0EkNra5#d2srEGIX72g{*-u^ie5%b~roU+CLr z9cVAS|AF>28$;j1`9R-9{j`VK545}4L)y(ONgmkMEGz9|_AKpeR)uylYeYMmb*3H6 z2GI6q<7qpy`LwOsI@%iV!Jw_ozN0P8ZqpWK@$$mvX6a}%vjX%Dv+}el`UmZ46i zA8m~Df;Pl)MeF1IrFG51`QU3fKWH7ZoV1o%30l*vGOb}&msU4xO{-$R)0fN!(^%Yh z(n@AaX+^W$w1U|w8iU_I(sE|^Xc^pA<%gxsGSX6J1!+n2PqYM%Gx{vvpG1q}yrjjj zJX+Lj5-no3h!)20*=ZrO!?YmYD?kgF-Jw`!Jp4c3TbPzc<2`sZlUYTY5$i`Yn6;zn z&EBEu&>zyYW}nhDcux#XjrF6c%+Ao1X4mO6h82M+%#zXMX4z>nY)_ih>?NAStTBBW z$2Co4HjpO7a%cjxFK7tIEvgJ1#Qi4>4&iquG`<;Twa{VQztJPOf1_XHd)stO$X-$0 zfF8x)-=xRz91{k|ai1!2>RRXo?oa6~eC|U};{KYR!hK=@PlpVbP**QDg@w-G{)(Q( z=hPI-!>)HRR>9SeP2|kMJnF+PcJ)<}I7D5&9VzC=spw+Yo^L`Hhw(PNzmT5S@-EzeMSM;}FKK%%3RxD!0emdKSb6C3KdAh2<)O=8R{jg+pfy_2%E~jv(f9ym)jwzE?tT>OnbI zPh!=RMD-+9J$SzA>e;7yl0Q*T3e|&huAXO9PfFF3O7-A5uB!*C$5WBRCEF_kN>_CBk)gyus(>*g!@ z_k3=7|03^}TPke0R9L9A_SbV^zrN7zAL#l+==#Glc+So8Wy4mP;{1J8aa;PR|HJw1 zmW%!imm1fPu|EqvulXO9!*TQ*e!`VQKkv4W`u$L)C+b6g^dFT&|K*O4N7s>Mx{g3MKXl7c z{-2hE{_{U7hyK=`Kb6CNJP@n%yNb?d=+2v$!v6a8vbG=kWA?wHs*2Gcy11HR^s}!0 z)pdTnqV2dv=SPhv&X0eQ$B@TDHPx)$)P8^bMc}*#n*MVYr zV`w9+A8j1AZL~?)j#I2JUVm?)*U=y20?hf6P|O!iF})PU^ctGpNYlGgENmcsBW&a3 zJlZU5D=E&?&5C(_4mJ1vdZ>l(zd|h)x6*OZTKyTukFGz1?z}wt&*QsBtPkVHb`;C$ zrT8QIsNceM%UwU(=s0T|HVnlrgxHOD+NocK?)Yx6a@csheuWS}cHDQ=aor9nigx1>ohx5M;?b%r zH=LrrX%y{VCihV+_dAN^KA>--ULL1dENt8w`y0oRJKp-qcl~%F)L+Nhd&&<`fAzllnStTQ?>7)< zXZ?f17DGP>n>+3XD?dc}p~??aeZy7Xh$rep?AB+brhgdr_ZuJi>vw3B#wDY}{(b`| zue<(@ReqfE<8_?kzRMjixbMn__5~knTmap;0J`%CK6xHJHZH(@*rRcQTiyhQ4c zXL+AwE`pwt&T%hf_P~*JM zbet^G@qv2XakTjFzNlTWA%&cR^8aSNdhxhN_&q{-E3z#yC!o(^0s7(bZu~&hu$a z*fLYpQ&d)xZaZRqT)T0ey6v=9+i#t=!}=$-!v@70wf>v5-w?a~wpsfPy7LI@<(9KW z<+m!2*ewtJt?RFGf9U$VZDBudMckU(XS=T3U+FyC5w^U{?+p9$gYK(O>0aJ$tqP_h~zzzADV4yz9p?zZ-ADIn3|J_hcxJpY61Qj&sy^ zi7}4%8x*l|Kj1vVM;WLO<8q36n#p(Rfv_J>9MpIM%Xj_lA)H4l_k+s)MGuE9DfizI z+=o%j=f)E_-k)Rqb=chgJ&JJ)W3;CgMSsa-Dc2;B@=v zn6}q(ZKo63&nLB?p*x>X={ku0){5(o{pF5-?B7j{PlxRfdItNE>v1-0_-M#IFTh7! zxPGHNJr}mM^nBQ^D(}`C_brLoF04;#iZ~a=c%>}85VpGXTa5Q8mOGe!7qWRyjjO)L z_n;V~olkQd^j+9;Qf${!6vtadiuGzjTZXMU#dhsPv0ZWLaqU1C?VelVP02 zeBX$99Q5w`k_dxwo=4ao_^8oBh?8ml%oOz&rl_|JaJsn zBmO=)z4}$$JmhA1JnwbShiB%7}k%lq%w%2Vp&1GLQ8fMpH*@I!zO? z6%^$T(6qk&jNN&eF5<60>GAzPPS2p}86*DslnLKYWF9wH?mCz`;>TrKwEV0Qe_msL zxBaq3{C#V7d{2_|<%sz4ZqA7BCvvG=Ztb5uDu?NAyoUC;=eBtx)}8Ys9!c{>Y%WFK zZ70<0uA^9PdFJ!udwmqk#Svrto@G2*AmYcB1@XO6#)UK;rQGzwnqEZH@m!YI4StU^ zJuT{w_n;WQNBNKQqhE0I7uWpHYW_IthcMmEUqbVjd}4m|LvDWDth#Y;Y0aNV^JBW3 z|2fTH=85_7eN{JqInDpP)+aD7JQQp;CE#jX)S698Ss9xNhyZwaz+^t7V)%&XI#eU-P z6J%FEkN(`1tEFQwdtSet`P|hV|Njv4_zLRl zxWs)Uk2A&%RL|=$)Ijy*QGe1<$0g!QoSxg)`;W_Y_kSqome)vP`R@E`{CB&ubAIHb zX%n4CF&eL6-1aK-7^gL*=pWlFP5}S$Iq;LQ+di*H{Btyzh4bP0gDY3$pPvu^yL@ua z*EC{}boIXBw|A(S)}y)llNJ%n%yzZZa!Y7At<>K=TK@kukNVtm>DGVOcna62LlKkFppiQEW$d-XQP#0hojNGP<8cxySB95x3>^N6&9?zPbJS zXuaEOy*uc5#30Po3thb(b$oTg_pY^kw_g!IRxkPo*RKC|{zv`He=)z?|1bUhxx#-G zV|}08FOO}P&e|?rv|fF*U7*`8cv$DI2miP2f_~R+m;ZMDNB#GIF~8dmX#f9lJ-cZ= zyQ`g5w4TtdXOI7IJ#l?<>-pc#|L8jRU(D~;6Yc*$uIHOt&$o1bzoPTI=ile0tLJ~3 zM}1E&*NxYD>AL?memBAM2D))x?})8s4Bh=-AB}VRYMk?q`q4G&ulq&({d;Tm|8@QS z4abqZeuX~MxbNMFz05d)#*etpxqb%bRG#C{P=8Iw^_Am|(0l4%2WbC&to;w&{{M&P z#E+f-|L}Y(4(oYz-TiOp$MrfF>v><}=T%|L#2C8q(?E?c5xea>NaIgD|47GjA4J^e zprOIKeh$%o9UAfX&%?AGhpYb^5%JHN5xe`Ckr7`Hbp61GDnCcp-;dP3QEDIVUtRm4 zYu{+K4{-suXH3LmDDFGmei*Cq=r}*V;Qgjs?u@^m!)0ap@mkKu|7JT(_33!L7$6KTc%-@2>06U2lHW{>A;Tt7n3)AGrT@?ZSGv?F!xf3~s*N`a-w9 zlhqEyZhuVC{=oAWH{Vnpf77(y)BSag*E{z-YDUB_ccJb}pgX?se8yd0@O-8*w+D3X zMR|8TqMU2*9<>+K-8f{Xu1|Q*P@nUi!S7(`*Sh{44O>sfxPH3z!FoNm|7QKY|J?d~ zs`bJCbL%r(>+@(o&hhti+>dU*VfmFKR9|9`5|d@#(fF>T}!WQGL*DPt@zSC+c(?;9TR+V2?uXDmS1;P3aL++Mm^=l>F&|DUVfOSQaZ zIxm*%{73AL_b+t*LwCHbP`Q=(ogV8&?D}iy%CAy+=(azWUzX**)b>W)n(^w0|6DYu z)^E)}&+pDBlz)xoQLdAgH=nMJ*jc(R;=kXu9_^_l8?asI#)yB;xhY~Bl|MkS zeZHr7e)o`WM!&-6b6Ai36x+2L-4e04=+=mhqiD|x){a3rNzyF7|+5Ti71lzI_pUfz$W<`FXu`+xI}kALj=nwv5vcMf~T}ha>*`4R~mKnRy() zH!0#c^kp5lMNHKjg z#r{2@{26(JoEQZrz2RT*lknVbb<>XXcl4jSqN|=Z+i1u3tgBT>p*OJtso_u_{+by3ZF-?om6C#`mXmUw=Nr z(Ej)H+Y5Sr@a+@%@09;u`A5%nFY3PiuEtAGKF__R>9PK}=kHkE@*XY!@)Px4QTehe z|Kk(We|lp2&reLh`o#2Wn*Qi{@pY}oFHg*OL-YNr?fyS_{>z&9yWx0lJ8Jy+o9Zj1 z?TmJ~>9;if_7l^w9&Y*_P5=Fg>DUf#`dv-G_r!GU7dQP6O~3!d^aq;$s6E)fuKYul z|MTzi?)>;m$F)WIem#)6^}IC{<;Nl6C_jFVD8@Sq-1&fa2;|512*r)^*Gv3n-(4T@ z8+=zkerxZJYsBt2$8YCd{{Y?m38Vh?bC1{meh%W=kKe{8;C6>uxIB#O+;a~6=Di4G z{5CxeO`>uw|M@<}&Hpd*?)<`U+1>aAzg2fJeuM5}{KmXEmy2)+J>FY<0Z z@f&ovJ@6ZIcYQ_d>gn)r>iKv1F8`+dzsq<3H|76D-n9?EaZknVi2EkD<6OyZZ54^=QU} z^?Vz@O?NSVd+w&=H|8#mmYF5$$;P zeQ;fH$63?nyCjWiC!+Q!Ii}C&f z7eBh5;k^b)kl=eOQq$+3m>%=Q^zu(kukgh57oM12@rmg#J~18dWq54)l{Nj*^$YKD zaQz)_h`=sJq`J-F)-+U=&l9Oa)wRn>7)O~-llD9eT!L$7H6VE?-DI$}3pA$?Es zANo_*AN@n@j=vh}4{Q44Ho)^}m&g7n#QI?~it$hviv2f^V!xGF-rYYT@5U!6_vm;S z&FMHkzEHU>6y@CbALV{hoIOAuF@DPFrsJooE^e;aeSh**yuU*AxZ@x7v|x<--&fu( z5BWuk*HXlH6uWU5;%LU`PqNZ=Iv$aC<2}T0DeuOcIG*{>{~l-IJr|F~c>l#?G2V;u zSd8~&JQm|U8jr>Go`~_@4cCt}(0;^q(v=V4_i*^1V7Pw2fVi0Ak`z0)s^S_np}BD{ z%XeUmN(XBC5Q22P^vrmfuX1nw?b4{l(u8-B5gs;^K^-oVxM}DGr)w#n~t> zCiv;Do6hfT1S!pZFP8Q5`x^l+LLD@{3&qL}Q9Od;Vn0LiY>Likwc_;@oyj4^M`?O< z-~V9!{2pz9K}rPMh;clMK?=YB!Z?~@uw6!R42?$n6xXBpkKYSn`7RU}p@E9|J;WfN z89oYf(`Qh0>b$>Xd33$*_h0y`yNeIeLipXG;;WRMVAxNOPz-WXE9QMDe_w`E*v(&z zVrR!Hu1brWHC5b#qVw#fxG%*`#3;q%C=L>QmB-bGudcb@yKPpyo#JNXtl|q4C)+K> zxFtY8YL*a(BG)eojluI;#kpt&Y){28w4&jCTE2WETFDGU7&m_p8jJm{cm%~sJwx$q zih~)C8eIAHv^w^;;-eG?Ic_oB^sBTcwkJ*{whu#C_xnK%U0jTzhx=V2E|o6ErOy4{ z5M8i~(Y3nYAvRUqg4W0ORNR*~#P(D?jyA^jRJ@2bG25(oJAEDJkK(hmDYmELyYvlg z&p43VlQzTlRGf=8$M#elLtEhZR9ug?#PO-P3vGqtQ}Garhcz=4&!)IouUEX8qO(4# z_#|zQ^IP#PicTY8T*&s(j%c6aT(px}jN*zEgOGZP8__OiJrwt%UCl-)9!0yE%~m|0 zcE|Qpyq)&I_EUV8Vi0;u@m-2eIw3A}u6-0Y#n}|+qP?*F6vxoFvHcX+qrI{H6nCM0 zu>BMdp?z_FE1p5$!TGItHSLGrNh>}?-!=dKA#ATJjQg8C&~(GtEqKo?1;zB#bO3&* zuDB3=ALqB?s&t@PQ^hUlARLd1`_d0^JSrYX2jh5Dyoe4l+pc&Q9g5$hE51mFp?!+& zDa6Ck|2T1dp(D`$C@w}v;`*Yv2K^AfzgFCa;-N@i#r^3hvx$nQ(9zg_idWMyIG+_C zrDJhEE51s{q5sA;joT|89gpja;%xL|TwfHs_aIHc{#9I$PDFpBxCi|N$Dd;NUZhDl z{uIxrlW~41-b|<9{7`(7VlZ%3@eMi+?Mn#RJ~|!kQ=E;?!11RzhR#I$6xXA(aQrFm zLO;dvr+5gRjpI-83_1tfPw{Fx7ssFCLv$XFKgCz*eDsI7=Cgefx&ZrEaeBHC`&V%> z`Wg1G;u>@j#t(`+(8Xr`6%V9K&_2a8=;vsk;?;C1+NbysU5554zCxGd_*2Xq9=^vQ zHAQ>V(-ml+;$n0q+NZb%U4`~3?m)jp`xFnPtIltkM6BNwq36*)#Up44?NdCP-a`8nZ>G1=KE-G09bDfO-=)8sB}op^z7+H>t`~|6 z(R(-_6xX2l(H|>rLm#3)R@|TdY5u)esBa?Uzs#0u`U;AFcPZXS1H4B{@kJWKdv6r; z29fWPNlj5-dK%Gtu@IMJ9EHEXrs*|koWR;B?m+P)hW?5NQrt{TQ9OgP5v@DBh3rKrtU=@x3`IDB6>nrpDjJR9uMSJv$W@$5MRBypiIj6z}Ef zp|}@KkH3?tcofBZd}b@2Pw^qvdc~V*CcIZl@ktsT*j2?hXl8ulF(pL%;?XR4@0a3e znicOwQ(T7PrmBYG+7vgyuVZ2{T@d%0! ze`YA2P4O^bwc_;@?|V9`_$0-9pl&F>Me%;9c&Q=UmyqJ-Gn?XE6dx|eD6U9xQ`$&z zQ;HwA^-$c4mc#y5Jc>S#{jGRDjlup_yqT8Qd&IE(lZ-2%eVTrYR>XV0(m+gi?-i?r z?WZ^&#g9E=6j!9N*nW!Ld&a7ueTsY0mjfH6cpSz1xfUs2N~`02aEfL&o-{Mf@tZA4Qyt;>Sg06vt5f$hEfOdK3?Bx+v~J@!qi^ibv48*uRQr zQ#=G%t=PS{tUlh0r}!vsfcNkzzDn`FGd@6Mdm^+k`X9yV>Fav08KxIw+!Xzfrq`g& zaK0$+KwIE^Q9O{g#QCCl3T=h{NAYUf8v9rAN!kYIv*H`HEsnqR5X(Aqg$}^>Q#^vckM=2^PY2@s zP`rx{LjR}uBK-jUpW+8}F#5kt5baArhv58GoR1F0`K!1h9j5oQp?o8k*L&I!_h5{N zTq9I|6dj57DV|S1MEex)q937siZ9YpXrJN-bTrx*4cR_A2JKUvkK!R}jN*!P9Qr@S zP3d^_FN%B7kI}y<9!DqO`k{CQorvqP;zRTkT#prBp_6buR&1FOPsa6_qJ6396r8V$ zi_xh#UlrG&)9{`?#ck+xoUe)p(is>pD4s!Q;(S%Sn$AM|6d$6WqJ4_5(Aj98V#|Vf z4%$cAJ~|iU1;vHvJd76<$I|)Oeu|sY1=xOyd(nk>w^fPQf#VhC{v`_INx)|+K ze1$Fvj1Q>Uo(TOM;{(OfbScJLic8XEIA0alrps}@D(*nP!1=0p2wj2xSn+JS66dSp z&2$y67m6>?FLAw4e3!1q@sHB_EOxGt`DrQ;{J34`d`IU z=tf*06tAb7aD7mGly1iLLGe|(1=}k-sdysYjq9!ArF1XOSH-*NKAf+LFVg)u-W2nLN4_W5y+;r2P0#os+D8!= zqlfVKJQY`^hXZS>*u7ux2;Rf1xG()0+fVTndKAZ-;uZ85#(RqQ(c?JY6knky&_2bM z6Y)v3kFtIA6plB=CFuf1!Pf(^JFeq>78tAY@e)*PtQ1e@t-)8V*^1#RDlmESREr293gV ze8uZ&oRA$-?B4Ge7ti?=U#0wzAva|EXngb|iqliP^q`R9Vl)BXo29raO&GGKid)b` zcwdF$z7+499;J93#Y;lwD_%sC;ByI~RM?)1JJ8hFo{9(3G}xYsXVA2G&$;5&G#$35;-eHF&RkJ^ zm1e;9%nP|aX+~^M#p!7#Y){3-Xf(E`;;J+=wx{A2Gz+$;;=VL1wx{B8G#j?3;zcw& zwx{ClGzZ@MuJ{7YiT8^uzDsjqJLZFEZxWgt-)B{vi{=SgjN*zkFWRTL1@LwL#}uiErj+dzCa73eTwhWB4}TJ$o5hExIdfXT(lV8C$Bh$ z7RT>m71yKB;&VjBU1$mX9UH|XXvvVxRy?1ULi-f&qNPK2LGeZUT*&S!en9bIT#^D1 z?Mp$+;=V(1K3WdjPqBMn;`8_%QE?+0gU{&{_n_s`KE)$wg^D+7|m)@qCJxv#eLVnYPFFQ+$$k!1hyogLcIBD-5~)XeV4(6i3s}xb7(~ zNxPu`R$PO2#e4G=x1rtez8uB5D83wgMe$YI6YVPk z**^LK+NU_04o3SFm!w0`KE*XCx~pUc8~X2MFvekxejo4mqzTRaZkTZk#)-^*Z=LZ# z#!s7#RQcHym2IbZ=5~?d*;WLXKz^>CjpCV1e#-hOo-tHY+=AksejvrY-$>Z32Ao(QapdT4djLu;TOS`+oqT9}{K#r(8B z=BEuYe-vzj`RVJJpEkvMQ7pF&ZGn1dOVmSKp&r^A?{TFlcZGJx`YDbV2XPP7OW!mr zOi?bD_C&q37wV;Nqh9(h>ZR|aUdnpuAha_s`~daQA*heCK8k~)rs6jAL)1$@LcMg9 z*)mPvML$8kbTaCV2dAK3Iu-TNX=opvfqLj{)I;Z>eRMA7r;9LueE2!$r%N$EU55GT za?DRR;{CUD2R`qiJMlRH-HZ1HQ>;fq{KwA|^3nZxZcPv1`8hp=_v%voH-a8Pee@{m zqsLGmJ&t-3z>}zloZO0oNVEsW;@ zjN{-wo5sg@-A%_hm?psU5t#fNCgz)mT?K}!dAPjQkYh|2_) zhH|}W43`H(=(u#;yC-;~9c&+y0{*u>?n{ds8UNiOnv=8^ES#)V%y7UFU zFWQgKt1t3>(QLjiJl6XD2_b!%+v^~1uY-sByKUZ1D6)NkuGG*OXt*pQP&>Y?mOZ~cy<)fol>SezVURzYm)dlnTgj2rYVn6>B?hENO^3?RQ_^U`JIR;Kg(Il&t$gp zvlUf-7IKt-%RJ@ZB44?a0_A%VQyPktudP^FhmUyzXNQ?^N?on z`=#xflWGTEzoH?YpY&lKZ}pKNh-*jx$Dc>}xzNXW9M;GAJtOozRr+-Z{TiiTU!z}#(yy=6pMt~a*WvW*2>NwoaPxJKZ_w}cDEf6Y{hCX^j-g-2 z(y!y_*F5@lJpDR>ew|3aPNH8Y)2~zL*QxYtKK(k4ew|Lg&Y)js(yz1V*V**z9Qw6@ zew|Cd&ZA#hPsMdU{dI8x{ko8TT|~de=-0*c>k|5PDg9a)1Yuo9zrIDkzD>Ut(XY$t z*A?{ZO8Rvb{kocdeTRO1mwqj#U)RvDYw6c@^egMMO5H%eZlqr~(XS=+>t_0O3;nv4 ze%(g@Ex4V2eUE;9pMEW+Uw6>2AJDHK(ywLo>qqqKPWp8h{aPLbQQb|yeoVi9Lci__ zf&$%3zwV=7_tUQj=+}ev>mmB}F#TFVzkW);9-&{4(yx{D>oNNEIQ@Epe*KL8diXj0 z`UU;^CH-1Ozn-LDzoK8ireCY+*Kg?8Z|T=l^y_K*^*j3Yd;0YZ{dzVC3iKTPdY*p$ zfqtzCct2RYK)?P-zy3tO{!G9ALcjh>zy3zQUZP(w)31NguYc38ar$q?EA;DC`t=(9 zdYyi~LBH}}Nb4~7(-fYEm33)EZ(-e{^;mx>>(r>$=bTp?u%6L|tV^^J^BHB`8q<4N zH)&JWE1JsruQua(U0K(bYjf5ydN1=#y^rU6ZNWNCTe7~;8v)<4LSuZH-}T%fF%W7>&+&7@yhCzt3`^y|~~YiIiP8TvI$zjmQtyV9@S=vUUs7qtid8lhi% z(%%4CA2(3e#f_EqaH>8}zh=>|tcyd+x;Rt&(XXtFBif&S9YDVhq+he?*O%y5*30=i zh<+VRzp`E~(kT5plztsXzYeEgN6@b$>DL_k^$q%U6#Y7ye$Ay{$I!21>DO`eH^e;p zbv*sbdOY!Z+llmhJ&AsuOutT{U#HTq`Sj~F`gJ<}I)i?lNx#mbUuV;=bLiIs`gJb- zI*)#RlYX5~zb>F(7t*hb=+_wix|n`lLccDhUkmBiW%MiigSfIkNW6}>i2g=gvp;C8 zE9lpi^y@16bv6C^4*mKr{aQ@FuAyJo(y#02*Y))42Ksd){kn;MEumjG)300T*RAyH zHu`lt{rVpL`abmmB}F#TFVzkW);9-&{4(yx{D>oNNEIQ@Epe*KJo{eph|l76kC zUr*AnU(>JE^y@eD>$mjlDf;y^{rVmKx8wKp>lym>Ed6?pemzgW{y@Lh(61Nh*IN2D zPQPBEU;m+BuhOso(y!O(*X#7_4f-`;zM^$_y`iRXzO8kcvncbna;?WXyxz*ZMcH>% zX#?g%${ejm8!w?+nHx6bF#SJ$s+I$yo>W&ZOl2iHeqh0%)io~r{<2Eb=~w1RHTn?!+KztBpkJ92#kD>CcVY+nHAKHYOusV!NmJ%N>B_t( zq|A9TmHAFsnd?L}lYV86lda5eqRQMR@w#i~HF;h$r^#35GX=_ACZ=KfwF~{)m41De zer4WLuI!%=DEsG1?Logr=vU?_HOjvFcV%CFQQ245Dsz&!vab&ALiW{(*K23d?=^?m zsXCl~9YMd2q+fIBSLPdG9Yw#6reAaESLPQ{9ZSECqhIsr*YWf#bBUO;Z!c2z?ZwKz Wy+oNilq&o8a$QKjE}~y!DZzi64h8D~ literal 0 HcmV?d00001 diff --git a/eo/contrib/mathsym/test_data.txt b/eo/contrib/mathsym/test_data.txt new file mode 100644 index 00000000..a8c792b1 --- /dev/null +++ b/eo/contrib/mathsym/test_data.txt @@ -0,0 +1,102 @@ +# 101 2 nan nan + 0 -0 + 0.1 -8.89903723981037e-05 + 0.2 -0.00122598240763888 + 0.3 -0.00517587564272387 + 0.4 -0.0132382052428645 + 0.5 -0.0254643081877282 + 0.6 -0.0407070337997998 + 0.7 -0.057285499199392 + 0.8 -0.0737562490233578 + 0.9 -0.0892727708954409 + 1 -0.103268200413493 + 1.1 -0.114577577792354 + 1.2 -0.120446083316857 + 1.3 -0.116000062935524 + 1.4 -0.0946298417869761 + 1.5 -0.0493963195458011 + 1.6 0.0248409598316732 + 1.7 0.129207388804052 + 1.8 0.259260510831339 + 1.9 0.404709502287215 + 2 0.550653582802201 + 2.1 0.680124882844178 + 2.2 0.777313232294796 + 2.3 0.830628236863242 + 2.4 0.834788256127692 + 2.5 0.79140362503436 + 2.6 0.707953643967287 + 2.7 0.595509207315954 + 2.8 0.46588939354196 + 2.9 0.329064872475183 + 3 0.191504886385553 + 3.1 0.0558518299407852 + 3.2 -0.0781019284912663 + 3.3 -0.211542824409141 + 3.4 -0.344524221510933 + 3.5 -0.474312294176053 + 3.6 -0.594727989459508 + 3.7 -0.696713721292122 + 3.8 -0.769988957905497 + 3.9 -0.805344773512717 + 4 -0.796949283133396 + 4.1 -0.744036874310458 + 4.2 -0.651525836186196 + 4.3 -0.529396820025977 + 4.4 -0.39098574050144 + 4.5 -0.250612439788816 + 4.6 -0.121113466670896 + 4.7 -0.0118426008551395 + 4.8 0.0724429930487275 + 4.9 0.13163323998176 + 5 0.169341449166714 + 5.1 0.191319990014267 + 5.2 0.203657703492626 + 5.3 0.211210264725322 + 5.4 0.216611758596317 + 5.5 0.220036646440173 + 5.6 0.219677788419796 + 5.7 0.212731354762643 + 5.8 0.196574232374672 + 5.9 0.169803441763318 + 6 0.132875383837662 + 6.1 0.0882099910986659 + 6.2 0.0397733622937463 + 6.3 -0.00771703924831375 + 6.4 -0.0497388405970527 + 6.5 -0.0828196592845663 + 6.6 -0.105101954751146 + 6.7 -0.116508794142315 + 6.8 -0.118508967610477 + 6.9 -0.113576955648085 + 7 -0.104507044103426 + 7.1 -0.0937591677397028 + 7.2 -0.0829871341075209 + 7.3 -0.0728391340503617 + 7.4 -0.0630443677389944 + 7.5 -0.0527284491080759 + 7.6 -0.0408508284036276 + 7.7 -0.0266394584962638 + 7.8 -0.00991225704809318 + 7.9 0.00878546797299183 + 8 0.0282459694154097 + 8.1 0.0468334978875681 + 8.2 0.0628175943181446 + 8.3 0.0747179317764707 + 8.4 0.0815794072993519 + 8.5 0.0831208473565567 + 8.6 0.0797359724522078 + 8.7 0.072361534724142 + 8.8 0.0622560784562081 + 8.9 0.0507477567273995 + 9 0.0390091892966309 + 9.1 0.0279034956336959 + 9.2 0.0179233472968783 + 9.3 0.00922050032813963 + 9.4 0.00170282350837218 + 9.5 -0.00483635091477891 + 9.6 -0.010593872761556 + 9.7 -0.0156676782318098 + 9.8 -0.020019888098685 + 9.9 -0.0234934811028401 + 10 -0.0258701880584331

nZhh)*IyDi`7@R`r68`meXH_LVA~e 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