70M@u0333333333bu\%n-ҌydL P³CR;50+ D&ˇM i, rFQ1c1$$7-Cterator_ == CheckedDowncastToActualType(&other)->iterator_; } private: Iterator(const Iterator& other) // The explicit constructor call suppresses a false warning // emitted by gcc when supplied with the -Wextra option. : ParamIteratorInterface(), base_(other.base_), iterator_(other.iterator_) {} const ParamGeneratorInterface* const base_; typename ContainerType::const_iterator iterator_; // A cached value of *iterator_. We keep it here to allow access by // pointer in the wrapping iterator's operator->(). // value_ needs to be mutable to be accessed in Current(). // Use of std::unique_ptr helps manage cached value's lifetime, \ if (!gtest_caught_expected) { \ gtest_msg.value = "Expected: " #statement \ " throws an exception of type " #expected_exception \ ".\n Actual: it throws nothing."; \ goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ } \ } else /*NOLINT*/ \ GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \ : fail(gtest_msg.value.c_str()) #if GTEST_HAS_EXCEPTIONS #define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \ catch (std::exception const& e) { \ gtest_msg.value = "it throws "; \ gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \ gtest_msg.value += " with description \""; \ gtest_msg.value += e.what(); \ gtest_msg.value += "\"."; \ goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ } #else // GTEST_HAS_EXCEPTIONS #define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() #endif // GTEST_HAS_EXCEPTIONS #define GTEST_TEST_NO_THROW_(statement, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::TrueWithString gtest_msg{}) { \ try { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } \ GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \ catch (...) { \ gtest_msg.value = "it throws."; } // This helper reduces code bloat. If we instead put its logic inside // the previous CopyArray() function, arrays with different sizes // would lead to different copies of the template code. template void CopyArray(const T* from, size_t size, U* to) { for (size_t i = 0; i != size; i++) { internal::CopyArray(from[i], to + i); } } // The relation between an NativeArray object (see below) and the // native array it represents. // We use 2 different structs to allow non-copyable types to be used, as long // as RelationToSourceReference() is passed. struct RelationToSourceReference {}; struct RelationToSourceCopy {}; // Adapts a native array to a read-only STL-style container. Instead // of the complete STL container concept, this adaptor only implements // members useful for Google Mock's container matchers. New members // should be added as needed. To simplify the implementation, we only // support Element being a raw type (i.e. having no top-level const or // reference modifier). It's the client's responsibility to satisfy // this requirement. Element can be an array type itself (hence // multi-dimensional arrays are supported). template class NativeArray { public: // STL-style container typedefs. typedef Element value_type; typedef Element* iterator; typedef const Element* const_iterator; // Constructs from a native array. References the source. NativeArray(const Element* array, size_t count, RelationToSourceReference) { InitRef(array, count); } // Constructs from a native array. Copies the source. NativeArray(const Element* array, size_t count, RelationToSourceCopy) { InitCopy(array, count); } // Copy constructor. NativeArray(const NativeArray& rhs) { (this->*rhs.clone_)(rhs.array_, rhs.size_); } ~NativeArray() { if (clone_ != &NativeArray::InitRef) delete[] array_; } // STL-style container methods. size_t size() const { return size_; } const_ long hr); // NOLINT #endif // GTEST_OS_WINDOWS // Types of SetUpTestSuite() and TearDownTestSuite() functions. using SetUpTestSuiteFunc = void (*)(); using TearDownTestSuiteFunc = void (*)(); struct CodeLocation { CodeLocation(std::string a_file, int a_line) : file(std::move(a_file)), line(a_line) {} std::string file; int line; }; // Helper to identify which setup function for TestCase / TestSuite to call. // Only one function is allowed, either TestCase or TestSute but not both. // Utility functions to help SuiteApiResolver using SetUpTearDownSuiteFuncType = void (*)(); inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull( SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) { return a == def ? nullptr : a; } template // Note that SuiteApiResolver inherits from T because // SetUpTestSuite()/TearDownTestSuite() could be protected. This way // SuiteApiResolver can access them. struct SuiteApiResolver : T { // testing::Test is only forward declared at this point. So we make it a // dependent class for the compiler to be OK with it. using Test = typename std::conditional::type; static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename, int line_num) { #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ SetUpTearDownSuiteFuncType test_case_fp = GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase); SetUpTearDownSuiteFuncType test_suite_fp = GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite); GTEST_CHECK_(!test_case_fp || !test_suite_fp) << "Test can not provide both SetUpTestSuite and SetUpTestCase, please " "make sure there is only one present at " << filename << ":" << line_num; return test_case_fp != nullptr ? test_case_fp : test_suite_fp; #else (void)(filename); (void)(line_num); return &T::Set. // For example, "bar///foo" becomes "bar/foo". Does not eliminate other // redundancies that might be in a pathname involving "." or "..". // // A pathname with multiple consecutive separators may occur either through // user error or as a result of some scripts or APIs that generate a pathname // with a trailing separator. On other platforms the same API or script // may NOT generate a pathname with a trailing "/". Then elsewhere that // pathname may have another "/" and pathname components added to it, // without checking for the separator already being there. // The script language and operating system may allow paths like "foo//bar" // but some of the functions in FilePath will not handle that correctly. In // particular, RemoveTrailingPathSeparator() only removes one separator, and // it is called in CreateDirectoriesRecursively() assuming that it will change // a pathname from directory syntax (trailing separator) to filename syntax. // // On Windows this method also replaces the alternate path separator '/' with // the primary path separator '\\', so that for example "bar\\/\\foo" becomes // "bar\\foo". void Normalize(); // Returns a pointer to the last occurrence of a valid path separator in // the FilePath. On Windows, for example, both '/' and '\' are valid path // separators. Returns NULL if no path separator was found. const char* FindLastPathSeparator() const; // Returns the length of the path root, including the directory separator at // the end of the prefix. Returns zero by definition if the path is relative. // Examples: // - [Windows] "..\Sibling" => 0 // - [Windows] "\Windows" => 1 // - [Windows] "C:/Windows\Notepad.exe" => 3 // - [Windows] "\\Host\Share\C$/Windows" => 13 // - [UNIX] "/bin" => 1 size_t CalculateRootLength() const; std::string pathname_; }; // class FilePath } // namespace internal } // namespace testing GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 #enditing { namespace internal { // Canonicalizes a given name with respect to the Standard C++ Library. // This handles removing the inline namespace within `std` that is // used by various standard libraries (e.g., `std::__1`). Names outside // of namespace std are returned unmodified. inline std::string CanonicalizeForStdLibVersioning(std::string s) { static const char prefix[] = "std::__"; if (s.compare(0, strlen(prefix), prefix) == 0) { std::string::size_type end = s.find("::", strlen(prefix)); if (end != s.npos) { // Erase everything between the initial `std` and the second `::`. s.erase(strlen("std"), end - strlen("std")); } } // Strip redundant spaces in typename to match MSVC // For example, std::pair -> std::pair static const char to_search[] = ", "; const char replace_char = ','; size_t pos = 0; while (true) { // Get the next occurrence from the current position pos = s.find(to_search, pos); if (pos == std::string::npos) { break; } // Replace this occurrence of substring s.replace(pos, strlen(to_search), 1, replace_char); ++pos; } return s; } #if GTEST_HAS_RTTI // GetTypeName(const std::type_info&) returns a human-readable name of type T. inline std::string GetTypeName(const std::type_info& type) { const char* const name = type.name(); #if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) int status = 0; // gcc's implementation of typeid(T).name() mangles the type name, // so we have to demangle it. #if GTEST_HAS_CXXABI_H_ using abi::__cxa_demangle; #endif // GTEST_HAS_CXXABI_H_ char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status); const std::string name_str(status == 0 ? readable_name : name); free(readable_name); return CanonicalizeForStdLibVersioning(name_str); #elif defined(_MSC_VER) // Strip struct and class due to differences between // MSVC and other compilers. std::pair is printed as // "struct std:ename U, bool B> struct ValuePolicy*, B> { using M = const MatcherInterface; using Shared = SharedPayload>; static const M& Get(const MatcherBase& m) { return *static_cast(m.buffer_.shared)->value; } static void Init(MatcherBase& m, M* impl) { m.buffer_.shared = new Shared(std::unique_ptr(impl)); } static constexpr auto shared_destroy = &Shared::Destroy; }; template void Init(M&& m) { using MM = typename std::decay::type; using Policy = ValuePolicy; vtable_ = GetVTable(); Policy::Init(*this, std::forward(m)); } const VTable* vtable_; Buffer buffer_; }; } // namespace internal // A Matcher is a copyable and IMMUTABLE (except by assignment) // object that can check whether a value of type T matches. The // implementation of Matcher is just a std::shared_ptr to const // MatcherInterface. Don't inherit from Matcher! template class Matcher : public internal::MatcherBase { public: // Constructs a null matcher. Needed for storing Matcher objects in STL // containers. A default-constructed matcher is not yet initialized. You // cannot use it until a valid value has been assigned to it. explicit Matcher() {} // NOLINT // Constructs a matcher from its implementation. explicit Matcher(const MatcherInterface* impl) : internal::MatcherBase(impl) {} template explicit Matcher( const MatcherInterface* impl, typename std::enable_if::value>::type* = nullptr) : internal::MatcherBase(impl) {} template ::type::is_gtest_matcher> Matcher(M&& m) : internal::MatcherBase(std::forward(m)) {} // NOLINT // Implicit constructor here allows people to write // EXPECT_CALL(foo, Bar(5)) insteeath tests. This allows one to write such a macro on // a system that does not support death tests and be sure that it will compile // on a death-test supporting system. It is exposed publicly so that systems // that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST // can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and // ASSERT_DEATH_IF_SUPPORTED. // // Parameters: // statement - A statement that a macro such as EXPECT_DEATH would test // for program termination. This macro has to make sure this // statement is compiled but not executed, to ensure that // EXPECT_DEATH_IF_SUPPORTED compiles with a certain // parameter if and only if EXPECT_DEATH compiles with it. // regex_or_matcher - A regex that a macro such as EXPECT_DEATH would use // to test the output of statement. This parameter has to be // compiled but not evaluated by this macro, to ensure that // this macro only accepts expressions that a macro such as // EXPECT_DEATH would accept. // terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED // and a return statement for ASSERT_DEATH_IF_SUPPORTED. // This ensures that ASSERT_DEATH_IF_SUPPORTED will not // compile inside functions where ASSERT_DEATH doesn't // compile. // // The branch that has an always false condition is used to ensure that // statement and regex are compiled (and thus syntactically correct) but // never executed. The unreachable code macro protects the terminator // statement from generating an 'unreachable code' warning in case // statement unconditionally returns or throws. The Message constructor at // the end allows the syntax of streaming additional messages into the // macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. #define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex_mespace which Google Test's Message class is in. // // To allow STL containers (and other types that has a << operator // defined in the global namespace) to be used in Google Test // assertions, testing::Message must access the custom << operator // from the global namespace. With this using declaration, // overloads of << defined in the global namespace and those // visible via Koenig lookup are both exposed in this function. using ::operator<<; *ss_ << val; return *this; } #ifdef GTEST_HAS_ABSL // Streams a non-pointer value with an AbslStringify definition to this // object. template ::value, // NOLINT int>::type = 0> inline Message& operator<<(const T& val) { // ::operator<< is needed here for a similar reason as with the non-Abseil // version above using ::operator<<; *ss_ << absl::StrCat(val); return *this; } #endif // GTEST_HAS_ABSL // Streams a pointer value to this object. // // This function is an overload of the previous one. When you // stream a pointer to a Message, this definition will be used as it // is more specialized. (The C++ Standard, section // [temp.func.order].) If you stream a non-pointer, then the // previous definition will be used. // // The reason for this overload is that streaming a NULL pointer to // ostream is undefined behavior. Depending on the compiler, you // may get "0", "(nil)", "(null)", or an access violation. To // ensure consistent result across compilers, we always treat NULL // as "(null)". template inline Message& operator<<(T* const& pointer) { // NOLINT if (pointer == nullptr) { *ss_ << "(null)"; } else { *ss_ << pointer; } return *this; } // Since the basic IO manipulators are overloaded for both narrow // and wide streams, we have to provide this sTEST_P(FlagDependentTest, TestFeature1) { // // Test your code using external_flag_1 and external_flag_2 here. // } // INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest, // Combine(Bool(), Bool())); // template internal::CartesianProductHolder Combine(const Generator&... g) { return internal::CartesianProductHolder(g...); } // ConvertGenerator() wraps a parameter generator in order to cast each produced // value through a known type before supplying it to the test suite // // Synopsis: // ConvertGenerator(gen) // - returns a generator producing the same elements as generated by gen, but // each element is static_cast to type T before being returned // // It is useful when using the Combine() function to get the generated // parameters in a custom type instead of std::tuple // // Example: // // This will instantiate tests in test suite AnimalTest each one with // the parameter values tuple("cat", BLACK), tuple("cat", WHITE), // tuple("dog", BLACK), and tuple("dog", WHITE): // // enum Color { BLACK, GRAY, WHITE }; // struct ParamType { // using TupleT = std::tuple; // std::string animal; // Color color; // ParamType(TupleT t) : animal(std::get<0>(t)), color(std::get<1>(t)) {} // }; // class AnimalTest // : public testing::TestWithParam {...}; // // TEST_P(AnimalTest, AnimalLooksNice) {...} // // INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest, // ConvertGenerator( // Combine(Values("cat", "dog"), // Values(BLACK, WHITE)))); // template internal::ParamConverterGenerator ConvertGenerator( internal::ParamGenerator gen) { return internal::ParamConverterGenerator(gen); } #define TEST_P(test_suite_name, test_name) \ class GTEST_TEST_CLASS_NAME_(test_s_GTEST_PARAM_TEST_H_ // Value-parameterized tests allow you to test your code with different // parameters without writing multiple copies of the same test. // // Here is how you use value-parameterized tests: #if 0 // To write value-parameterized tests, first you should define a fixture // class. It is usually derived from testing::TestWithParam (see below for // another inheritance scheme that's sometimes useful in more complicated // class hierarchies), where the type of your parameter values. // TestWithParam is itself derived from testing::Test. T can be any // copyable type. If it's a raw pointer, you are responsible for managing the // lifespan of the pointed values. class FooTest : public ::testing::TestWithParam { // You can implement all the usual class fixture members here. }; // Then, use the TEST_P macro to define as many parameterized tests // for this fixture as you want. The _P suffix is for "parameterized" // or "pattern", whichever you prefer to think. TEST_P(FooTest, DoesBlah) { // Inside a test, access the test parameter with the GetParam() method // of the TestWithParam class: EXPECT_TRUE(foo.Blah(GetParam())); ... } TEST_P(FooTest, HasBlahBlah) { ... } // Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test // case with any set of parameters you want. Google Test defines a number // of functions for generating test parameters. They return what we call // (surprise!) parameter generators. Here is a summary of them, which // are all in the testing namespace: // // // Range(begin, end [, step]) - Yields values {begin, begin+step, // begin+step+step, ...}. The values do not // include end. step defaults to 1. // Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. // ValuesIn(container) - Yields values from a C-style array, an STL // ValuesIn(begin,end) container, or an iterator range [begin, end). // os); } #ifdef __cpp_lib_char8_t inline void PrintTo(char8_t c, ::std::ostream* os) { PrintTo(ImplicitCast_(c), os); } #endif // gcc/clang __{u,}int128_t #if defined(__SIZEOF_INT128__) GTEST_API_ void PrintTo(__uint128_t v, ::std::ostream* os); GTEST_API_ void PrintTo(__int128_t v, ::std::ostream* os); #endif // __SIZEOF_INT128__ // The default resolution used to print floating-point values uses only // 6 digits, which can be confusing if a test compares two values whose // difference lies in the 7th digit. So we'd like to print out numbers // in full precision. // However if the value is something simple like 1.1, full will print a // long string like 1.100000001 due to floating-point numbers not using // a base of 10. This routiune returns an appropriate resolution for a // given floating-point number, that is, 6 if it will be accurate, or a // max_digits10 value (full precision) if it won't, for values between // 0.0001 and one million. // It does this by computing what those digits would be (by multiplying // by an appropriate power of 10), then dividing by that power again to // see if gets the original value back. // A similar algorithm applies for values larger than one million; note // that for those values, we must divide to get a six-digit number, and // then multiply to possibly get the original value again. template int AppropriateResolution(FloatType val) { int full = std::numeric_limits::max_digits10; if (val < 0) val = -val; #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wfloat-equal" #endif if (val < 1000000) { FloatType mulfor6 = 1e10; // Without these static casts, the template instantiation for float would // fail to compile when -Wdouble-promotion is enabled, as the arithmetic and // comparison logic would promote floats to doubles. if (val >= static_cast(100000.0)) { // 100,000 to 999,999 mulfor6 = 1.0; } else if (va // global namespace. // * Prefer AbslStringify(..) to operator<<(..), per https://abseil.io/tips/215. // * Define foo::PrintTo(..) if the type already has AbslStringify(..), but an // alternative presentation in test results is of interest. // // However if T is an STL-style container then it is printed element-wise // unless foo::PrintTo(const T&, ostream*) is defined. Note that // operator<<() is ignored for container types. // // If none of the above is defined, it will print the debug string of // the value if it is a protocol buffer, or print the raw bytes in the // value otherwise. // // To aid debugging: when T is a reference type, the address of the // value is also printed; when T is a (const) char pointer, both the // pointer value and the NUL-terminated string it points to are // printed. // // We also provide some convenient wrappers: // // // Prints a value to a string. For a (const or not) char // // pointer, the NUL-terminated string (but not the pointer) is // // printed. // std::string ::testing::PrintToString(const T& value); // // // Prints a value tersely: for a reference type, the referenced // // value (but not the address) is printed; for a (const or not) char // // pointer, the NUL-terminated string (but not the pointer) is // // printed. // void ::testing::internal::UniversalTersePrint(const T& value, ostream*); // // // Prints value using the type inferred by the compiler. The difference // // from UniversalTersePrint() is that this function prints both the // // pointer and the NUL-terminated string for a (const or not) char pointer. // void ::testing::internal::UniversalPrint(const T& value, ostream*); // // // Prints the fields of a tuple tersely to a string vector, one // // element for each field. Tuple support must be enabled in // // gtest-port.h. // std::vector UniversalTersePrintTupleFieldsToStrings( // const Tuple& value); // // Known limitation: // // The print primitiveST_TYPED_TEST_H_ // This header implements typed tests and type-parameterized tests. // Typed (aka type-driven) tests repeat the same test for types in a // list. You must know which types you want to test with when writing // typed tests. Here's how you do it: #if 0 // First, define a fixture class template. It should be parameterized // by a type. Remember to derive it from testing::Test. template class FooTest : public testing::Test { public: ... typedef std::list List; static T shared_; T value_; }; // Next, associate a list of types with the test suite, which will be // repeated for each type in the list. The typedef is necessary for // the macro to parse correctly. typedef testing::Types MyTypes; TYPED_TEST_SUITE(FooTest, MyTypes); // If the type list contains only one type, you can write that type // directly without Types<...>: // TYPED_TEST_SUITE(FooTest, int); // Then, use TYPED_TEST() instead of TEST_F() to define as many typed // tests for this test suite as you want. TYPED_TEST(FooTest, DoesBlah) { // Inside a test, refer to the special name TypeParam to get the type // parameter. Since we are inside a derived class template, C++ requires // us to visit the members of FooTest via 'this'. TypeParam n = this->value_; // To visit static members of the fixture, add the TestFixture:: // prefix. n += TestFixture::shared_; // To refer to typedefs in the fixture, add the "typename // TestFixture::" prefix. typename TestFixture::List values; values.push_back(n); ... } TYPED_TEST(FooTest, HasPropertyA) { ... } // TYPED_TEST_SUITE takes an optional third argument which allows to specify a // class that generates custom test name suffixes based on the type. This should // be a class which has a static template function GetName(int index) returning // a string for each type. The provided integer index equals the index of the // type in the provided type list. In many cases ation object. This field is never changed once // the object is constructed. We don't mark it as const here, as // doing so will cause a warning in the constructor of UnitTest. // Mutable state in *impl_ is protected by mutex_. internal::UnitTestImpl* impl_; // We disallow copying UnitTest. UnitTest(const UnitTest&) = delete; UnitTest& operator=(const UnitTest&) = delete; }; // A convenient wrapper for adding an environment for the test // program. // // You should call this before RUN_ALL_TESTS() is called, probably in // main(). If you use gtest_main, you need to call this before main() // starts for it to take effect. For example, you can define a global // variable like this: // // testing::Environment* const foo_env = // testing::AddGlobalTestEnvironment(new FooEnvironment); // // However, we strongly recommend you to write your own main() and // call AddGlobalTestEnvironment() there, as relying on initialization // of global variables makes the code harder to read and may cause // problems when you register multiple environments from different // translation units and the environments have dependencies among them // (remember that the compiler doesn't guarantee the order in which // global variables from different translation units are initialized). inline Environment* AddGlobalTestEnvironment(Environment* env) { return UnitTest::GetInstance()->AddEnvironment(env); } // Initializes Google Test. This must be called before calling // RUN_ALL_TESTS(). In particular, it parses a command line for the // flags that Google Test recognizes. Whenever a Google Test flag is // seen, it is removed from argv, and *argc is decremented. // // No value is returned. Instead, the Google Test flag variables are // updated. // // Calling the function for the second time has no user-visible effect. GTEST_API_ void InitGoogleTest(int* argc, char** argv); // This overloaded version can be used in Windows programs compiled in // UNICODE mode. GTE/ Sets the default_xml_generator attribute to the provided listener. The // listener is also added to the listener list and previous // default_xml_generator is removed from it and deleted. The listener can // also be NULL in which case it will not be added to the list. Does // nothing if the previous and the current listener objects are the same. void SetDefaultXmlGenerator(TestEventListener* listener); // Controls whether events will be forwarded by the repeater to the // listeners in the list. bool EventForwardingEnabled() const; // The actual list of listeners. internal::TestEventRepeater* repeater_; // Listener responsible for the standard result output. TestEventListener* default_result_printer_; // Listener responsible for the creation of the XML output file. TestEventListener* default_xml_generator_; // We disallow copying TestEventListeners. TestEventListeners(const TestEventListeners&) = delete; TestEventListeners& operator=(const TestEventListeners&) = delete; }; // A UnitTest consists of a vector of TestSuites. // // This is a singleton class. The only instance of UnitTest is // created when UnitTest::GetInstance() is first called. This // instance is never deleted. // // UnitTest is not copyable. // // This class is thread-safe as long as the methods are called // according to their specification. class GTEST_API_ UnitTest { public: // Gets the singleton UnitTest object. The first time this method // is called, a UnitTest object is constructed and returned. // Consecutive calls will return the same object. static UnitTest* GetInstance(); // Runs all tests in this UnitTest object and prints the result. // Returns 0 if successful, or 1 otherwise. // // This method can only be called from the main thread. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. int Run() GTEST_MUST_USE_RESULT_; // Returns the working directory when the first TEST() or TEST_F() // was executed. T Returns the elapsed time, in milliseconds. TimeInMillis elapsed_time() const { return elapsed_time_; } // Gets the time of the test case start, in ms from the start of the // UNIX epoch. TimeInMillis start_timestamp() const { return start_timestamp_; } // Returns the i-th test part result among all the results. i can range from 0 // to total_part_count() - 1. If i is not in that range, aborts the program. const TestPartResult& GetTestPartResult(int i) const; // Returns the i-th test property. i can range from 0 to // test_property_count() - 1. If i is not in that range, aborts the // program. const TestProperty& GetTestProperty(int i) const; private: friend class TestInfo; friend class TestSuite; friend class UnitTest; friend class internal::DefaultGlobalTestPartResultReporter; friend class internal::ExecDeathTest; friend class internal::TestResultAccessor; friend class internal::UnitTestImpl; friend class internal::WindowsDeathTest; friend class internal::FuchsiaDeathTest; // Gets the vector of TestPartResults. const std::vector& test_part_results() const { return test_part_results_; } // Gets the vector of TestProperties. const std::vector& test_properties() const { return test_properties_; } // Sets the start time. void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; } // Sets the elapsed time. void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } // Adds a test property to the list. The property is validated and may add // a non-fatal failure if invalid (e.g., if it conflicts with reserved // key names). If a property is already recorded for the same key, the // value will be updated, rather than storing multiple values for the same // key. xml_element specifies the element for which the property is being // recorded and is used for validation. void RecordProperty(const std::string& xml_element, but not from an ASSERT_EQ). It asserts that the given statement will cause // exactly one non-fatal Google Test failure with 'substr' being part of the // failure message. // // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only // affects and considers failures generated in the current thread and // EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. // // 'statement' is allowed to reference local variables and members of // the current object. // // The verification of the assertion is done correctly even when the statement // throws an exception or aborts the current function. // // Known restrictions: // - You cannot stream a failure message to this macro. // // Note that even though the implementations of the following two // macros are much alike, we cannot refactor them to use a common // helper macro, due to some peculiarity in how the preprocessor // works. If we do that, the code won't compile when the user gives // EXPECT_NONFATAL_FAILURE() a statement that contains a macro that // expands to code containing an unprotected comma. The // AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc // catches that. // // For the same reason, we have to write // if (::testing::internal::AlwaysTrue()) { statement; } // instead of // GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) // to avoid an MSVC warning on unreachable code. #define EXPECT_NONFATAL_FAILURE(statement, substr) \ do { \ ::testing::TestPartResultArray gtest_failures; \ ::testing::internal::SingleFailureChecker gtest_checker( \ >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ (substr)); \ { \ ::testing::ScopedFakeTestPartResultReporter gtest_reporterg, kInteger); // NOLINT GMOCK_DECLARE_KIND_(unsigned long long, kInteger); // NOLINT #if GMOCK_WCHAR_T_IS_NATIVE_ GMOCK_DECLARE_KIND_(wchar_t, kInteger); #endif // All standard floating-point types. GMOCK_DECLARE_KIND_(float, kFloatingPoint); GMOCK_DECLARE_KIND_(double, kFloatingPoint); GMOCK_DECLARE_KIND_(long double, kFloatingPoint); #undef GMOCK_DECLARE_KIND_ // Evaluates to the kind of 'type'. #define GMOCK_KIND_OF_(type) \ static_cast< ::testing::internal::TypeKind>( \ ::testing::internal::KindOf::value) // LosslessArithmeticConvertibleImpl::value // is true if and only if arithmetic type From can be losslessly converted to // arithmetic type To. // // It's the user's responsibility to ensure that both From and To are // raw (i.e. has no CV modifier, is not a pointer, and is not a // reference) built-in arithmetic types, kFromKind is the kind of // From, and kToKind is the kind of To; the value is // implementation-defined when the above pre-condition is violated. template using LosslessArithmeticConvertibleImpl = std::integral_constant< bool, // clang-format off // Converting from bool is always lossless (kFromKind == kBool) ? true // Converting between any other type kinds will be lossy if the type // kinds are not the same. : (kFromKind != kToKind) ? false : (kFromKind == kInteger && // Converting between integers of different widths is allowed so long // as the conversion does not go from signed to unsigned. (((sizeof(From) < sizeof(To)) && !(std::is_signed::value && !std::is_signed::value)) || // Converting between integers of the same width only requires the // two types to have the same signedness. ((sizeof(From) == sizeof(To)) && (std::is_signed::value == std::is_signed::value))) ) ? trut( !internal::HasStrictnessModifier(), "Can't apply StrictMock to a class hierarchy that already has a " "strictness modifier. See " "https://google.github.io/googletest/" "gmock_cook_book.html#NiceStrictNaggy"); StrictMock() : MockClass() { static_assert(sizeof(*this) == sizeof(MockClass), "The impl subclass shouldn't introduce any padding"); } // Ideally, we would inherit base class's constructors through a using // declaration, which would preserve their visibility. However, many existing // tests rely on the fact that current implementation reexports protected // constructors as public. These tests would need to be cleaned up first. // Single argument constructor is special-cased so that it can be // made explicit. template explicit StrictMock(A&& arg) : MockClass(std::forward(arg)) { static_assert(sizeof(*this) == sizeof(MockClass), "The impl subclass shouldn't introduce any padding"); } template StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args) : MockClass(std::forward(arg1), std::forward(arg2), std::forward(args)...) { static_assert(sizeof(*this) == sizeof(MockClass), "The impl subclass shouldn't introduce any padding"); } private: StrictMock(const StrictMock&) = delete; StrictMock& operator=(const StrictMock&) = delete; }; #undef GTEST_INTERNAL_EMPTY_BASE_CLASS } // namespace testing #endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ // Expands and concatenates the arguments. Constructed macros reevaluate. #define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2) // Expands and stringifies the only argument. #define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__) // Returing source_text(std::string("EXPECT_CALL(") + obj + ", " + call + ")"); LogWithLocation(internal::kInfo, file, line, source_text + " invoked"); return function_mocker_->AddNewExpectation(file, line, source_text, matchers_); } // This operator overload is used to swallow the superfluous parameter list // introduced by the ON/EXPECT_CALL macros. See the macro comments for more // explanation. MockSpec& operator()(const internal::WithoutMatchers&, void* const) { return *this; } private: template friend class internal::FunctionMocker; // The function mocker that owns this spec. internal::FunctionMocker* const function_mocker_; // The argument matchers specified in the spec. ArgumentMatcherTuple matchers_; }; // class MockSpec // Wrapper type for generically holding an ordinary value or lvalue reference. // If T is not a reference type, it must be copyable or movable. // ReferenceOrValueWrapper is movable, and will also be copyable unless // T is a move-only value type (which means that it will always be copyable // if the current platform does not support move semantics). // // The primary template defines handling for values, but function header // comments describe the contract for the whole template (including // specializations). template class ReferenceOrValueWrapper { public: // Constructs a wrapper from the given value/reference. explicit ReferenceOrValueWrapper(T value) : value_(std::move(value)) {} // Unwraps and returns the underlying value/reference, exactly as // originally passed. The behavior of calling this more than once on // the same object is unspecified. T Unwrap() { return std::move(value_); } // Provides nondestructive access to the underlying value/reference. // Always returns a const reference (more precisely, // const std::add_lvalue_reference::type). The bCallCount() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { g_gmock_mutex.AssertHeld(); call_count_++; } // Checks the action count (i.e. the number of WillOnce() and // WillRepeatedly() clauses) against the cardinality if this hasn't // been done before. Prints a warning if there are too many or too // few actions. void CheckActionCountIfNotDone() const GTEST_LOCK_EXCLUDED_(mutex_); friend class ::testing::Sequence; friend class ::testing::internal::ExpectationTester; template friend class TypedExpectation; // Implements the .Times() clause. void UntypedTimes(const Cardinality& a_cardinality); // This group of fields are part of the spec and won't change after // an EXPECT_CALL() statement finishes. const char* file_; // The file that contains the expectation. int line_; // The line number of the expectation. const std::string source_text_; // The EXPECT_CALL(...) source text. std::string description_; // User-readable name for the expectation. // True if and only if the cardinality is specified explicitly. bool cardinality_specified_; Cardinality cardinality_; // The cardinality of the expectation. // The immediate pre-requisites (i.e. expectations that must be // satisfied before this expectation can be matched) of this // expectation. We use std::shared_ptr in the set because we want an // Expectation object to be co-owned by its FunctionMocker and its // successors. This allows multiple mock objects to be deleted at // different times. ExpectationSet immediate_prerequisites_; // This group of fields are the current state of the expectation, // and can change as the mock function is called. int call_count_; // How many times this expectation has been invoked. bool retired_; // True if and only if this expectation has retired. UntypedActions untyped_actions_; bool extra_matcher_specified_; bool repeated_actiockerBase(); virtual ~UntypedFunctionMockerBase(); // Verifies that all expectations on this mock function have been // satisfied. Reports one or more Google Test non-fatal failures // and returns false if not. bool VerifyAndClearExpectationsLocked() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); // Clears the ON_CALL()s set on this mock function. virtual void ClearDefaultActionsLocked() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0; // In all of the following Untyped* functions, it's the caller's // responsibility to guarantee the correctness of the arguments' // types. // Writes a message that the call is uninteresting (i.e. neither // explicitly expected nor explicitly unexpected) to the given // ostream. virtual void UntypedDescribeUninterestingCall(const void* untyped_args, ::std::ostream* os) const GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; // Returns the expectation that matches the given function arguments // (or NULL is there's no match); when a match is found, // untyped_action is set to point to the action that should be // performed (or NULL if the action is "do default"), and // is_excessive is modified to indicate whether the call exceeds the // expected number. virtual const ExpectationBase* UntypedFindMatchingExpectation( const void* untyped_args, const void** untyped_action, bool* is_excessive, ::std::ostream* what, ::std::ostream* why) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; // Prints the given function arguments to the ostream. virtual void UntypedPrintArgs(const void* untyped_args, ::std::ostream* os) const = 0; // Sets the mock object this mock method belongs to, and registers // this information in the global mock registry. Will be called // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock // method. void RegisterOwner(const void* mock_obj) GTEST_ARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Google Mock - a framework for writing C++ mock classes. // // This file implements the ON_CALL() and EXPECT_CALL() macros. // // A user can use the ON_CALL() macro to specify the default action of // a mock method. The syntax is: // // ON_CALL(mock_object, Method(argument-matchers)) // .With(multi-argument-matcher) // .WillByDefault(action); // // where the .With() clause is optional. // // A user can use the EXPECT_CALL() macro to specify an expectation on // a mock method. The syntax is: // // EXPECT_CALL(mock_object, Method(argument-matchers)) // .With(multi-argument-matchers) // .Times(cardinality) // .InSequence(sequences) // .After(expectations) // .WillOnce(action) // .WillRepeatedly(action) // .RetiresOnSaturation(); // // where all clauses are optional, and .InSequence()/.After()/ // .WillOnce() can appear any number of times. // IWYU pragma: private, include "gmock/gmock.h" // IWYU pragma: friend gmock/.* #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ #include #include #include #include #include #include #include #include #include #include #include #include "gmock/gmock-actions.h" #include "gmock/gmock-cardinalities.h" #include "gmock/gmock-matchers.h" #include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-port.h" #include "gtest/gtest.h" #if GTEST_HAS_EXCEPTIONS #include // Np5, \ p6, p7, p8) \ , typename p0##_type, typename p1##_type, typename p2##_type, \ typename p3##_type, typename p4##_type, typename p5##_type, \ typename p6##_type, typename p7##_type, typename p8##_type #define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ p6, p7, p8, p9) \ , typename p0##_type, typename p1##_type, typename p2##_type, \ typename p3##_type, typename p4##_type, typename p5##_type, \ typename p6##_type, typename p7##_type, typename p8##_type, \ typename p9##_type // Initializes the value parameters. #define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS() () #define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0) \ (p0##_type gmock_p0) : p0(::std::move(gmock_p0)) #define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1) \ (p0##_type gmock_p0, p1##_type gmock_p1) \ : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) #define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2) \ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2) \ : p0(::std::move(gmock_p0)), \ p1(::std::move(gmock_p1)), \ p2(::std::move(gmock_p2)) #define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ p3##_type gmock_p3) \ : p0(::std::move(gmock_p0)), \ p1(::std::move(gmock_p1)), \ p2(::std::move(gmock_p2)), \ p3(::std::move(gmock_p3)) #define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ p3##_type gmock_p3, p4##_type gmock_p4) single-template-parameter action where 'bool' refers // to the type of x, or are we using a two-template-parameter action // where the compiler is asked to infer the type of x? // // Implementation notes: // // GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and // GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for // implementing ACTION_TEMPLATE. The main trick we use is to create // new macro invocations when expanding a macro. For example, we have // // #define ACTION_TEMPLATE(name, template_params, value_params) // ... GMOCK_INTERNAL_DECL_##template_params ... // // which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) // to expand to // // ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... // // Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the // preprocessor will continue to expand it to // // ... typename T ... // // This technique conforms to the C++ standard and is portable. It // allows us to implement action templates using O(N) code, where N is // the maximum number of template/value parameters supported. Without // using it, we'd have to devote O(N^2) amount of code to implement all // combinations of m and n. // Declares the template parameters. #define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 #define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, name1) \ kind0 name0, kind1 name1 #define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ kind2, name2) \ kind0 name0, kind1 name1, kind2 name2 #define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ kind2, name2, kind3, name3) \ kind0 name0, kind1 name1, kind2 name2, kind3 name3 #define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS( \ kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4) _PP_IDENTITY)(_Ret)>( \ GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) #define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ GMOCK_PP_COMMA_IF(_i) \ GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ GMOCK_PP_IDENTITY) \ (_elem) #define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ GMOCK_PP_COMMA_IF(_i) \ GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ gmock_a##_i #define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ GMOCK_PP_COMMA_IF(_i) \ ::std::forward(gmock_a##_i) #define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ GMOCK_PP_COMMA_IF(_i) \ GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ gmock_a##_i #define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ GMOCK_PP_COMMA_IF(_i) \ gmock_a##_i #define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ GMOCK_PP_COMMA_IF(_i) \ ::testing::A() #define GMOCK_INTERNAL_ARG_O(_i, ...) \ typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type #define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ const ::testing::Matcher::template Arg<_i>::type>& #define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) #define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) #define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) #define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_stener listener; if (MatchPrintAndExplain(x, matcher, &listener)) { ss << "\n The matcher failed on the initial attempt; but passed when " "rerun to generate the explanation."; } ss << "\n Actual: " << listener.str(); return AssertionFailure() << ss.str(); } private: const M matcher_; }; // A helper function for converting a matcher to a predicate-formatter // without the user needing to explicitly write the type. This is // used for implementing ASSERT_THAT() and EXPECT_THAT(). // Implementation detail: 'matcher' is received by-value to force decaying. template inline PredicateFormatterFromMatcher MakePredicateFormatterFromMatcher( M matcher) { return PredicateFormatterFromMatcher(std::move(matcher)); } // Implements the polymorphic IsNan() matcher, which matches any floating type // value that is Nan. class IsNanMatcher { public: template bool MatchAndExplain(const FloatType& f, MatchResultListener* /* listener */) const { return (::std::isnan)(f); } void DescribeTo(::std::ostream* os) const { *os << "is NaN"; } void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; } }; // Implements the polymorphic floating point equality matcher, which matches // two float values using ULP-based approximation or, optionally, a // user-specified epsilon. The template is meant to be instantiated with // FloatType being either float or double. template class FloatingEqMatcher { public: // Constructor for FloatingEqMatcher. // The matcher's input will be compared with expected. The matcher treats two // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards, // equality comparisons between NANs will always return false. We specify a // negative max_abs_error_ term to indicate that ULP-based approximation will // be used for comparison. FloatingEqMatcher(FloatType expected, bool nan value_tuple); } // Describes failures in matching matchers against values. If there // is no failure, nothing will be streamed to os. template void ExplainMatchFailureTupleTo(const MatcherTuple& matchers, const ValueTuple& values, ::std::ostream* os) { TuplePrefix::value>::ExplainMatchFailuresTo( matchers, values, os); } // TransformTupleValues and its helper. // // TransformTupleValuesHelper hides the internal machinery that // TransformTupleValues uses to implement a tuple traversal. template class TransformTupleValuesHelper { private: typedef ::std::tuple_size TupleSize; public: // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'. // Returns the final value of 'out' in case the caller needs it. static OutIter Run(Func f, const Tuple& t, OutIter out) { return IterateOverTuple()(f, t, out); } private: template struct IterateOverTuple { OutIter operator()(Func f, const Tup& t, OutIter out) const { *out++ = f(::std::get(t)); return IterateOverTuple()(f, t, out); } }; template struct IterateOverTuple { OutIter operator()(Func /* f */, const Tup& /* t */, OutIter out) const { return out; } }; }; // Successively invokes 'f(element)' on each element of the tuple 't', // appending each result to the 'out' iterator. Returns the final value // of 'out'. template OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) { return TransformTupleValuesHelper::Run(f, t, out); } // Implements _, a matcher that matches any value of any // type. This is a polymorphic matcher, so we need a tempwarning C5046 is new as of VS2017 version 15.8. #if defined(_MSC_VER) && _MSC_VER >= 1915 #define GMOCK_MAYBE_5046_ 5046 #else #define GMOCK_MAYBE_5046_ #endif GTEST_DISABLE_MSC_WARNINGS_PUSH_( 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by clients of class B */ /* Symbol involving type with internal linkage not defined */) namespace testing { // To implement a matcher Foo for type T, define: // 1. a class FooMatcherImpl that implements the // MatcherInterface interface, and // 2. a factory function that creates a Matcher object from a // FooMatcherImpl*. // // The two-level delegation design makes it possible to allow a user // to write "v" instead of "Eq(v)" where a Matcher is expected, which // is impossible if we pass matchers by pointers. It also eases // ownership management as Matcher objects can now be copied like // plain values. // A match result listener that stores the explanation in a string. class StringMatchResultListener : public MatchResultListener { public: StringMatchResultListener() : MatchResultListener(&ss_) {} // Returns the explanation accumulated so far. std::string str() const { return ss_.str(); } // Clears the explanation accumulated so far. void Clear() { ss_.str(""); } private: ::std::stringstream ss_; StringMatchResultListener(const StringMatchResultListener&) = delete; StringMatchResultListener& operator=(const StringMatchResultListener&) = delete; }; // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION // and MUST NOT BE USED IN USER CODE!!! namespace internal { // The MatcherCastImpl class template is a helper for implementing // MatcherCast(). We need this helper in order to partially // specialize the implementation of MatcherCast() (C++ allows // class/struct templates to be partially specialized, but not // function templates.). // This general version is used when MatcherCast()'s argumeE. // Google Mock - a framework for writing C++ mock classes. // // The MATCHER* family of macros can be used in a namespace scope to // define custom matchers easily. // // Basic Usage // =========== // // The syntax // // MATCHER(name, description_string) { statements; } // // defines a matcher with the given name that executes the statements, // which must return a bool to indicate if the match succeeds. Inside // the statements, you can refer to the value being matched by 'arg', // and refer to its type by 'arg_type'. // // The description string documents what the matcher does, and is used // to generate the failure message when the match fails. Since a // MATCHER() is usually defined in a header file shared by multiple // C++ source files, we require the description to be a C-string // literal to avoid possible side effects. It can be empty, in which // case we'll use the sequence of words in the matcher name as the // description. // // For example: // // MATCHER(IsEven, "") { return (arg % 2) == 0; } // // allows you to write // // // Expects mock_foo.Bar(n) to be called where n is even. // EXPECT_CALL(mock_foo, Bar(IsEven())); // // or, // // // Verifies that the value of some_expression is even. // EXPECT_THAT(some_expression, IsEven()); // // If the above assertion fails, it will print something like: // // Value of: some_expression // Expected: is even // Actual: 7 // // where the description "is even" is automatically calculated from the // matcher name IsEven. // // Argument Type // ============= // // Note that the type of the value being matched (arg_type) is // determined by the context in which you use the matcher and is // supplied to you by the compiler, so you don't need to worry about // declaring it (nor can you). This allows the matcher to be // polymorphic. For example, IsEven() can be used to match any type // where the value of "(arg % 2) == 0" can be implicitly converted to // a bool. In the "Bar(IsEven())" ex // because MSVC produces duplicate symbols in different translation units // in this case. Until MS fixes that bug we put Impl into the class scope // and put the typedef both here (for use in assert statement) and // in the Impl class. But both definitions must be the same. typedef typename internal::Function::Result Result; // Asserts at compile time that F returns void. static_assert(std::is_void::value, "Result type should be void."); return Action(new Impl(action_)); } private: template class Impl : public ActionInterface { public: typedef typename internal::Function::Result Result; typedef typename internal::Function::ArgumentTuple ArgumentTuple; explicit Impl(const A& action) : action_(action) {} void Perform(const ArgumentTuple& args) override { // Performs the action and ignores its result. action_.Perform(args); } private: // Type OriginalFunction is the same as F except that its return // type is IgnoredValue. typedef typename internal::Function::MakeResultIgnoredValue OriginalFunction; const Action action_; }; const A action_; }; template struct WithArgsAction { InnerAction inner_action; // The signature of the function as seen by the inner action, given an out // action with the given result and argument types. template using InnerSignature = R(typename std::tuple_element>::type...); // Rather than a call operator, we must define conversion operators to // particular action types. This is necessary for embedded actions like // DoDefault(), which rely on an action conversion operators rather than // providing a call operator because even with a particular set of arguments // they don't have a fixed return type. template < typename R, typename... Args, l::IllegalDoDefault(__FILE__, __LINE__); } return internal::Apply(fun_, ::std::move(args)); } // An action can be used as a OnceAction, since it's obviously safe to call it // once. operator OnceAction() const { // NOLINT // Return a OnceAction-compatible callable that calls Perform with the // arguments it is provided. We could instead just return fun_, but then // we'd need to handle the IsDoDefault() case separately. struct OA { Action action; R operator()(Args... args) && { return action.Perform( std::forward_as_tuple(std::forward(args)...)); } }; return OA{*this}; } private: template friend class Action; template void Init(G&& g, ::std::true_type) { fun_ = ::std::forward(g); } template void Init(G&& g, ::std::false_type) { fun_ = IgnoreArgs::type>{::std::forward(g)}; } template struct IgnoreArgs { template Result operator()(const InArgs&...) const { return function_impl(); } FunctionImpl function_impl; }; // fun_ is an empty function if and only if this is the DoDefault() action. ::std::function fun_; }; // The PolymorphicAction class template makes it easy to implement a // polymorphic action (i.e. an action that can be used in mock // functions of than one type, e.g. Return()). // // To define a polymorphic action, a user first provides a COPYABLE // implementation class that has a Perform() method template: // // class FooAction { // public: // template // Result Perform(const ArgumentTuple& args) const { // // Processes the arguments and returns a result, using // // std::get(args) to get the N-th (0-based) argument in the tuple. // } // ... // }; // // Then the user creates the polymorphic action using hen defining // a new action, you should also consider implementing ActionInterface // or using MakePolymorphicAction() instead, especially if you need to // use the action a lot. While these approaches require more work, // they give you more control on the types of the mock function // arguments and the action parameters, which in general leads to // better compiler error messages that pay off in the long run. They // also allow overloading actions based on parameter types (as opposed // to just based on the number of parameters). // // CAVEAT: // // ACTION*() can only be used in a namespace scope as templates cannot be // declared inside of a local class. // Users can, however, define any local functors (e.g. a lambda) that // can be used as actions. // // MORE INFORMATION: // // To learn more about using these macros, please search for 'ACTION' on // https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md // IWYU pragma: private, include "gmock/gmock.h" // IWYU pragma: friend gmock/.* #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ #ifndef _WIN32_WCE #include #endif #include #include #include #include #include #include #include #include #include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-pp.h" GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100) namespace testing { // To implement an action Foo, define: // 1. a class FooAction that implements the ActionInterface interface, and // 2. a factory function that creates an Action object from a // const FooAction*. // // The two-level delegation design follows that of Matcher, providing // consistency for extension developers. It also eases ownership // management as Action objects can now be copied like plain values. namespace internal { // BuiltInDefaultValueGetter::Get()nction can handle NULL argument(s). // A NULL C string is considered different to any non-NULL wide C string, // including the empty string. // NB: The implementations on different platforms slightly differ. // On windows, this method uses _wcsicmp which compares according to LC_CTYPE // environment variable. On GNU platform this method uses wcscasecmp // which compares according to LC_CTYPE category of the current locale. // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the // current locale. static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); // Returns true if and only if the given string ends with the given suffix, // ignoring case. Any string is considered to end with an empty suffix. static bool EndsWithCaseInsensitive(const std::string& str, const std::string& suffix); // Formats an int value as "%02d". static std::string FormatIntWidth2(int value); // "%02d" for width == 2 // Formats an int value to given width with leading zeros. static std::string FormatIntWidthN(int value, int width); // Formats an int value as "%X". static std::string FormatHexInt(int value); // Formats an int value as "%X". static std::string FormatHexUInt32(uint32_t value); // Formats a byte as "%02X". static std::string FormatByte(unsigned char value); private: String(); // Not meant to be instantiated. }; // class String // Gets the content of the stringstream's buffer as an std::string. Each '\0' // character in the buffer is replaced with "\\0". GTEST_API_ std::string StringStreamToString(::std::stringstream* stream); } // namespace internal } // namespace testing #endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ # Customization Points The custom directory is an injection point for custom user configurations. ## Header `gtest.h` ### The following macros can nothing if the current thread holds the mutex. Otherwise, crashes // with high probability. void AssertHeld(); private: // Initializes owner_thread_id_ and critical_section_ in static mutexes. void ThreadSafeLazyInit(); // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503, // we assume that 0 is an invalid value for thread IDs. unsigned int owner_thread_id_; // For static mutexes, we rely on these members being initialized to zeros // by the linker. MutexType type_; long critical_section_init_phase_; // NOLINT GTEST_CRITICAL_SECTION* critical_section_; Mutex(const Mutex&) = delete; Mutex& operator=(const Mutex&) = delete; }; #define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ extern ::testing::internal::Mutex mutex #define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) // We cannot name this class MutexLock because the ctor declaration would // conflict with a macro named MutexLock, which is defined on some // platforms. That macro is used as a defensive measure to prevent against // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than // "MutexLock l(&mu)". Hence the typedef trick below. class GTestMutexLock { public: explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); } ~GTestMutexLock() { mutex_->Unlock(); } private: Mutex* const mutex_; GTestMutexLock(const GTestMutexLock&) = delete; GTestMutexLock& operator=(const GTestMutexLock&) = delete; }; typedef GTestMutexLock MutexLock; // Base class for ValueHolder. Allows a caller to hold and delete a value // without knowing its type. class ThreadLocalValueHolderBase { public: virtual ~ThreadLocalValueHolderBase() {} }; // Provides a way for a thread to send notifications to a ThreadLocal // regardless of its parameter type. class ThreadLocalBase { public: // Creates a new ValueHolder object holding a default value passed to // this. However, there is no compile-time way of // detecting whether they are enabled or not. Therefore, we assume that // they are enabled unless the user tells us otherwise. #define GTEST_HAS_EXCEPTIONS 1 #elif defined(__IBMCPP__) && defined(__EXCEPTIONS) && __EXCEPTIONS // xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled. #define GTEST_HAS_EXCEPTIONS 1 #elif defined(__HP_aCC) // Exception handling is in effect by default in HP aCC compiler. It has to // be turned of by +noeh compiler option if desired. #define GTEST_HAS_EXCEPTIONS 1 #else // For other compilers, we assume exceptions are disabled to be // conservative. #define GTEST_HAS_EXCEPTIONS 0 #endif // defined(_MSC_VER) || defined(__BORLANDC__) #endif // GTEST_HAS_EXCEPTIONS #ifndef GTEST_HAS_STD_WSTRING // The user didn't tell us whether ::std::wstring is available, so we need // to figure it out. // Cygwin 1.7 and below doesn't support ::std::wstring. // Solaris' libc++ doesn't support it either. Android has // no support for it at least as recent as Froyo (2.2). #if (!(defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_CYGWIN) || \ defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_HAIKU) || \ defined(GTEST_OS_ESP32) || defined(GTEST_OS_ESP8266) || \ defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) || \ defined(GTEST_OS_NXP_QN9090) || defined(GTEST_OS_NRF52))) #define GTEST_HAS_STD_WSTRING 1 #else #define GTEST_HAS_STD_WSTRING 0 #endif #endif // GTEST_HAS_STD_WSTRING #ifndef GTEST_HAS_FILE_SYSTEM // Most platforms support a file system. #define GTEST_HAS_FILE_SYSTEM 1 #endif // GTEST_HAS_FILE_SYSTEM // Determines whether RTTI is available. #ifndef GTEST_HAS_RTTI // The user didn't tell us whether RTTI is enabled, so we need to // figure it out. #ifdef _MSC_VER #ifdef _CPPRTTI // MSVC defines this macro if and only if RTTI is enabled. #define GTEST_HAS_RTTI 1 #else #define GTEST_HAS_RTTI 0 #endif // Starting with version 4.3.2,ax on other platforms, // including Windows. // Logging: // GTEST_LOG_() - logs messages at the specified severity level. // LogToStderr() - directs all log messages to stderr. // FlushInfoLog() - flushes informational log messages. // // Stdout and stderr capturing: // CaptureStdout() - starts capturing stdout. // GetCapturedStdout() - stops capturing stdout and returns the captured // string. // CaptureStderr() - starts capturing stderr. // GetCapturedStderr() - stops capturing stderr and returns the captured // string. // // Integer types: // TypeWithSize - maps an integer to a int type. // TimeInMillis - integers of known sizes. // BiggestInt - the biggest signed integer type. // // Command-line utilities: // GetInjectableArgvs() - returns the command line as a vector of strings. // // Environment variable utilities: // GetEnv() - gets the value of an environment variable. // BoolFromGTestEnv() - parses a bool environment variable. // Int32FromGTestEnv() - parses an int32_t environment variable. // StringFromGTestEnv() - parses a string environment variable. // // Deprecation warnings: // GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as // deprecated; calling a marked function // should generate a compiler warning // The definition of GTEST_INTERNAL_CPLUSPLUS_LANG comes first because it can // potentially be used as an #include guard. #if defined(_MSVC_LANG) #define GTEST_INTERNAL_CPLUSPLUS_LANG _MSVC_LANG #elif defined(__cplusplus) #define GTEST_INTERNAL_CPLUSPLUS_LANG __cplusplus #endif #if !defined(GTEST_INTERNAL_CPLUSPLUS_LANG) || \ GTEST_INTERNAL_CPLUSPLUS_LANG < 201402L #error C++ versions less than C++14 are not supported. #endif // MSVC >= 19.11 (VS 2017 Update 3) supports __has_include. #ifdef __has_include #definteInfo accumulates tests obtained from TEST_P // macro invocations for a particular test suite and generators // obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that // test suite. It registers tests with all values generated by all // generators when asked. template class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase { public: // ParamType and GeneratorCreationFunc are private types but are required // for declarations of public methods AddTestPattern() and // AddTestSuiteInstantiation(). using ParamType = typename TestSuite::ParamType; // A function that returns an instance of appropriate generator type. typedef ParamGenerator(GeneratorCreationFunc)(); using ParamNameGeneratorFunc = std::string(const TestParamInfo&); explicit ParameterizedTestSuiteInfo(std::string name, CodeLocation code_location) : test_suite_name_(std::move(name)), code_location_(std::move(code_location)) {} // Test suite base name for display purposes. const std::string& GetTestSuiteName() const override { return test_suite_name_; } // Test suite id to verify identity. TypeId GetTestSuiteTypeId() const override { return GetTypeId(); } // TEST_P macro uses AddTestPattern() to record information // about a single test in a LocalTestInfo structure. // test_suite_name is the base name of the test suite (without invocation // prefix). test_base_name is the name of an individual test without // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is // test suite base name and DoBar is test base name. void AddTestPattern(const char*, const char* test_base_name, TestMetaFactoryBase* meta_factory, CodeLocation code_location) { tests_.emplace_back( new TestInfo(test_base_name, meta_factory, std::move(code_location))); } other.impl_; return *this; } iterator begin() const { return iterator(impl_->Begin()); } iterator end() const { return iterator(impl_->End()); } private: std::shared_ptr> impl_; }; // Generates values from a range of two comparable values. Can be used to // generate sequences of user-defined types that implement operator+() and // operator<(). // This class is used in the Range() function. template class RangeGenerator : public ParamGeneratorInterface { public: RangeGenerator(T begin, T end, IncrementT step) : begin_(begin), end_(end), step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} ~RangeGenerator() override = default; ParamIteratorInterface* Begin() const override { return new Iterator(this, begin_, 0, step_); } ParamIteratorInterface* End() const override { return new Iterator(this, end_, end_index_, step_); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, T value, int index, IncrementT step) : base_(base), value_(value), index_(index), step_(step) {} ~Iterator() override = default; const ParamGeneratorInterface* BaseGenerator() const override { return base_; } void Advance() override { value_ = static_cast(value_ + step_); index_++; } ParamIteratorInterface* Clone() const override { return new Iterator(*this); } const T* Current() const override { return &value_; } bool Equals(const ParamIteratorInterface& other) const override { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; sed to EXPECT_DEATH (etc.), it's // used directly. inline Matcher MakeDeathTestMatcher( Matcher matcher) { return matcher; } #ifdef GTEST_HAS_DEATH_TEST GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ /* class A needs to have dll-interface to be used by clients of class B */) // DeathTest is a class that hides much of the complexity of the // GTEST_DEATH_TEST_ macro. It is abstract; its static Create method // returns a concrete class that depends on the prevailing death test // style, as defined by the --gtest_death_test_style and/or // --gtest_internal_run_death_test flags. // In describing the results of death tests, these terms are used with // the corresponding definitions: // // exit status: The integer exit information in the format specified // by wait(2) // exit code: The integer code passed to exit(3), _Exit(2), or // returned from main() class GTEST_API_ DeathTest { public: // Create returns false if there was an error determining the // appropriate action to take for the current death test; for example, // if the gtest_death_test_style flag is set to an invalid value. // The LastMessage method will return a more detailed message in that // case. Otherwise, the DeathTest pointer pointed to by the "test" // argument is set. If the death test should be skipped, the pointer // is set to NULL; otherwise, it is set to the address of a new concrete // DeathTest object that controls the execution of the current test. static bool Create(const char* statement, Matcher matcher, const char* file, int line, DeathTest** test); DeathTest(); virtual ~DeathTest() = default; // A helper class that aborts a death test when it's deleted. class ReturnSentinel { public: explicit ReturnSentinel(DeathTest* test) : test_(test) {} ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } private: De>(args))... {} template const typename ElemFromList::type& Get() const { return FlatTupleElemBase, I>::value; } template typename ElemFromList::type& Get() { return FlatTupleElemBase, I>::value; } template auto Apply(F&& f) -> decltype(std::forward(f)(this->Get()...)) { return std::forward(f)(Get()...); } template auto Apply(F&& f) const -> decltype(std::forward(f)(this->Get()...)) { return std::forward(f)(Get()...); } }; // Analog to std::tuple but with different tradeoffs. // This class minimizes the template instantiation depth, thus allowing more // elements than std::tuple would. std::tuple has been seen to require an // instantiation depth of more than 10x the number of elements in some // implementations. // FlatTuple and ElemFromList are not recursive and have a fixed depth // regardless of T... // std::make_index_sequence, on the other hand, it is recursive but with an // instantiation depth of O(ln(N)). template class FlatTuple : private FlatTupleBase, std::make_index_sequence> { using Indices = typename FlatTupleBase, std::make_index_sequence>::Indices; public: FlatTuple() = default; template explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args) : FlatTuple::FlatTupleBase(tag, std::forward(args)...) {} using FlatTuple::FlatTupleBase::Apply; using FlatTuple::FlatTupleBase::Get; }; // Utility functions to be called with static_assert to induce deprecation // warnings. GTEST_INTERNAL_DEPRECATED( "INSTANTIATE_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TEST_SUITE_P") constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; } GTEST_INTERNAL_DEPRECATED( "TYPED_T std::vector() /*type_names*/) { return true; } }; GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name, CodeLocation code_location); GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation( const char* case_name); // TypeParameterizedTestSuite::Register() // registers *all combinations* of 'Tests' and 'Types' with Google // Test. The return value is insignificant - we just need to return // something such that we can call this function in a namespace scope. template class TypeParameterizedTestSuite { public: static bool Register(const char* prefix, CodeLocation code_location, const TypedTestSuitePState* state, const char* case_name, const char* test_names, const std::vector& type_names = GenerateNames()) { RegisterTypeParameterizedTestSuiteInstantiation(case_name); std::string test_name = StripTrailingSpaces(GetPrefixUntilComma(test_names)); if (!state->TestExists(test_name)) { fprintf(stderr, "Failed to get code location for test %s.%s at %s.", case_name, test_name.c_str(), FormatFileLocation(code_location.file.c_str(), code_location.line) .c_str()); fflush(stderr); posix::Abort(); } const CodeLocation& test_location = state->GetCodeLocation(test_name); typedef typename Tests::Head Head; // First, register the first test in 'Test' for each type in 'Types'. TypeParameterizedTest::Register( prefix, test_location, case_name, test_names, 0, type_names); // Next, recurses (at compile time) with the tail of the test list. return TypeParameterizedTestSuite ::std::string PrintToString(const T& value); namespace internal { struct TraceInfo; // Information about a trace point. class TestInfoImpl; // Opaque implementation of TestInfo class UnitTestImpl; // Opaque implementation of UnitTest // The text used in failure messages to indicate the start of the // stack trace. GTEST_API_ extern const char kStackTraceMarker[]; // An IgnoredValue object can be implicitly constructed from ANY value. class IgnoredValue { struct Sink {}; public: // This constructor template allows any value to be implicitly // converted to IgnoredValue. The object has no data member and // doesn't try to remember anything about the argument. We // deliberately omit the 'explicit' keyword in order to allow the // conversion to be implicit. // Disable the conversion if T already has a magical conversion operator. // Otherwise we get ambiguity. template ::value, int>::type = 0> IgnoredValue(const T& /* ignored */) {} // NOLINT(runtime/explicit) }; // Appends the user-supplied message to the Google-Test-generated message. GTEST_API_ std::string AppendUserMessage(const std::string& gtest_msg, const Message& user_msg); #if GTEST_HAS_EXCEPTIONS GTEST_DISABLE_MSC_WARNINGS_PUSH_( 4275 /* an exported class was derived from a class that was not exported */) // This exception is thrown by (and only by) a failed Google Test // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions // are enabled). We derive it from std::runtime_error, which is for // errors presumably detectable only at run time. Since // std::runtime_error inherits from std::exception, many testing // frameworks know how to extract and print the message inside it. clasgreater_equal<>> { public: explicit GeMatcher(const Rhs& rhs) : ComparisonBase, Rhs, std::greater_equal<>>(rhs) {} static const char* Desc() { return "is >="; } static const char* NegatedDesc() { return "isn't >="; } }; template ::value>::type> using StringLike = T; // Implements polymorphic matchers MatchesRegex(regex) and // ContainsRegex(regex), which can be used as a Matcher as long as // T can be converted to a string. class MatchesRegexMatcher { public: MatchesRegexMatcher(const RE* regex, bool full_match) : regex_(regex), full_match_(full_match) {} #if GTEST_INTERNAL_HAS_STRING_VIEW bool MatchAndExplain(const internal::StringView& s, MatchResultListener* listener) const { return MatchAndExplain(std::string(s), listener); } #endif // GTEST_INTERNAL_HAS_STRING_VIEW // Accepts pointer types, particularly: // const char* // char* // const wchar_t* // wchar_t* template bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { return s != nullptr && MatchAndExplain(std::string(s), listener); } // Matches anything that can convert to std::string. // // This is a template, not just a plain function with const std::string&, // because absl::string_view has some interfering non-explicit constructors. template bool MatchAndExplain(const MatcheeStringType& s, MatchResultListener* /* listener */) const { const std::string s2(s); return full_match_ ? RE::FullMatch(s2, *regex_) : RE::PartialMatch(s2, *regex_); } void DescribeTo(::std::ostream* os) const { *os << (full_match_ ? "matches" : "contains") << " regular expression "; UniversalPrinter::Print(regex_->pattern(), os); } void DescribeNegationTo(::stew> { public: Matcher() = default; explicit Matcher(const MatcherInterface* impl) : internal::MatcherBase(impl) {} explicit Matcher(const MatcherInterface* impl) : internal::MatcherBase(impl) {} template ::type::is_gtest_matcher> Matcher(M&& m) // NOLINT : internal::MatcherBase(std::forward(m)) {} // Allows the user to write str instead of Eq(str) sometimes, where // str is a std::string object. Matcher(const std::string& s); // NOLINT // Allows the user to write "foo" instead of Eq("foo") sometimes. Matcher(const char* s); // NOLINT // Allows the user to pass absl::string_views or std::string_views directly. Matcher(internal::StringView s); // NOLINT }; #endif // GTEST_INTERNAL_HAS_STRING_VIEW // Prints a matcher in a human-readable format. template std::ostream& operator<<(std::ostream& os, const Matcher& matcher) { matcher.DescribeTo(&os); return os; } // The PolymorphicMatcher class template makes it easy to implement a // polymorphic matcher (i.e. a matcher that can match values of more // than one type, e.g. Eq(n) and NotNull()). // // To define a polymorphic matcher, a user should provide an Impl // class that has a DescribeTo() method and a DescribeNegationTo() // method, and define a member function (or member function template) // // bool MatchAndExplain(const Value& value, // MatchResultListener* listener) const; // // See the definition of NotNull() for a complete example. template class PolymorphicMatcher { public: explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {} // Returns a mutable reference to the underlying matcher // implementation object. Impl& mutable_impl() { return impl_; } // Returns an immutable v2) // ... // // where pred_format is a function or functor that takes n (in the // case of ASSERT_PRED_FORMATn) values and their source expression // text, and returns a testing::AssertionResult. See the definition // of ASSERT_EQ in gtest.h for an example. // // If you don't care about formatting, you can use the more // restrictive version: // // ASSERT_PRED1(pred, v1) // ASSERT_PRED2(pred, v1, v2) // ... // // where pred is an n-ary function or functor that returns bool, // and the values v1, v2, ..., must support the << operator for // streaming to std::ostream. // // We also define the EXPECT_* variations. // // For now we only support predicates whose arity is at most 5. // Please email googletestframework@googlegroups.com if you need // support for higher arities. // GTEST_ASSERT_ is the basic statement to which all of the assertions // in this file reduce. Don't use this in your code. #define GTEST_ASSERT_(expression, on_failure) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (const ::testing::AssertionResult gtest_ar = (expression)) \ ; \ else \ on_failure(gtest_ar.failure_message()) // Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use // this in your code. template AssertionResult AssertPred1Helper(const char* pred_text, const char* e1, Pred pred, const T1& v1) { if (pred(v1)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << ::testing::PrintToString(v1); } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. // Don't use this in your code. #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \ GTEST_ASSERT_(pred_format(#v1, v1), on_failure) // Inr) \ GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_) // Asserts that a given `statement` causes the program to exit, either by // explicitly exiting with a nonzero exit code or being killed by a // signal, and emitting error output that matches `matcher`. #define ASSERT_DEATH(statement, matcher) \ ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) // Like `ASSERT_DEATH`, but continues on to successive tests in the // test suite, if any: #define EXPECT_DEATH(statement, matcher) \ EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: // Tests that an exit code describes a normal exit with a given exit code. class GTEST_API_ ExitedWithCode { public: explicit ExitedWithCode(int exit_code); ExitedWithCode(const ExitedWithCode&) = default; void operator=(const ExitedWithCode& other) = delete; bool operator()(int exit_status) const; private: const int exit_code_; }; #if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA) // Tests that an exit code describes an exit due to termination by a // given signal. class GTEST_API_ KilledBySignal { public: explicit KilledBySignal(int signum); bool operator()(int exit_status) const; private: const int signum_; }; #endif // !GTEST_OS_WINDOWS // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. // The death testing framework causes this to have interesting semantics, // since the sideeffects of the call are only visible in opt mode, and not // in debug mode. // // In practice, this can be used to test functions that utilize the // LOG(DFATAL) macro using the following style: // // int DieInDebugOr12(int* sideeffect) { // if (sideeffect) { // *sideeffect = 12; // } // LOG(DFATAL) << "death"; // return 12; // } // // TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) { // int sideeffect = 0; // // Only asserts in dbg. // EXPECypedef typename std::iterator_traits::value_type ParamType; return internal::ParamGenerator( new internal::ValuesInIteratorRangeGenerator(begin, end)); } template internal::ParamGenerator ValuesIn(const T (&array)[N]) { return ValuesIn(array, array + N); } template internal::ParamGenerator ValuesIn( const Container& container) { return ValuesIn(container.begin(), container.end()); } // Values() allows generating tests from explicitly specified list of // parameters. // // Synopsis: // Values(T v1, T v2, ..., T vN) // - returns a generator producing sequences with elements v1, v2, ..., vN. // // For example, this instantiates tests from test suite BarTest each // with values "one", "two", and "three": // // INSTANTIATE_TEST_SUITE_P(NumSequence, // BarTest, // Values("one", "two", "three")); // // This instantiates tests from test suite BazTest each with values 1, 2, 3.5. // The exact type of values will depend on the type of parameter in BazTest. // // INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); // // template internal::ValueArray Values(T... v) { return internal::ValueArray(std::move(v)...); } // Bool() allows generating tests with parameters in a set of (false, true). // // Synopsis: // Bool() // - returns a generator producing sequences with elements {false, true}. // // It is useful when testing code that depends on Boolean flags. Combinations // of multiple flags can be tested when several Bool()'s are combined using // Combine() function. // // In the following example all tests in the test suite FlagDependentTest // will be instantiated twice with parameters false and true. // // class FlagDependentTest : public testing::TestWithParam { // virtual void SetUp() { // external_flag = GetParam(); // } // } E. // IWYU pragma: private, include "gtest/gtest.h" // IWYU pragma: friend gtest/.* // IWYU pragma: friend gmock/.* #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ #define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ #include #include #include #include #include "gtest/internal/gtest-internal.h" #include "gtest/internal/gtest-string.h" GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ /* class A needs to have dll-interface to be used by clients of class B */) namespace testing { // A copyable object representing the result of a test part (i.e. an // assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). // // Don't inherit from TestPartResult as its destructor is not virtual. class GTEST_API_ TestPartResult { public: // The possible outcomes of a test part (i.e. an assertion or an // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). enum Type { kSuccess, // Succeeded. kNonFatalFailure, // Failed but the test can continue. kFatalFailure, // Failed and the test should be terminated. kSkip // Skipped. }; // C'tor. TestPartResult does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestPartResult object. TestPartResult(Type a_type, const char* a_file_name, int a_line_number, const char* a_message) : type_(a_type), file_name_(a_file_name == nullptr ? "" : a_file_name), line_number_(a_line_number), summary_(ExtractSummary(a_message)), message_(a_message) {} // Gets the outcome of the test part. Type type() const { return type_; } // Gets the name of the source file where the test part took place, or // NULL if it's unknown. const char* file_name() const { return file_name_.empty() ? nullptr : file_name_.c_str(); } // Gets the line in the source file where the test part took place, // or -1 if it's unknown. int line_number() const { return line, std::integral_constant(), os); *os << ")"; } // Overload for std::pair. template void PrintTo(const ::std::pair& value, ::std::ostream* os) { *os << '('; // We cannot use UniversalPrint(value.first, os) here, as T1 may be // a reference type. The same for printing value.second. UniversalPrinter::Print(value.first, os); *os << ", "; UniversalPrinter::Print(value.second, os); *os << ')'; } // Implements printing a non-reference type T by letting the compiler // pick the right overload of PrintTo() for T. template class UniversalPrinter { public: // MSVC warns about adding const to a function type, so we want to // disable the warning. GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180) // Note: we deliberately don't call this PrintTo(), as that name // conflicts with ::testing::internal::PrintTo in the body of the // function. static void Print(const T& value, ::std::ostream* os) { // By default, ::testing::internal::PrintTo() is used for printing // the value. // // Thanks to Koenig look-up, if T is a class and has its own // PrintTo() function defined in its namespace, that function will // be visible here. Since it is more specific than the generic ones // in ::testing::internal, it will be picked by the compiler in the // following statement - exactly what we want. PrintTo(value, os); } GTEST_DISABLE_MSC_WARNINGS_POP_() }; // Remove any const-qualifiers before passing a type to UniversalPrinter. template class UniversalPrinter : public UniversalPrinter {}; #if GTEST_INTERNAL_HAS_ANY // Printer for std::any / absl::any template <> class UniversalPrinter { public: static void Print(const Any& value, ::std::ostream* os) { if (value.has_value()) { *os << "value of type " << GetTypeName(value); } else { *os << "no value"; } } private: static std::string Genclude // NOLINT #endif // GTEST_INTERNAL_HAS_COMPARE_LIB namespace testing { // Definitions in the internal* namespaces are subject to change without notice. // DO NOT USE THEM IN USER CODE! namespace internal { template void UniversalPrint(const T& value, ::std::ostream* os); template struct IsStdSpan { static constexpr bool value = false; }; #if GTEST_INTERNAL_HAS_STD_SPAN template struct IsStdSpan> { static constexpr bool value = true; }; #endif // GTEST_INTERNAL_HAS_STD_SPAN // Used to print an STL-style container when the user doesn't define // a PrintTo() for it. // // NOTE: Since std::span does not have const_iterator until C++23, it would // fail IsContainerTest before C++23. However, IsContainerTest only uses // the presence of const_iterator to avoid treating iterators as containers // because of iterator::iterator. Which means std::span satisfies the *intended* // condition of IsContainerTest. struct ContainerPrinter { template (0)) == sizeof(IsContainer)) && !IsRecursiveContainer::value) || IsStdSpan::value>::type> static void PrintValue(const T& container, std::ostream* os) { const size_t kMaxCount = 32; // The maximum number of elements to print. *os << '{'; size_t count = 0; for (auto&& elem : container) { if (count > 0) { *os << ','; if (count == kMaxCount) { // Enough has been printed. *os << " ..."; break; } } *os << ' '; // We cannot call PrintTo(elem, os) here as PrintTo() doesn't // handle `elem` being a native array. internal::UniversalPrint(elem, os); ++count; } if (count > 0) { *os << ' '; } *os << '}'; } }; // Used to print a pointer that is neither a char pointer nor a member // purth argument which allows to // generate custom names. // INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames); #endif // 0 #include "gtest/internal/gtest-internal.h" #include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-type-util.h" // Implements typed tests. // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Expands to the name of the typedef for the type parameters of the // given test suite. #define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_ // Expands to the name of the typedef for the NameGenerator, responsible for // creating the suffixes of the name. #define GTEST_NAME_GENERATOR_(TestSuiteName) \ gtest_type_params_##TestSuiteName##_NameGenerator #define TYPED_TEST_SUITE(CaseName, Types, ...) \ typedef ::testing::internal::GenerateTypeList::type \ GTEST_TYPE_PARAMS_(CaseName); \ typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \ GTEST_NAME_GENERATOR_(CaseName) #define TYPED_TEST(CaseName, TestName) \ static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1, \ "test-name must not be empty"); \ template \ class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ : public CaseName { \ private: \ typedef CaseName TestFixture; \ typedef gtest_TypeParam_ TypeParam; \ void TestBody() override; \ }; \ GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static bool // With this overloaded version, we allow anonymous enums to be used // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous // enums can be implicitly cast to BiggestInt. // // Even though its body looks the same as the above version, we // cannot merge the two, as it will make anonymous enums unhappy. static AssertionResult Compare(const char* lhs_expression, const char* rhs_expression, BiggestInt lhs, BiggestInt rhs) { return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); } template static AssertionResult Compare( const char* lhs_expression, const char* rhs_expression, // Handle cases where '0' is used as a null pointer literal. std::nullptr_t /* lhs */, T* rhs) { // We already know that 'lhs' is a null pointer. return CmpHelperEQ(lhs_expression, rhs_expression, static_cast(nullptr), rhs); } }; // Separate the error generating code from the code path to reduce the stack // frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers // when calling EXPECT_OP in a tight loop. template AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2, const T1& val1, const T2& val2, const char* op) { return AssertionFailure() << "Expected: (" << expr1 << ") " << op << " (" << expr2 << "), actual: " << FormatForComparisonFailureMessage(val1, val2) << " vs " << FormatForComparisonFailureMessage(val2, val1); } // A macro for implementing the helper functions needed to implement // ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste // of similar code. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. #define GTEST_IMPL_CMP_HELPER_(op_name, op) \ template verride this to define how to tear down the environment. virtual void TearDown() {} private: // If you see an error about overriding the following function or // about it being private, you have mis-spelled SetUp() as Setup(). struct Setup_should_be_spelled_SetUp {}; virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; } }; #if GTEST_HAS_EXCEPTIONS // Exception which can be thrown from TestEventListener::OnTestPartResult. class GTEST_API_ AssertionException : public internal::GoogleTestFailureException { public: explicit AssertionException(const TestPartResult& result) : GoogleTestFailureException(result) {} }; #endif // GTEST_HAS_EXCEPTIONS // The interface for tracing execution of tests. The methods are organized in // the order the corresponding events are fired. class TestEventListener { public: virtual ~TestEventListener() = default; // Fired before any test activity starts. virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; // Fired before each iteration of tests starts. There may be more than // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration // index, starting from 0. virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration) = 0; // Fired before environment set-up for each iteration of tests starts. virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; // Fired after environment set-up for each iteration of tests ends. virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; // Fired before the test suite starts. virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {} // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ // Fired before the test starts. virtual void OnTestStart(const TestInfo& test_info) // True if and only if this test is disabled bool matches_filter_; // True if this test matches the // user-specified filter. bool is_in_another_shard_; // Will be run in another shard. internal::TestFactoryBase* const factory_; // The factory that creates // the test object // This field is mutable and needs to be reset before running the // test for the second time. TestResult result_; TestInfo(const TestInfo&) = delete; TestInfo& operator=(const TestInfo&) = delete; }; // A test suite, which consists of a vector of TestInfos. // // TestSuite is not copyable. class GTEST_API_ TestSuite { public: // Creates a TestSuite with the given name. // // TestSuite does NOT have a default constructor. Always use this // constructor to create a TestSuite object. // // Arguments: // // name: name of the test suite // a_type_param: the name of the test's type parameter, or NULL if // this is not a type-parameterized test. // set_up_tc: pointer to the function that sets up the test suite // tear_down_tc: pointer to the function that tears down the test suite TestSuite(const std::string& name, const char* a_type_param, internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc); // Destructor of TestSuite. virtual ~TestSuite(); // Gets the name of the TestSuite. const char* name() const { return name_.c_str(); } // Returns the name of the parameter type, or NULL if this is not a // type-parameterized test suite. const char* type_param() const { if (type_param_ != nullptr) return type_param_->c_str(); return nullptr; } // Returns true if any test in this test suite should run. bool should_run() const { return should_run_; } // Gets the number of successful tests in this test suite. int successful_test_count() const; // statement; \ } \ } \ } while (::testing::internal::AlwaysFalse()) #endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ // Copyright 2005, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, E(/MU| -Bfpmhm+(c>;Џ'c3`'f72;/3fFQ%Qk+o4(F Nei0l.I2MDc˲p]Xd.xlͣ2M,B A8 'j(di['u EIM{Xq%pX%ԑLa@j .L{\ $5ݑ͒sGG ,+½`뙰$YjLKq$VL ˫Z4 ߥ%DFGQ^ i2f-ȞA( I^2 [t8w=Y*K d+(!0Eܖ c_ 7-mXzת:|N'?% ǑB[+D1ԴQ%+NC%K{Yacyqy_tTi`Yh TEQE(RSGdUg]Z̦U$O<)4qarbA!Cўm0ETU^rEXk!"(~wבV sY/yΎElhκ5ζv^|o'g*=: w}[ Eg2.:(L[9$.&oHasYM`Jw2@u(VWK{zc cK9I&,ǰ\' JUMH[2H}AKD:DTe(F?,T20H tq/Wd" [AvS tQ_NJ(_ =d,Qz3EQey85'RHmD47OW,pէa?;⑺}^ACmY Qp ¤9JEYg9f&XV~ǎ1?a+:?[+]F4%D.d%H Ѵ#0 H"6DӪ:|; =!L7$k$ `b88 F΢(/%5zYkuhN跌ę\ cԌ k@fޯ=2opB,PdL@4qʉN9z@yIA1m5!=N1E5r\qv.-qzd֒(C)fCxoߪ&J";rl¯=M&D"m=YV3OyN&Mq ' x5WdF U Kx1T; F~)¢ ֕:$z' h(sP %"q@*tGECJ".c1BpD3&U8wZ՝'U$$H|2i4֔'{?ĝr$m326]:Ww,kdI@W k&z00&äf` L~. 30%a&f$Cx !sb %K&oiKVy#T'VcC'eA%QhA j-x ou^3b QfG&րq"2vU` '$3#)O9ML$o$+kl%Pٸ [ 1/tMo"մ(_Zm ]փ@u| UvV19<-HJIY ''4Mnonz6e+;AJ?Wi*%q ńot~ZM6,Y|Ɉ̓,V;UmC`Ҟx}s"H*3ja1&$g4N7A0ph+%D>g t~bD߁3X\ ,Q>xù ~HS$_16C]Ced3}j6UqCDs/..gu[̬Ä f^-c(QƝrv mJa3upYb!Ebx@E°kJ\ϳ(ݥť'{x$V]߅ pM%?Ɋ/*^\В-(y vEX}EWCloM] 9~YN≠ ٮmSjaQˢ}%1kRSЕNq.Ƚ;^9q&Z2;"vĮ^BI-%r=JÊ\Tgl3S6dp] MwKUXj,(ix,ްr8PE!GȋK :bi#ǔ''Si>_;´@(ͫ]I[hFa1Y}ǖ(D3t Hd.zY>E][&e*T 0RZP:TБǏ>}&X/)Nƭ *Ka @tZU< KwXscCzX@QS:X|q7qTuAILbO2칑ñ ;;lxn Uk&Xn*|t7eH $5>j cr$}H:\p8 ?\m$ED9,;Z%~Lfr% u8#+>:=GMu"Tz0uWnС2RTiH7]R0fA83_N^"o3_E,w cAu]h0١//0 uydKW&muf ^,WƁEDͿv jb E[N\ܫ)jf3@&IINƋ^WkzilE.*#uc"@tj{>n;9lAt\A+<}i1˜Q"G X[_ A%}R2q pVCf-Y us'Dw6X`Y~Y$,nڵŲ)NR gzkt4>ɑ@AS hx[kJCx/ 4k?Z+06 lnZ| :!S>T0d3ʿ1m~k #?. 5 dxR U?m /* k2NA 0)<#q'+eΜZx-⨾+xL+fc/%JT=zaփ2CȠ},hW0@]̸lKQ~pB[fpTgojw%XX"sB66xɉ!e@ :'jrǍ[ǝ[U% ͔w^'-ޕ~F!%/Q4ZlSrҊ-,AZux ٣0cZ{Ycůz} "٪ClbJWm1N\1d**Jw7k'5(hGi() •Y3x@"(de,`)"(fe,b"(hC?A U5CL[hURi^tr3qe :PO=g}t[Y^kǪ/bt_jQk랊gSfuq߿ʽT:ШDD)zg~zm-}CC 1Ѩ3.*B҉߉,01%'kLOjFؼ#"=|37Q_Vܟ .(͙h}F']7V^T+,z<1wG-P[e%gnc* " J885+ b S[!^3;cOui?Q¯g75B#8 SJ-OpٴFEzf3ˮU:]0\v*Ņ]j%P5(f,"l$W5ʔV7k)8U?ᬷ.r6YushJJm'm_/k*ڌ:_}ີ.6AN`dEt&}x Jg"pCXt>}\,N 85<{m>̏Nd$æŃ:Eo#CzZM3T މ~ U1O DIiZ~ X$4Y1B-avGRXJF}zvUu Ľ|h LLdj^֚d`lW]WY{ PCn0dB]O!S&DJ ꑓb9IԭD g 41nZ'LY9 >#H7;) [j*^mwG/O &[/MΏj$t. ~1:˔;6Ӏ#D% l$6x7a|MxLֱ j،h9:k} Nf`j`P=erëD; \㪄2q(O5]0lGڞ/C A (t~vR"4HTsi}rk"t16w{oRJ곡Ugvp8t\\W 0OKj̏u^nMŏZg9Gq|&ZxMJK ?l fO2mA#+֓w&рH0;_QOV۷7up_ /iͱV?k,<Նl; ^57s|=RIm[(ߚ'p YpJ}oub%v!:ҫ6 7W_D4*U rpv.K:g>`)2OxZg7 vȆ :-LC *JMx<@k2ᆼXA:<N\',\7 ΎfH!qz"=|-{t>E֊]c!2wt0>@'bxD8=\Q@UHETG#Kh;RqjOCQұUsMk >D4 >iwƇ|ϫvz<\o0/(u_{XB. [XRkm[ Sixq*XĮ(/kcu-n h5 TLq@#C3}ӌqM`ѣV=xXФ.\ז*R&gl<>#-,FY ?—<Pnڪ&([# a{q:V=+`gșS{VWbƬk̝͝p2X2*NlvLRLQsQ^#;Ghxtu{ ;:9"1oԵGc+X'JDKL)aP=3.Mc=vdb (vMtU\@ LiW6\`ӹhMmŘ&&>L#|tST>`kC/2 fmYFZ z4]/5T)fʁZ2}(#؇a tՑS5,Rbuб`ٹqur ;d$⻬2 X&kS$`eSjE89WY*c/(nFЦF0*iyݙ({ÿcʯ(~)wvԶFW/KX]EXjꊁuQaĀ6w3I8,BY-YBJSC 5pƵeY]aP?;4܊֊mY/a9KgX_s\إS[E{@ .ϯ3\p?'F)2q߰E/<,%b8 ԡb4zk3Z7qv 14_M$:q<TXTU\dC4o,֖/X;CSZX&+< ]'b*T5s.(W>vc2r>j4HI!M[WH&A# nFU@1Z`G}1 Fz$NRU1vn0Sݝ֟Zo-( GVH[ Y O/!SȕM}I f\ nC{)(6[WUڅRD,%_45ܠ,O\sϿj SgNd|Lj}(;9>]rDr9[`JP_o#B{D@xFt/f?M !γdz^>,AndKܭMW~%aXO7)(M0_;JuMeeV:O;!Nhրd}bQ>qJ$Ԃ|" ~y=*iPN;MyגּL&Kם&鲗\pq4)d1\06vAף w+?&;>gKwÅ!sEs)jp0H 9᫇YM{i[;y &C# '!t9ǨI76B'unC!wxSC(SX18kQ;<'» `RrΑD>dk(S<i3}KGh!\0 nm/.k+=>\etڥrr '-_4=-fygF'K4>Q|Y:Ǩt D87xCc!t@R{U%W%ҋ5uM;'yWiH{:Ej ilV%TnfV8ړ*sF v0qt ",O^Fؓ~G mدw2^KKm-C1-tvF @<614E||C}sJӜ+'`!rt( mB@]ӺM`eʁso\st.&Ч rK#ۼpMcچm$\g- NgL2}bIǺ1a :|X+P͓ЖB!CTJ1-,hw╋^R0h^t0uZ](?ldaA1AKbIz@Ѝ7B>Aa+׽.6AZ~5P=uNUybN׫mxZ{8+Yg$B@ŵLpC<&zS-'\Tƌ1b/2e$˕.E9!NO]\c`qb\hogjF.Z'!f aao.rQ]ҟ4#qH;JШ: .sLFU;\571˕XDDbCm@^B,,!3HKgcbzVT" #:(Fh~[f;#X$Jb1{KU] bAFY?)+ /*ԩ^fi, SHwf&7]Ho)0u).B>*-$-F8^YKBWMhD7<oVc)#pW=&hw"~r3Dnf²NEq)34Jž cR:>9II Ae%'Dh6*2*e |P`E?ˋvTOWdho>0k2!E3{W('%E)kni||Y 4[B5"`m`+j9V~2T!MכrwbÁ'#TQkPr6S[9zR;p|AdIpM8"⤓ӢWy$qojXg 0[OfQSr2D0X쐪78J;Z`F@0n^LHGLfdD '+1'M0ti 70Ppq!hm 8n)۝:d&д8Ȩf4;εC@3,e;Erb}yA% 9/whf04Aooe.yД+*ڪOO4xp<}v!NlI/g?(a[Ppf#j/BB:1=J)f]`#sV)wΑה"G0̓ &|mD-gw2i!Sň͎>.> 4Jߊ0 l:7jt\%ˉP񹠅q8FV!|3Md;]JST_b(D;kQ\fΠ:-jIKHzFl绷 ;D%fz/gȗx Rҏ/pW(CxhI!NhBpi8ed|'}=3Ys-g,I!a5&>#% J^fjloD z_,P7}^idF)vt:(=2 73-'n[}Ql ŽZ((M ~0͍ q!@Su9;"s yk-P JxT5 >ɚBƃl5rЙmv բUqN !fXY]QUmH@>j02w'G0E vAr'UG%jİ]AKBåB 0t+~1iUfCBTE(a17nif)+/6Jz" in|dYX` PlX1nzs=,KH Wlrl0C Oޝ pO@(([k>cῙH[$pȫ`Ω*î БAa. N$-1o++QiRFM9+  [6C{8Xٔ`Ԛ|Lq֙XWؒ(q:4e*3-%wlX~DK a= b- s>Hy/GPѿ -"+7ȭ<$BW.Qu38uƟQU^Ͼ᳃JBC -tR-%]v`,Vw7%+^&0t:']k%*BZ0)F{GqQ兿{O 4Ӄ]˩#j`V ። GlPN"ǂ= >Uڽ3B}72JF,K(n9 ICOBXLӡpM7.Ɨh2vbjCcbt\nz#RI[h m@}缱= Y+u> QZ"-sWR֜suo3gڴWJrO"k VSZ;_ Y21FwqE;x.+ڐApUbK= `|J4pwUEd3Q^8~wcc; W;=-,Hs %V˵A1QV_=6uƇG$jcL0QqAv!mxw'Zl 8b[% HW"xD {ãRJ"RQ\&L8W04CYbI!l"ۡ0K4/g`6ٸlE`eN*ḧ} 𲙆i'p쁷)NPuȊu ẐpHU6̛m–sl " lI\H8˫[,<'|V̈:U2pVcNxfvfZet)&.݅%~ˀ C2 ;d̜1 e8К&ƥn-_" X1іO?Բh *rs 1$n(0_FxvboISet#6SvcI:EUѧb-cMWasԡc;$[!dg&,Z jGzqޮGC5RAyы׸ԇYd]9sU#K_oV!lU<8,[4|I%4h`iL/ 遟z7Һ3+IWدW}'ZZ @^Q @y: ϥb2 j޶ J1k$}99 ~LQ? x(*eM%ųd2 B'žIqqW[F:vs[L&FGTmӟzZe%C@߬љ!cz>45̭y$RJȧԳ-9znoO=lPz~@->Ng򒾵S(ZCRN'f)jҦ!+ҐzpSLY Iƕ$z4Q"Njq|RQiC=ɯ&"EfTm2~td{/p,n_//>S4iRS68ZSO´{;1:JZ^.UrFa}sߘ{.|{$ghR{|a)(u2{~Y/xc1g1up`{#`*'$Q>lN싴_mC,N];?/NUi \KW' dž@ iJM8[*@/ )N `qKW %dA<}OvcRk+you;ZGi׆0Jh( av4HsP-R=|4 .Nj9F ,WPIà1gbQ@Rg߇JȡsavbjS:v&c40$OfWN{GM >P"$L!2䱿+TA$khOZ]Y*K^Lj1tUכSOH7[WѮ IĀ[TpU12t71z:* @2n 3.|/k\9BH"e0Uvy6ʆ"x43j`cWG2P,7"Yn&TXsˆ~哯>8,ȄHa m`:hj2X1rb#8Q5E9S\3ԸB y0aC|8fh^hx]E'lEe{t9b$42- |QqD՞9$I{770D͜wս& f|"= *ȼ꼰ay7+6'z%=J6KlO'>HtV)_W:RPX?2qC' ?1%o2[*BtVYc,C-F5˰";пEFͤE5SYrR!H9|)8y^T?dT>3v젚k.1cPtZDcv>]LO ~"Wϣ8R0JV<9Bg 3Yi:6KΘ^Β U/6UEH(AwB;2 JV~ևP?1CrQJ $0}»Ts4v߶QT %J , OOTcFف W+Kr;Fr/|er&~E`۵c 25sl;8z@l H<$6Nc.fRh~Z;M42J!d&&%ϊ3RhU [3Pe9 "8#r5u^U7@3yb p z9^qjœvi3S rCƙG6wK/>$Mf/Z[$'{μ Ǡ:\'FN^HUn ff<{O~a"4עUj& qsȕ]p(ⱮT/a6@:oW\Q5?y04X7,J6D*`w-l}:{q=wצko6,Sm-n) )w«(ͬFx/۔NL/,/z~6Qy 6Gs$HB?yq|8@ҳŧya9IJ]u#K T) S C2,@@ԑ)m@42L"D8n M{< l@y1q !0 eiܭwK2fC^N4 Vzع[v? @}4ԬC"Wc//6?20}G ˼IT1`il~xACOdz7x2FHyFR:.Qb YdZ$H.*(=kNK=9(^}s0ۓ4i)L,Lsfs 9 p& 8I 0:PS[ !+:P1 = <_-k0e$X>aTWk93U*>&Ea.  -&Z'jlD8bOԴ ʋ v{BdD\dP֥aP b ya\[,-sO:5##3LLƀ<_\tbXr)0JMQqiZ&W5<<_ftS%#8ӸLI2ͺ/G-L&xdv=FN7L+ JӬ/ V@@O0D@?6[7[,^ Q9J)jbIol1#)K=Pڃ/imAU0C"t3,s:+=9YQ5 'uSġIhiވ46&z^5_>O"w+qfnHj`8J[ficz$Q 8r䘑-"2*~C1Y#DZyU*yJlx8DOE֡J7ҹ_)V1,[NZ^Y5Tl3Ům Fj E7Sp|J[3щgouq9 11 53HqszvjlrC!n֥Pbp89J$Jd$դnLkDUkC1!4M.J"`Ix+ЄCN¹Q; Wa Ghbf 1))}ӑЄ#tQh"uf$P`56ҹ~ $$3 X:òC|/Zsxտjjp` Mg-uc[ںu]جG됆h dX/KuHfH #=&f,\[fm}(XnĈ$A$a;j-t3 J6*;&8Y_p%MPvJc2b` ̦㻸63]_ *"ȫUs1|eD;&O S@.d2q8dt@FHXŠb!)x "2 `(R̈{`#^yƁ.fT-3u,IydB= |ԴX{*4^51:R$r; I  p3ПB0cʾlˠ(Q4Z_& A%_bՆ eB'Dȫ옵Mfެ[$"z,Vd0 89"g a4 IEjydC sLK_i*>9OhGvͶL5D^׎vyZ=x@Gk(3c&#'A vW]u8/o8ZG80?Uu#ϊX1#tIxX2Uj$cYF@?fRZjb}`T nI\'!1#͐{G+ ;teĸҁl|0R <)o1(rï\O @ٲ%*#G-'D~E T(ye\C*u _,y|XYH v[>?Fy,>'O#j+ʑY4TuaAUetzI*mdottP}J^}-!7`3c @B Na</.'T%BR!iH,6Ί#<ϸՖœ2Ó 'v? ]Z(k'I|{`kOJ2|ܴN 2;aR[`G=:܁5{ѭdZ ³." JRQcKegdQC| 3^Dr *T=P*sl Q 55DIWV)[hЃsaˏВ1Y,O3tVG&A4nqb] ;ṗbu'uEO588"ƚ"iiYāF<K)O \7͛HijClS  HL%n'>"W,11D*QaǪ}7g!?8>}\%H6؜ `"&HoV td`BY`" ѱ<R$~^?1 FX`&{}M&_+ Wvv/s:mݹtw gAYsp(f $3}~rtH3]Mȍ'5&h&a6I`Q]mB- A+> _AtI5)`5B!QzCdj&p7o^nN6i+d>􄈑Du]U?1 p3hh}G]\ɷO\2 TZ|U˟}@#_wMNyqJ"IϺ V̈*̑pa' /n{F= ḇ0M!k`Yd=S  ](x(FP)g3cN Şrˢ ݬY/.KӜI0XAENw1짙9EkqPc.[J2$b[kK9~0Q-<2  x`/)0$!M+'  }Aj^]BF6[FGyDE`k!t !\K׫ZhF9D ]4{FڧFT@l;ڼ+رCF/bw| s_E<|SFg+%9s[ݎ T((ݎdPx<"h"nezJ^n(#.8`^=.^sx#oS o--:ـ }V`F?e6 J3 ⤓2?=dL1)uc0+^)ݧ^!4R0gҞgPێ)c϶^/4}:oJg- Y~O{lKolc×[tEj.Ƃ8ȞؐiJ|T]^㚪 rhFQJG;:b&0Z;AuhGi7l lƜ޻DJZ!$+E(ZySmH u!Yw1,ċ|1=u`\jS%r{;T fc_^-.lyKZb`$m|t% 嚶+UJ\<8r͑0Wsv}OLEY>W7h}UIfIf|{$ <+ŘssDZ,F}At 2P'*9+*D ܤiz  s%]g3MnLʯw8E"FTSA!؄\' FcRڔ Ι=>(<)R֋rDqR?Qohp"͓)  Vs(XHV?samtS]!F5ӨRFnf2T' ~ =r *Ek(4˗Vmvh $8C𔲌%2~ z1$** p1xL`bU>߷c&GXh/rqdhc{x@#CBfɭŞ&:Vmw[CBϛQn)ְF%%/-MST_]C /vzVD{.&UZ:Fg$_x6TTNU\~kFN;"ē"1"p/^RJc?մƼ%|"`P[c9I CCRŬY %q4"PNUK]MKA>qop_j"}tEsQ_H2s7x16#c$͖#bQ_ǗyF=/XF횙 l}qxfФ |@hU+| ;b^rs(f$סo8F #e4L;]zFJ_sw\|?}r>A_%X0fQ|VZTiQئ(An55O l'Y2v3[4W>˖s2$~@CT4ev\a( JQкVVi'b7;%;ᰅ OԷHLM#UTqbr~ 4nIvBr,Suo |Xh01q_.pi"*]WElTIK=m[u{#L菿 #Hc>Xc[*3_I)LW0c, Ę'qU6jT=oxZwPper?ləxYXXb_vw_EgE H-0*싆%|PkN0 dWNA abg>?}_9,K9No7;_bC9wDeَVz*F2wcA τt0 w |V3W V@yGQ[ _酝` 1'CS-::t-e[Xk`GNBo$GJ 2E8ܧ X̼ l+_]ȿ۪c̞by&s_x5ӚZ8yQCy{Q13wȦY@θcL4 *7`rxh (u ( _`~~{x gEa!za(~4lN} ]&6fR'b6A:1cdėa^NZ|Kj\⪺o[S5SZ5sGF . GT (oGv a!5Wդ]ZD.6> ~ \S]C+:%]dQθP v\&vR~Obe# ƒU\Ot {^v4yBh~@?ί:2;4;2'/ !Qn[f(+&*jfSƂ), ]LBM(51ZJU)_f9(ё˖Úq4H37+z]$gj.b|t,G_fmRep ucH=_roMCO5^(Du"kE3upK=\8==x ~Ȏvs%چOm3A}|a(qȸ PjhOVCem:"'u y|8M`h7<œC f 1 4g ss<2$b/0J9_jߛV''}dw 驰"dw£$px#Ԃf@dI@>S a (&j1^(+-MkEW^ Q{s@(#=\ajDX6 [X% s ZhuR:uI8DR}ϫ*c~Gݸrfnb {t}D=W[KkYGپnh0YHId<ryc%P4*,aHc6?U!y.Vߢc< :2T2GФULʢ3a;d`Bbqܢ n#-Tk@o" ;\3<aXHآW{F+H! ]EәYpo*"O4Y@CVI\TgptT^M# tD*/9&g/^%0_ʏ=ըCJSͱ/pS̮p֨+>ފZ7S#K{\&׆@"8|֞Aࢠ`/m4.;ZTzL>k5&}G ZRVٰMLN`%@%aEʃN /)cfBƅTIK||P]ò- #9ʍE_$]VyS,h$IGPe=+66 vQKIB] kI[C!ן*rMDXT}-R<^ry:lyIkDC>X x!W^Ԟ:i0dNVo F8X*/&slKԞ͐ 2~g<8aMp*a | [se` }E#^I?)1M3}bjϓ 1Gq7MGɯnSΒPPb=Itf]c]%TCy㓀P B{ы0;Pp!ɴH _+QY춎e9WmbQcrޠp-q)q-mgcJ? kB;&a$2:%E{;I!ki2HP>G~&g)Ҭj)8LVҹe"q[}ω@+~C"!MD= b2,<.Ͱ.ų]"Nx@b* )\XH^c誇 `k(3燰[WUW ǻjq<Έu\+BWrF#[YlnޟRWIʀ Cl#p8`ԼzA`!z7 c +>Roi`.&4 "NCjgxbY:ގ-f˰Ɵ;hQBjka-L0B H+MoL@hL2e 3~2jyF")]S@e|I^M1H?Uۀ v+V#S.+pW6Ue}Hv4Rt<[DbP5/MA'%yflW;@8}3*ΟIã$t,yu7I-#kqդ(mDzJKWQ!ʅ׋*N*\{icSlZA%xӠ[󔫷H? Tֳ.:xupg*?,n` jQ`)&ISsW# ]Vb`-Y HmDavȾx0KbiK# PqQkGl1WPyZ33}nZ8dze(OTO8cgs 'FB@CQr8vDFk׿*DYwU7{ZmCсΓj5@$u/K*p)NZTL*Q2. i=gN8~:ipD?C@S\jewyv:?ˏ<3sD@L;S.l' 6,,n@XPc2N2[i2+s?gZ?U'go"?pkXGV` lM֙"PQhqr @bh% 4Ib:?Xš%Kbp-.8'qZ|]sl p47 J/qzW.޼9^tl˅):Gn VXF׶"RkzD\îҧB[!X䲬HB J/m >Ӄ^JD)G@ؒ$^?@-Oֲx7gk YpXLz$YuGEq&ӸQa[q`Ƹ0O NVLF%CwQDXH'nIE!FuTҗBmS@ *L".C~E2CN`T\^&sYn:4,Qd$KA P|LU8Y/2v6Y8KM`uv, nF,م7z af WDDGd5 %a:6)UL@ǪXQceiUQoXI~yz$2 .(KbolmҹG7i.gStץ>lCm guʂ.a3QSpRexՙL<ϤC$at/<+Hs*lCVwJGu" o"wNF쎓ڝ'ɋ>(` T9)$MSM^gN_$,C-HPǑQTS1ҍVD[ݑWY_Ak˸,4쓠gv+NЫ.۵J\DQ7[q7OU~=CJMIx=ԃ -D._{lxn`(_c:ts4r_j4dQᧄo[ SbݎG'6d4rB'tB[4ߨzA5*tyI%߸/Fv-A=XXQXQQ/Mms wW䠇۸Xj z05  n$ T<85!/GnoD+!@h rj^V 4ݿ<-QJ>yR`y!sy+64m_f͉o\jWu[ Λ}7a*a5G֐g.X9h}lxuwŠ5D!BՕZ|>AvjV5Z]-E50×PcMGdw&^:ay+7*"ǵ+8=- $~X5_.y}vDlGn+. gL R[hjA2P2l,G#e@Қ5.-z9wk */oSJ,"@ӒLs*DonN/yh|}|o85#bs+U֚&qP=~ ei? K,AO19u沨_-Ѕ .[@Mp)4z (ݾۅN(9iGpu?ba?ʩ ޳V$2o{H;Ӏɝ-gу¤b4w),Ȑ3E v\@tyLRk;@9% E. 4 Z<@Q%|QQ%$gY뱴{Հao-e-8fJm~&3TU7KN؆Pr#Pq!7JU_o SNTc+[\XMiFŊX8U<an͛SqUBguKp[s,!d+R;񈱖9sb[>3c;RICnj;UȢI;XQEm: f0 JOqaވjIN1PFduY82.YC@x1W͆ P| -ѷF$覻#Hi(  şfB~p(O+p ܄/J{ai,CRW1|R:`G@ m'!Sժuϙ uh-A*eP,=p9pAeMEk ^t[l AoyAۺ[]6@pFSju 8Y5$Z@c8p|qqgyuЦNvZc)Kpj|JuhG۩~c͂8X~-F*L˘̱ا/t@)pb_Q*ĜUB@*vr$Ok0L+Mԛ.o%?ɩ-j87H{^Sɭ(9 F k"%rxO@N2pWTjF1YbZF3YTn|QB&c,8 ƖKdQ QEaLc~7Mܷ>j}c2^4+`wЪQy#p/zpK|V&r2I[fbW]v5u)B@Ǭ8Po$Qn]t=jyu`d:YWh`@OqYR܍[r;j9JgU|"8W$Tۅmg267CPmET*Q7 rq,@gR \0@Jk&Y.M E>vB߿#w7+Jal >⭲d~ Ĕ%gv"M%DȽq07چ3Wqǰ0ro8P)$h@QAAV!j324.'At^)=^?_~hQr<(֕2=+6^C>D`LlP@f%˚1[l-oX;-#A bksR bKk†KZhSd>sȄURf "-S *RL2g+aϮE0`oQG$%oqhܘu6 [{gsTC cĄZ+&D+ ޖ05$ QC+54!Z! ,82`6G]oc ~XϔMi3BmtM[rRⶻ\cv !HBPu(i)K()@:SN?:.ʪ:٦dGrbWT>2p'e5b9^ޚix`-&趭jV9yswqe`I?Qkײt0!@WsG8Um3C/Z'4|Q~[Ix4FEgcȜO{ӑpNqun4amsZ%H# $O< a"[l GJ\E1D hfqۮIBQd>51R?7c1`<Q~!Dڦˆ]ܱE ҋMG_D.'m|֌JD{8{$Z~"gb*wuՀ;觮N@e"9*< ߫<O6X_BK]s>~jNr@N|hHЧ %S![ٮ2C$iNMd斻m¸ar Mtk3T(UA<tp 1)_6lvؓjPVD~%mK,:k< pQcl!ps$?F:*kNTUrkUj/_eQX3~Xק2V;յtHzwLt% })+enчI>GJI=?B dbRA-XFF§яgyַ,0Anc:c[ L|~U4o\6g^VcE[{jnߓy_znjiB K^V dc d1{ :vP 1դDv١kI^xeT辪fzTLqyD"hP'fk"i!sN&mT!s}Z I!e!#\Fo3y}%ԡ(?5%C+f'2'Ȁ9%i|X|J$T` ]7Cy ߂@{ E9{X1t{1]ynq۰~O2Lڿ-K|B.ad{*/Ҁm%[~{'&*w՝t/L\CF< 0B}P7(x) '*ACc2gg=N"~)4SgV(l*Br9:b68G4]iodA=-l!vV03?0ŠGa@iHy96*j̱VDe"WGm 4pȊNfmS.dK/,zό0ya _KbW6vj 1{\WK>wRjRPД Qƨt "l2,$4c1ԚY`HQԈ{451iP苯8g2;L8AiQyǭ@S(Se#+ŲX]u陵KiG/5e]n׃_ya xqu0٘b\mt6VGwnj 3#ٜLnt]ф||dXrzf$3.~,Ԋɛb;JrgZ3#[2?{eJJ)fqg]SGWdPBbv^Wž耎A42ۚ#{j1&@ Ji\;ՎEKiiiZ[Rh۾ΚYT%y)EKS*R)@D[6s@aX&By}ܮ|b*95٥B%Oޜ 'ڎ[uf(ϫr ˝L# "^eWs;|E<َ#(Y. $lcMW n j+i]ɭgn[ے]d}cw +/,.yǓMZgʲ#j Ek>k Lv ?H@z#Fp7 3E<ٶ%<(Ke0#O@xST?pFcǶ#epJZxyEBMH 2t;ngcjžJZgqʾ-Kyݢdbt͊Oo%ś%*k;ρ"_p{čԻ{6 ?&aDtZiƖvdc[ꘔ\D]hhNk/-d]h-ag\ +lk"gE3jpm dkUv&Lj"Ar1a y r 6bo&=> rcf/y(1EbZ(c}` tO3hL1޾%b1]tZ1=" X :#!1s=lxH符Jxh@Og9kT,*[XU4[*p' 4դx- Xm.¾ͣ˽ h~؟%^,1 µU]ހB)jDNb+KqIrut8n 6 -CGԥs> Ћ'oҵi>OC'~~zh`F'r#,0tL|*9ev+}G>]86m1PePqb|2תY}^Km_mH%ikj83V 7ݾ.U^RRVc7dچPX6v'{˕$1]-.1D`q(Ƃ믐XJ|t3ЏN , Uw !D3&$ؔLz0|ًX^:{5RMfYB U9fxhm;.M6쌫O1#LHWP߈%kXyžK e|MLHX$s,!j!It!@X0CYa&p_xZe!4i_ZH5.8%.o٩f׸_+"{^L?/20VLk9߀^cH5!]js_)@ #/`_h7;tH`]"IJae۫>},r4diEyJāedUt1Z_2k𱴲eǠjԢ->5[\25 惣v*.1  ^$8h:d?{ѯa$\619veYe$!tXntbﭚGXqH~ Klo;dHPҥlp>&Gjl3)۲ի5u%a%̾ONY.V#B4HW8F:,#:x˫y,Wo}t1/ we(;:% ߩvCQ9X)hbĩ.)!iIbI+ٚ$5%71 ."{[?RF0:kc*PEۉ`gFInq[r SbE^xIB^n>C5tĸ~N%.aHP8H Ts>@crJkAt꧃[R;%.7_dF:ւ1-K*Ψꉖx~C|&?@Mo 9rX29P9;/OˢsH᱁ɾd d"Qy!@QΙIJ pUN48.BqNYsJQP71SY⣴xuw8øݱ؍Hha֚/U̐ДIyv{4S9˒k<&o2.iֹ H;x"L(R'I"Ζܸ<8J xO^,LGoNy2zo>voET\Hr'%{grP!w()L|eԾ93݂4&)侒@1H !#L`s8&q(_UO ORTͷAUh/T6ZȘi nW Aaj'R cd+sX.%(zY7426Sҕd$y%]eg-ڊ#@| ًc1dVlq'DUlT97C!5TkrP]v.IH<8۽OdN ֔Fű8)=Xu- |"_1xb7A`! (Z:d=9` nE9ջb6g]%L g7|wwOɾN~ }u}C_Pw'sixнLb5߰nAh=?D:$_})u$[~ ~B/E@"pvhO;IgLQ"H8VQ0J7:Ix+&0E8(7$r9U 1ղ(<9BG>з^hpÅL) Njcv!k ~ &h6Nq?a9J2=X6Od6&+Xz06sI6`)ZU`I每'dղG4X_%^4^1): O 8afNMQ[E2зy,T x5ٸ~ڮ5UP(J lxbrWQ 5 aC )# 508Y]/690`Dd)aVGqm(jDmn CZ51pv<PJa4\h8nL ݨ0͌./QVnQ;ĭɄnKlAm|8:!QY.%*? ˿Q܂(ږ`Ѥ4M]fbڥX#H`P0=֍wRIg/O;K~VP;XSN>LSf֟6X@rBz'NGCtw40c~$ q=0QDDZ&ic&Y5 %ue߀4[~"~# 4ξbHeC.? P^ #gVD,)1# Mƿ: "мPh ԛ;UuF6PןJǒ!npbn:`BVYI2s=DM40 '-aɭq!);6Ө4t%lgDž j~$ik"*Y`z,J]@UZf O"3#N+R,׋B\ ݋7R@)kIP_́i~ΨRLX&ƪ4 2>zTV%{gΣ5M9ltP$ȶ~\@1ۆF74|4u#h|#(l]8VB%/p}v"~JfKAνPe}q ):CZkP8au2yW\ q17nK#Pq]X&fG7׏LD7ԕ OV@MEJz{hTbYS#b%JqΘ\:ka$so? 1!!CnTwgk YWVEGygۮcI]$ . 4(&M.nk).Si>]ݬLR\ "3F}~obkJ@gt7(VdmӃu: SRFI5m=o2<'5,oZur6c0G>ENM<$o =|@]i!75҄s xqM7L PkZliUvpc#6.ڦ];Zk݅6_)Ɨ$ֿ8$uܩF(5meGߝlafje'8c/SS\jeO\_ϬsxE!У^3ʴuCoå9IKg P>7B͞0=;;x䖡=Yy\Vdfs a ـH&p ={h0f'NVTE%.O?o+0%S @ʰ@}P]OvwYu͋hbŵVh`BNYҥ%-v9O l.<&:.B4f7|Jw=Q|=B7Il"1i=L5sn.[ČsQtjعvimni5ĮfB8Җ _.49Rb`$b#}%2#[xENBU|fߩ ғz@jŤ ܣ[fQ_[/^ӛUĖ*?nn!5O֦lZ<)/yP=TsySے,d3tӐh,#[j$&PR☾)Znlk (:뫱SOoNzU}9?,4tf(gC6EP'jsMLwxtQFH@i#?9$SW#&{IJQB +;377-#ɂ[8wJ$tfݨ]hQf jΩϤ!Qq֞aJ <7ٞIU*spA7S ܍v@= :i"\>y\^g<KuXb|#u|l{"-QRʅP'Lʂ9 隲dP;J"+hRv4*zd3XXmgKFn =hＣ&SRV0w P3G[?%-&/ZIUX9~G\}7P.W>a(-d VgCi zkI-6{bUW7{ }iܥOZؘ^` ̤:ݶWK2NUuГ_D`6,DZu-MXaNgY@uZRj(MP#I |>@>)ysGvqBK6^Dd:0=ld@-5aWeC{D&-< PF+6,ֵPt64z(GԥQ/￭z" AlcƩyU_ʵ2~G"π(@ `v2|J3prFSD`J'Du 3Z3OsC%qpURXsTZ0'Nx*|\z逞TUnJ;5-'qy6(W2KPsJ5fV#&4Av{b~(ԗ eg+tًQU:wO/_NǷP>՗blJj8u6v?A6KY8n΄3*n"TqgrV2agԶJw'=3Rp}9 %uێA Q<"UrN8}b^wW7w5ܐhb@zF~qː\ >/lڦ~gSSu肒`!/ %/C?A\n9ԍM kG?ɭ:\D@'@|_-{ P2fqHHGbSC0F>'t,@*DrYO) R>LO:bPvZZQ9ۓډOǽrs]Z{w=T2+z%MakuT<h^( xHLX~;b.Q5ItʐsQCvf$:1,AlqՍ]m5E'1\HFnD_u A/!ѳ/o@֒ G*~knsHyz7AlA/͐VK+;AKܠ1ăV3Ԅ8TcH>52Y#[~*W.t8-g-l4 D<$F gosU!0 )87#LEc!{ݡf!ALJal}diW&*, Jw;w٘'G3uI.3I_#})@ly`O">f aynTZ`oJsS;YVH$n~k cݝ!*9GAyS*J9^ۻ{8ueM2^u U),F{3hyWK~ _jtZ lǯ(&QE<,SG hKbi; G`l91ͼUs"lA3+G8P!W5,v2In'9_7=ՓmPFW E_mVPAn5Ic(},"!BC?/7xqMj+Ɠ3z-R2ug`F$,vf_3K-+Jt/M GNst4Nbl@!岹\4vqX݄\DI"ceGQBJ8 ,)etҴx.kՐeLR'7Kba"y"%U1.Mc*v!d,[L*-%#&rh~H F#_ѨS:fZ)qfLj 6; 22zAb0a}YOaْ`0OhxWӊ$a|b4xVC. 1ޣou`) /zXSyRb$ rh% SrЦ<E6 UV%|B"D T=/$ bO;?QR.O4&A tF\ X7[mj J37ns?a}*OVT8c7c{mlgW\i7YֲyIJC yׂ6\W s~Ӳ)bFL4ZpWZmU7H &SEFg'7dhCqUfeHэ#}NzHz}*A"Q@z~ {8n4-X֎4n˴kؐ"N!tH#Z:TA΋va{mY8clދ [V7 @IǠBb}i~o"d0 C[VcYšr >z]976ar$e3a Ky4#y3<HQ@CBPa&1* FWpa Wgų_hx&^ P}XHil[{z5_ $TvTIp0|G>,q!NV>o\?+&6rb]EUIe?`a=ΨCU_-@_ŕ+ٽI-_>CꩩՒ\,E$x Cyq+ۉKKC|`\&!GaE0,t`0 2"uꉤ*jPpl IwM& ks+ TVn{BM~<Q$54? O opKnu$kyj$LtCZbD<xZ D{u9Zt9;ڡ,MHR9A7ot :9T!;yj+dK:o%rIE,U?ǎS|> 0?d[@ ygiz_93 c$WrS8<%*D'ij33k䛀獤dU:q0daK΋/0En+tq0!a~zLE5dSƮh x YN]?)5ꞵNY`ZS51&)bT:Fz9j>WJNʹ C4xY2iY 4kY#)UXw(taVdv #=[@y@[u~.u3?dj%('ϤK8)[|EoR*cnO1fpQ_$뽡s2Ih@@hqNtwp[\k~!3fxl&7Dcj.t0Ή%JG Hh08FY`is(@845iRU39'Hн[7^ M}fIpM8\8\ zԽxg*v_(7}}&-CZTtFмBj495gxPuY oOQ*Ԃ쁿(vL]7 oTwHQkϢ,q dv r] (vcհdw: 9пP,} ޓm$ %Ms7nSbƀ U@?aGelV)ײ5Kߎm.ɝNbjK)u)DwiƩAGf q'E~g?EFjUyoU$͞fk/F@~Yzϩz{6.M;숡&λH屝kAsS;vU%T+lAQɇj_i7DžEjV0(([}jsÛyK0Zh%zݮ_%܎dl_p:)9%?-1vj}kAԸ䲔o"j/4h(YB'#fك#x <ח`wW冕r0ڇؠA ʺ0HBr mr .?f%1gr}\6m&ذ=OJřR5.* MG: jch. OvaW^9E,~=}bu>iL{h8wlۥy6 ng'z< e!(eRۓh_(=pT_ttu-yX+’:,_N≯_NLtlgd 8\^I9_o"M`do*b_AaY'WɃbbev4ܴLrB O喻Qh.Ig3&?!hfNx߰6m#?ѼI(j6D0"oP&g{6#Qg%yo܏w`[*8WUp1, y7.GRl/6.k ,pʡӿ^ #ݜU&b1!SZɬ+-rU"gKF7ptW;:V͉C> g[M.wm5GX86GlU+\.[r[j^+UB#?Q6=p>Wƅg=>_)w!2d$ 0ոG?oY<\2\$>1uN"7:+Gh (=$k: F˙~tȀL%dE@stoڿ4(49M fI٥л)p^/ +o^M A,FW뿛m>OSG,;qf . 7ӋT9"­f$9m^jkZvN.7MN?/"!K_?@xS~ˁRp^4W˗-*1OfIeInv98wW~ȃ T `-'ufݪȫ_ ۡaEuG5ch)k=)88Cg5\t'tn¤$50="Nwko߮mEcT+nzH_鯵Km6ϭ ; EeYM/{`_dZ[j#c_-/%e6W?ІF: <80 q>|ƹ,#9n͏vY֣WTXsh"6 ֙0O7%M4qr )8lNF]Y֚Bh@'H:iJsF@*RTBzy.N@b#} q ?Vgϫʲfd3R|M b]E=X1g}s-{ac-ŠC4=hӯ#@.uǾ8ʋp, #R%1ykG!C1 eHJ [Eic|5 qۤ\.?"2m5g$Ӟ &O^0 XI672ܵIʘ?MVJS_'H[\C|w+uxBWVC04TP" 1gd W E1)xƀ Q `6g/#zc-DueE Kp/fͦ(#Zo1d HIl|KKg){$~WCa5N@T?(?lД}y!]fٳCTqѯjb c,XloUqD="o_Սr ,TO,&$dE[bD~!ެY=gF_4$ԧPjq0m94M: 6zL[TIax+(γjP%7+.zyZʧ \g/[!al$t5li+|EFޚa/F&=_nJ;U]ig8AJ]'zފS<ԑzN1FCIfП62; {p o'Erdyu8'2GIuN2R&W1 ^3UzaK%GFyn "`-G jFofpPs6W.U|aW\:@=ie `,yU@UVs:/vLscj&̥a sw.goGY$a <pm>Xڰ"(j;0%ZR^og*GxP[8QR{j]-O5݀y>"!?N۠1ywt`P$ --E ָ1<󴔢)&(ta|גRq'febhN2tnȷZAϞtܸ ԲpUT sE󥤥PGKLQA1~~E2C Ȑp\-wa@E!vf PTA,* Li<0<޽ GUc3kDG6 !BRn_k 3j@҅6toٟۀ_'ԭϻiylY2>rR*7RM<۬_PaK4Ү YfB.r3" 䠢EmA_sShFm;}47| bC4=jm.lJ0yO(ixmJtt̿س?qSp_";Z&*5Բ Xf# $T{P ibmVE>DMJV7.yf0ua1LaΌbK6NR#F~)+])m͉*(IVWƚg8}k0Е8ԑpu(mC9A5rXV%:ua{2EQ 33yKGc$XKwΚMS Z+kcDzZ;9HF>c^}W~)YYFK+2b. >%υiPfF<5 sNCǷ7|و1)p ,)iݾx^n G1J|j&GéݕX0*O]ˌi`W?3Ȇ{+kzT .`N[*KJ-IYLO}?B'z;6B Һm{phlRu 3 ;]i%A ? ${aиƗ(ոBe{Lm#ɔsg>B=/ga;rۡ7 t+9XޣE_U7ӂo9ȩ\bjw.PhIoqS?_OuG%eXҬȗ>έ䌋 <ƀg_ q8gxO,M 8{ƹ7֘/5 lvZ6n~ dc>#pw&UsC׼GjBLZY}z(?j $|$_xޖ7 m a&یcnރD0֑yORV;AG|R8I7&#Ԇ*[)/\z9)3V@k3B*'CM r*ѧ 12N詥LOrI9@H߅NU":䅴[ Rt2Yid) Y%~z]\{ȃ*mo#.(3rA㑫 YX.8`6P^*cT98AP.PTDx5A_;O&J%#Ǧ1gkxvՕnٟy wppS Z:uXmWi$2d~4^6AB}-Bh7odL f.vbfRJPih/bACΐ~`qFkDDŽ8Lϥ*2[a֖Fn^or7%,h8{E hwPQR^NcGSdظƯ;nHw"0A. KlQ\0 .xSÜ魇C f\XZ[Xy_?d_i O#@0Xx,('IoCssDϸJ~xjp q-潵c0mE^zwE_ED8A?&"% &&>Oho&eݓo0aEYI ]7HgࢴK/18q{(p8R)W& ]=Ygqbk&o,L0&n?O%){͆N+:Ut5sƶA([qiHEXV+A95HB4r-CڐiμCٕ:Oio_a? ~)v= VOMXr*Pl2Op82340?Finwƒȓ62WOUyT,=jACu0xKӯy#)ȹᖎ\H5#=Fg HpBAP'`HcHM J2^a*3YֳeĝF0Au3eU|0p&Kə^2YAOvJGuV(/դ!q$Б*1e'!gd u;] 7@qc7Mئw4Ҁ6n[>}6PQן1,(8A$m׳U/ }"KCiё?$sJ z[6";rmtM10(9e[Q ݾhf4c\EM (ʰ U|$d/+Fgd>SuEf58կ`%B>r3@9DיO7-!` 2RXnņ5zԀ. @ђx$z-zkt1jr`ӴV.We]P/#E6 t|?ўw`RcPnqpj"qo82`k05U{ _+\٬pgD 2r%^ĩ\lo"faem+4ROt e&A(z"Twbcrb*r,]g G]Q GD/SP<2rBL ~eGuq5k)p9G҂&UjOjATK6Id<o"Bs]kw2d#]FZ*  qˀHJ(ٴ$Xa+:5tP߁lI!F QIĸ5Շ18EQi8]E7:cwi2v]s40mIcT.<"NN-Ze> Va0_ \oA dS݇Y ɖN<:0H,՝)շ A9Z `WV% ,6XEې9* F |Eq-b:"- z-^o2^'&(Jr f4`j {-S`tZr2Y/ٴǕ'.Ԏ?KFN<`]r+p[=$m¶;t}M0YT$6e.<2UCEJ͹ކ5ٍ;VE(Ķ68{z9s65! >F޺cףC w!SBzuA}Փ`0rY/U-ݧ`-klu ſ۱5jE&]F$ \Biڴo~&poӠPXgx"bXxyt$-2b0@;,r rfx\ M;Z&ह(`M {\IRp1b TQнD{{ f"攄 +;'61~ɌFy%xP1F^$KȒjTBM`tǖT#>g͊ST(``$ Ih:Tq+w٩O0Яİzfy{*<C#H+)FRf ^0W3<i-T0B'EA̔*k9IjɮrhS 7ڙ2j!i%~6/ʫ)e2ﴅo[C,'tj#& 7ƚ[2p팔\f8jOş?GoCs* o.r6D*ͮVj92Lf5n,} K 6m4NfI/V]: %PݣD}=PEe-V:D[g4-ĉrDxײ%FoݎGfбd_8%>yd,+Q1L嶳̜7({ *.Bmh}5#.jX3uvE40IQ7F]'}tSg[de'; ZFO"daj0j+Ḓ6 aqCZE8&)j[ 5[mjq/DQ ^~E7'A& KhQ9\%k IGkuA\ZKxr`Tg92-17W"H8Irmv <=FY caPT6ۭA@ڰ¼=PKԴW/`Yڵr^? J|tئVW &e b3lPSae#P\ y~'[ˋ(Sڨ< ΘWjGg! !^GQ$C\ށr*y f +%@O"?Xd-v3kakBPg%w0@==o:p =˴ ~b=HPl!Q,tI5tb/\zgZYſOT;5VcLt+KbqAYuzUm!cS?&Y"1YEQB( Xd97Yl^Y Ńwe4\MgFCx!UjR^aMFަU:HFw[3'l#=Us]S9Wvd3azk?(GA^! NC0TmCRVv%<˺+٭kث1g#ͰI*ў(F3# $\qK?m N 2.\bd2}m.9 Hk.YGSL;**GnXoL5֡B+4:\ϻ{dg9V1cfomCm)4+u/mIl! m9[T?DhSD3 $D@ wyqPyQ xIg-Qј2AS@Ϯ.d Qyo,˻nP[E,єZVIPv5by)nQUjR1PU~׀w ʷa DNg(h.*,HzxEx ["\ZVD/H+ILz[љç4$Vn`țo=:ݚcNW;C PK i 7~V{Tw~X&Rcnk#\8{FܞO.*2(5W" ٵFё|zgQ "0}Jo5XIR^ןnt/Y8؈gVS1hT*|(Cy:[Φvœp z+lʀ}rc@ #icՉDyz~s4Tݮ 'cӗ" |g&IpĜa ?WRzHp1M%N QjSBc vp$Md 7R9MMf(&$;2W@'TtGkI6GeC3L 3?YwT;79V7ҫDs~cv # 2 0%dXT5)Lm ORYR^CۅEd 9yo瑖py|NAt37 70%lBk \DnN]ETWMwܫ]iMMq+.VD#%lyO2o*گ/Mڛ=18D/+ 8ם2w- y;UmZ&訶KV5}i Ag;GGԲZeav(k="8(krOD]mqsI\WR1ng ffۦс=δҙ&mV%dӚ$VEN@KʳY7xhCɠx>㋸3݌{. eGNs>Tc0(d j`y)ST =J u pIbF &?TrijE8 ]%ȗ6֩ 5 u&R>6|aH𵺋hJU!}=neXVz㡭>zHx@aG;Xx3)r^6Rʕ5g3َğk]| B!0)gT Pa_cgSՁS{1trۼ x)]>G* aGee;B?3KbB!vA7A{| vlU0/>.Џ.TȀz'f9,0N )f4:qڣXt v;3;I&߮\ۖsy=ͷY)]E1j-vP;A ,4$~x`ƸFESI?wg870$㔮`ｳV)͙ 哠ǙEU`+.>R-׉'ч&ѝŷ:( t &S(1S0bZPGI\E+}\H?7&zGKmP()ΟX9S,GڕĤ}~3=-B1~s9)0M}djdҴЀ\Z#0rt(H.7rl[Ύo Ҋ% *4sQ6\Ӎ{FBR5m3%h%ye~[7GCsFXgEMWI0D/CX%xSf+ 1-7M+@6_N6lL 7 VP#V9N/%T#hVcKcKe냋nN%E" C =< umA9P9]lQ¼R#:+]te|0"]X`Y`W$.l ixpy Jŷ1S`H6OŁ fcRx5bH)OWFxtKKt)-v!*": S idiJ0b7+^/ʦ^dGg$.(Dz769 Z-@,5VͩsZo P+ؾ*+I!q6, xZ7Yƣ, Y_MEK2$%}^xf#9i%JW햓RkeWg܃ Jts3{Bʟv\o莭?ff.Є ۦر{"Ҕ,ƒåRl$(BԼP生66}qgE Ӎ77-uXS1ٚj?ݻ/[$\~${VÍ?\@xKG!θi/r5_6~uU ;MLaʅ:墸A̒|RRc^$R%F))[(rA$!,izif3&u.\џu8 =#p%Qxz%6Y*ӵٓF"}+`q\aMJ; a UtgYm4l@dw̭ nw"󤷕nro_ 4d-?CSL&$V}uvE ҅# 8+ WMLRHD̺K&2Zڐh@*}ڔy#I<}H x 3Fe+eؙn3 dQ3*/`H[ʺljک M"%ɤr(t \P0wD3X"Kvl]$şo+!.*(@"lLݶ.x'RlWׅl!yw@j܍(Ztlk#>뱢TۭJkWGEMxZJ?,%N0k8vv3`%AߨSgxjԸdh[fwJK~Y$ECaFVYU\C}8h;by^jxQnts 6ۢksh2K&N |UMRlS}fq޼VLt6x8OkЙbXS`| tǜn<t)5j5&JrbRh`M,Z8X!8t"9cDFV?<]A3-{KJ;7ͦHk&}FI./vdox{fȩ0$#OZm`P6(KnE#yLUL`9"&c@٤LCy%8I/: D,5-w,+d+"ψ 0vݔ+(fҫ2!|ٳl y?Lk&Ԋ𓒒,Xrf_u}(O[KE|J#Z,zQ^`M5 yXEb_5"ϼ`5^!zH&}.3 \zaVi:bVRy$bPCs Wbcn`7GeP*?Aj|TC}mx;-b^ަtSMPM5r:jqek'XSMT\*)lN,8;+NҐ2 /!bDH$#vAiOJ obwVƗMNuZiQ.;'kz_m?ZxG*^B2+$I=ً4. :=)5lU #맳^Q՚Gp)oI:#.ii<ےcsѤ~[Gn5Cv }7zcz[S/si 6ʒyGy؏t8XbRfӫ0Aꊌ>7I;R j |gn#>ZC(3Ae7Z)s͠zVޤ ڞG`rj3eTKn4#YiA>UU&SKUM#-|15i挙ZBGI;ĹDuzZ~q1|wKZ /|Z4-Ƙ+Mle7fz{Bu QM).I/Y'Ehe+pfWbxX5UMsԐA mWWcU3vMK1y+f]rH\p*,@:J~RdGIS=2#nm)!µ(4KU">pΰc:PmD`kQ<|X@n W ktɁ*@NTs~2%4&M+N79%CI;YwU0H2%$O?Z'z=|Ȍ&SG?qGaq]^y-Jc疺J oxfb!@M%p{!_b8Q>lq *6i1l|Ξ|D1 BlB<ၔmI6Ȅߘu.x1wNݸ xjC^b+G܆&3)ꃫ ۜntk=kMu懼QUuK (4*{kfk5K2 ΰz's˪O%ț,k5mﮘMwBw &}"evx5"` $35֠5EYN ;mU* 骪*=a5YelӒ1ʲ99kX'%a 1P 20'&|B x0.E3՚D!ٻ zx=^|i&+mߦ|MH܍[$ +)i}ê L{aH4i4 . 3QK]\HP6k#V'vkwpC3Bn+naub9cvqH,g ?iPHR]Ia%/ً !=K`z[27l( l+O}*`V0/1nH\~"!,t܂2Y04'eLU~mSZ&V{m* dM\INPx8՜pt8\#p ٗ0ɉbc^=iYM'"(JY8/*t"DK dD-c7E7`Hs8+I3X?,IW:(2^7*̤r`D#We>//U<:w"٫HDۍYw  m /xn 2ا,pɦ+PۘLJjOi$4)drT$o5#]+>j\LEudór~d@Q%P7g0519i`>thub[Mf3! ck ٶngDQ#p'ct U)" b֊V)FgII&^Dʕ*eB 6đq@'_/{ {2ub$Z(cq1BrH9942 h((lf VS>~nYTQ /62Ż [#7p?!mOLe&ԧg4S'"&]@h9, 4S/ɠ69.JEAbEU uy4n0O~MJg& fgS>)=$y(J"rgyRmNb\j( -_!*DbX#/oG E@9r͵{1>NR0nAOEѥ鹶_UU\wN!a_ݐX._-0u+hg.}rG; Mf~"M1կP7`HfceԆ~o|o]OCl>~&DWllTsBI 5!V;OC/Wz-kĥ9<нDAmaߕ$)Ffi(!d Jdw&/AϝX ǷqTȗqJ9Z+GVU|7q1tW`Ո ]_z^*M9˨Nf(m[ӕ<Wz! 9%"- ޲[pJJ0w 60B[6֠3ߡNŷbc1+[ .*+lTP=n J&5h9HFX|LBoQaDZ׌kɗbވa n/N5MO6ZfPOމgBu nrv͟z\ X3mm*33#,egݧ9(ڠ`mޣIJ? v-E "}< D0|$ kBW,/힣VQ;.bm o^nlq?8=]&tprx¯.,5saN ӈj@,̀1!;p9EُӃ73cY:xŐePNxoZZB񍱅[_}иOF؝qȯ!V?byOFw0*>CmQ3b3OR'馮DJgSkqG$({ #g,j-TK%QsBǤ GRfaTzt# f*rBz׼ ]yRN0)GGYp̿ԵlöoupEPW!L):< 4Z[)x8q: &Wln%Q :QUr%Duy|Jb S{Uȫ[2 rncUe|0q\ICu[{/OI*d o!+l:;qR&tvTPk>Rtߚѩzn.Ԣ7Ɯ"Yr;(&kJ]~Sp@#h54]&`znqёQͻY Vlu՗Squ]gCB 4ጴ~(()3XGrCAiHb(TWBWAS I8] uƜt {*}AYP,! QkJ"*&bFGǰUf 'hKa{$éø.t?>-Ǭ9 ~5DYeD#/v٦HP _jKd&*O'{i0@ :95ب1_ϟkSox/JEe+N  zZ1?V1[~~ APVq\d8f 8S/ (}tq2.-xϚS%JHsxn;zMŗ&p[]o谫d_SG CSlp\HfSe8COx0 $T<I2@ Q0_X,m+UfI~}=!C)"LqJ|U1^d0\&pBDR,- y;qVd"+=unYFw3\ }]+4w}BAIN%mgCmдݩsӈEp8lYsv4aȿڊ+2*e@ ƅmd6e/ pl#Ӱ-a<6aZ0e@m{511~˲c aƐs֊Ed8Ifv 0-4p-)Ecl>Fa+k++`3`a$>O۫?zUjRjC5Hq`Y+˅-^}`h48轁=9rz*O9*wTl \ bbt /Jǽ? >Ԏç&soKHl0*tJ:sTQNE#p(>"Z]ߙbC5$ v.p3hłalJuXgCsc&bhRdt>x6E}y Hbe!= \imÛk4 $DHuH*kA;Sy_%/E:ЛSD"$&h9A6mQZk&uQl3֭&{ҕH^[+Gm" ymQo5u4ìlsh'x<=:;j`Nک>~vZ3-+')$ vLdFW.1$go0 J%<Px!tTĚ1)(<(嶛7H,6'6ũd. Wq(=v*C} I1Awm/"%Z%+UhiGtUo8/K;=uC|u kW'*Pڀڼv r Ep"vZBTlO#4(=q 6*XΒ+Մft>ChZ%>WА?R-n8Z -W@4B 9=逆i/Z|$+kRHcɋ}I3?US|A-]C0hEȄUb3FCG$%^i]0յ(N(lY~C|$T#7W2%!ο#EC1LrQ"V8A P dd,Ia rUP >(DgVkj$+1D$ CjBNU , {ymz6?]8f_liDGEHW<mz0'7j=|)\ @wMB='k/k55f_6}j~"Ցghwڼ1Lڙ#rىkW~lh\H)wH5AMKf[C\R ڹ![EQJi U?M5_*p|sˡKGPHD804Dk*K#羄ɟAJFZuh/uCmyбHI$JeĐE^ Xn:f: VNYp+G6m_ǩ&6v߷H0&Ch+~9HS 1^d~eum]u?(ZzB!QT%qPwm!ӸO* c^QS vC %4 _R WI7Qpچۯ8'VaNe"-6e6A䤗2g^; +\9 ;ٕ41 hl;ykE&7sa$1'K,  BAW0 ^%wI4V/bh+&$F1[gw;^5ĐX z׾ɴm~܈(. uh68C)QyZ2</kM2'wlI!%Ix/ڶAJJ^#wbnvĵ~72E)+KH8 bOِ.! $FȩkK!𒣓 ^4k$1캵\| қ2Ba尰өތ씖أZ{QW@9՟kՇ#"@SOTƆ/k˺T,u3V#(ier1渤Aep]9]@A9)ȨޅqMb*YMLrw5ֲZ-EQDCǯz?[!оԀ pGf8nG N7ASȽǶĉy͇\`"j"k(jV<^z頕 ;9!Ǯ+E SjvN= KI%. [{ӏ`?JB*Cb40OU Z?MX-c':R&BI_5"BMVxE.i)CstR-2oԺejVG\wS4#f$VȏVd3Kת0RlB^I XFaz=7F(% _ 4G6\u-Ķ!|rX< Ś4یar f}hġ&AI `"(J%KuԠ`϶4`&j/RiK7T%۰ms^Y~T ~w9^%Cm~±&^CrV~o5þW'%,/٬.\؏+8qʬNh-B|Ҁe @խ>#y2+{lSTBӣ}LW`+PQ0^:v^M(,CggIҀ_@!~hjkNsUFGZ BdT!9l J|Nb%ndL^ *VjP6rfk*J7Ss@bFxGy:qь;A ~bxФ7rI3 <ش)G6IVJf Mi# ›(E"/?Z1Bs0W,7&m$Nst]1!KXM#mڿ*"N禀4v"Z>υAa];52J#t;:V'@x`|!6 @-}uuwp$v7Э4?ſ brUŚ r"U"ZeFiœڌ)4Ă8/箊K E~[?rC9PVR*6g `QO.<>ʫ/0R`֬떅 {^e 9ѤnX>â}:@@D1WTĄ(Ծi4@+ Dx&-p).R0):-<@s|BN%_cz:"pi޴HˆE#^K^Oqtaؙ9hņe_PzժN?2j1Giqt ¤X{kK v/Gh+KySN |muxջG*Z$Kleg-D!o&LJ&c$D|dlW. ]wtD[7TO[-*3 jE|->Sg ̣^lIS'Ag |kq&\sG`c..("ʾi "I!G͂f s !{~茋ԀNg>V\ |3ۊ`4ȱb< 8r3 E1!}H*6Rv_3\ %u*!rlrHz'l տu; [ht狿DH[aUstS.x=G3g4KSJ*5t9㝏CiCj[ș+!7? D #d%=N,,lh>["Af =ƍ4yɀxNs#wF&t `qlb,= pqpVH4wFoʜav  Y>AYđk4i-qy8( IGICKTqDQk3dvojsh6q} 76 G @I&)yqGd~o83AˤF~( t զ t0wA逄Uhug6P| tWUlO(!I׾VO Fd.h-:ks+j^o2- D0e[kYDw,` uEw O ?*hwي|Uڋu,T7դ3G!#= F^2gPRus0'&$÷7yJ֜I >{: XsMuƫ}eAt72HVɨ6к4X1 SR 90AM!פn߽ -n~sA4H3!)԰^zXhCKOO(`%EC:zu9)sHA`u冺e/of-sӴh5&sˮ?Yľ0Nfཁh 4H~ڢBRnSئU؄ZD#4J_9~6^SCCEJ:L.!1E̅Z @zӬ.Z ñbla[ǣ7 yD8)iM/i!{'{D+(imj{-g3 qD/1aQ.=owy<=_h*mquݓՎmt3P_fq_H*QwWZ6<Rؙ`%U--9V^3=Gb$&~%"S8A?0_5ï12&92ND''wy8ԈÈBFN&#qN V %9o>StW4jF4YE1ly_OO̚,KLv r֯ 2eF) S! [9|5V/袰 ΃G*!s2@|lڧ@o3^lJra7'} x}fdͶYJG2eʹU(//H' =)9\(`'ZC0g:tȀcT݇[Iq1{Āt;Tہt;)/ApŏSx x%c`o}+KQs>$W'rX +H[V"kشB k]ھ"hR527&":+4T\M"# dBGy lFb{L'c0XQ@Hy?1d,e] 0Ú, ǎܽq.&M` du0# 'a'I%7 ėP4ʑa~mY ,* ucdtHp[iz"#|6Iv~$1MQ ELYɕv#:A'FQYHʆ`pۡBCnuM_?C;3Pixdwp4&V^r̕#a-U覨k^Q$W^F2גŅ?Ү PUN2_ c&1V]Q쁀A(dNԛu/++>gXTOIgV+lhlS?4eCd[5S/XkrY SH*֍-'7`MƵIlAB L>iJ Rsbj;ʤjsJ`]'ЋAMc쒜 O \].φQ G;=g4 !O&qG6$!!6|Q篇7e$\Y49D~И?JL܄ 5DץDVr!$% ?N*ZHܜM!mfc)*Ħ-+Ԉ2)V&7Jkڊ:MCm:ĜCɽelB{;$|]؛Mh&hPl'Yv[1bX񪡬I?"_!yuyW,;-fS1xҩŲÆƘ!_X}JݕdūP\/q.\GDk=8%\]ϥlƠQMjs֤Ѯ}v,V5O9 H"STz1k݆iR@. ETM]7(LmDa;0Ɇy DfA`#LCA.WPlROt2 6+5+I%x$ &2!1+LUa}AS6`'n6i!T:blnU(A]-U 1sx7dkt6"nIPbzx*9& R1B"yYa*IK6ԖW᪪GxŀJ8_Τ2x5TjzJD8'/%vTP"dE.XCK>z!2Qa~ Of `$a.\;D\)X RLdȱ'Eۃi5c48LEk]o蹨-K5;x%.Ɖܲ"$.)d3 /ށR(4\Cv``Rn '9(BlC*@U |Kڣ%n SyCAOj65sR{gwf'EqsP/Y &)-P1igB+སn41\@. /-JPow_)}S@w7Z rdmw؋@y:Μr'# OZIh'(ԓ l m xyq_}b,bb b7 z8@bn\{p$̒M'[;ՙGQB/LrOq9Ȟ'ɕ9x;xAcI5!|-ehQ lO|^$}Vپ^l<|U^Pkȫ_ApmpLkѤ&{*gUK;lzvt!A 6Lhc-:ot06xĄ<%v'(ygAւoLHg1UvۃLj$W'|,b_L΋=0`bpeKP(B|Ӕ o 3oAae PE,ᾧ#.?TI'*/7[Vjճ":)ht $X8lI! !y.|$,ElZ|x j;uVϙ@!9D'cȩjpX_8=w?kϤ&AϓbNÆeFȸL{(gv$#L?'ڵ~ O ~|uGX Q1P\FϠЅKnch+qͩ*#)ͅ:`nT*5pSdOj!?2*:AfdCZ$Pap 6nv o"\pQ ՜ǁ3#:{;rc/km, dqC/[$72ry$saoߕ_Bd? dUjLO;Ll{15:F#UCU7пd0wD֧X/Uc1Y0^mqs?~QuF0~0,@ ]ߦ?хjџ ']jcl)`26y⽧BZ:7e}ì 2y3ui㓶D p cB=-:v`8XRXNי'ԧBx)Vs2xbUD`Ao#$z#T[0&ikXW9r2 '/RQ%xՒqSm= [ºnk6{uSTI vjMv>65֒Sr_1uvSe*ݎ@p }@"k ; 9J0& 4Wg 3yt'y\@T HNhh&ri'I3-LdX6櫨~Z}v&ZOHp;{ GBܥݯDTxbe dH@*R9 j戬o!4 {nxd;$GB5 ֽ* D͹EM.:mWt$i7ZIԆt#+$FI=.J ]Q?uEYR]N ^)aLnY}N)\$lG(3a'f=Yˈ: &h-0;\^=I:N/N )BjBwә16zB )y CW@fή`vV,+< V $aےa`xr|.#`MփqdXeff1krݽb,`6@<%s3gn*!ѥk ;ȹiTn"g@o]Mbb&҃iÜV#^c޶ֆբ! +ZM nTG^Oi8RD D(c]SMðNM:M`$i9WJ&&Sb{ JqKIeT)Y@uogrI9&LX+e*qҨU%J+zƦYP`ȋ*ӆj8F +W\n#y 9 @iQ" gi3,E$I}<{^3_IDaV;:я0[̣T|4PR$ZoWYsǿy; G7|$1=Шl &fW/iӗ-!atw\fIFr6AqW);wtgiYL]G̟6ϧekg|[t '<al!LB`W} ;6l5w:}t<6/l~D )-~w`i |Z3-Oj,ݲi6ڶ]ճzZKbaJ}U.0= '[0X ^0мCܴjFc2]D{KW y]|EN層22my쪚pC..(w4M"c@ "y4T⋢7ycuCM FωO)փ|J+7ϑYl|D\5hO=Rvdu/ $ &bH$l9rWKdUL&1wPo6k8cҝt<=QiüP>cD%,YӞ h~Bek5$x):*rexu=ƦeM+\ 1;6l(*|D /3 C`DNj']r)^́o@RȰ FN2Z#./qůlhL:B~!O#9DJDVv@}l@$#SG~rGc8>X^01B֐=G,Dދ@X8 unVO}vV61Vq Ѣ]Pqy P_s`_P@*j> G+g'] ~Q#-Kat.J{ oW6ˊ.ꗺ rOgT;3&M?DWD بG ͅ8|" *kӥyi۞ A[l_uKX5ߣXუ'Pwuxg#p&s"b$u~n!qI'YK@C.d Җ 7SjblU[\gh0"[Iws:Ѿ H Q I5&W0-W<AՍߩV?WcWS^oQ%cϢETDzV,msrolĮ|]ZkswEnKZr1u'jP)A$ f C/'ѿ7ťg@Y<(1t]JOgwâ}w]|%93s|f 1gbjM9 .mꭣSv!Hj(՜ϧpfU=SrRd:e3{+Ѭی lr06~tkwiǻaGg?Hq><_a`ߓ+Z΀VycDLy@ ֭l]E­.v4PAgqES= DQp[ʹ0DknH匄՜ U㸺3>>ޛtJYPLJ]fGI@ck èCܛWJGwrUH 9{|XJC1ԠZ1B;) iNp8&h= B]sj53)Xpsgoۨ h]"FCh[uسonKU[EE<$ ȭ n)G(3((;A- Bd-!(=М`5"O2h\tA7`6D|ATem,T0 v8Q[Qf:ӫ^i8oFD~ A>oy\]=┛\8(z9Zg݈ sBڸ|"GV{ٝT=5A͇Xk_W yi >5YAYR·h%kVzV"כY0ñf%1Yx@"0aF$Z晊j(^Ux o kpdC =ASNOG.PcI5/%v weJw ҚV =~r}5&l_u٭"a3jsIDQ"&Cl!ܥNЄ˪l*Tx:N57 hIm,rtL :4e['|l6AJ' RߟW %80w`;T-.k)HZ , idE,r*GX<+q}^"9Ogv4%, $j5 4!WN.}P>S O1FSUd .Soa2~+4Rb?0,!p#!3C*w t >|@w]D\2%Ggn^r?Ҷ_EK2Y7q*2-t`1h|e0|reroGʨ'q +/Yȅ7Y/X?G-笐 ESV[fmYS(@2V XuWyxQyE%jWy 7$BQCPDɨ.;]J Un *9»JE:rV\I֬Y7f|^0mupc-ysd+QU cTk}%xO.dzsgt ".n}MH4-v[˳IgQlj@$W%b2я0pCՖPSQ 7P? zӀ!B2I%e8T %O(%(9B6&ƔyR)4`eխB/zJ#${O|V,U], P.+]uP vC 5hmOe^2C.l? l`o7r7_{+w)YjQ(Ips|" sNPt)AHk]G ab1a=pʏʬܦcat*S u"r; WxpEWQ&&m𡋗[ A}XK62qǬ{N%CBuἢJBꜫȗU_ٶrY@A~W?\}s&!~k޷ KU|b2}ZS#xa9q@TVj!$7S}E4,EγbmD"C隒~SLn@P-+1 DX@\12uE~,Id[Tp,P]8~Ɗ{AMFg1>][n8ai~]\,`ruiF?5TEVԫ?(LwF6v]W_co @K,m9$}񼳺4 G'=2=^QTZO$2Ԓ!H {%0xPbta1#"o0p%%rxP֗s7?g-g K*_ Ef pvһ'Mǟ}Sz萒ke<Ʊy{ft\'o6Vw7ųa;_\axX)J\SInȱ)~QT&ܬ8n fk;{ #wIϯ|oK8$ GI;fr:l!ÉɄ[C _bvu5S+L9qUH|&&KanPL]sdN5E7C#+q5b[%ߘ @(_daC6-s!m+w4E80wO TS;wzŻi咐ʞ贆1TChoxNg.x֮"4Jd1U(]2] Wº@kiBZYpõ"nRDpI?Ip϶<Xt9={.ڹK]yT]}W`iTKi.*$jvK1֬V-Qj|GZ^oSZL`Yw;0Uo7 <O+c{v'3 WUc~3k~"Y!DC=߶Aow!2ܨopeٍPZ#-٥/4&elP ^f'1K'-<qwsCck'{ʩZ1JiNLyZ|PxZZv6]fp8}ݑثum/j+p'q_<}֬j}[=&+r?˺r/WJ⺡!w[>]O\DaBEDp#vMI` ͱ x|pdçlƄ0baGtʢ]o|}@ì@`XW~ *˟'5%4_QuJ=l^Th@Soe6YFOM&ô;$[EZvן0mh&$y46½Q棢uqB&J+ؒ{^by^$odc8eomL| Y'-W<<$Q|BmhIEPZ Lv`C*_ܯGrr|Ynlg r+2Nd$:}MߕU]=vpu1>KR?}R %}R.atb傗Ƚ>,\߽e?`|8q8b .a(2|$D]X;"&LCRZNQ4kK+Or'[1qu/HElbЩ"KFI5Dl`RA}NƔ GkX2(^' O@y<S! c!,!3faa!`D*ZQL êNdiHP#N UN gL1ۡ@OBqn~H)s?dJAo]ю508Zm#KvyGjmY/)JxT$<$0Oj3|"\ZLyyѶ"J I[zsge^sU/#^FOs^:''<;lD;|p7G@n9 넵‚ˏ*?Zv& 1h6㝦 ѧ88' &姕z)4˜PfZ8%M."Qs8kH' :YnM p32$|Bw #E]? 05A7Eqϩd- E=n 1 `e\R\x[0\*2JwA hQQ#_P^ iD~pu4'lCڐg{ѨϏs鳐?1юbI 2(&UxeF] 1cr/Dw8p(0X &i܅Tf:ءlǐn[ ֶ^!&Do Ws ]N#g0YM`٨Ηt/,7n/weUE|eԦymL*G&x{FZAx LQEk?٠ -Gdt+Uһ*н%YM` Pv)P; 3{Gb+1N,A0 e} {o`8^~bj2]v_> ~Yџhڮb˪"K̦eJb1@ܫ'waqp"J hU2?琏Eyye;S5~G~~nc~#\|_pM\/4U UtK 8}_QAƉ&)Kp&;eynВ0trLWZ 7 r%du8PW80XlՁߚS<]A*X 1M_weʛ(30 L@ȇ_, d~9lta UHցཧbsQ;jmnkp`>sK

b0q$Sc :& &r9R>u*QIumDR8ʌ_2ij,aܝ=#hA.ί@2DϞ;gG㠒\t@f^5ZD}x]a?ܥ."+[ӥYi$ %>f}᭍[9.6P!wl/84=63]йB{Λ5e?[{u 00yoTE̹ʫJ$j iZJ 5%23nWGla^3ijK>FlR![l"N?';.&_w@ƹz̦2# ~9-{oAQ&0q-){ѫ(=qti)1^$Nc:7SEu&P[J́nD<@&YqIIC\rB@g;P'[1Ȥ\ }`DfQƟ2%BtF/m25okKoo`NȪJR$ (@LyC.)ˆp7JbPe4%>5J~%HF+2R/6ɸx9-?NiTof8Wڝ(VߨX@ -%al(~'_GˎD{H"HrwIR;[$oq^a ?uZT8̀wo7^SVNBF'76RLih3J+4F-CRs!Us޵l0bCG\Ȫ%přA%2gmĝۃpԿY+>yơ *{fFs^@~@"J8nrٹtc:BhG_!c!@`<<n #א{Ԥ\%5|iDYm3WKqƈJy (At`u`tKC~PV3 =Uhκ3JF@ 6 1Vdxɤu:lnk2\djEaТ.PE'(h~1#dq`Cz R86VDixEPE@0q#)霵EXR@ؠ.x0 -j0_GA:LN% D3[Ϻ!^#f>5]Mnx#w3Ds%J8LE" '}73 xMeIn4)&4ֳFGɴw旫=r_~/8lMCWE9i2QZ<&@fo?`[=LmK7 c)ʰB` ;|$ߍᴸSgkt jaVa. ݾ f|zޠ{(?afK1+bhHɡ$KnoJGtr ET[txHyO ld" 5RkA*c5jf* 2 a{o+l(zy-+|YQV2[G( ɖtj˫W~ DA9T7\3uLRPr ,d" GQԣ9sIC53q52nNP'vP,*:,lS+L0H!((Y/8br/k;PP$_R ;x/u `،p0DN&a_ia|1_ә[aL 9V_]Y%&xve Ӗ2ej}vvh-<0fF˗=BNL,\j_Jdr^yO?;]~faaHbڱMHOl[1͛#Y-5l ʹ F]sǷ)Vyot&"iZ#mM$#~;_:A>7\jaHp$mn 4v"QM"+D4`(hg%}Q=Yo= L%peBV@Co  9oD]dC1`2Bw$1Ԋ^5jSՐ~`b#.dA.$'! O sAeA֙d[8dP}aWٍM1k/3؉S yo¼=k7!~ &A/#RrvAԵGB>ۘBך< g-=gMޠ) Ƥj-[&@.9Zkf- P6عzbm#hưʮ$)-Lѿl9~(bϐ@kι \Ht͝xa(h:J}wqǎD[ +w#^<H.ЪE$ @2cw.H<m9,4M46u`uIIQSӮCŞ`+ D V¤{)۟ٱmKdPBnKb f%MB0&mV'|^ؗ:,-<9a=ldc(ND#R`-f -Ҹ\ %s:xĞ0UjAxcw FLLuY ".dCKJI$sP=hԨRtu=Y LtlH+Lj#O_0+D渱 ~dN-=̣0epyˣq \W&6B ڻZ'4Yw^^c鈴NBPHl^aZRÎ^jFӔ]Qlc`\ixK`2Kz[qI$`CɦOkx=vjY!|(wϙ$ܴ:5Ȭl ?nw̨ݧQՏzT_|&[Tׅi*9\VAк˫qmF6R]{B3uDl?A}C¶I% *Nȝ*v (|MM5]W.mi8b ^$#Qp Zf`[):Q2H[ TԷ5|DH(tz\\vh|ǘREC9=QnpOؓLjPNŶӖ2紷_%o'ގ)QݞBF#PNB-XDU^vAgj VI-G^Ӥ7XсDzjD<A9X] `TR1<#؛0O#j?S S70u1ZuBeibPj N!Į`<`Q`\?}gke2\}QrPMVO'?m$;Ԣ!7rb-[D$g9yJG j?Ia_58,NxGrߙp(%ޤ 8ڶ̧lo@:E[G2_jP$DI~Œx.0%vЏXOfWЈJk!F#$7b`D 9puO|N1M\BRAC䜂OPgٓ{'֖|Rp^#~h.""HcM}NPG HSN=`3})bbxЛu*srq9ϰJV,N Mє19tvx?.Ӣݒؒ`lqRv?)ZiɌm"qJa uȘpl6G}y(NhF|bZ713yuswZnF}.I?d 07&_w!jRm;O}ΟfA@æpC:(+ q'="S~N9d>\nǧ ee5~9- ^tP%aF/zܘCT?d{XR I5VH'CvE+6W$[_);'hӍ]<.'ߓ1A0Ƙ:'$08뺮범bvZkZkuZkRJҟtRJ7I%VU0PF=*>"X"+4 x)D{Po@+q+;"'/8Po|4r;P N%8 5Y>O+"J 4F?HK&D@s`˱ֈuP|lFg慃V$ %6ܺ*z(%႔z"3=}\6|pYe@7 ܊qPArKU)=G&D̏bzg%YNve9ر( ļ1:ƚbv{hYY쑺hrwrSi*Zіi6-LA>󢗙azg91o3IUWңZswc!9k 1.1K0GeU4_+ժ͌:@&ü;/7#Du!' 0~S5C 5Ƽ[1h%XV'|v|T5@p[D.i;ypȵP 8Jf&iuF;Jd(0"?">pŧ1fNE(#.u]?Q}̢*|J-7%&pXz#ETESZp^PC!P}8=k$hDϦF'Վiۃ83YH8BF?ʢ\3 uY;IMהȦu$閭!Oq)^])1k8:~F/+'<GyO Etm*qdLҿiũ 4ftr%w9Sijn̝p1 =[REc'uFH-$/a<(j8J";RxJNCOࢃh3 `e)K I!3)~-Wvd!Og QdhJv]N7R{QR k5KgdBF c3H_dcCAZiG[&{C V9-cdf\ SKлWRiaq#5{L2lG$q﯁Z zhL3NvCEb =|f. 6cgڠrJ, X!:Y5SE=IJnmn:ǧ3*`+ACYkh_ Ѹ [#t *|ZBs̙&IT6 . bA:s$%wA'9b嶴BŜq{uxgĹh;O_U©~U&@;)5\Oq\0 Zʼn&K*U5!#28e~EضyIPq{3Y$Wҝ9n4ئʑ}gdMVHJs`n<^D KC0 50kDL9fK$qW`hd"c8ԹgDV~|t7' x3=)1^mlm +ONrz jߵgЛLtqżeʏq=Epr.9L*vGM0BrXP=~14K #OkTy'j^ѽ@7D+]/gُ^oZ fUrX*5=WmnZu`y1[ [ĵRD)un7(BU/}ka|Ř/l^6!3>7PD5G2PR Fk *]xYe<2{~ @]:ׇ6jw Jn5Lሂoie(>ӸLɮ)4, 4rul"`n#ZzOƱ'ju0f,h^1d GO/Zj߂ pf٩r0aצPgeV%2z6!Ji t t@FʥIǓX` u>es<0o6'vj-hxwbȔe1̻J(,Dvҽү{#  FMr3Daa8L=ХwSfOz*ҋfZƾor*^ȑ NEB ~4hrWKm6/|+&|_X&70|>?__,ޮjf_Z-yh@CGo ,!ͱOoQ=-@\PI&GxC?MлQjX*-aN<ޜ6>][&)*t)\TOb]T+0b|i!q!Ib+A `"{V}w7Uyn/„g,b<.:|Y=iQyYв˷ToZG 6͹ )[v9mW{p\t%/9v!MIIU ]W=eDzK{Ƶu-m)}c]2Km`pG%OSK4*fCeU7VxEEChr*j\/9vaKrQ0QYbԯw\mg.=* ||U"ZJ]O-)3Op&b^eRM%!܎*b됚hK"/ 48ed 7旞.)8et1PţxCG(!Cit^I6lJ_検F)w1vJ. i?ʌE\4/hˋOdl?ɣst#Wl$"<퍎O4$ L[hu"֛E!nd%7+"K.j{R2@3ƊI'-aNe˽js`Ph.30notSHemPu'GfzZH 76u亚=3Y6K? 1(6:X :?9l ?V:fڭ$c]pr;h;o r>&˲|'$@P%]ߚLvi>"+a66G~#t}.94w.ṳVwjO }B[W2Ka9^Ü XQn<&Џd>tY].̊UntvO27̂ W&&<-16-35xjI&JA]8"[LFЉ,5Gv=*\ϛ[OgBAyS@X'ԢU"ʴ3NVaBfyFWa a#̳kͤ^k_f(Ȏ\$.=l#O >``&1M؋rD KA+5uR`)3^bu'0nlQ2f8Y\ K $g#N\f8nȌ񛼻.i?YՏM4hrDEfqu_cJz>_V"ۅI)./$ FPy89mQ?D\*xְɟPtUn8k{QsRI {nɄMm)&-yy9/۶'d۹05і1?6"DYVoyzԳDR.K-9y&JzN?-C  1|㽹qsF?,]8Q+~6hlXy4i:t9(#_sʼZ_h B"iVGZy6 70T ԐN5m#HXH* މVC tGvkX@m/ uɼ0u2'Az424,J>l9Kc@"\/-7@1 V⺢4b t׆ls=l{wZ)UKvգy3 i5ۢ]Cf` ʴADpkO#bJWjXi3`AӋXHGV b 2y9У1'؊qi>P(T|ΛWρ=GdeBRhdbX5oa'p?@N3a؁bVKɈyz W;!]j,Ę"nC=⥷X/~ O#z >C(V;bjG)l8zA >Wܯ͎>_ Y1ɲ[A[lUan>!|F6Jt6f _?ikG7 8v!+HɌT3]6S#?\k;D6De`O89EfK 1u8p !-jMynjRVYGW9hR!Rb͇4U,Sq薥J( 6єėdrՄfk1 j\6*`^AA0d(K(aȿnW9utTk|kAum|=**uDC x (ntz2+Tިeb.GX!6)F5/3sg(Ayo\2 } SDqnUbnVֶS <^c+ePBQ 2 LǮA`)F~183Puk/-}L.nc5v}PiBya S)B八7҅L_]"<4Ȧ+`2 pW,7J*z}]pt!&}jQ(k̡k8IQĚg ũ~nYb~dboVi O1zg- +T 6[s$`NbW6ֱS7䜌nzPvY{D >. sdNj(ޏ 3dTJ0,#xlcmT}S0 -^p@^D9);բz9 so>Fd6-㷧xzlqv%kG̔Yqiߟ^%wUw/wta)FW='@B; &qDj wWÙ2*탸H_9(l"Xn-•h-D8Diq,{$ӜJȶq/E%L'<*XZh8v̾ݽڣ_c(fv|z#$cF,&)(Hc0 [sNc_؀9/Vl! ˿2zuJ)hӃ.< lpa]3#u?)fJc)ıͧ2hAǿ"hc/JVZ: {Q9RWawEuJ@SԱ$Mt%eO'r7cd%N CF :$b =h) I_ş_bMQsz~̈T%is &SN@9d;]GF`!=yº"'jѢ~&|H$@2 X(bciS])ʷBW%v-_ZG]]_iw+~]G+dZ?@K 7l͕NeinJ9˝Rm1 `qgd3T!;UyR[^u]qDWdٵϲi2:6;I* [iD)b{[e":'|8xlY /nj״&B7m~U0m+ܦivN tkɭJe 4d̻G;> c; vׁfI}g (|6we7[=㭗>0( D,1TܿSm{:Zg tZs0 Kp< A@GGVB.B"0 @b0ÐhE%%\^L4=3_9|.ŭXuG#ADS[.UG1eQNҾ9pC&lEAг:Z8h; _lBŅP1HK ī8bR!mIYk 8[: уҏ>+\Jvlj}6 Jx3MGpV? :Z}:,U 1p ks81tiѴ1fbNj8Mcs驥L~8]}n!?RLƀD2NȠ4@(Я Ժ<'8ɻ q@~?"o^߆k;%~1'իT(^RJ?$ƾMVaZL|j̅իVs\ۣtLmtVpwlX]K6A4mǖBMն ;rlq]G(V r K,zpyoR:FZZǶ`a~<.oh"CBG1jF$bH#OV1ḙAlmGs T }a15V"ts_R@x)f^SDCwhߪn3ɫ]bf2D'aEk^ˁo3sd6e(\]C:@'hXc=;<w;1ilX[gaSl lln͗\% (ٮpDTsJn^L</i"&RpbxNͮr9 B'4`_Rv4E;7vCgÒ^talҐ# + h-Io/=bsW/ږqmCGjv<jJvw8(~QeXWJO; ȌüUf4X.;ss@0wkH!t} &p2XKo5Dptn0T<0EȾi>t.9՞ЖS>8k6f&50׷j`5 $ҿLHތF@P?B fy{bb[f*3 W9G).,lLEmfc.np[5sOY~l+mZA $Yym}"!5Fm #iڙ.ߐ0}%\{# \a%u !.\hqB1o|+6Ul ^,lj]/£NE:A5!JT/lªq_Ȫ|4p+:t`ӻP#HID;dsžL&;%h)W"u⧔јn0.5pcnʯKܜewjKmqskI~֚y!WFւ ,)cF=ˆ3{A0Unkhjї9ܶ-^X%qǠ"]J /)8'8+z6#[$RE?}y.KD^$T"ծ=ֱs ~|?x_k@*\FϦ欰\xd\1{ *jGwٳ?Hðܣg4 FkS_Xta^! r,[jց\XhF`3Y:DК/{7 i9GGjP5j-qus)l!3}t2.ڎe8QOi,0<&иfˌ?<;dU<6)ى/iS7ӱ F^56!e^'1իP"h`,&7pYPpí0 4R*]Fؿx(c*i6QR&YM(*`$Ua YV] S.x^fP)E@ɱ۰|AB-zQ9n UuX{S*Gtp?eV/olR +nIidNuJ}i|@l:t7d0©D+da >TGǥ~G'_[-1.~4v ޸ADZL SOxذS7y/*`2K$@OhbY4厜kq>9+>)9Pbo@/gń_Z"_vIV'! -hK^q6%Y Eumq\ZpxjlǗ&oCc5Ӽo0S O\EFRԏPѺuK$"%^(,8#p7횯G4Lz#D!"GFmo8(DVgʄ " FRG۩ =e%ÛĪd$D.]uMfq3e)! X&s JŻ1j]{u* BX.JNVfcQfwx(q@:~24Ag}($+K*n#D Ѫ_\L9_QJKCu&m9V#M)MDwkU㑚{Ү*nH(>'[3UnG9}MתA #Ęn"II@ќCDA#h6,e.r .+ZV ġF@t9\ |?izUcrCZ^ǜBR$ٖ״:AR]ϻl^߂nU`̵JOud(BVuSdQW60Wv}|rRtL{/iFJд~ Oz}1IU5-^ߞ;fJ; $.8s؂A)3L3jE~cMG,3R"SU\JxDrx3C Uv0xXhŸ.ҧ" 潀>K<߇#;BptfuᤙmRyB:Up*zq=u/Cbc/}XJhլ|v;7@~o\LɡHI~R]D{*PJ*U_Y/UI zVА C6b2d٤G`,"7 p_s!?z3XF9F'mzc VUe}]0hg D$f p+Y̜ǍҐtph3 QR2[B&/f|َC ÈY.rV585S}'6r3&BtRpA9`㾄$m0+sn̉I hKYi@F҇2(uI..9ŕNPt%v$U?5)⇗)t!c wHnâug WOSFnlBGM$fuĭETXH!,2PK`f~Rfsf fJǍGhi"5AjdkޚG20tɇY& S0s'&7gz(7t.)UQ ʬp>+N&rra2<њHLd.x3VѺú!Qٴ*LׇR` Y8#ʿ̕cutp/G5rR?P6%ǀ֏&nc.Ψg\'oV*% V5sꔝm7'- ;P̜5WQ\QM]TbMZP=]+Ae,[q& 1*30Jp)ѶmJD*DJnNqJ]t-qr5Rҧ6`IƑf 7`W0uHnIrOnmF璁F+n4gJO <w"):vQx5Zյ]@INB»0@әܥE4Р,0ŸlX^G.El@م,v=ˎᖦp}YZin![[F)d qQ #fTL¢P^ߌ~7/}m LEVZXQ }@4p`Ee7jA{?e(sAA{%9. c)Ȱ sѶ_<LY̅:o?Lr! \[!6X0u84ս-|:ǤK60PQRőS?s{r i-=Z񭒊Pڸm۾k9i@.nlk7c )oK 7 7E]Ec7~o<֯bw[[rV,{|iq"x~F b?5(Yl޸WxO[@耊 dv9nRUR iv9n&1Qu4 }ApdP5Yj3@ǥ_ݨ"GeY l<`X/i4i ki 4p6y9_C=wB%C/MRE @)ꥼxu //*xpƏ|yk6W O־ۖƩ^vD8 A|9RR,F!NLjI )vTDOUG(. lviZ[GM ~T~!³LX\ 4ik=ғ,\ʆdہxI񽸵cicYZ/!Itǜ]36?x hik4r͖q޾1?]<$'(B4KciY "ݨ; >&; { K aw 3TSF`S gjfc H@ב4=2AH{&c#Ƭ([>d|*7]#ɩmsCncjM"#<x|&dgJO<[5G~YvM026?d@ֲ">7'㥭% A#n!9IR(؈Tu~U=m'**C޼Gev(ooNjt>Y{)\UX݊8QY1{q%s|1j]vUDTkw݈%'0GB$t0[PE~Nlk-,oȟRfâjDĢmlD2XP΅S9ڴ._ _y@<)qeQW@Qbsc:6E0RT-Ga7_nCYOh>GX/83JQ:KÊ4V˗,NRSr Q:4ZR#=Stfv&'MOD?o!Tab[Nj$޽uцՖxl՞g ɘ0HK](Y*kSGe[Uw!fD-޶ eA:g yJCzʼ`^.nFbꗌԕ\L:vp65P_aY\fyphn:PgڂoY)Tɧ-wU<܆Qv|・6=S@2hVVZfRXu6=Z)%afm.UF?dmK{(CqzZb CrM @ 46='!MK#hXXC3?|TmȠpm򬺮U=l,*y,FGe,D(>`/ʀ{3 $qÉx;0~%녚IAH+yѓJQeȿؤ\zFӻEǾ-UG$q>Gqy?] ZSx~wҸW:C44%>U am]F=WM_"ldBVTVo.ؒDITV!CG­"zࢰ1^sjM+{^V<@RQTi.cS-qq&3}:Y^ȓcG?KS W[὜?YJFx{Q_t+u>FʌH݋\=NwKY(Oz{ҙ/zi^<7D7ajwu+8VGߊ) A1; Ҙؖa*06#b r}>$MG xes  ,#w~PĞw /'H*Y[u:$-=gV&'3!vPy =+c m}hX93&Q-ckٍ^ST k]zje {mGT,~ <߰!^Q#<ՅJ-D5IY{$W@XDHLG_x7,.?y &)=1%9K-3HC$>0;Y纖&;{8Oe,MJNM *r թ 7D厧f BVy A$5f+6b"9t%¾}KI]nFY1Eetb&QѿlM8-zݯa- >2ukN}ɘ6;*!.'cҭA6Xϩ bIt.Գ)! VG8%g|zem|ǟ^=vpCY.~R0s=EM^F={tZ 3 zp>cv[TZNr(.0ʝE۵bX GWozG:Y2PeJ8g  ;6ЁC]/faY}KDa}$ p#ڛ>A>r nx oբ[|-"< 4*23iL,;{ﻤP[|gT3a3TaAfHb?)$D/'3}PcS. &X1JURpX~(~Z]xpRotd!i,B`ta0\¼wtLʇ7Qyp,7mkϰeWek)ޮ>nv*ŝ72~Ƭ5Ir-B}Pپb6>+y6Q3*q=3 Y(FL *ԥ&<~FVZ:jsDЌ4ñkduS\y]t>\oQ.ݤ&Κh\iL +Jwq^YߛJ*4^j&_Nwȼ<w9^iݬXz%\'݃FWA[f p,+i$jGQ#!cug Щ18qMk;U!g⅕%ńT&9lq|;|"Ny\ r`$gZw/7!| 1r_(DY&qd*1y}=jI}5u$Z,Ge3 Qxɺתb*aÙo4o,]yՕnu%wꊬPo2.c l]hؙA_QܰŦ;J5%i k4 =V&U;M3'dm-%Sҡ ,cqO^gO] A)L7RUn;8Bθ9͐齘ӟ< pi@ͪÄC:$u[|ϕF/kkfZ\gL"e)n t+P1LKCa y!D,HGTtI?o3(o3SSPM #([!ٳH!x !D0wNt+ @XȮ 'U~#ͷb.1Ώ p<0I"/Se$&ꬬ&mӂ0&hDP;ub\ѷv]jS_xE)$$5#ouu&^MukDܞ[!<QHO0 YA@)GNzڤ#@׺AJW%Y!xOsZ >VyO ]Z=EfRrT]p6]NvB*\Wm7i\U{xWGb( JP%3 흩!'6MP6,M#Oz4fF=ީ6y>RVxrj6Îz fPd\j_hXJA߶μp4 ]7.erkxg|icc#\+ذ0a8,])Gx?TK{ه=#A|HWuud1/v\>nv0_MѨ$5e\9^lBJ:*E˟lg`[UQ!LiɽTYΏ9nw4w`A& ,$5CtF]؜jcDT%ח8 2a dRLyii(F^  n+HMT(?bȗr| uEqjx a *bD_Z w~ [%h5T!I_xtwKUD`R}NêPfAc?֤ɄDb9[Z3T HW=S_'?+1n?%}L"[P`"֏9̣6S ?ğmݥMr|u[B=Ow uߊ` lF:Q{ʋ##(l͜G8d]C)⡾/H4eV$[T"7WG㕴w넰 (I]g~b膑Uy<~’<-H~5ۃE!]1xH<;ݻ% }Q-BJ*%dBb`@IHDȔԻ0-eH]cyDӍ&qc1 <r`e [Ď8?uS wEt,#Q7uZ;rsXxF}ĵbca@w(Y^Ӂ`Su?v@} h񙴳HJ=;5;?\1s$fQF=󢰦}c+ L W]^C?znjу_ڤ'⣙y+h|gݎ:hVi]B $ᘟ47T%!fă~XHXue5ZIl]\s+跟>rЕutr کMyFѼkl*+EL BMюn?@ nMЎ⩿-@]2ZQD2xJЊ[(DDeЊAI])SU.[uCtm%&by),3 3F^NUġh BK[_3[t TC4t`B38ͼrp+X0(13 Gl*g㉜Yǝ|Ov!TMz.ܔJA3-0L-&N<uf QU>@8$Dq  t;0{JGd]8);g\ihM-K`+;L#6"qÂүf!KF bIOȕ=A qCM؎ET5Y]D.ͣA.ApIi0>0h)dٖY);D|SRj'%YӽG[Df~3`qUIA2Ųׅг*'I;:[2[DY`31n_I?J씨B=}%yRDI7lA&Aa*-&,ӘiKOXM#ㇼryxtl֛L%=ONA*AƅoU7iuO1q~ u;__nw0'ڄ)QF *iPFK+6~cKA3vKE+j?e+E A"ONBE|/k?F $JQ= DžbQ@R,wlH<QNe&ʡb^2젧K"xqJ`Cn=NAt&А OOf RS{pU_CXTQ> v?W#.]#̖>$y49[]18S{`2@ =2'&">j[ KWK.U 84Ҷ9"h#:B'Vp ysRт5N,L)Yh̥|mN{Խ<lϦ^Ƨ}$Xԅ+pk-Y6楎p}m?CI@tbm `æԂlFRl{|@]Hp@Ɩ)ȧ)w Ф?w(1G.leF|0ۻ'FQo ! _Dә@qz^Rbղ8z9z{Ϝ/ԑy2BHfA.qXrpMA\IJI~\]L~[9#xx\XQuƇ QB  #Oni5hLO>žDa>)Ka St_\fQMEo"_C" 1X~q-n%KDkGE?N((`ܗK 8 6myO^"χ'.2\"+R#7߿pnzAy'`Q4qGuO?ILGfoTp`Ļg,_xS`ngm]{,l-9^dG&Tyro=h慅Eo6r0l"Ce]gf'472LPň!g;T% n m+ N?ay=ЬE"59-b8k8*˒1!B[fi~PA]k= #:.0gZ=,-vLBc%&!ll0RP<UuAB"DW)YJ/=`5|zSWM\B'h`XC(NfF%\D(jw [ 貁+{N{ѲxK Pb lֵϖ`PefSýG\7ݓIm$l7Ǘwq( td3Ls{-ŽK?D>`53CJȋQn(5 `͆ntXs.)}e B k[E?NnWT nD ;Q]3_J)Iv%Pׄri.,hʃMbLTWͳuʁʡ[ ɀW ϔc ZSƯJNL2LuLh|Rh2\XLHU-tm}I([yYB,:DƏaI\lj,, K7# v?r`*:ȇ2尞)G`feљNjziF?o t6m[rJ g7  `Ndm;:7UAΔ~`bрl lwbc4“N5`Qze(״ܮU_c!<8{Wp{GT:@G 4#q1,ShN""(ZTrϒKMI޴<3ք :H$c9C%O< nBbFA9:M"}S=ylgx#cGL Za*$(k!Jrޜh+J̖m(:a++4;e " @+}*p9-raڭN_b$VV@\B+oěz.rio:Vxkd@X0DHM;(j[Ag.]|Կ P"oN=,xHy;6δn0+kԒorD ӟ}3 2:=y6+VHy1YLS-hHqqM82/?a2n:h@HI*Op&`5zAe:#|%L⸼ C@~}CPd̃ X3eC Ɛ}8>%G/ !>t7@}ڀbvߡ=108Ek Al XbUj@4Nޜ_i R(h4JkP2G5PLY5m )ŇA~xo1LMȼvۭ-eHXTWqiH՜2l@`:SPz݀s& ^͊`G=Jsm9B uv(QurJ[\Mpvk 3z:po;CGJz{+V$46= &rb}`1"wni" zz]OLi2т8f=B_dПJloVM+mt(Uq7)D6Op8'Kx=%v5iՉX{%#eX'N4D.&eg\z{= MiB)oڂ>vG(1',{HB'L N,;4AkY3qy 3si[l Yӌj o=Ip]6Bܰl]5$DE9rw 3È W4A8|{Ăt+ 3?:#Lp:] 턿tKyj֦A/Kj'0Tkt&Հ>q@9|OGeb/If-^E刵EwbFvP!ϘO3T;F L8-!Ԙ֊5M7}UHO6nRB2`7-O dR}q?~<^)X?}Be澃"tF hl'Ax zf)~`Up! QBin^q4ar2D €{ߪсѡV"'k_<6a# CkY$7̯r] 00·SC*Ҥ;>9eZ(N!}~ _7E6MQSmIf~B[x+"ʘF9WAkA?IÄ"OBj` TNʧ$((3TMUen>/pZ7`zH7D7`GAt,J2dvjT>&aȈ_ fLuE g!Nҕ(1Sd= %"5ͤ`+E6G6ڈK+8˳)eaa:#:cxeVh"`+rhFۉ?K?cCr,@5(R'SWץOy9eŁZ4מg\5Jc759IYt&H(#f<@%(buB[[8v5^mb0*Q:+-@A;0zL]YmDA wLRz\c`nFK5w$ ^ċafPVg/VA{Ge?UɞbSjܝk. l?\U\Os/Nq|-= iT&@>?pG(,F6?0`rr, N@h%'J~ pN{>V#>z&Wذ~]o8 StYilV\EE;[>Cd+`[2_E )\f^AN! G :8?Y| `dRҁX|לD Jp!Ho+6c,BV|d|q^hsL1&IJe &4{֘8μ;W !?~X5ₚ5~$CTN>zm=g{Fcbθ:.wgl<+FrXZm~=PEᮇ0ID9MQʀ GbOYL⠽RNv*^I !-;'&퇬+XMqL#Ć%R g%O{Bv@bOίC?AK2B`/Gh(bCX[{ML &cx`ryUL&MȌ 9W46eVOi_ uܣl<)wf>-髰V. 0x>abc[EdtHQhcw c?7]pr"oE "\C .N5B=!zD,*?i"q 4ʱ z#婧( Wg+r]|(><^/Ƙ wjwO`i:AeE*Y%HeIbHzq T_ GM^ً~VE8|+cڠNY1ZLS&9cu讦 $+yW6&Q:%=q F^0A%Owq=0u.ִG򦣗ހэ ztŵ4`~=37Qih3P-E!Qdy-[冂 JA_3T⭙'nwk1 Ѻq<*ܖ'I]σ"2 Gk'};"R &CJDz+$EgM\>3.G(7!i*2I3EـxEk΃qּPy JPZ"~HϔHΟ)dp)%MJ Lgi  wD1tV2rG 3*BVw[*_iN(s>`LqTp틏~8.͉bQh"0G҇҉T)#g[ӃLݸ"|7asH6%)WU^ɰŇ6'XiRRN4۸,/tsl׎.& '$Ro7PaP64ۓ%t9 ze:[PRQ=d+lp@ Dc^ $\ABo ))78*$zHtGXz[@6BDš~`{,mxU?YԮLJG 3nk^v׾:J ,]7|$1뾂@fqm霰Tv,P۟CQ8 :elD:("gˈ,]@o+lri2ϝck)К'Īr(Y؛^%ZT0|j۟Yq"6غ/cu[v^Yr\tԱd~N+"䠓༘ɛ;FW7(J )iLaX:#6,QeH<׿{#hq0pxj9n EE92'taRtwnjL嵇=M av8lgT|;_Jc²}[a}#tGCw*yE0E!*8?(&qA`C@S X؇HΞB%PK\I[KHLiB'M:4z^.hQ{ a?CB蝓YuAP:4ꗟ;씒]y&?ΣC?N؋]ۃWKxʛA׆?B&{jU̧TfjٝC)-M,΄q2\ 1Pc1(M?=;T6=G \+}f'MG"+cbe "wH?\'O<ǚ&n#*<+P4ɶ/Y1a:`f?v{6q ՂnoIyμ"o8dfy-y}`ѓ;u * QX1G0p]VV&w&UWLtsȨ9lZ~^D,{&nz[{wX(QغSp}6p_uלz6'qܓskD/,D(v}ڛM?C{ьZ7m\n>>ϱJnThYUzbi:]f_g~Lo*F[x"@&ʺL(T6"*K$a|&vm"`$Zc!u9 4:K0Ц)y]4f R+03!m4\^LlV~H^)^k:ẁT->xV5 ҂n뜵ZK[pMm&bP?u놛j+D|EWxqv d%xVR_vJbeM py#N.c/B@D1cCI:ung_6Hk:HW;#-pA"Aq| =yYO ϕc 0hw G t~ ek FcαycPJ-OW-iI%Yn"VAG>,TfUh6CNZROE<֬\v{^.2/fhb ^܌Wcrqo`4GKW~[QwJ-+EwT=gM^ߩ\j9F 38;az O))W+{6[fWvB)1G7B槖'Cui/n4*D1[DBm_NTHSH6bCC|Yqd=d fdn~jE|n;^gL;M?ZY$LZolim7gLdXL):o)yWxL:# S:J~6U9[A&(WNJa #ˣx@&n0My.>ATZ%wuW*ʆ*kMF6ZDh\U;3`#0ᙶahkJobh6I q:xν YGUQf/ةY-.f\f y)V~^-hd#+j(#L[ >e )m45،mm$3/+tf2>hy.'ǜ6~&?fI6Bfh{$Ņ|=*9񢐳ƞgc['mpBO~d{ {%G+bPm|!<~یRҨ~-tEsIp5KU)$o6*y=S[Q>2]8F%VKQk1OYP)h .*ZۙFbt3z g ~Yjttv< ߗHni2(㽔֯6-ܭBC;{O2A;B-QR `q0 KROqGS S(QKBMd)|1?:Av DlyDQZ Z왐䏯W=ƧHK,JD궝Y5u>aV_@ M&dIgC#BaBөqy? jWUI+i1D5.I8cߖ_K dCs:3 PюЉmDGD2=Zc pM;p?~ }oTsܔ>}K {S4ct*jh z\DCD7W{PlicٵL5֤I-:3hw>* '$d2 3p)i*?"qM(%3NyuUp6K^SN6mM"ýM1\|O8W $5gj#«r;+kwbi؎S-ELmf۸t*Z/_A0,˺`or^ǫuO8_k;oX]K [DVaP. 4@\%/AB,b<#\v兀TxEonw H?[|kc#4=܊oVaFk 4aFID!PJ@A"`Ha D6V;#I_mv-(%ߖ[$@z8WO12 z) O pKP 2d%yTAXXҺ,[D{] bcI΋rm2pNTɀzm>k R*i]= q\dzDF(R2" . qY@|%Ud?¹ٮjs'-#*GyVû4IGpwtt{E?xSID 2\A"U`O>H`aPگ&!j>  VÏd U +NžP^WW7֩Pt]@tsyI׳VAFot~xI%~'d-OYz٘J@x +@|d@Q}I41J:~}8- G2Pm H^<^)zA9% bi qha$J8RO* AQDe-37D>[n{G' %]Fr@&v:Hi|Ыe pr Ж/`7@C%4ECiC{ R%n}mQ2g%@Rba&~: y8cܚcϜ{jiAe> 8k_ĚQeìH%y@,.o~ZV1PY)w*פck0 b0=m~ ط[Q z6+UVK^y1/} D?4) ~r$5a \ϾCH#.NĊh☐…)qPJДO5[.VO'aLan/ =)@ a}0ȷ`u L'AqIFa|\MCLJz{HjViiJҜȓb΀wjr\.D@Yn =߲6Ý;8Z@SY3os^eRL ռFZM2]@ʇef*F-lɾv?{4FΥLJhw2zQq^28M1ݸۧ+WP&ʘqkBeNqڪ Luo%{&prU50ƾ|Q>NiՀ&[Z4obQ>ɄY܌=epld!UxM*,AZ{Z OHT*@(GǫyTxvI8MC tM!#>,WQ2j=yP j9Xt>Rh][(Ej|Qn4I0nF$oUyқp۶z&(pw7HA+b["PfvUzzlN+MH)5Z`(úcL%9FEd{Ifgƛd.c)#-nvg8F)d2D/yn)ZWy'B0|% r7L|0Ekhg4b$G2n {> WG)$7 tK)1aܯeJ'b?*"+H2e2 inT{hD@ǾRҍ98fgl ͆<:ͳ q:0@iȝK1PJUՑo[A 6xALj^kgBl,{H>fZ>'&0DY_" =А[s| q%lFEALtl;x^t'&Ͳ h:9ұjl77W&r㮉}pM*K.Q#a=AX3ú.;>0~U6q%#o'tԌO/2La;@>Da=2l@%@z$,pVRP ZHY龩H K3 ș0ؔ=)PQIuMrz6Cp,ؠr576E@p7%PK/\T(sᩓs۟8.u0GPI_cX*P8ɛ6{,)6k,;m"?І8B2E$z)%e<w APtg$N/ gbz?taWbI-4~E|Gf~=NA/Vy!RIb8oaZWTQK-  .$>q;:7|WO^NdZDrOL83Lpa]׃҉@ U=%d6D?IȁGXя5VTRBRG ϕM J)A➴2|QEA a~q1ΥxR|J DśOB 45ae`+cDW'~=RTY/ /T+:*WlxJ= `Xwo¸ W >qqŐXp5~0c[T!J(NzyW.R A Qw$M4h\(oP?@t_ɧ,3sf'XZҹԡX50RY1aβ8]cc뎍;L/8OH.c޵"a/amqC/$@9^/w[hPt;cfNe\{Z 5DNq_xȮ$3*Fǥ(Ebn~ހ_=A$HtYˑ }Qz$Zr=ӭ/&&Xx1esf'z*g6Ǎ 3Fa Sfrq>L;o`t/03cbd^Iӹ@A\(ncAY{J(D:&\ʆ pm mukpӇkv̼9BRP]>|+| 5G*j9;󇞦|F,ǥ bNjONccm X;%N(=xϦ[ ɏ(/6uA׊K[H@@L_˲,Z 0O־jNr FoU:6zDcBZChdx"Ayf-x ٥KqV+D+'-h$ꬸߔ ?e7e^ƎU sF(P_S, e < Ѐ[9EG/T\h(׆gƪͨVD7p=4|1EB5J3U5"ĀXdYS% Iz/eVORWNv!w{$n1ۊp4SHX^^1%%utZ9SkyQV|gZcy\@E616]Ϣ6I\i7L%EHZzA_%9M݉ZMxVG-qs jJ.I ,r*8L]ғs582!,A%]/xyXiUzB+:;ǃPxH7*@3_`$.%}]hZpvKOHX~Z(py?>Gā056:R_0i%?pOUJ|A]"ܡ[WGD![4? Cy:F gByh!- w: d c4==gD2#?b]Iu\j'3t y8@p2,cM6D5]hoKW|~fXJ$K˜(% E˷Ёnok!0A xO%` eZE2;5# ar1",W_D-!^J@9%/T%zD\Ϭ =`vNDs'_1N4G.+vY9Dְs:Zz=uvaQqÙ\HD$~WҜqpkpWY[m9N = n4%!kR1s$u_ݮt ^64==}-zGCnh_#C]8ӧP"ĉp /tB+V S!|52 Qg%|`aTEBBd;ܢ-^pHaXjDF_ }!`|:Q?b*B dnVU`Y* %ቶ |<ʏ{+)?88mu$ >Y| DYj ĸ2u?V5Y;k8#f @pTOa˽g>NeH  @<`)A Y^))p4yd ~Amo%A\f >t3~\ÊDy:1 ZbcyQi2K [n9R|'ů=Hc>/}-^f|gRHPboT>ûA WoW4` %VyOyѪCFeiЇKс"[Zȸ OAC,>@ Sx\HRFZzx~'*wk u6٠'g0-1Y4 V BA*k۸fwSƌ;ǼˁHLģΡlkI!lRFۼ,jE{(] m0/@J$70Zvڬҧo֯tсh}[ŵ VW7På̸,.+ zWd @ESXHQVya%QtnHOӰTvޣCʚ ٤=&o6B8рt"QTw%WXX/Bt,SqӬ*UVz1c&$5ONA~X|x*i+18xu_4q}1fpM_l $ q)xC ˓fS#ݏ?BRpɾ!'J \]j5A^S 4Cа|r#I}Eyb'/eшM{SbH 8fSr1H PJMԔceܠˊ6֍+ as,튩nNi9XD'ADmV25?N& ɱc! $˫2E;cF|̭c j)0jۛ$Z{2/q 1? T*GLo& 4Oo9!㎒"f`WϞx 1[y#d1qcc}UB|ma؏:H] rsUeM˅ Pmx |q#= zк]JoAZbdoяSnM T9 lT\HM#Ȯ+i[R7u,[,bIp|-V0HUQ5 Mt ꇄ<˪t^Di))QO(+/tVajtAW@Gpu!|Lo>Qt6&O WnJj AA>~E+ WMEI4v(8;|(~lj$RNu}mhZƦI%$\%V9;Jy.Z (A"#X9bi0qaU[$d/h-DjDF t_$F(Awd]cDL=^J0.iu Fn6''6s,Ҝ&C"ʏ@iG#F O,xo'MTCKy` 8ҽ8mKA7 v!څ>Bcjq{ims`y;Nt3j/q)Y&uJ0{7obNCh2*%> YxHwHiiPVzxMijc8ܫx ^Ǘtg. ƪA4&j*a+9HGϴ A: +|v=YHQ uk5G{ǘ"CG@ԁa,]_k [wƍwz;'%Sǝ ʟ/$g@wpinBŕ>`eirrK(2,4Y/ 4?U` b6#-7ۮ$M`$ف #G9}m9؋yR::ѝ)1P&68!ԉA>tNziWAq Y1 #wpd^*qq<ԈO,XaE(IUӮ+B̷Ҫ}έ MDg$_F4͆jsUKV<^r=(}LD 1[+G<5Ά3Rm,NMWf'a~a7 q;t$~xY!",+]. dr@y@=UbPq ]ghLggқDN]k[Ke?jA> ̀.0- VKO7c+x^9i_%i$|A,w(VSd >h"E(;~f  q'.Zf2ϡd\K3Iq8ES/R s7qHC *r&C;a.۰98Qkd$7o]s^"5U^ n +gρ*A؂~vf/'?`J}E!~4fcivCAS@O0XmӮxh%AȺH> C[ ztc\F3p݇ oOca^p`^j+}q+@|SDZ;?9JmK_Dk6ʛd2`q±7A|9d/ݝ$sW~%NpmIᒡӇwΉ@B넭y5H** _1@ F4J*Z>xDӦRm *4 07{Y!5bl [1B O50Xc;1xړCHuI/[>|R0$_1؈G1X?'% -.GP]ݍgt:ەCT&t kb*j$*8]!͈JQ$zmwoyKov3ʘ"Js%K39v Ok˵iZQ"rFc #8=ѥ68!ZGTɡ_ZU$\JSR<$?308>;RZ}"jx(+xoffX%] 0!/+F8N(:^-SJ  ϧ1&Ya^3bwSY)sa;c Ǐ-BmO#WћD +x$zcB]d/gOr\u"k{K4C@C֝"!|Npp|0ZQd;`wf c+\w=5]wM"($Dt~cf۪?$Cy2iZSFJKN|P6 y#D r^m} {Y2AճJгK=~f 7ͯ##L!`>F"Q6YKvLJI$l{ S/1zF,mPF0bg7=fr9Eirذ PՑ λňLsa=lqn}ppS9^HC9}!LZ$%U^Ӥ%bI$A#kjw뜂ëFpn d֩ } E/ Lߍ Vdyl~͓5L;0\/xG%z)pұwˎUБ{M(h=R}ldMGtRQO'U#ۨ.|q(U3,Jåy)_%PŇuZa=ΰ`whrAq Q':BAI$M94ף4(n$0W/yA*.N㊹pliw =1ǑUN5IE~ywKVfg+њ! oA6J]UXqԛ~薧3t@ߟ@xzTUiD_ 4wR&;)LBOJFVN:dW%gYD00$JN4>9c$: Ynv`7ѓt'EOʷo;kVjiT-@g\LB*:6v jU'y6Fk9Vj]o9Kd1H;:HR";E0)8):bF"p&3@qB2A_2DGw=%I3undtD.'zK8TеdsһNqS(kjLD٥ct_e$VXhE qzfEܿ.N֑QLE,{oHb>w=2EOlۗ5v5[BPѶ޾n"x?ͅwO@ sBH>Ož8Dg 8orH}~:tbBn <_oNjmWKp%H ͹)a{ұ+7Zg0$ ^SCpE`! ^--[ ]XPg0ɰ~v楉Ìc+!&mV Y!4UȔ4&R+;81J)Bp{l /˿vfgFՋ? Q=I4E!JDd0C. gbAu֥"N G߮p92&$D@0KlhWӺsv1&rftߑ30pS࠵ȈǶMA`!knu2_ŋwVW"1<lpm`r Q9HfTs7v [3k3[$,s/j϶5F\UEzg*bYt^(xmq=J#J:a!N#}>+$!I)C5xv \/|$FM9YX#*;jrH67vc~q[UHbux\®R 9c;)K+-ѱ8dV7 B CgK"$\s(b}HÍ\ δRǦ#|)%0q3F*"a"ࢁ*nZx2A?e\l]j dx|7(7 |fVruuB~%tufgU`R(>SFisul l߾/&2-}<R /+_ҍ&W42bC!N%g:Sf@Ӹ؝E=]y!vzd(n~mAfֶ-iE k[Ea&L].\;qN|˛ZEN{IЪ|ўExGN+Jx<K*x'?9 Vux+V64 B춻qƋ݄@̘}ٳj]lVH> t\ /ɈY ?^ TRRrr(/ HD03H1"yf3o"n^7~a;K7ީ oqEMEUrɎ.]h^_t4.3+MxVotx﷼ߦk~mf3G'媞E$$ʎ-Mog=ytі^%K4cuRF%,KS[2*] ŷ*rivQ0ꬣḯdVY*^6 qxQ{&_d/]轖wr^~B|7Ү<!hϲŎk6eu#0Wf: 5ҁ#\| UV0ӑ QhÀ"U~ gum9')hYIBUNdҚD| \yP6X'@EbA9,|;H'ٟ #HQ"EoqY ַn @ײAt  3C S%!F@D䆡ˉHM3ӿp|ӹdbʄp"в.?JM78py2q5&k l{J"L\ҜETaCAZw;T 7(E{r]={O?$Cs +\z%4mC>q-S"@