diff --git a/pedometer/src/dart-sdk/include/dart_api.h b/pedometer/src/dart-sdk/include/dart_api.h new file mode 100644 index 0000000..abc0291 --- /dev/null +++ b/pedometer/src/dart-sdk/include/dart_api.h @@ -0,0 +1,3909 @@ +/* + * Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file + * for details. All rights reserved. Use of this source code is governed by a + * BSD-style license that can be found in the LICENSE file. + */ + +#ifndef RUNTIME_INCLUDE_DART_API_H_ +#define RUNTIME_INCLUDE_DART_API_H_ + +/** \mainpage Dart Embedding API Reference + * + * This reference describes the Dart Embedding API, which is used to embed the + * Dart Virtual Machine within C/C++ applications. + * + * This reference is generated from the header include/dart_api.h. + */ + +/* __STDC_FORMAT_MACROS has to be defined before including to + * enable platform independent printf format specifiers. */ +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif + +#include +#include +#include + +#ifdef __cplusplus +#define DART_EXTERN_C extern "C" +#else +#define DART_EXTERN_C extern +#endif + +#if defined(__CYGWIN__) +#error Tool chain and platform not supported. +#elif defined(_WIN32) +#if defined(DART_SHARED_LIB) +#define DART_EXPORT DART_EXTERN_C __declspec(dllexport) +#else +#define DART_EXPORT DART_EXTERN_C +#endif +#else +#if __GNUC__ >= 4 +#if defined(DART_SHARED_LIB) +#define DART_EXPORT \ + DART_EXTERN_C __attribute__((visibility("default"))) __attribute((used)) +#else +#define DART_EXPORT DART_EXTERN_C +#endif +#else +#error Tool chain not supported. +#endif +#endif + +#if __GNUC__ +#define DART_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) +#elif _MSC_VER +#define DART_WARN_UNUSED_RESULT _Check_return_ +#else +#define DART_WARN_UNUSED_RESULT +#endif + +/* + * ======= + * Handles + * ======= + */ + +/** + * An isolate is the unit of concurrency in Dart. Each isolate has + * its own memory and thread of control. No state is shared between + * isolates. Instead, isolates communicate by message passing. + * + * Each thread keeps track of its current isolate, which is the + * isolate which is ready to execute on the current thread. The + * current isolate may be NULL, in which case no isolate is ready to + * execute. Most of the Dart apis require there to be a current + * isolate in order to function without error. The current isolate is + * set by any call to Dart_CreateIsolateGroup or Dart_EnterIsolate. + */ +typedef struct _Dart_Isolate* Dart_Isolate; +typedef struct _Dart_IsolateGroup* Dart_IsolateGroup; + +/** + * An object reference managed by the Dart VM garbage collector. + * + * Because the garbage collector may move objects, it is unsafe to + * refer to objects directly. Instead, we refer to objects through + * handles, which are known to the garbage collector and updated + * automatically when the object is moved. Handles should be passed + * by value (except in cases like out-parameters) and should never be + * allocated on the heap. + * + * Most functions in the Dart Embedding API return a handle. When a + * function completes normally, this will be a valid handle to an + * object in the Dart VM heap. This handle may represent the result of + * the operation or it may be a special valid handle used merely to + * indicate successful completion. Note that a valid handle may in + * some cases refer to the null object. + * + * --- Error handles --- + * + * When a function encounters a problem that prevents it from + * completing normally, it returns an error handle (See Dart_IsError). + * An error handle has an associated error message that gives more + * details about the problem (See Dart_GetError). + * + * There are four kinds of error handles that can be produced, + * depending on what goes wrong: + * + * - Api error handles are produced when an api function is misused. + * This happens when a Dart embedding api function is called with + * invalid arguments or in an invalid context. + * + * - Unhandled exception error handles are produced when, during the + * execution of Dart code, an exception is thrown but not caught. + * Prototypically this would occur during a call to Dart_Invoke, but + * it can occur in any function which triggers the execution of Dart + * code (for example, Dart_ToString). + * + * An unhandled exception error provides access to an exception and + * stacktrace via the functions Dart_ErrorGetException and + * Dart_ErrorGetStackTrace. + * + * - Compilation error handles are produced when, during the execution + * of Dart code, a compile-time error occurs. As above, this can + * occur in any function which triggers the execution of Dart code. + * + * - Fatal error handles are produced when the system wants to shut + * down the current isolate. + * + * --- Propagating errors --- + * + * When an error handle is returned from the top level invocation of + * Dart code in a program, the embedder must handle the error as they + * see fit. Often, the embedder will print the error message produced + * by Dart_Error and exit the program. + * + * When an error is returned while in the body of a native function, + * it can be propagated up the call stack by calling + * Dart_PropagateError, Dart_SetReturnValue, or Dart_ThrowException. + * Errors should be propagated unless there is a specific reason not + * to. If an error is not propagated then it is ignored. For + * example, if an unhandled exception error is ignored, that + * effectively "catches" the unhandled exception. Fatal errors must + * always be propagated. + * + * When an error is propagated, any current scopes created by + * Dart_EnterScope will be exited. + * + * Using Dart_SetReturnValue to propagate an exception is somewhat + * more convenient than using Dart_PropagateError, and should be + * preferred for reasons discussed below. + * + * Dart_PropagateError and Dart_ThrowException do not return. Instead + * they transfer control non-locally using a setjmp-like mechanism. + * This can be inconvenient if you have resources that you need to + * clean up before propagating the error. + * + * When relying on Dart_PropagateError, we often return error handles + * rather than propagating them from helper functions. Consider the + * following contrived example: + * + * 1 Dart_Handle isLongStringHelper(Dart_Handle arg) { + * 2 intptr_t* length = 0; + * 3 result = Dart_StringLength(arg, &length); + * 4 if (Dart_IsError(result)) { + * 5 return result; + * 6 } + * 7 return Dart_NewBoolean(length > 100); + * 8 } + * 9 + * 10 void NativeFunction_isLongString(Dart_NativeArguments args) { + * 11 Dart_EnterScope(); + * 12 AllocateMyResource(); + * 13 Dart_Handle arg = Dart_GetNativeArgument(args, 0); + * 14 Dart_Handle result = isLongStringHelper(arg); + * 15 if (Dart_IsError(result)) { + * 16 FreeMyResource(); + * 17 Dart_PropagateError(result); + * 18 abort(); // will not reach here + * 19 } + * 20 Dart_SetReturnValue(result); + * 21 FreeMyResource(); + * 22 Dart_ExitScope(); + * 23 } + * + * In this example, we have a native function which calls a helper + * function to do its work. On line 5, the helper function could call + * Dart_PropagateError, but that would not give the native function a + * chance to call FreeMyResource(), causing a leak. Instead, the + * helper function returns the error handle to the caller, giving the + * caller a chance to clean up before propagating the error handle. + * + * When an error is propagated by calling Dart_SetReturnValue, the + * native function will be allowed to complete normally and then the + * exception will be propagated only once the native call + * returns. This can be convenient, as it allows the C code to clean + * up normally. + * + * The example can be written more simply using Dart_SetReturnValue to + * propagate the error. + * + * 1 Dart_Handle isLongStringHelper(Dart_Handle arg) { + * 2 intptr_t* length = 0; + * 3 result = Dart_StringLength(arg, &length); + * 4 if (Dart_IsError(result)) { + * 5 return result + * 6 } + * 7 return Dart_NewBoolean(length > 100); + * 8 } + * 9 + * 10 void NativeFunction_isLongString(Dart_NativeArguments args) { + * 11 Dart_EnterScope(); + * 12 AllocateMyResource(); + * 13 Dart_Handle arg = Dart_GetNativeArgument(args, 0); + * 14 Dart_SetReturnValue(isLongStringHelper(arg)); + * 15 FreeMyResource(); + * 16 Dart_ExitScope(); + * 17 } + * + * In this example, the call to Dart_SetReturnValue on line 14 will + * either return the normal return value or the error (potentially + * generated on line 3). The call to FreeMyResource on line 15 will + * execute in either case. + * + * --- Local and persistent handles --- + * + * Local handles are allocated within the current scope (see + * Dart_EnterScope) and go away when the current scope exits. Unless + * otherwise indicated, callers should assume that all functions in + * the Dart embedding api return local handles. + * + * Persistent handles are allocated within the current isolate. They + * can be used to store objects across scopes. Persistent handles have + * the lifetime of the current isolate unless they are explicitly + * deallocated (see Dart_DeletePersistentHandle). + * The type Dart_Handle represents a handle (both local and persistent). + * The type Dart_PersistentHandle is a Dart_Handle and it is used to + * document that a persistent handle is expected as a parameter to a call + * or the return value from a call is a persistent handle. + * + * FinalizableHandles are persistent handles which are auto deleted when + * the object is garbage collected. It is never safe to use these handles + * unless you know the object is still reachable. + * + * WeakPersistentHandles are persistent handles which are automatically set + * to point Dart_Null when the object is garbage collected. They are not auto + * deleted, so it is safe to use them after the object has become unreachable. + */ +typedef struct _Dart_Handle* Dart_Handle; +typedef Dart_Handle Dart_PersistentHandle; +typedef struct _Dart_WeakPersistentHandle* Dart_WeakPersistentHandle; +typedef struct _Dart_FinalizableHandle* Dart_FinalizableHandle; +// These structs are versioned by DART_API_DL_MAJOR_VERSION, bump the +// version when changing this struct. + +typedef void (*Dart_HandleFinalizer)(void* isolate_callback_data, void* peer); + +/** + * Is this an error handle? + * + * Requires there to be a current isolate. + */ +DART_EXPORT bool Dart_IsError(Dart_Handle handle); + +/** + * Is this an api error handle? + * + * Api error handles are produced when an api function is misused. + * This happens when a Dart embedding api function is called with + * invalid arguments or in an invalid context. + * + * Requires there to be a current isolate. + */ +DART_EXPORT bool Dart_IsApiError(Dart_Handle handle); + +/** + * Is this an unhandled exception error handle? + * + * Unhandled exception error handles are produced when, during the + * execution of Dart code, an exception is thrown but not caught. + * This can occur in any function which triggers the execution of Dart + * code. + * + * See Dart_ErrorGetException and Dart_ErrorGetStackTrace. + * + * Requires there to be a current isolate. + */ +DART_EXPORT bool Dart_IsUnhandledExceptionError(Dart_Handle handle); + +/** + * Is this a compilation error handle? + * + * Compilation error handles are produced when, during the execution + * of Dart code, a compile-time error occurs. This can occur in any + * function which triggers the execution of Dart code. + * + * Requires there to be a current isolate. + */ +DART_EXPORT bool Dart_IsCompilationError(Dart_Handle handle); + +/** + * Is this a fatal error handle? + * + * Fatal error handles are produced when the system wants to shut down + * the current isolate. + * + * Requires there to be a current isolate. + */ +DART_EXPORT bool Dart_IsFatalError(Dart_Handle handle); + +/** + * Gets the error message from an error handle. + * + * Requires there to be a current isolate. + * + * \return A C string containing an error message if the handle is + * error. An empty C string ("") if the handle is valid. This C + * String is scope allocated and is only valid until the next call + * to Dart_ExitScope. +*/ +DART_EXPORT const char* Dart_GetError(Dart_Handle handle); + +/** + * Is this an error handle for an unhandled exception? + */ +DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle); + +/** + * Gets the exception Object from an unhandled exception error handle. + */ +DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle); + +/** + * Gets the stack trace Object from an unhandled exception error handle. + */ +DART_EXPORT Dart_Handle Dart_ErrorGetStackTrace(Dart_Handle handle); + +/** + * Produces an api error handle with the provided error message. + * + * Requires there to be a current isolate. + * + * \param error the error message. + */ +DART_EXPORT Dart_Handle Dart_NewApiError(const char* error); +DART_EXPORT Dart_Handle Dart_NewCompilationError(const char* error); + +/** + * Produces a new unhandled exception error handle. + * + * Requires there to be a current isolate. + * + * \param exception An instance of a Dart object to be thrown or + * an ApiError or CompilationError handle. + * When an ApiError or CompilationError handle is passed in + * a string object of the error message is created and it becomes + * the Dart object to be thrown. + */ +DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception); + +/** + * Propagates an error. + * + * If the provided handle is an unhandled exception error, this + * function will cause the unhandled exception to be rethrown. This + * will proceed in the standard way, walking up Dart frames until an + * appropriate 'catch' block is found, executing 'finally' blocks, + * etc. + * + * If the error is not an unhandled exception error, we will unwind + * the stack to the next C frame. Intervening Dart frames will be + * discarded; specifically, 'finally' blocks will not execute. This + * is the standard way that compilation errors (and the like) are + * handled by the Dart runtime. + * + * In either case, when an error is propagated any current scopes + * created by Dart_EnterScope will be exited. + * + * See the additional discussion under "Propagating Errors" at the + * beginning of this file. + * + * \param An error handle (See Dart_IsError) + * + * \return On success, this function does not return. On failure, the + * process is terminated. + */ +DART_EXPORT void Dart_PropagateError(Dart_Handle handle); + +/** + * Converts an object to a string. + * + * May generate an unhandled exception error. + * + * \return The converted string if no error occurs during + * the conversion. If an error does occur, an error handle is + * returned. + */ +DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object); + +/** + * Checks to see if two handles refer to identically equal objects. + * + * If both handles refer to instances, this is equivalent to using the top-level + * function identical() from dart:core. Otherwise, returns whether the two + * argument handles refer to the same object. + * + * \param obj1 An object to be compared. + * \param obj2 An object to be compared. + * + * \return True if the objects are identically equal. False otherwise. + */ +DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2); + +/** + * Allocates a handle in the current scope from a persistent handle. + */ +DART_EXPORT Dart_Handle Dart_HandleFromPersistent(Dart_PersistentHandle object); + +/** + * Allocates a handle in the current scope from a weak persistent handle. + * + * This will be a handle to Dart_Null if the object has been garbage collected. + */ +DART_EXPORT Dart_Handle +Dart_HandleFromWeakPersistent(Dart_WeakPersistentHandle object); + +/** + * Allocates a persistent handle for an object. + * + * This handle has the lifetime of the current isolate unless it is + * explicitly deallocated by calling Dart_DeletePersistentHandle. + * + * Requires there to be a current isolate. + */ +DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object); + +/** + * Assign value of local handle to a persistent handle. + * + * Requires there to be a current isolate. + * + * \param obj1 A persistent handle whose value needs to be set. + * \param obj2 An object whose value needs to be set to the persistent handle. + * + * \return Success if the persistent handle was set + * Otherwise, returns an error. + */ +DART_EXPORT void Dart_SetPersistentHandle(Dart_PersistentHandle obj1, + Dart_Handle obj2); + +/** + * Deallocates a persistent handle. + * + * Requires there to be a current isolate group. + */ +DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object); + +/** + * Allocates a weak persistent handle for an object. + * + * This handle has the lifetime of the current isolate. The handle can also be + * explicitly deallocated by calling Dart_DeleteWeakPersistentHandle. + * + * If the object becomes unreachable the callback is invoked with the peer as + * argument. The callback can be executed on any thread, will have a current + * isolate group, but will not have a current isolate. The callback can only + * call Dart_DeletePersistentHandle or Dart_DeleteWeakPersistentHandle. This + * gives the embedder the ability to cleanup data associated with the object. + * The handle will point to the Dart_Null object after the finalizer has been + * run. It is illegal to call into the VM with any other Dart_* functions from + * the callback. If the handle is deleted before the object becomes + * unreachable, the callback is never invoked. + * + * Requires there to be a current isolate. + * + * \param object An object with identity. + * \param peer A pointer to a native object or NULL. This value is + * provided to callback when it is invoked. + * \param external_allocation_size The number of externally allocated + * bytes for peer. Used to inform the garbage collector. + * \param callback A function pointer that will be invoked sometime + * after the object is garbage collected, unless the handle has been deleted. + * A valid callback needs to be specified it cannot be NULL. + * + * \return The weak persistent handle or NULL. NULL is returned in case of bad + * parameters. + */ +DART_EXPORT Dart_WeakPersistentHandle +Dart_NewWeakPersistentHandle(Dart_Handle object, + void* peer, + intptr_t external_allocation_size, + Dart_HandleFinalizer callback); + +/** + * Deletes the given weak persistent [object] handle. + * + * Requires there to be a current isolate group. + */ +DART_EXPORT void Dart_DeleteWeakPersistentHandle( + Dart_WeakPersistentHandle object); + +/** + * Updates the external memory size for the given weak persistent handle. + * + * May trigger garbage collection. + */ +DART_EXPORT void Dart_UpdateExternalSize(Dart_WeakPersistentHandle object, + intptr_t external_allocation_size); + +/** + * Allocates a finalizable handle for an object. + * + * This handle has the lifetime of the current isolate group unless the object + * pointed to by the handle is garbage collected, in this case the VM + * automatically deletes the handle after invoking the callback associated + * with the handle. The handle can also be explicitly deallocated by + * calling Dart_DeleteFinalizableHandle. + * + * If the object becomes unreachable the callback is invoked with the + * the peer as argument. The callback can be executed on any thread, will have + * an isolate group, but will not have a current isolate. The callback can only + * call Dart_DeletePersistentHandle or Dart_DeleteWeakPersistentHandle. + * This gives the embedder the ability to cleanup data associated with the + * object and clear out any cached references to the handle. All references to + * this handle after the callback will be invalid. It is illegal to call into + * the VM with any other Dart_* functions from the callback. If the handle is + * deleted before the object becomes unreachable, the callback is never + * invoked. + * + * Requires there to be a current isolate. + * + * \param object An object with identity. + * \param peer A pointer to a native object or NULL. This value is + * provided to callback when it is invoked. + * \param external_allocation_size The number of externally allocated + * bytes for peer. Used to inform the garbage collector. + * \param callback A function pointer that will be invoked sometime + * after the object is garbage collected, unless the handle has been deleted. + * A valid callback needs to be specified it cannot be NULL. + * + * \return The finalizable handle or NULL. NULL is returned in case of bad + * parameters. + */ +DART_EXPORT Dart_FinalizableHandle +Dart_NewFinalizableHandle(Dart_Handle object, + void* peer, + intptr_t external_allocation_size, + Dart_HandleFinalizer callback); + +/** + * Deletes the given finalizable [object] handle. + * + * The caller has to provide the actual Dart object the handle was created from + * to prove the object (and therefore the finalizable handle) is still alive. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_DeleteFinalizableHandle(Dart_FinalizableHandle object, + Dart_Handle strong_ref_to_object); + +/** + * Updates the external memory size for the given finalizable handle. + * + * The caller has to provide the actual Dart object the handle was created from + * to prove the object (and therefore the finalizable handle) is still alive. + * + * May trigger garbage collection. + */ +DART_EXPORT void Dart_UpdateFinalizableExternalSize( + Dart_FinalizableHandle object, + Dart_Handle strong_ref_to_object, + intptr_t external_allocation_size); + +/* + * ========================== + * Initialization and Globals + * ========================== + */ + +/** + * Gets the version string for the Dart VM. + * + * The version of the Dart VM can be accessed without initializing the VM. + * + * \return The version string for the embedded Dart VM. + */ +DART_EXPORT const char* Dart_VersionString(); + +/** + * Isolate specific flags are set when creating a new isolate using the + * Dart_IsolateFlags structure. + * + * Current version of flags is encoded in a 32-bit integer with 16 bits used + * for each part. + */ + +#define DART_FLAGS_CURRENT_VERSION (0x0000000c) + +typedef struct { + int32_t version; + bool enable_asserts; + bool use_field_guards; + bool use_osr; + bool obfuscate; + bool load_vmservice_library; + bool copy_parent_code; + bool null_safety; + bool is_system_isolate; +} Dart_IsolateFlags; + +/** + * Initialize Dart_IsolateFlags with correct version and default values. + */ +DART_EXPORT void Dart_IsolateFlagsInitialize(Dart_IsolateFlags* flags); + +/** + * An isolate creation and initialization callback function. + * + * This callback, provided by the embedder, is called when the VM + * needs to create an isolate. The callback should create an isolate + * by calling Dart_CreateIsolateGroup and load any scripts required for + * execution. + * + * This callback may be called on a different thread than the one + * running the parent isolate. + * + * When the function returns NULL, it is the responsibility of this + * function to ensure that Dart_ShutdownIsolate has been called if + * required (for example, if the isolate was created successfully by + * Dart_CreateIsolateGroup() but the root library fails to load + * successfully, then the function should call Dart_ShutdownIsolate + * before returning). + * + * When the function returns NULL, the function should set *error to + * a malloc-allocated buffer containing a useful error message. The + * caller of this function (the VM) will make sure that the buffer is + * freed. + * + * \param script_uri The uri of the main source file or snapshot to load. + * Either the URI of the parent isolate set in Dart_CreateIsolateGroup for + * Isolate.spawn, or the argument to Isolate.spawnUri canonicalized by the + * library tag handler of the parent isolate. + * The callback is responsible for loading the program by a call to + * Dart_LoadScriptFromKernel. + * \param main The name of the main entry point this isolate will + * eventually run. This is provided for advisory purposes only to + * improve debugging messages. The main function is not invoked by + * this function. + * \param package_root Ignored. + * \param package_config Uri of the package configuration file (either in format + * of .packages or .dart_tool/package_config.json) for this isolate + * to resolve package imports against. If this parameter is not passed the + * package resolution of the parent isolate should be used. + * \param flags Default flags for this isolate being spawned. Either inherited + * from the spawning isolate or passed as parameters when spawning the + * isolate from Dart code. + * \param isolate_data The isolate data which was passed to the + * parent isolate when it was created by calling Dart_CreateIsolateGroup(). + * \param error A structure into which the embedder can place a + * C string containing an error message in the case of failures. + * + * \return The embedder returns NULL if the creation and + * initialization was not successful and the isolate if successful. + */ +typedef Dart_Isolate (*Dart_IsolateGroupCreateCallback)( + const char* script_uri, + const char* main, + const char* package_root, + const char* package_config, + Dart_IsolateFlags* flags, + void* isolate_data, + char** error); + +/** + * An isolate initialization callback function. + * + * This callback, provided by the embedder, is called when the VM has created an + * isolate within an existing isolate group (i.e. from the same source as an + * existing isolate). + * + * The callback should setup native resolvers and might want to set a custom + * message handler via [Dart_SetMessageNotifyCallback] and mark the isolate as + * runnable. + * + * This callback may be called on a different thread than the one + * running the parent isolate. + * + * When the function returns `false`, it is the responsibility of this + * function to ensure that `Dart_ShutdownIsolate` has been called. + * + * When the function returns `false`, the function should set *error to + * a malloc-allocated buffer containing a useful error message. The + * caller of this function (the VM) will make sure that the buffer is + * freed. + * + * \param child_isolate_data The callback data to associate with the new + * child isolate. + * \param error A structure into which the embedder can place a + * C string containing an error message in the case the initialization fails. + * + * \return The embedder returns true if the initialization was successful and + * false otherwise (in which case the VM will terminate the isolate). + */ +typedef bool (*Dart_InitializeIsolateCallback)(void** child_isolate_data, + char** error); + +/** + * An isolate unhandled exception callback function. + * + * This callback has been DEPRECATED. + */ +typedef void (*Dart_IsolateUnhandledExceptionCallback)(Dart_Handle error); + +/** + * An isolate shutdown callback function. + * + * This callback, provided by the embedder, is called before the vm + * shuts down an isolate. The isolate being shutdown will be the current + * isolate. It is safe to run Dart code. + * + * This function should be used to dispose of native resources that + * are allocated to an isolate in order to avoid leaks. + * + * \param isolate_group_data The same callback data which was passed to the + * isolate group when it was created. + * \param isolate_data The same callback data which was passed to the isolate + * when it was created. + */ +typedef void (*Dart_IsolateShutdownCallback)(void* isolate_group_data, + void* isolate_data); + +/** + * An isolate cleanup callback function. + * + * This callback, provided by the embedder, is called after the vm + * shuts down an isolate. There will be no current isolate and it is *not* + * safe to run Dart code. + * + * This function should be used to dispose of native resources that + * are allocated to an isolate in order to avoid leaks. + * + * \param isolate_group_data The same callback data which was passed to the + * isolate group when it was created. + * \param isolate_data The same callback data which was passed to the isolate + * when it was created. + */ +typedef void (*Dart_IsolateCleanupCallback)(void* isolate_group_data, + void* isolate_data); + +/** + * An isolate group cleanup callback function. + * + * This callback, provided by the embedder, is called after the vm + * shuts down an isolate group. + * + * This function should be used to dispose of native resources that + * are allocated to an isolate in order to avoid leaks. + * + * \param isolate_group_data The same callback data which was passed to the + * isolate group when it was created. + * + */ +typedef void (*Dart_IsolateGroupCleanupCallback)(void* isolate_group_data); + +/** + * A thread death callback function. + * This callback, provided by the embedder, is called before a thread in the + * vm thread pool exits. + * This function could be used to dispose of native resources that + * are associated and attached to the thread, in order to avoid leaks. + */ +typedef void (*Dart_ThreadExitCallback)(); + +/** + * Callbacks provided by the embedder for file operations. If the + * embedder does not allow file operations these callbacks can be + * NULL. + * + * Dart_FileOpenCallback - opens a file for reading or writing. + * \param name The name of the file to open. + * \param write A boolean variable which indicates if the file is to + * opened for writing. If there is an existing file it needs to truncated. + * + * Dart_FileReadCallback - Read contents of file. + * \param data Buffer allocated in the callback into which the contents + * of the file are read into. It is the responsibility of the caller to + * free this buffer. + * \param file_length A variable into which the length of the file is returned. + * In the case of an error this value would be -1. + * \param stream Handle to the opened file. + * + * Dart_FileWriteCallback - Write data into file. + * \param data Buffer which needs to be written into the file. + * \param length Length of the buffer. + * \param stream Handle to the opened file. + * + * Dart_FileCloseCallback - Closes the opened file. + * \param stream Handle to the opened file. + * + */ +typedef void* (*Dart_FileOpenCallback)(const char* name, bool write); + +typedef void (*Dart_FileReadCallback)(uint8_t** data, + intptr_t* file_length, + void* stream); + +typedef void (*Dart_FileWriteCallback)(const void* data, + intptr_t length, + void* stream); + +typedef void (*Dart_FileCloseCallback)(void* stream); + +typedef bool (*Dart_EntropySource)(uint8_t* buffer, intptr_t length); + +/** + * Callback provided by the embedder that is used by the vmservice isolate + * to request the asset archive. The asset archive must be an uncompressed tar + * archive that is stored in a Uint8List. + * + * If the embedder has no vmservice isolate assets, the callback can be NULL. + * + * \return The embedder must return a handle to a Uint8List containing an + * uncompressed tar archive or null. + */ +typedef Dart_Handle (*Dart_GetVMServiceAssetsArchive)(); + +/** + * The current version of the Dart_InitializeFlags. Should be incremented every + * time Dart_InitializeFlags changes in a binary incompatible way. + */ +#define DART_INITIALIZE_PARAMS_CURRENT_VERSION (0x00000004) + +/** Forward declaration */ +struct Dart_CodeObserver; + +/** + * Callback provided by the embedder that is used by the VM to notify on code + * object creation, *before* it is invoked the first time. + * This is useful for embedders wanting to e.g. keep track of PCs beyond + * the lifetime of the garbage collected code objects. + * Note that an address range may be used by more than one code object over the + * lifecycle of a process. Clients of this function should record timestamps for + * these compilation events and when collecting PCs to disambiguate reused + * address ranges. + */ +typedef void (*Dart_OnNewCodeCallback)(struct Dart_CodeObserver* observer, + const char* name, + uintptr_t base, + uintptr_t size); + +typedef struct Dart_CodeObserver { + void* data; + + Dart_OnNewCodeCallback on_new_code; +} Dart_CodeObserver; + +/** + * Describes how to initialize the VM. Used with Dart_Initialize. + * + * \param version Identifies the version of the struct used by the client. + * should be initialized to DART_INITIALIZE_PARAMS_CURRENT_VERSION. + * \param vm_isolate_snapshot A buffer containing a snapshot of the VM isolate + * or NULL if no snapshot is provided. If provided, the buffer must remain + * valid until Dart_Cleanup returns. + * \param instructions_snapshot A buffer containing a snapshot of precompiled + * instructions, or NULL if no snapshot is provided. If provided, the buffer + * must remain valid until Dart_Cleanup returns. + * \param initialize_isolate A function to be called during isolate + * initialization inside an existing isolate group. + * See Dart_InitializeIsolateCallback. + * \param create_group A function to be called during isolate group creation. + * See Dart_IsolateGroupCreateCallback. + * \param shutdown A function to be called right before an isolate is shutdown. + * See Dart_IsolateShutdownCallback. + * \param cleanup A function to be called after an isolate was shutdown. + * See Dart_IsolateCleanupCallback. + * \param cleanup_group A function to be called after an isolate group is shutdown. + * See Dart_IsolateGroupCleanupCallback. + * \param get_service_assets A function to be called by the service isolate when + * it requires the vmservice assets archive. + * See Dart_GetVMServiceAssetsArchive. + * \param code_observer An external code observer callback function. + * The observer can be invoked as early as during the Dart_Initialize() call. + */ +typedef struct { + int32_t version; + const uint8_t* vm_snapshot_data; + const uint8_t* vm_snapshot_instructions; + Dart_IsolateGroupCreateCallback create_group; + Dart_InitializeIsolateCallback initialize_isolate; + Dart_IsolateShutdownCallback shutdown_isolate; + Dart_IsolateCleanupCallback cleanup_isolate; + Dart_IsolateGroupCleanupCallback cleanup_group; + Dart_ThreadExitCallback thread_exit; + Dart_FileOpenCallback file_open; + Dart_FileReadCallback file_read; + Dart_FileWriteCallback file_write; + Dart_FileCloseCallback file_close; + Dart_EntropySource entropy_source; + Dart_GetVMServiceAssetsArchive get_service_assets; + bool start_kernel_isolate; + Dart_CodeObserver* code_observer; +} Dart_InitializeParams; + +/** + * Initializes the VM. + * + * \param params A struct containing initialization information. The version + * field of the struct must be DART_INITIALIZE_PARAMS_CURRENT_VERSION. + * + * \return NULL if initialization is successful. Returns an error message + * otherwise. The caller is responsible for freeing the error message. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT char* Dart_Initialize( + Dart_InitializeParams* params); + +/** + * Cleanup state in the VM before process termination. + * + * \return NULL if cleanup is successful. Returns an error message otherwise. + * The caller is responsible for freeing the error message. + * + * NOTE: This function must not be called on a thread that was created by the VM + * itself. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT char* Dart_Cleanup(); + +/** + * Sets command line flags. Should be called before Dart_Initialize. + * + * \param argc The length of the arguments array. + * \param argv An array of arguments. + * + * \return NULL if successful. Returns an error message otherwise. + * The caller is responsible for freeing the error message. + * + * NOTE: This call does not store references to the passed in c-strings. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT char* Dart_SetVMFlags(int argc, + const char** argv); + +/** + * Returns true if the named VM flag is of boolean type, specified, and set to + * true. + * + * \param flag_name The name of the flag without leading punctuation + * (example: "enable_asserts"). + */ +DART_EXPORT bool Dart_IsVMFlagSet(const char* flag_name); + +/* + * ======== + * Isolates + * ======== + */ + +/** + * Creates a new isolate. The new isolate becomes the current isolate. + * + * A snapshot can be used to restore the VM quickly to a saved state + * and is useful for fast startup. If snapshot data is provided, the + * isolate will be started using that snapshot data. Requires a core snapshot or + * an app snapshot created by Dart_CreateSnapshot or + * Dart_CreatePrecompiledSnapshot* from a VM with the same version. + * + * Requires there to be no current isolate. + * + * \param script_uri The main source file or snapshot this isolate will load. + * The VM will provide this URI to the Dart_IsolateGroupCreateCallback when a child + * isolate is created by Isolate.spawn. The embedder should use a URI that + * allows it to load the same program into such a child isolate. + * \param name A short name for the isolate to improve debugging messages. + * Typically of the format 'foo.dart:main()'. + * \param isolate_snapshot_data + * \param isolate_snapshot_instructions Buffers containing a snapshot of the + * isolate or NULL if no snapshot is provided. If provided, the buffers must + * remain valid until the isolate shuts down. + * \param flags Pointer to VM specific flags or NULL for default flags. + * \param isolate_group_data Embedder group data. This data can be obtained + * by calling Dart_IsolateGroupData and will be passed to the + * Dart_IsolateShutdownCallback, Dart_IsolateCleanupCallback, and + * Dart_IsolateGroupCleanupCallback. + * \param isolate_data Embedder data. This data will be passed to + * the Dart_IsolateGroupCreateCallback when new isolates are spawned from + * this parent isolate. + * \param error Returns NULL if creation is successful, an error message + * otherwise. The caller is responsible for calling free() on the error + * message. + * + * \return The new isolate on success, or NULL if isolate creation failed. + */ +DART_EXPORT Dart_Isolate +Dart_CreateIsolateGroup(const char* script_uri, + const char* name, + const uint8_t* isolate_snapshot_data, + const uint8_t* isolate_snapshot_instructions, + Dart_IsolateFlags* flags, + void* isolate_group_data, + void* isolate_data, + char** error); +/** + * Creates a new isolate inside the isolate group of [group_member]. + * + * Requires there to be no current isolate. + * + * \param group_member An isolate from the same group into which the newly created + * isolate should be born into. Other threads may not have entered / enter this + * member isolate. + * \param name A short name for the isolate for debugging purposes. + * \param shutdown_callback A callback to be called when the isolate is being + * shutdown (may be NULL). + * \param cleanup_callback A callback to be called when the isolate is being + * cleaned up (may be NULL). + * \param isolate_data The embedder-specific data associated with this isolate. + * \param error Set to NULL if creation is successful, set to an error + * message otherwise. The caller is responsible for calling free() on the + * error message. + * + * \return The newly created isolate on success, or NULL if isolate creation + * failed. + * + * If successful, the newly created isolate will become the current isolate. + */ +DART_EXPORT Dart_Isolate +Dart_CreateIsolateInGroup(Dart_Isolate group_member, + const char* name, + Dart_IsolateShutdownCallback shutdown_callback, + Dart_IsolateCleanupCallback cleanup_callback, + void* child_isolate_data, + char** error); + +/* TODO(turnidge): Document behavior when there is already a current + * isolate. */ + +/** + * Creates a new isolate from a Dart Kernel file. The new isolate + * becomes the current isolate. + * + * Requires there to be no current isolate. + * + * \param script_uri The main source file or snapshot this isolate will load. + * The VM will provide this URI to the Dart_IsolateGroupCreateCallback when a child + * isolate is created by Isolate.spawn. The embedder should use a URI that + * allows it to load the same program into such a child isolate. + * \param name A short name for the isolate to improve debugging messages. + * Typically of the format 'foo.dart:main()'. + * \param kernel_buffer + * \param kernel_buffer_size A buffer which contains a kernel/DIL program. Must + * remain valid until isolate shutdown. + * \param flags Pointer to VM specific flags or NULL for default flags. + * \param isolate_group_data Embedder group data. This data can be obtained + * by calling Dart_IsolateGroupData and will be passed to the + * Dart_IsolateShutdownCallback, Dart_IsolateCleanupCallback, and + * Dart_IsolateGroupCleanupCallback. + * \param isolate_data Embedder data. This data will be passed to + * the Dart_IsolateGroupCreateCallback when new isolates are spawned from + * this parent isolate. + * \param error Returns NULL if creation is successful, an error message + * otherwise. The caller is responsible for calling free() on the error + * message. + * + * \return The new isolate on success, or NULL if isolate creation failed. + */ +DART_EXPORT Dart_Isolate +Dart_CreateIsolateGroupFromKernel(const char* script_uri, + const char* name, + const uint8_t* kernel_buffer, + intptr_t kernel_buffer_size, + Dart_IsolateFlags* flags, + void* isolate_group_data, + void* isolate_data, + char** error); +/** + * Shuts down the current isolate. After this call, the current isolate is NULL. + * Any current scopes created by Dart_EnterScope will be exited. Invokes the + * shutdown callback and any callbacks of remaining weak persistent handles. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_ShutdownIsolate(); +/* TODO(turnidge): Document behavior when there is no current isolate. */ + +/** + * Returns the current isolate. Will return NULL if there is no + * current isolate. + */ +DART_EXPORT Dart_Isolate Dart_CurrentIsolate(); + +/** + * Returns the callback data associated with the current isolate. This + * data was set when the isolate got created or initialized. + */ +DART_EXPORT void* Dart_CurrentIsolateData(); + +/** + * Returns the callback data associated with the given isolate. This + * data was set when the isolate got created or initialized. + */ +DART_EXPORT void* Dart_IsolateData(Dart_Isolate isolate); + +/** + * Returns the current isolate group. Will return NULL if there is no + * current isolate group. + */ +DART_EXPORT Dart_IsolateGroup Dart_CurrentIsolateGroup(); + +/** + * Returns the callback data associated with the current isolate group. This + * data was passed to the isolate group when it was created. + */ +DART_EXPORT void* Dart_CurrentIsolateGroupData(); + +/** + * Returns the callback data associated with the specified isolate group. This + * data was passed to the isolate when it was created. + * The embedder is responsible for ensuring the consistency of this data + * with respect to the lifecycle of an isolate group. + */ +DART_EXPORT void* Dart_IsolateGroupData(Dart_Isolate isolate); + +/** + * Returns the debugging name for the current isolate. + * + * This name is unique to each isolate and should only be used to make + * debugging messages more comprehensible. + */ +DART_EXPORT Dart_Handle Dart_DebugName(); + +/** + * Returns the ID for an isolate which is used to query the service protocol. + * + * It is the responsibility of the caller to free the returned ID. + */ +DART_EXPORT const char* Dart_IsolateServiceId(Dart_Isolate isolate); + +/** + * Enters an isolate. After calling this function, + * the current isolate will be set to the provided isolate. + * + * Requires there to be no current isolate. Multiple threads may not be in + * the same isolate at once. + */ +DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate); + +/** + * Kills the given isolate. + * + * This function has the same effect as dart:isolate's + * Isolate.kill(priority:immediate). + * It can interrupt ordinary Dart code but not native code. If the isolate is + * in the middle of a long running native function, the isolate will not be + * killed until control returns to Dart. + * + * Does not require a current isolate. It is safe to kill the current isolate if + * there is one. + */ +DART_EXPORT void Dart_KillIsolate(Dart_Isolate isolate); + +/** + * Notifies the VM that the embedder expects |size| bytes of memory have become + * unreachable. The VM may use this hint to adjust the garbage collector's + * growth policy. + * + * Multiple calls are interpreted as increasing, not replacing, the estimate of + * unreachable memory. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_HintFreed(intptr_t size); + +/** + * Notifies the VM that the embedder expects to be idle until |deadline|. The VM + * may use this time to perform garbage collection or other tasks to avoid + * delays during execution of Dart code in the future. + * + * |deadline| is measured in microseconds against the system's monotonic time. + * This clock can be accessed via Dart_TimelineGetMicros(). + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_NotifyIdle(int64_t deadline); + +/** + * Notifies the VM that the system is running low on memory. + * + * Does not require a current isolate. Only valid after calling Dart_Initialize. + */ +DART_EXPORT void Dart_NotifyLowMemory(); + +/** + * Starts the CPU sampling profiler. + */ +DART_EXPORT void Dart_StartProfiling(); + +/** + * Stops the CPU sampling profiler. + * + * Note that some profile samples might still be taken after this fucntion + * returns due to the asynchronous nature of the implementation on some + * platforms. + */ +DART_EXPORT void Dart_StopProfiling(); + +/** + * Notifies the VM that the current thread should not be profiled until a + * matching call to Dart_ThreadEnableProfiling is made. + * + * NOTE: By default, if a thread has entered an isolate it will be profiled. + * This function should be used when an embedder knows a thread is about + * to make a blocking call and wants to avoid unnecessary interrupts by + * the profiler. + */ +DART_EXPORT void Dart_ThreadDisableProfiling(); + +/** + * Notifies the VM that the current thread should be profiled. + * + * NOTE: It is only legal to call this function *after* calling + * Dart_ThreadDisableProfiling. + * + * NOTE: By default, if a thread has entered an isolate it will be profiled. + */ +DART_EXPORT void Dart_ThreadEnableProfiling(); + +/** + * Register symbol information for the Dart VM's profiler and crash dumps. + * + * This consumes the output of //topaz/runtime/dart/profiler_symbols, which + * should be treated as opaque. + */ +DART_EXPORT void Dart_AddSymbols(const char* dso_name, + void* buffer, + intptr_t buffer_size); + +/** + * Exits an isolate. After this call, Dart_CurrentIsolate will + * return NULL. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_ExitIsolate(); +/* TODO(turnidge): We don't want users of the api to be able to exit a + * "pure" dart isolate. Implement and document. */ + +/** + * Creates a full snapshot of the current isolate heap. + * + * A full snapshot is a compact representation of the dart vm isolate heap + * and dart isolate heap states. These snapshots are used to initialize + * the vm isolate on startup and fast initialization of an isolate. + * A Snapshot of the heap is created before any dart code has executed. + * + * Requires there to be a current isolate. Not available in the precompiled + * runtime (check Dart_IsPrecompiledRuntime). + * + * \param buffer Returns a pointer to a buffer containing the + * snapshot. This buffer is scope allocated and is only valid + * until the next call to Dart_ExitScope. + * \param size Returns the size of the buffer. + * \param is_core Create a snapshot containing core libraries. + * Such snapshot should be agnostic to null safety mode. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateSnapshot(uint8_t** vm_snapshot_data_buffer, + intptr_t* vm_snapshot_data_size, + uint8_t** isolate_snapshot_data_buffer, + intptr_t* isolate_snapshot_data_size, + bool is_core); + +/** + * Returns whether the buffer contains a kernel file. + * + * \param buffer Pointer to a buffer that might contain a kernel binary. + * \param buffer_size Size of the buffer. + * + * \return Whether the buffer contains a kernel binary (full or partial). + */ +DART_EXPORT bool Dart_IsKernel(const uint8_t* buffer, intptr_t buffer_size); + +/** + * Make isolate runnable. + * + * When isolates are spawned, this function is used to indicate that + * the creation and initialization (including script loading) of the + * isolate is complete and the isolate can start. + * This function expects there to be no current isolate. + * + * \param isolate The isolate to be made runnable. + * + * \return NULL if successful. Returns an error message otherwise. The caller + * is responsible for freeing the error message. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT char* Dart_IsolateMakeRunnable( + Dart_Isolate isolate); + +/* + * ================== + * Messages and Ports + * ================== + */ + +/** + * A port is used to send or receive inter-isolate messages + */ +typedef int64_t Dart_Port; + +/** + * ILLEGAL_PORT is a port number guaranteed never to be associated with a valid + * port. + */ +#define ILLEGAL_PORT ((Dart_Port)0) + +/** + * A message notification callback. + * + * This callback allows the embedder to provide an alternate wakeup + * mechanism for the delivery of inter-isolate messages. It is the + * responsibility of the embedder to call Dart_HandleMessage to + * process the message. + */ +typedef void (*Dart_MessageNotifyCallback)(Dart_Isolate dest_isolate); + +/** + * Allows embedders to provide an alternative wakeup mechanism for the + * delivery of inter-isolate messages. This setting only applies to + * the current isolate. + * + * Most embedders will only call this function once, before isolate + * execution begins. If this function is called after isolate + * execution begins, the embedder is responsible for threading issues. + */ +DART_EXPORT void Dart_SetMessageNotifyCallback( + Dart_MessageNotifyCallback message_notify_callback); +/* TODO(turnidge): Consider moving this to isolate creation so that it + * is impossible to mess up. */ + +/** + * Query the current message notify callback for the isolate. + * + * \return The current message notify callback for the isolate. + */ +DART_EXPORT Dart_MessageNotifyCallback Dart_GetMessageNotifyCallback(); + +/** + * The VM's default message handler supports pausing an isolate before it + * processes the first message and right after the it processes the isolate's + * final message. This can be controlled for all isolates by two VM flags: + * + * `--pause-isolates-on-start` + * `--pause-isolates-on-exit` + * + * Additionally, Dart_SetShouldPauseOnStart and Dart_SetShouldPauseOnExit can be + * used to control this behaviour on a per-isolate basis. + * + * When an embedder is using a Dart_MessageNotifyCallback the embedder + * needs to cooperate with the VM so that the service protocol can report + * accurate information about isolates and so that tools such as debuggers + * work reliably. + * + * The following functions can be used to implement pausing on start and exit. + */ + +/** + * If the VM flag `--pause-isolates-on-start` was passed this will be true. + * + * \return A boolean value indicating if pause on start was requested. + */ +DART_EXPORT bool Dart_ShouldPauseOnStart(); + +/** + * Override the VM flag `--pause-isolates-on-start` for the current isolate. + * + * \param should_pause Should the isolate be paused on start? + * + * NOTE: This must be called before Dart_IsolateMakeRunnable. + */ +DART_EXPORT void Dart_SetShouldPauseOnStart(bool should_pause); + +/** + * Is the current isolate paused on start? + * + * \return A boolean value indicating if the isolate is paused on start. + */ +DART_EXPORT bool Dart_IsPausedOnStart(); + +/** + * Called when the embedder has paused the current isolate on start and when + * the embedder has resumed the isolate. + * + * \param paused Is the isolate paused on start? + */ +DART_EXPORT void Dart_SetPausedOnStart(bool paused); + +/** + * If the VM flag `--pause-isolates-on-exit` was passed this will be true. + * + * \return A boolean value indicating if pause on exit was requested. + */ +DART_EXPORT bool Dart_ShouldPauseOnExit(); + +/** + * Override the VM flag `--pause-isolates-on-exit` for the current isolate. + * + * \param should_pause Should the isolate be paused on exit? + * + */ +DART_EXPORT void Dart_SetShouldPauseOnExit(bool should_pause); + +/** + * Is the current isolate paused on exit? + * + * \return A boolean value indicating if the isolate is paused on exit. + */ +DART_EXPORT bool Dart_IsPausedOnExit(); + +/** + * Called when the embedder has paused the current isolate on exit and when + * the embedder has resumed the isolate. + * + * \param paused Is the isolate paused on exit? + */ +DART_EXPORT void Dart_SetPausedOnExit(bool paused); + +/** + * Called when the embedder has caught a top level unhandled exception error + * in the current isolate. + * + * NOTE: It is illegal to call this twice on the same isolate without first + * clearing the sticky error to null. + * + * \param error The unhandled exception error. + */ +DART_EXPORT void Dart_SetStickyError(Dart_Handle error); + +/** + * Does the current isolate have a sticky error? + */ +DART_EXPORT bool Dart_HasStickyError(); + +/** + * Gets the sticky error for the current isolate. + * + * \return A handle to the sticky error object or null. + */ +DART_EXPORT Dart_Handle Dart_GetStickyError(); + +/** + * Handles the next pending message for the current isolate. + * + * May generate an unhandled exception error. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_HandleMessage(); + +/** + * Drains the microtask queue, then blocks the calling thread until the current + * isolate recieves a message, then handles all messages. + * + * \param timeout_millis When non-zero, the call returns after the indicated + number of milliseconds even if no message was received. + * \return A valid handle if no error occurs, otherwise an error handle. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_WaitForEvent(int64_t timeout_millis); + +/** + * Handles any pending messages for the vm service for the current + * isolate. + * + * This function may be used by an embedder at a breakpoint to avoid + * pausing the vm service. + * + * This function can indirectly cause the message notify callback to + * be called. + * + * \return true if the vm service requests the program resume + * execution, false otherwise + */ +DART_EXPORT bool Dart_HandleServiceMessages(); + +/** + * Does the current isolate have pending service messages? + * + * \return true if the isolate has pending service messages, false otherwise. + */ +DART_EXPORT bool Dart_HasServiceMessages(); + +/** + * Processes any incoming messages for the current isolate. + * + * This function may only be used when the embedder has not provided + * an alternate message delivery mechanism with + * Dart_SetMessageCallbacks. It is provided for convenience. + * + * This function waits for incoming messages for the current + * isolate. As new messages arrive, they are handled using + * Dart_HandleMessage. The routine exits when all ports to the + * current isolate are closed. + * + * \return A valid handle if the run loop exited successfully. If an + * exception or other error occurs while processing messages, an + * error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_RunLoop(); + +/** + * Lets the VM run message processing for the isolate. + * + * This function expects there to a current isolate and the current isolate + * must not have an active api scope. The VM will take care of making the + * isolate runnable (if not already), handles its message loop and will take + * care of shutting the isolate down once it's done. + * + * \param errors_are_fatal Whether uncaught errors should be fatal. + * \param on_error_port A port to notify on uncaught errors (or ILLEGAL_PORT). + * \param on_exit_port A port to notify on exit (or ILLEGAL_PORT). + * \param error A non-NULL pointer which will hold an error message if the call + * fails. The error has to be free()ed by the caller. + * + * \return If successfull the VM takes owernship of the isolate and takes care + * of its message loop. If not successful the caller retains owernship of the + * isolate. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT bool Dart_RunLoopAsync( + bool errors_are_fatal, + Dart_Port on_error_port, + Dart_Port on_exit_port, + char** error); + +/* TODO(turnidge): Should this be removed from the public api? */ + +/** + * Gets the main port id for the current isolate. + */ +DART_EXPORT Dart_Port Dart_GetMainPortId(); + +/** + * Does the current isolate have live ReceivePorts? + * + * A ReceivePort is live when it has not been closed. + */ +DART_EXPORT bool Dart_HasLivePorts(); + +/** + * Posts a message for some isolate. The message is a serialized + * object. + * + * Requires there to be a current isolate. + * + * \param port The destination port. + * \param object An object from the current isolate. + * + * \return True if the message was posted. + */ +DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle object); + +/** + * Returns a new SendPort with the provided port id. + * + * \param port_id The destination port. + * + * \return A new SendPort if no errors occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id); + +/** + * Gets the SendPort id for the provided SendPort. + * \param port A SendPort object whose id is desired. + * \param port_id Returns the id of the SendPort. + * \return Success if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_SendPortGetId(Dart_Handle port, + Dart_Port* port_id); + +/* + * ====== + * Scopes + * ====== + */ + +/** + * Enters a new scope. + * + * All new local handles will be created in this scope. Additionally, + * some functions may return "scope allocated" memory which is only + * valid within this scope. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_EnterScope(); + +/** + * Exits a scope. + * + * The previous scope (if any) becomes the current scope. + * + * Requires there to be a current isolate. + */ +DART_EXPORT void Dart_ExitScope(); + +/** + * The Dart VM uses "zone allocation" for temporary structures. Zones + * support very fast allocation of small chunks of memory. The chunks + * cannot be deallocated individually, but instead zones support + * deallocating all chunks in one fast operation. + * + * This function makes it possible for the embedder to allocate + * temporary data in the VMs zone allocator. + * + * Zone allocation is possible: + * 1. when inside a scope where local handles can be allocated + * 2. when processing a message from a native port in a native port + * handler + * + * All the memory allocated this way will be reclaimed either on the + * next call to Dart_ExitScope or when the native port handler exits. + * + * \param size Size of the memory to allocate. + * + * \return A pointer to the allocated memory. NULL if allocation + * failed. Failure might due to is no current VM zone. + */ +DART_EXPORT uint8_t* Dart_ScopeAllocate(intptr_t size); + +/* + * ======= + * Objects + * ======= + */ + +/** + * Returns the null object. + * + * \return A handle to the null object. + */ +DART_EXPORT Dart_Handle Dart_Null(); + +/** + * Is this object null? + */ +DART_EXPORT bool Dart_IsNull(Dart_Handle object); + +/** + * Returns the empty string object. + * + * \return A handle to the empty string object. + */ +DART_EXPORT Dart_Handle Dart_EmptyString(); + +/** + * Returns types that are not classes, and which therefore cannot be looked up + * as library members by Dart_GetType. + * + * \return A handle to the dynamic, void or Never type. + */ +DART_EXPORT Dart_Handle Dart_TypeDynamic(); +DART_EXPORT Dart_Handle Dart_TypeVoid(); +DART_EXPORT Dart_Handle Dart_TypeNever(); + +/** + * Checks if the two objects are equal. + * + * The result of the comparison is returned through the 'equal' + * parameter. The return value itself is used to indicate success or + * failure, not equality. + * + * May generate an unhandled exception error. + * + * \param obj1 An object to be compared. + * \param obj2 An object to be compared. + * \param equal Returns the result of the equality comparison. + * + * \return A valid handle if no error occurs during the comparison. + */ +DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, + Dart_Handle obj2, + bool* equal); + +/** + * Is this object an instance of some type? + * + * The result of the test is returned through the 'instanceof' parameter. + * The return value itself is used to indicate success or failure. + * + * \param object An object. + * \param type A type. + * \param instanceof Return true if 'object' is an instance of type 'type'. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object, + Dart_Handle type, + bool* instanceof); + +/** + * Query object type. + * + * \param object Some Object. + * + * \return true if Object is of the specified type. + */ +DART_EXPORT bool Dart_IsInstance(Dart_Handle object); +DART_EXPORT bool Dart_IsNumber(Dart_Handle object); +DART_EXPORT bool Dart_IsInteger(Dart_Handle object); +DART_EXPORT bool Dart_IsDouble(Dart_Handle object); +DART_EXPORT bool Dart_IsBoolean(Dart_Handle object); +DART_EXPORT bool Dart_IsString(Dart_Handle object); +DART_EXPORT bool Dart_IsStringLatin1(Dart_Handle object); /* (ISO-8859-1) */ +DART_EXPORT bool Dart_IsExternalString(Dart_Handle object); +DART_EXPORT bool Dart_IsList(Dart_Handle object); +DART_EXPORT bool Dart_IsMap(Dart_Handle object); +DART_EXPORT bool Dart_IsLibrary(Dart_Handle object); +DART_EXPORT bool Dart_IsType(Dart_Handle handle); +DART_EXPORT bool Dart_IsFunction(Dart_Handle handle); +DART_EXPORT bool Dart_IsVariable(Dart_Handle handle); +DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle); +DART_EXPORT bool Dart_IsClosure(Dart_Handle object); +DART_EXPORT bool Dart_IsTypedData(Dart_Handle object); +DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle object); +DART_EXPORT bool Dart_IsFuture(Dart_Handle object); + +/* + * ========= + * Instances + * ========= + */ + +/* + * For the purposes of the embedding api, not all objects returned are + * Dart language objects. Within the api, we use the term 'Instance' + * to indicate handles which refer to true Dart language objects. + * + * TODO(turnidge): Reorganize the "Object" section above, pulling down + * any functions that more properly belong here. */ + +/** + * Gets the type of a Dart language object. + * + * \param instance Some Dart object. + * + * \return If no error occurs, the type is returned. Otherwise an + * error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance); + +/** + * Returns the name for the provided class type. + * + * \return A valid string handle if no error occurs during the + * operation. + */ +DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle cls_type); + +/** + * Returns the name for the provided function or method. + * + * \return A valid string handle if no error occurs during the + * operation. + */ +DART_EXPORT Dart_Handle Dart_FunctionName(Dart_Handle function); + +/** + * Returns a handle to the owner of a function. + * + * The owner of an instance method or a static method is its defining + * class. The owner of a top-level function is its defining + * library. The owner of the function of a non-implicit closure is the + * function of the method or closure that defines the non-implicit + * closure. + * + * \return A valid handle to the owner of the function, or an error + * handle if the argument is not a valid handle to a function. + */ +DART_EXPORT Dart_Handle Dart_FunctionOwner(Dart_Handle function); + +/** + * Determines whether a function handle referes to a static function + * of method. + * + * For the purposes of the embedding API, a top-level function is + * implicitly declared static. + * + * \param function A handle to a function or method declaration. + * \param is_static Returns whether the function or method is declared static. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_FunctionIsStatic(Dart_Handle function, + bool* is_static); + +/** + * Is this object a closure resulting from a tear-off (closurized method)? + * + * Returns true for closures produced when an ordinary method is accessed + * through a getter call. Returns false otherwise, in particular for closures + * produced from local function declarations. + * + * \param object Some Object. + * + * \return true if Object is a tear-off. + */ +DART_EXPORT bool Dart_IsTearOff(Dart_Handle object); + +/** + * Retrieves the function of a closure. + * + * \return A handle to the function of the closure, or an error handle if the + * argument is not a closure. + */ +DART_EXPORT Dart_Handle Dart_ClosureFunction(Dart_Handle closure); + +/** + * Returns a handle to the library which contains class. + * + * \return A valid handle to the library with owns class, null if the class + * has no library or an error handle if the argument is not a valid handle + * to a class type. + */ +DART_EXPORT Dart_Handle Dart_ClassLibrary(Dart_Handle cls_type); + +/* + * ============================= + * Numbers, Integers and Doubles + * ============================= + */ + +/** + * Does this Integer fit into a 64-bit signed integer? + * + * \param integer An integer. + * \param fits Returns true if the integer fits into a 64-bit signed integer. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer, + bool* fits); + +/** + * Does this Integer fit into a 64-bit unsigned integer? + * + * \param integer An integer. + * \param fits Returns true if the integer fits into a 64-bit unsigned integer. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer, + bool* fits); + +/** + * Returns an Integer with the provided value. + * + * \param value The value of the integer. + * + * \return The Integer object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value); + +/** + * Returns an Integer with the provided value. + * + * \param value The unsigned value of the integer. + * + * \return The Integer object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewIntegerFromUint64(uint64_t value); + +/** + * Returns an Integer with the provided value. + * + * \param value The value of the integer represented as a C string + * containing a hexadecimal number. + * + * \return The Integer object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* value); + +/** + * Gets the value of an Integer. + * + * The integer must fit into a 64-bit signed integer, otherwise an error occurs. + * + * \param integer An Integer. + * \param value Returns the value of the Integer. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer, + int64_t* value); + +/** + * Gets the value of an Integer. + * + * The integer must fit into a 64-bit unsigned integer, otherwise an + * error occurs. + * + * \param integer An Integer. + * \param value Returns the value of the Integer. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer, + uint64_t* value); + +/** + * Gets the value of an integer as a hexadecimal C string. + * + * \param integer An Integer. + * \param value Returns the value of the Integer as a hexadecimal C + * string. This C string is scope allocated and is only valid until + * the next call to Dart_ExitScope. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer, + const char** value); + +/** + * Returns a Double with the provided value. + * + * \param value A double. + * + * \return The Double object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewDouble(double value); + +/** + * Gets the value of a Double + * + * \param double_obj A Double + * \param value Returns the value of the Double. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj, double* value); + +/** + * Returns a closure of static function 'function_name' in the class 'class_name' + * in the exported namespace of specified 'library'. + * + * \param library Library object + * \param cls_type Type object representing a Class + * \param function_name Name of the static function in the class + * + * \return A valid Dart instance if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_GetStaticMethodClosure(Dart_Handle library, + Dart_Handle cls_type, + Dart_Handle function_name); + +/* + * ======== + * Booleans + * ======== + */ + +/** + * Returns the True object. + * + * Requires there to be a current isolate. + * + * \return A handle to the True object. + */ +DART_EXPORT Dart_Handle Dart_True(); + +/** + * Returns the False object. + * + * Requires there to be a current isolate. + * + * \return A handle to the False object. + */ +DART_EXPORT Dart_Handle Dart_False(); + +/** + * Returns a Boolean with the provided value. + * + * \param value true or false. + * + * \return The Boolean object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewBoolean(bool value); + +/** + * Gets the value of a Boolean + * + * \param boolean_obj A Boolean + * \param value Returns the value of the Boolean. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj, bool* value); + +/* + * ======= + * Strings + * ======= + */ + +/** + * Gets the length of a String. + * + * \param str A String. + * \param length Returns the length of the String. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* length); + +/** + * Returns a String built from the provided C string + * (There is an implicit assumption that the C string passed in contains + * UTF-8 encoded characters and '\0' is considered as a termination + * character). + * + * \param value A C String + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char* str); +/* TODO(turnidge): Document what happens when we run out of memory + * during this call. */ + +/** + * Returns a String built from an array of UTF-8 encoded characters. + * + * \param utf8_array An array of UTF-8 encoded characters. + * \param length The length of the codepoints array. + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewStringFromUTF8(const uint8_t* utf8_array, + intptr_t length); + +/** + * Returns a String built from an array of UTF-16 encoded characters. + * + * \param utf16_array An array of UTF-16 encoded characters. + * \param length The length of the codepoints array. + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewStringFromUTF16(const uint16_t* utf16_array, + intptr_t length); + +/** + * Returns a String built from an array of UTF-32 encoded characters. + * + * \param utf32_array An array of UTF-32 encoded characters. + * \param length The length of the codepoints array. + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewStringFromUTF32(const int32_t* utf32_array, + intptr_t length); + +/** + * Returns a String which references an external array of + * Latin-1 (ISO-8859-1) encoded characters. + * + * \param latin1_array Array of Latin-1 encoded characters. This must not move. + * \param length The length of the characters array. + * \param peer An external pointer to associate with this string. + * \param external_allocation_size The number of externally allocated + * bytes for peer. Used to inform the garbage collector. + * \param callback A callback to be called when this string is finalized. + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle +Dart_NewExternalLatin1String(const uint8_t* latin1_array, + intptr_t length, + void* peer, + intptr_t external_allocation_size, + Dart_HandleFinalizer callback); + +/** + * Returns a String which references an external array of UTF-16 encoded + * characters. + * + * \param utf16_array An array of UTF-16 encoded characters. This must not move. + * \param length The length of the characters array. + * \param peer An external pointer to associate with this string. + * \param external_allocation_size The number of externally allocated + * bytes for peer. Used to inform the garbage collector. + * \param callback A callback to be called when this string is finalized. + * + * \return The String object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle +Dart_NewExternalUTF16String(const uint16_t* utf16_array, + intptr_t length, + void* peer, + intptr_t external_allocation_size, + Dart_HandleFinalizer callback); + +/** + * Gets the C string representation of a String. + * (It is a sequence of UTF-8 encoded values with a '\0' termination.) + * + * \param str A string. + * \param cstr Returns the String represented as a C string. + * This C string is scope allocated and is only valid until + * the next call to Dart_ExitScope. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle str, + const char** cstr); + +/** + * Gets a UTF-8 encoded representation of a String. + * + * Any unpaired surrogate code points in the string will be converted as + * replacement characters (U+FFFD, 0xEF 0xBF 0xBD in UTF-8). If you need + * to preserve unpaired surrogates, use the Dart_StringToUTF16 function. + * + * \param str A string. + * \param utf8_array Returns the String represented as UTF-8 code + * units. This UTF-8 array is scope allocated and is only valid + * until the next call to Dart_ExitScope. + * \param length Used to return the length of the array which was + * actually used. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringToUTF8(Dart_Handle str, + uint8_t** utf8_array, + intptr_t* length); + +/** + * Gets the data corresponding to the string object. This function returns + * the data only for Latin-1 (ISO-8859-1) string objects. For all other + * string objects it returns an error. + * + * \param str A string. + * \param latin1_array An array allocated by the caller, used to return + * the string data. + * \param length Used to pass in the length of the provided array. + * Used to return the length of the array which was actually used. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringToLatin1(Dart_Handle str, + uint8_t* latin1_array, + intptr_t* length); + +/** + * Gets the UTF-16 encoded representation of a string. + * + * \param str A string. + * \param utf16_array An array allocated by the caller, used to return + * the array of UTF-16 encoded characters. + * \param length Used to pass in the length of the provided array. + * Used to return the length of the array which was actually used. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringToUTF16(Dart_Handle str, + uint16_t* utf16_array, + intptr_t* length); + +/** + * Gets the storage size in bytes of a String. + * + * \param str A String. + * \param length Returns the storage size in bytes of the String. + * This is the size in bytes needed to store the String. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_StringStorageSize(Dart_Handle str, intptr_t* size); + +/** + * Retrieves some properties associated with a String. + * Properties retrieved are: + * - character size of the string (one or two byte) + * - length of the string + * - peer pointer of string if it is an external string. + * \param str A String. + * \param char_size Returns the character size of the String. + * \param str_len Returns the length of the String. + * \param peer Returns the peer pointer associated with the String or 0 if + * there is no peer pointer for it. + * \return Success if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_StringGetProperties(Dart_Handle str, + intptr_t* char_size, + intptr_t* str_len, + void** peer); + +/* + * ===== + * Lists + * ===== + */ + +/** + * Returns a List of the desired length. + * + * \param length The length of the list. + * + * \return The List object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewList(intptr_t length); + +typedef enum { + Dart_CoreType_Dynamic, + Dart_CoreType_Int, + Dart_CoreType_String, +} Dart_CoreType_Id; + +// TODO(bkonyi): convert this to use nullable types once NNBD is enabled. +/** + * Returns a List of the desired length with the desired legacy element type. + * + * \param element_type_id The type of elements of the list. + * \param length The length of the list. + * + * \return The List object if no error occurs. Otherwise returns an error + * handle. + */ +DART_EXPORT Dart_Handle Dart_NewListOf(Dart_CoreType_Id element_type_id, + intptr_t length); + +/** + * Returns a List of the desired length with the desired element type. + * + * \param element_type Handle to a nullable type object. E.g., from + * Dart_GetType or Dart_GetNullableType. + * + * \param length The length of the list. + * + * \return The List object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewListOfType(Dart_Handle element_type, + intptr_t length); + +/** + * Returns a List of the desired length with the desired element type, filled + * with the provided object. + * + * \param element_type Handle to a type object. E.g., from Dart_GetType. + * + * \param fill_object Handle to an object of type 'element_type' that will be + * used to populate the list. This parameter can only be Dart_Null() if the + * length of the list is 0 or 'element_type' is a nullable type. + * + * \param length The length of the list. + * + * \return The List object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewListOfTypeFilled(Dart_Handle element_type, + Dart_Handle fill_object, + intptr_t length); + +/** + * Gets the length of a List. + * + * May generate an unhandled exception error. + * + * \param list A List. + * \param length Returns the length of the List. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* length); + +/** + * Gets the Object at some index of a List. + * + * If the index is out of bounds, an error occurs. + * + * May generate an unhandled exception error. + * + * \param list A List. + * \param index A valid index into the List. + * + * \return The Object in the List at the specified index if no error + * occurs. Otherwise returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index); + +/** +* Gets a range of Objects from a List. +* +* If any of the requested index values are out of bounds, an error occurs. +* +* May generate an unhandled exception error. +* +* \param list A List. +* \param offset The offset of the first item to get. +* \param length The number of items to get. +* \param result A pointer to fill with the objects. +* +* \return Success if no error occurs during the operation. +*/ +DART_EXPORT Dart_Handle Dart_ListGetRange(Dart_Handle list, + intptr_t offset, + intptr_t length, + Dart_Handle* result); + +/** + * Sets the Object at some index of a List. + * + * If the index is out of bounds, an error occurs. + * + * May generate an unhandled exception error. + * + * \param array A List. + * \param index A valid index into the List. + * \param value The Object to put in the List. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list, + intptr_t index, + Dart_Handle value); + +/** + * May generate an unhandled exception error. + */ +DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list, + intptr_t offset, + uint8_t* native_array, + intptr_t length); + +/** + * May generate an unhandled exception error. + */ +DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list, + intptr_t offset, + const uint8_t* native_array, + intptr_t length); + +/* + * ==== + * Maps + * ==== + */ + +/** + * Gets the Object at some key of a Map. + * + * May generate an unhandled exception error. + * + * \param map A Map. + * \param key An Object. + * + * \return The value in the map at the specified key, null if the map does not + * contain the key, or an error handle. + */ +DART_EXPORT Dart_Handle Dart_MapGetAt(Dart_Handle map, Dart_Handle key); + +/** + * Returns whether the Map contains a given key. + * + * May generate an unhandled exception error. + * + * \param map A Map. + * + * \return A handle on a boolean indicating whether map contains the key. + * Otherwise returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key); + +/** + * Gets the list of keys of a Map. + * + * May generate an unhandled exception error. + * + * \param map A Map. + * + * \return The list of key Objects if no error occurs. Otherwise returns an + * error handle. + */ +DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map); + +/* + * ========== + * Typed Data + * ========== + */ + +typedef enum { + Dart_TypedData_kByteData = 0, + Dart_TypedData_kInt8, + Dart_TypedData_kUint8, + Dart_TypedData_kUint8Clamped, + Dart_TypedData_kInt16, + Dart_TypedData_kUint16, + Dart_TypedData_kInt32, + Dart_TypedData_kUint32, + Dart_TypedData_kInt64, + Dart_TypedData_kUint64, + Dart_TypedData_kFloat32, + Dart_TypedData_kFloat64, + Dart_TypedData_kInt32x4, + Dart_TypedData_kFloat32x4, + Dart_TypedData_kFloat64x2, + Dart_TypedData_kInvalid +} Dart_TypedData_Type; + +/** + * Return type if this object is a TypedData object. + * + * \return kInvalid if the object is not a TypedData object or the appropriate + * Dart_TypedData_Type. + */ +DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object); + +/** + * Return type if this object is an external TypedData object. + * + * \return kInvalid if the object is not an external TypedData object or + * the appropriate Dart_TypedData_Type. + */ +DART_EXPORT Dart_TypedData_Type +Dart_GetTypeOfExternalTypedData(Dart_Handle object); + +/** + * Returns a TypedData object of the desired length and type. + * + * \param type The type of the TypedData object. + * \param length The length of the TypedData object (length in type units). + * + * \return The TypedData object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewTypedData(Dart_TypedData_Type type, + intptr_t length); + +/** + * Returns a TypedData object which references an external data array. + * + * \param type The type of the data array. + * \param data A data array. This array must not move. + * \param length The length of the data array (length in type units). + * + * \return The TypedData object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewExternalTypedData(Dart_TypedData_Type type, + void* data, + intptr_t length); + +/** + * Returns a TypedData object which references an external data array. + * + * \param type The type of the data array. + * \param data A data array. This array must not move. + * \param length The length of the data array (length in type units). + * \param peer A pointer to a native object or NULL. This value is + * provided to callback when it is invoked. + * \param external_allocation_size The number of externally allocated + * bytes for peer. Used to inform the garbage collector. + * \param callback A function pointer that will be invoked sometime + * after the object is garbage collected, unless the handle has been deleted. + * A valid callback needs to be specified it cannot be NULL. + * + * \return The TypedData object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle +Dart_NewExternalTypedDataWithFinalizer(Dart_TypedData_Type type, + void* data, + intptr_t length, + void* peer, + intptr_t external_allocation_size, + Dart_HandleFinalizer callback); + +/** + * Returns a ByteBuffer object for the typed data. + * + * \param type_data The TypedData object. + * + * \return The ByteBuffer object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_NewByteBuffer(Dart_Handle typed_data); + +/** + * Acquires access to the internal data address of a TypedData object. + * + * \param object The typed data object whose internal data address is to + * be accessed. + * \param type The type of the object is returned here. + * \param data The internal data address is returned here. + * \param len Size of the typed array is returned here. + * + * Notes: + * When the internal address of the object is acquired any calls to a + * Dart API function that could potentially allocate an object or run + * any Dart code will return an error. + * + * Any Dart API functions for accessing the data should not be called + * before the corresponding release. In particular, the object should + * not be acquired again before its release. This leads to undefined + * behavior. + * + * \return Success if the internal data address is acquired successfully. + * Otherwise, returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object, + Dart_TypedData_Type* type, + void** data, + intptr_t* len); + +/** + * Releases access to the internal data address that was acquired earlier using + * Dart_TypedDataAcquireData. + * + * \param object The typed data object whose internal data address is to be + * released. + * + * \return Success if the internal data address is released successfully. + * Otherwise, returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object); + +/** + * Returns the TypedData object associated with the ByteBuffer object. + * + * \param byte_buffer The ByteBuffer object. + * + * \return The TypedData object if no error occurs. Otherwise returns + * an error handle. + */ +DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle byte_buffer); + +/* + * ============================================================ + * Invoking Constructors, Methods, Closures and Field accessors + * ============================================================ + */ + +/** + * Invokes a constructor, creating a new object. + * + * This function allows hidden constructors (constructors with leading + * underscores) to be called. + * + * \param type Type of object to be constructed. + * \param constructor_name The name of the constructor to invoke. Use + * Dart_Null() or Dart_EmptyString() to invoke the unnamed constructor. + * This name should not include the name of the class. + * \param number_of_arguments Size of the arguments array. + * \param arguments An array of arguments to the constructor. + * + * \return If the constructor is called and completes successfully, + * then the new object. If an error occurs during execution, then an + * error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_New(Dart_Handle type, + Dart_Handle constructor_name, + int number_of_arguments, + Dart_Handle* arguments); + +/** + * Allocate a new object without invoking a constructor. + * + * \param type The type of an object to be allocated. + * + * \return The new object. If an error occurs during execution, then an + * error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_Allocate(Dart_Handle type); + +/** + * Allocate a new object without invoking a constructor, and sets specified + * native fields. + * + * \param type The type of an object to be allocated. + * \param num_native_fields The number of native fields to set. + * \param native_fields An array containing the value of native fields. + * + * \return The new object. If an error occurs during execution, then an + * error handle is returned. + */ +DART_EXPORT Dart_Handle +Dart_AllocateWithNativeFields(Dart_Handle type, + intptr_t num_native_fields, + const intptr_t* native_fields); + +/** + * Invokes a method or function. + * + * The 'target' parameter may be an object, type, or library. If + * 'target' is an object, then this function will invoke an instance + * method. If 'target' is a type, then this function will invoke a + * static method. If 'target' is a library, then this function will + * invoke a top-level function from that library. + * NOTE: This API call cannot be used to invoke methods of a type object. + * + * This function ignores visibility (leading underscores in names). + * + * May generate an unhandled exception error. + * + * \param target An object, type, or library. + * \param name The name of the function or method to invoke. + * \param number_of_arguments Size of the arguments array. + * \param arguments An array of arguments to the function. + * + * \return If the function or method is called and completes + * successfully, then the return value is returned. If an error + * occurs during execution, then an error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_Invoke(Dart_Handle target, + Dart_Handle name, + int number_of_arguments, + Dart_Handle* arguments); +/* TODO(turnidge): Document how to invoke operators. */ + +/** + * Invokes a Closure with the given arguments. + * + * May generate an unhandled exception error. + * + * \return If no error occurs during execution, then the result of + * invoking the closure is returned. If an error occurs during + * execution, then an error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_InvokeClosure(Dart_Handle closure, + int number_of_arguments, + Dart_Handle* arguments); + +/** + * Invokes a Generative Constructor on an object that was previously + * allocated using Dart_Allocate/Dart_AllocateWithNativeFields. + * + * The 'target' parameter must be an object. + * + * This function ignores visibility (leading underscores in names). + * + * May generate an unhandled exception error. + * + * \param target An object. + * \param name The name of the constructor to invoke. + * Use Dart_Null() or Dart_EmptyString() to invoke the unnamed constructor. + * \param number_of_arguments Size of the arguments array. + * \param arguments An array of arguments to the function. + * + * \return If the constructor is called and completes + * successfully, then the object is returned. If an error + * occurs during execution, then an error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_InvokeConstructor(Dart_Handle object, + Dart_Handle name, + int number_of_arguments, + Dart_Handle* arguments); + +/** + * Gets the value of a field. + * + * The 'container' parameter may be an object, type, or library. If + * 'container' is an object, then this function will access an + * instance field. If 'container' is a type, then this function will + * access a static field. If 'container' is a library, then this + * function will access a top-level variable. + * NOTE: This API call cannot be used to access fields of a type object. + * + * This function ignores field visibility (leading underscores in names). + * + * May generate an unhandled exception error. + * + * \param container An object, type, or library. + * \param name A field name. + * + * \return If no error occurs, then the value of the field is + * returned. Otherwise an error handle is returned. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_GetField(Dart_Handle container, Dart_Handle name); + +/** + * Sets the value of a field. + * + * The 'container' parameter may actually be an object, type, or + * library. If 'container' is an object, then this function will + * access an instance field. If 'container' is a type, then this + * function will access a static field. If 'container' is a library, + * then this function will access a top-level variable. + * NOTE: This API call cannot be used to access fields of a type object. + * + * This function ignores field visibility (leading underscores in names). + * + * May generate an unhandled exception error. + * + * \param container An object, type, or library. + * \param name A field name. + * \param value The new field value. + * + * \return A valid handle if no error occurs. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_SetField(Dart_Handle container, Dart_Handle name, Dart_Handle value); + +/* + * ========== + * Exceptions + * ========== + */ + +/* + * TODO(turnidge): Remove these functions from the api and replace all + * uses with Dart_NewUnhandledExceptionError. */ + +/** + * Throws an exception. + * + * This function causes a Dart language exception to be thrown. This + * will proceed in the standard way, walking up Dart frames until an + * appropriate 'catch' block is found, executing 'finally' blocks, + * etc. + * + * If an error handle is passed into this function, the error is + * propagated immediately. See Dart_PropagateError for a discussion + * of error propagation. + * + * If successful, this function does not return. Note that this means + * that the destructors of any stack-allocated C++ objects will not be + * called. If there are no Dart frames on the stack, an error occurs. + * + * \return An error handle if the exception was not thrown. + * Otherwise the function does not return. + */ +DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception); + +/** + * Rethrows an exception. + * + * Rethrows an exception, unwinding all dart frames on the stack. If + * successful, this function does not return. Note that this means + * that the destructors of any stack-allocated C++ objects will not be + * called. If there are no Dart frames on the stack, an error occurs. + * + * \return An error handle if the exception was not thrown. + * Otherwise the function does not return. + */ +DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception, + Dart_Handle stacktrace); + +/* + * =========================== + * Native fields and functions + * =========================== + */ + +/** + * Gets the number of native instance fields in an object. + */ +DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj, + int* count); + +/** + * Gets the value of a native field. + * + * TODO(turnidge): Document. + */ +DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj, + int index, + intptr_t* value); + +/** + * Sets the value of a native field. + * + * TODO(turnidge): Document. + */ +DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj, + int index, + intptr_t value); + +/** + * The arguments to a native function. + * + * This object is passed to a native function to represent its + * arguments and return value. It allows access to the arguments to a + * native function by index. It also allows the return value of a + * native function to be set. + */ +typedef struct _Dart_NativeArguments* Dart_NativeArguments; + +/** + * Extracts current isolate group data from the native arguments structure. + */ +DART_EXPORT void* Dart_GetNativeIsolateGroupData(Dart_NativeArguments args); + +typedef enum { + Dart_NativeArgument_kBool = 0, + Dart_NativeArgument_kInt32, + Dart_NativeArgument_kUint32, + Dart_NativeArgument_kInt64, + Dart_NativeArgument_kUint64, + Dart_NativeArgument_kDouble, + Dart_NativeArgument_kString, + Dart_NativeArgument_kInstance, + Dart_NativeArgument_kNativeFields, +} Dart_NativeArgument_Type; + +typedef struct _Dart_NativeArgument_Descriptor { + uint8_t type; + uint8_t index; +} Dart_NativeArgument_Descriptor; + +typedef union _Dart_NativeArgument_Value { + bool as_bool; + int32_t as_int32; + uint32_t as_uint32; + int64_t as_int64; + uint64_t as_uint64; + double as_double; + struct { + Dart_Handle dart_str; + void* peer; + } as_string; + struct { + intptr_t num_fields; + intptr_t* values; + } as_native_fields; + Dart_Handle as_instance; +} Dart_NativeArgument_Value; + +enum { + kNativeArgNumberPos = 0, + kNativeArgNumberSize = 8, + kNativeArgTypePos = kNativeArgNumberPos + kNativeArgNumberSize, + kNativeArgTypeSize = 8, +}; + +#define BITMASK(size) ((1 << size) - 1) +#define DART_NATIVE_ARG_DESCRIPTOR(type, position) \ + (((type & BITMASK(kNativeArgTypeSize)) << kNativeArgTypePos) | \ + (position & BITMASK(kNativeArgNumberSize))) + +/** + * Gets the native arguments based on the types passed in and populates + * the passed arguments buffer with appropriate native values. + * + * \param args the Native arguments block passed into the native call. + * \param num_arguments length of argument descriptor array and argument + * values array passed in. + * \param arg_descriptors an array that describes the arguments that + * need to be retrieved. For each argument to be retrieved the descriptor + * contains the argument number (0, 1 etc.) and the argument type + * described using Dart_NativeArgument_Type, e.g: + * DART_NATIVE_ARG_DESCRIPTOR(Dart_NativeArgument_kBool, 1) indicates + * that the first argument is to be retrieved and it should be a boolean. + * \param arg_values array into which the native arguments need to be + * extracted into, the array is allocated by the caller (it could be + * stack allocated to avoid the malloc/free performance overhead). + * + * \return Success if all the arguments could be extracted correctly, + * returns an error handle if there were any errors while extracting the + * arguments (mismatched number of arguments, incorrect types, etc.). + */ +DART_EXPORT Dart_Handle +Dart_GetNativeArguments(Dart_NativeArguments args, + int num_arguments, + const Dart_NativeArgument_Descriptor* arg_descriptors, + Dart_NativeArgument_Value* arg_values); + +/** + * Gets the native argument at some index. + */ +DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args, + int index); +/* TODO(turnidge): Specify the behavior of an out-of-bounds access. */ + +/** + * Gets the number of native arguments. + */ +DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args); + +/** + * Gets all the native fields of the native argument at some index. + * \param args Native arguments structure. + * \param arg_index Index of the desired argument in the structure above. + * \param num_fields size of the intptr_t array 'field_values' passed in. + * \param field_values intptr_t array in which native field values are returned. + * \return Success if the native fields where copied in successfully. Otherwise + * returns an error handle. On success the native field values are copied + * into the 'field_values' array, if the argument at 'arg_index' is a + * null object then 0 is copied as the native field values into the + * 'field_values' array. + */ +DART_EXPORT Dart_Handle +Dart_GetNativeFieldsOfArgument(Dart_NativeArguments args, + int arg_index, + int num_fields, + intptr_t* field_values); + +/** + * Gets the native field of the receiver. + */ +DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args, + intptr_t* value); + +/** + * Gets a string native argument at some index. + * \param args Native arguments structure. + * \param arg_index Index of the desired argument in the structure above. + * \param peer Returns the peer pointer if the string argument has one. + * \return Success if the string argument has a peer, if it does not + * have a peer then the String object is returned. Otherwise returns + * an error handle (argument is not a String object). + */ +DART_EXPORT Dart_Handle Dart_GetNativeStringArgument(Dart_NativeArguments args, + int arg_index, + void** peer); + +/** + * Gets an integer native argument at some index. + * \param args Native arguments structure. + * \param arg_index Index of the desired argument in the structure above. + * \param value Returns the integer value if the argument is an Integer. + * \return Success if no error occurs. Otherwise returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_GetNativeIntegerArgument(Dart_NativeArguments args, + int index, + int64_t* value); + +/** + * Gets a boolean native argument at some index. + * \param args Native arguments structure. + * \param arg_index Index of the desired argument in the structure above. + * \param value Returns the boolean value if the argument is a Boolean. + * \return Success if no error occurs. Otherwise returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_GetNativeBooleanArgument(Dart_NativeArguments args, + int index, + bool* value); + +/** + * Gets a double native argument at some index. + * \param args Native arguments structure. + * \param arg_index Index of the desired argument in the structure above. + * \param value Returns the double value if the argument is a double. + * \return Success if no error occurs. Otherwise returns an error handle. + */ +DART_EXPORT Dart_Handle Dart_GetNativeDoubleArgument(Dart_NativeArguments args, + int index, + double* value); + +/** + * Sets the return value for a native function. + * + * If retval is an Error handle, then error will be propagated once + * the native functions exits. See Dart_PropagateError for a + * discussion of how different types of errors are propagated. + */ +DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args, + Dart_Handle retval); + +DART_EXPORT void Dart_SetWeakHandleReturnValue(Dart_NativeArguments args, + Dart_WeakPersistentHandle rval); + +DART_EXPORT void Dart_SetBooleanReturnValue(Dart_NativeArguments args, + bool retval); + +DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args, + int64_t retval); + +DART_EXPORT void Dart_SetDoubleReturnValue(Dart_NativeArguments args, + double retval); + +/** + * A native function. + */ +typedef void (*Dart_NativeFunction)(Dart_NativeArguments arguments); + +/** + * Native entry resolution callback. + * + * For libraries and scripts which have native functions, the embedder + * can provide a native entry resolver. This callback is used to map a + * name/arity to a Dart_NativeFunction. If no function is found, the + * callback should return NULL. + * + * The parameters to the native resolver function are: + * \param name a Dart string which is the name of the native function. + * \param num_of_arguments is the number of arguments expected by the + * native function. + * \param auto_setup_scope is a boolean flag that can be set by the resolver + * to indicate if this function needs a Dart API scope (see Dart_EnterScope/ + * Dart_ExitScope) to be setup automatically by the VM before calling into + * the native function. By default most native functions would require this + * to be true but some light weight native functions which do not call back + * into the VM through the Dart API may not require a Dart scope to be + * setup automatically. + * + * \return A valid Dart_NativeFunction which resolves to a native entry point + * for the native function. + * + * See Dart_SetNativeResolver. + */ +typedef Dart_NativeFunction (*Dart_NativeEntryResolver)(Dart_Handle name, + int num_of_arguments, + bool* auto_setup_scope); +/* TODO(turnidge): Consider renaming to NativeFunctionResolver or + * NativeResolver. */ + +/** + * Native entry symbol lookup callback. + * + * For libraries and scripts which have native functions, the embedder + * can provide a callback for mapping a native entry to a symbol. This callback + * maps a native function entry PC to the native function name. If no native + * entry symbol can be found, the callback should return NULL. + * + * The parameters to the native reverse resolver function are: + * \param nf A Dart_NativeFunction. + * + * \return A const UTF-8 string containing the symbol name or NULL. + * + * See Dart_SetNativeResolver. + */ +typedef const uint8_t* (*Dart_NativeEntrySymbol)(Dart_NativeFunction nf); + +/** + * FFI Native C function pointer resolver callback. + * + * See Dart_SetFfiNativeResolver. + */ +typedef void* (*Dart_FfiNativeResolver)(const char* name, uintptr_t args_n); + +/* + * =========== + * Environment + * =========== + */ + +/** + * An environment lookup callback function. + * + * \param name The name of the value to lookup in the environment. + * + * \return A valid handle to a string if the name exists in the + * current environment or Dart_Null() if not. + */ +typedef Dart_Handle (*Dart_EnvironmentCallback)(Dart_Handle name); + +/** + * Sets the environment callback for the current isolate. This + * callback is used to lookup environment values by name in the + * current environment. This enables the embedder to supply values for + * the const constructors bool.fromEnvironment, int.fromEnvironment + * and String.fromEnvironment. + */ +DART_EXPORT Dart_Handle +Dart_SetEnvironmentCallback(Dart_EnvironmentCallback callback); + +/** + * Sets the callback used to resolve native functions for a library. + * + * \param library A library. + * \param resolver A native entry resolver. + * + * \return A valid handle if the native resolver was set successfully. + */ +DART_EXPORT Dart_Handle +Dart_SetNativeResolver(Dart_Handle library, + Dart_NativeEntryResolver resolver, + Dart_NativeEntrySymbol symbol); +/* TODO(turnidge): Rename to Dart_LibrarySetNativeResolver? */ + +/** + * Returns the callback used to resolve native functions for a library. + * + * \param library A library. + * \param resolver a pointer to a Dart_NativeEntryResolver + * + * \return A valid handle if the library was found. + */ +DART_EXPORT Dart_Handle +Dart_GetNativeResolver(Dart_Handle library, Dart_NativeEntryResolver* resolver); + +/** + * Returns the callback used to resolve native function symbols for a library. + * + * \param library A library. + * \param resolver a pointer to a Dart_NativeEntrySymbol. + * + * \return A valid handle if the library was found. + */ +DART_EXPORT Dart_Handle Dart_GetNativeSymbol(Dart_Handle library, + Dart_NativeEntrySymbol* resolver); + +/** + * Sets the callback used to resolve FFI native functions for a library. + * The resolved functions are expected to be a C function pointer of the + * correct signature (as specified in the `@FfiNative()` function + * annotation in Dart code). + * + * NOTE: This is an experimental feature and might change in the future. + * + * \param library A library. + * \param resolver A native function resolver. + * + * \return A valid handle if the native resolver was set successfully. + */ +DART_EXPORT Dart_Handle +Dart_SetFfiNativeResolver(Dart_Handle library, Dart_FfiNativeResolver resolver); + +/* + * ===================== + * Scripts and Libraries + * ===================== + */ + +typedef enum { + Dart_kCanonicalizeUrl = 0, + Dart_kImportTag, + Dart_kKernelTag, +} Dart_LibraryTag; + +/** + * The library tag handler is a multi-purpose callback provided by the + * embedder to the Dart VM. The embedder implements the tag handler to + * provide the ability to load Dart scripts and imports. + * + * -- TAGS -- + * + * Dart_kCanonicalizeUrl + * + * This tag indicates that the embedder should canonicalize 'url' with + * respect to 'library'. For most embedders, the + * Dart_DefaultCanonicalizeUrl function is a sufficient implementation + * of this tag. The return value should be a string holding the + * canonicalized url. + * + * Dart_kImportTag + * + * This tag is used to load a library from IsolateMirror.loadUri. The embedder + * should call Dart_LoadLibraryFromKernel to provide the library to the VM. The + * return value should be an error or library (the result from + * Dart_LoadLibraryFromKernel). + * + * Dart_kKernelTag + * + * This tag is used to load the intermediate file (kernel) generated by + * the Dart front end. This tag is typically used when a 'hot-reload' + * of an application is needed and the VM is 'use dart front end' mode. + * The dart front end typically compiles all the scripts, imports and part + * files into one intermediate file hence we don't use the source/import or + * script tags. The return value should be an error or a TypedData containing + * the kernel bytes. + * + */ +typedef Dart_Handle (*Dart_LibraryTagHandler)( + Dart_LibraryTag tag, + Dart_Handle library_or_package_map_url, + Dart_Handle url); + +/** + * Sets library tag handler for the current isolate. This handler is + * used to handle the various tags encountered while loading libraries + * or scripts in the isolate. + * + * \param handler Handler code to be used for handling the various tags + * encountered while loading libraries or scripts in the isolate. + * + * \return If no error occurs, the handler is set for the isolate. + * Otherwise an error handle is returned. + * + * TODO(turnidge): Document. + */ +DART_EXPORT Dart_Handle +Dart_SetLibraryTagHandler(Dart_LibraryTagHandler handler); + +/** + * Handles deferred loading requests. When this handler is invoked, it should + * eventually load the deferred loading unit with the given id and call + * Dart_DeferredLoadComplete or Dart_DeferredLoadCompleteError. It is + * recommended that the loading occur asynchronously, but it is permitted to + * call Dart_DeferredLoadComplete or Dart_DeferredLoadCompleteError before the + * handler returns. + * + * If an error is returned, it will be propogated through + * `prefix.loadLibrary()`. This is useful for synchronous + * implementations, which must propogate any unwind errors from + * Dart_DeferredLoadComplete or Dart_DeferredLoadComplete. Otherwise the handler + * should return a non-error such as `Dart_Null()`. + */ +typedef Dart_Handle (*Dart_DeferredLoadHandler)(intptr_t loading_unit_id); + +/** + * Sets the deferred load handler for the current isolate. This handler is + * used to handle loading deferred imports in an AppJIT or AppAOT program. + */ +DART_EXPORT Dart_Handle +Dart_SetDeferredLoadHandler(Dart_DeferredLoadHandler handler); + +/** + * Notifies the VM that a deferred load completed successfully. This function + * will eventually cause the corresponding `prefix.loadLibrary()` futures to + * complete. + * + * Requires the current isolate to be the same current isolate during the + * invocation of the Dart_DeferredLoadHandler. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_DeferredLoadComplete(intptr_t loading_unit_id, + const uint8_t* snapshot_data, + const uint8_t* snapshot_instructions); + +/** + * Notifies the VM that a deferred load failed. This function + * will eventually cause the corresponding `prefix.loadLibrary()` futures to + * complete with an error. + * + * If `transient` is true, future invocations of `prefix.loadLibrary()` will + * trigger new load requests. If false, futures invocation will complete with + * the same error. + * + * Requires the current isolate to be the same current isolate during the + * invocation of the Dart_DeferredLoadHandler. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_DeferredLoadCompleteError(intptr_t loading_unit_id, + const char* error_message, + bool transient); + +/** + * Canonicalizes a url with respect to some library. + * + * The url is resolved with respect to the library's url and some url + * normalizations are performed. + * + * This canonicalization function should be sufficient for most + * embedders to implement the Dart_kCanonicalizeUrl tag. + * + * \param base_url The base url relative to which the url is + * being resolved. + * \param url The url being resolved and canonicalized. This + * parameter is a string handle. + * + * \return If no error occurs, a String object is returned. Otherwise + * an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_DefaultCanonicalizeUrl(Dart_Handle base_url, + Dart_Handle url); + +/** + * Loads the root library for the current isolate. + * + * Requires there to be no current root library. + * + * \param buffer A buffer which contains a kernel binary (see + * pkg/kernel/binary.md). Must remain valid until isolate group shutdown. + * \param buffer_size Length of the passed in buffer. + * + * \return A handle to the root library, or an error. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_LoadScriptFromKernel(const uint8_t* kernel_buffer, intptr_t kernel_size); + +/** + * Gets the library for the root script for the current isolate. + * + * If the root script has not yet been set for the current isolate, + * this function returns Dart_Null(). This function never returns an + * error handle. + * + * \return Returns the root Library for the current isolate or Dart_Null(). + */ +DART_EXPORT Dart_Handle Dart_RootLibrary(); + +/** + * Sets the root library for the current isolate. + * + * \return Returns an error handle if `library` is not a library handle. + */ +DART_EXPORT Dart_Handle Dart_SetRootLibrary(Dart_Handle library); + +/** + * Lookup or instantiate a legacy type by name and type arguments from a + * Library. + * + * \param library The library containing the class or interface. + * \param class_name The class name for the type. + * \param number_of_type_arguments Number of type arguments. + * For non parametric types the number of type arguments would be 0. + * \param type_arguments Pointer to an array of type arguments. + * For non parameteric types a NULL would be passed in for this argument. + * + * \return If no error occurs, the type is returned. + * Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_GetType(Dart_Handle library, + Dart_Handle class_name, + intptr_t number_of_type_arguments, + Dart_Handle* type_arguments); + +/** + * Lookup or instantiate a nullable type by name and type arguments from + * Library. + * + * \param library The library containing the class or interface. + * \param class_name The class name for the type. + * \param number_of_type_arguments Number of type arguments. + * For non parametric types the number of type arguments would be 0. + * \param type_arguments Pointer to an array of type arguments. + * For non parameteric types a NULL would be passed in for this argument. + * + * \return If no error occurs, the type is returned. + * Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_GetNullableType(Dart_Handle library, + Dart_Handle class_name, + intptr_t number_of_type_arguments, + Dart_Handle* type_arguments); + +/** + * Lookup or instantiate a non-nullable type by name and type arguments from + * Library. + * + * \param library The library containing the class or interface. + * \param class_name The class name for the type. + * \param number_of_type_arguments Number of type arguments. + * For non parametric types the number of type arguments would be 0. + * \param type_arguments Pointer to an array of type arguments. + * For non parameteric types a NULL would be passed in for this argument. + * + * \return If no error occurs, the type is returned. + * Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle +Dart_GetNonNullableType(Dart_Handle library, + Dart_Handle class_name, + intptr_t number_of_type_arguments, + Dart_Handle* type_arguments); + +/** + * Creates a nullable version of the provided type. + * + * \param type The type to be converted to a nullable type. + * + * \return If no error occurs, a nullable type is returned. + * Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_TypeToNullableType(Dart_Handle type); + +/** + * Creates a non-nullable version of the provided type. + * + * \param type The type to be converted to a non-nullable type. + * + * \return If no error occurs, a non-nullable type is returned. + * Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_TypeToNonNullableType(Dart_Handle type); + +/** + * A type's nullability. + * + * \param type A Dart type. + * \param result An out parameter containing the result of the check. True if + * the type is of the specified nullability, false otherwise. + * + * \return Returns an error handle if type is not of type Type. + */ +DART_EXPORT Dart_Handle Dart_IsNullableType(Dart_Handle type, bool* result); +DART_EXPORT Dart_Handle Dart_IsNonNullableType(Dart_Handle type, bool* result); +DART_EXPORT Dart_Handle Dart_IsLegacyType(Dart_Handle type, bool* result); + +/** + * Lookup a class or interface by name from a Library. + * + * \param library The library containing the class or interface. + * \param class_name The name of the class or interface. + * + * \return If no error occurs, the class or interface is + * returned. Otherwise an error handle is returned. + */ +DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, + Dart_Handle class_name); +/* TODO(asiva): The above method needs to be removed once all uses + * of it are removed from the embedder code. */ + +/** + * Returns an import path to a Library, such as "file:///test.dart" or + * "dart:core". + */ +DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library); + +/** + * Returns a URL from which a Library was loaded. + */ +DART_EXPORT Dart_Handle Dart_LibraryResolvedUrl(Dart_Handle library); + +/** + * \return An array of libraries. + */ +DART_EXPORT Dart_Handle Dart_GetLoadedLibraries(); + +DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url); +/* TODO(turnidge): Consider returning Dart_Null() when the library is + * not found to distinguish that from a true error case. */ + +/** + * Report an loading error for the library. + * + * \param library The library that failed to load. + * \param error The Dart error instance containing the load error. + * + * \return If the VM handles the error, the return value is + * a null handle. If it doesn't handle the error, the error + * object is returned. + */ +DART_EXPORT Dart_Handle Dart_LibraryHandleError(Dart_Handle library, + Dart_Handle error); + +/** + * Called by the embedder to load a partial program. Does not set the root + * library. + * + * \param buffer A buffer which contains a kernel binary (see + * pkg/kernel/binary.md). Must remain valid until isolate shutdown. + * \param buffer_size Length of the passed in buffer. + * + * \return A handle to the main library of the compilation unit, or an error. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_LoadLibraryFromKernel(const uint8_t* kernel_buffer, + intptr_t kernel_buffer_size); + +/** + * Indicates that all outstanding load requests have been satisfied. + * This finalizes all the new classes loaded and optionally completes + * deferred library futures. + * + * Requires there to be a current isolate. + * + * \param complete_futures Specify true if all deferred library + * futures should be completed, false otherwise. + * + * \return Success if all classes have been finalized and deferred library + * futures are completed. Otherwise, returns an error. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_FinalizeLoading(bool complete_futures); + +/* + * ===== + * Peers + * ===== + */ + +/** + * The peer field is a lazily allocated field intended for storage of + * an uncommonly used values. Most instances types can have a peer + * field allocated. The exceptions are subtypes of Null, num, and + * bool. + */ + +/** + * Returns the value of peer field of 'object' in 'peer'. + * + * \param object An object. + * \param peer An out parameter that returns the value of the peer + * field. + * + * \return Returns an error if 'object' is a subtype of Null, num, or + * bool. + */ +DART_EXPORT Dart_Handle Dart_GetPeer(Dart_Handle object, void** peer); + +/** + * Sets the value of the peer field of 'object' to the value of + * 'peer'. + * + * \param object An object. + * \param peer A value to store in the peer field. + * + * \return Returns an error if 'object' is a subtype of Null, num, or + * bool. + */ +DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void* peer); + +/* + * ====== + * Kernel + * ====== + */ + +/** + * Experimental support for Dart to Kernel parser isolate. + * + * TODO(hausner): Document finalized interface. + * + */ + +// TODO(33433): Remove kernel service from the embedding API. + +typedef enum { + Dart_KernelCompilationStatus_Unknown = -1, + Dart_KernelCompilationStatus_Ok = 0, + Dart_KernelCompilationStatus_Error = 1, + Dart_KernelCompilationStatus_Crash = 2, + Dart_KernelCompilationStatus_MsgFailed = 3, +} Dart_KernelCompilationStatus; + +typedef struct { + Dart_KernelCompilationStatus status; + bool null_safety; + char* error; + uint8_t* kernel; + intptr_t kernel_size; +} Dart_KernelCompilationResult; + +typedef enum { + Dart_KernelCompilationVerbosityLevel_Error = 0, + Dart_KernelCompilationVerbosityLevel_Warning, + Dart_KernelCompilationVerbosityLevel_Info, + Dart_KernelCompilationVerbosityLevel_All, +} Dart_KernelCompilationVerbosityLevel; + +DART_EXPORT bool Dart_IsKernelIsolate(Dart_Isolate isolate); +DART_EXPORT bool Dart_KernelIsolateIsRunning(); +DART_EXPORT Dart_Port Dart_KernelPort(); + +/** + * Compiles the given `script_uri` to a kernel file. + * + * \param platform_kernel A buffer containing the kernel of the platform (e.g. + * `vm_platform_strong.dill`). The VM does not take ownership of this memory. + * + * \param platform_kernel_size The length of the platform_kernel buffer. + * + * \param snapshot_compile Set to `true` when the compilation is for a snapshot. + * This is used by the frontend to determine if compilation related information + * should be printed to console (e.g., null safety mode). + * + * \param verbosity Specifies the logging behavior of the kernel compilation + * service. + * + * \return Returns the result of the compilation. + * + * On a successful compilation the returned [Dart_KernelCompilationResult] has + * a status of [Dart_KernelCompilationStatus_Ok] and the `kernel`/`kernel_size` + * fields are set. The caller takes ownership of the malloc()ed buffer. + * + * On a failed compilation the `error` might be set describing the reason for + * the failed compilation. The caller takes ownership of the malloc()ed + * error. + * + * Requires there to be a current isolate. + */ +DART_EXPORT Dart_KernelCompilationResult +Dart_CompileToKernel(const char* script_uri, + const uint8_t* platform_kernel, + const intptr_t platform_kernel_size, + bool incremental_compile, + bool snapshot_compile, + const char* package_config, + Dart_KernelCompilationVerbosityLevel verbosity); + +typedef struct { + const char* uri; + const char* source; +} Dart_SourceFile; + +DART_EXPORT Dart_KernelCompilationResult Dart_KernelListDependencies(); + +/** + * Sets the kernel buffer which will be used to load Dart SDK sources + * dynamically at runtime. + * + * \param platform_kernel A buffer containing kernel which has sources for the + * Dart SDK populated. Note: The VM does not take ownership of this memory. + * + * \param platform_kernel_size The length of the platform_kernel buffer. + */ +DART_EXPORT void Dart_SetDartLibrarySourcesKernel( + const uint8_t* platform_kernel, + const intptr_t platform_kernel_size); + +/** + * Detect the null safety opt-in status. + * + * When running from source, it is based on the opt-in status of `script_uri`. + * When running from a kernel buffer, it is based on the mode used when + * generating `kernel_buffer`. + * When running from an appJIT or AOT snapshot, it is based on the mode used + * when generating `snapshot_data`. + * + * \param script_uri Uri of the script that contains the source code + * + * \param package_config Uri of the package configuration file (either in format + * of .packages or .dart_tool/package_config.json) for the null safety + * detection to resolve package imports against. If this parameter is not + * passed the package resolution of the parent isolate should be used. + * + * \param original_working_directory current working directory when the VM + * process was launched, this is used to correctly resolve the path specified + * for package_config. + * + * \param snapshot_data + * + * \param snapshot_instructions Buffers containing a snapshot of the + * isolate or NULL if no snapshot is provided. If provided, the buffers must + * remain valid until the isolate shuts down. + * + * \param kernel_buffer + * + * \param kernel_buffer_size A buffer which contains a kernel/DIL program. Must + * remain valid until isolate shutdown. + * + * \return Returns true if the null safety is opted in by the input being + * run `script_uri`, `snapshot_data` or `kernel_buffer`. + * + */ +DART_EXPORT bool Dart_DetectNullSafety(const char* script_uri, + const char* package_config, + const char* original_working_directory, + const uint8_t* snapshot_data, + const uint8_t* snapshot_instructions, + const uint8_t* kernel_buffer, + intptr_t kernel_buffer_size); + +#define DART_KERNEL_ISOLATE_NAME "kernel-service" + +/* + * ======= + * Service + * ======= + */ + +#define DART_VM_SERVICE_ISOLATE_NAME "vm-service" + +/** + * Returns true if isolate is the service isolate. + * + * \param isolate An isolate + * + * \return Returns true if 'isolate' is the service isolate. + */ +DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate); + +/** + * Writes the CPU profile to the timeline as a series of 'instant' events. + * + * Note that this is an expensive operation. + * + * \param main_port The main port of the Isolate whose profile samples to write. + * \param error An optional error, must be free()ed by caller. + * + * \return Returns true if the profile is successfully written and false + * otherwise. + */ +DART_EXPORT bool Dart_WriteProfileToTimeline(Dart_Port main_port, char** error); + +/* + * ============== + * Precompilation + * ============== + */ + +/** + * Compiles all functions reachable from entry points and marks + * the isolate to disallow future compilation. + * + * Entry points should be specified using `@pragma("vm:entry-point")` + * annotation. + * + * \return An error handle if a compilation error or runtime error running const + * constructors was encountered. + */ +DART_EXPORT Dart_Handle Dart_Precompile(); + +typedef void (*Dart_CreateLoadingUnitCallback)( + void* callback_data, + intptr_t loading_unit_id, + void** write_callback_data, + void** write_debug_callback_data); +typedef void (*Dart_StreamingWriteCallback)(void* callback_data, + const uint8_t* buffer, + intptr_t size); +typedef void (*Dart_StreamingCloseCallback)(void* callback_data); + +DART_EXPORT Dart_Handle Dart_LoadingUnitLibraryUris(intptr_t loading_unit_id); + +// On Darwin systems, 'dlsym' adds an '_' to the beginning of the symbol name. +// Use the '...CSymbol' definitions for resolving through 'dlsym'. The actual +// symbol names in the objects are given by the '...AsmSymbol' definitions. +#if defined(__APPLE__) +#define kSnapshotBuildIdCSymbol "kDartSnapshotBuildId" +#define kVmSnapshotDataCSymbol "kDartVmSnapshotData" +#define kVmSnapshotInstructionsCSymbol "kDartVmSnapshotInstructions" +#define kVmSnapshotBssCSymbol "kDartVmSnapshotBss" +#define kIsolateSnapshotDataCSymbol "kDartIsolateSnapshotData" +#define kIsolateSnapshotInstructionsCSymbol "kDartIsolateSnapshotInstructions" +#define kIsolateSnapshotBssCSymbol "kDartIsolateSnapshotBss" +#else +#define kSnapshotBuildIdCSymbol "_kDartSnapshotBuildId" +#define kVmSnapshotDataCSymbol "_kDartVmSnapshotData" +#define kVmSnapshotInstructionsCSymbol "_kDartVmSnapshotInstructions" +#define kVmSnapshotBssCSymbol "_kDartVmSnapshotBss" +#define kIsolateSnapshotDataCSymbol "_kDartIsolateSnapshotData" +#define kIsolateSnapshotInstructionsCSymbol "_kDartIsolateSnapshotInstructions" +#define kIsolateSnapshotBssCSymbol "_kDartIsolateSnapshotBss" +#endif + +#define kSnapshotBuildIdAsmSymbol "_kDartSnapshotBuildId" +#define kVmSnapshotDataAsmSymbol "_kDartVmSnapshotData" +#define kVmSnapshotInstructionsAsmSymbol "_kDartVmSnapshotInstructions" +#define kVmSnapshotBssAsmSymbol "_kDartVmSnapshotBss" +#define kIsolateSnapshotDataAsmSymbol "_kDartIsolateSnapshotData" +#define kIsolateSnapshotInstructionsAsmSymbol \ + "_kDartIsolateSnapshotInstructions" +#define kIsolateSnapshotBssAsmSymbol "_kDartIsolateSnapshotBss" + +/** + * Creates a precompiled snapshot. + * - A root library must have been loaded. + * - Dart_Precompile must have been called. + * + * Outputs an assembly file defining the symbols listed in the definitions + * above. + * + * The assembly should be compiled as a static or shared library and linked or + * loaded by the embedder. Running this snapshot requires a VM compiled with + * DART_PRECOMPILED_SNAPSHOT. The kDartVmSnapshotData and + * kDartVmSnapshotInstructions should be passed to Dart_Initialize. The + * kDartIsolateSnapshotData and kDartIsolateSnapshotInstructions should be + * passed to Dart_CreateIsolateGroup. + * + * The callback will be invoked one or more times to provide the assembly code. + * + * If stripped is true, then the assembly code will not include DWARF + * debugging sections. + * + * If debug_callback_data is provided, debug_callback_data will be used with + * the callback to provide separate debugging information. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateAppAOTSnapshotAsAssembly(Dart_StreamingWriteCallback callback, + void* callback_data, + bool stripped, + void* debug_callback_data); +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateAppAOTSnapshotAsAssemblies( + Dart_CreateLoadingUnitCallback next_callback, + void* next_callback_data, + bool stripped, + Dart_StreamingWriteCallback write_callback, + Dart_StreamingCloseCallback close_callback); + +/** + * Creates a precompiled snapshot. + * - A root library must have been loaded. + * - Dart_Precompile must have been called. + * + * Outputs an ELF shared library defining the symbols + * - _kDartVmSnapshotData + * - _kDartVmSnapshotInstructions + * - _kDartIsolateSnapshotData + * - _kDartIsolateSnapshotInstructions + * + * The shared library should be dynamically loaded by the embedder. + * Running this snapshot requires a VM compiled with DART_PRECOMPILED_SNAPSHOT. + * The kDartVmSnapshotData and kDartVmSnapshotInstructions should be passed to + * Dart_Initialize. The kDartIsolateSnapshotData and + * kDartIsolateSnapshotInstructions should be passed to Dart_CreateIsolate. + * + * The callback will be invoked one or more times to provide the binary output. + * + * If stripped is true, then the binary output will not include DWARF + * debugging sections. + * + * If debug_callback_data is provided, debug_callback_data will be used with + * the callback to provide separate debugging information. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateAppAOTSnapshotAsElf(Dart_StreamingWriteCallback callback, + void* callback_data, + bool stripped, + void* debug_callback_data); +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateAppAOTSnapshotAsElfs(Dart_CreateLoadingUnitCallback next_callback, + void* next_callback_data, + bool stripped, + Dart_StreamingWriteCallback write_callback, + Dart_StreamingCloseCallback close_callback); + +/** + * Like Dart_CreateAppAOTSnapshotAsAssembly, but only includes + * kDartVmSnapshotData and kDartVmSnapshotInstructions. It also does + * not strip DWARF information from the generated assembly or allow for + * separate debug information. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateVMAOTSnapshotAsAssembly(Dart_StreamingWriteCallback callback, + void* callback_data); + +/** + * Sorts the class-ids in depth first traversal order of the inheritance + * tree. This is a costly operation, but it can make method dispatch + * more efficient and is done before writing snapshots. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_SortClasses(); + +/** + * Creates a snapshot that caches compiled code and type feedback for faster + * startup and quicker warmup in a subsequent process. + * + * Outputs a snapshot in two pieces. The pieces should be passed to + * Dart_CreateIsolateGroup in a VM using the same VM snapshot pieces used in the + * current VM. The instructions piece must be loaded with read and execute + * permissions; the data piece may be loaded as read-only. + * + * - Requires the VM to have not been started with --precompilation. + * - Not supported when targeting IA32. + * - The VM writing the snapshot and the VM reading the snapshot must be the + * same version, must be built in the same DEBUG/RELEASE/PRODUCT mode, must + * be targeting the same architecture, and must both be in checked mode or + * both in unchecked mode. + * + * The buffers are scope allocated and are only valid until the next call to + * Dart_ExitScope. + * + * \return A valid handle if no error occurs during the operation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_data_buffer, + intptr_t* isolate_snapshot_data_size, + uint8_t** isolate_snapshot_instructions_buffer, + intptr_t* isolate_snapshot_instructions_size); + +/** + * Like Dart_CreateAppJITSnapshotAsBlobs, but also creates a new VM snapshot. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_CreateCoreJITSnapshotAsBlobs( + uint8_t** vm_snapshot_data_buffer, + intptr_t* vm_snapshot_data_size, + uint8_t** vm_snapshot_instructions_buffer, + intptr_t* vm_snapshot_instructions_size, + uint8_t** isolate_snapshot_data_buffer, + intptr_t* isolate_snapshot_data_size, + uint8_t** isolate_snapshot_instructions_buffer, + intptr_t* isolate_snapshot_instructions_size); + +/** + * Get obfuscation map for precompiled code. + * + * Obfuscation map is encoded as a JSON array of pairs (original name, + * obfuscated name). + * + * \return Returns an error handler if the VM was built in a mode that does not + * support obfuscation. + */ +DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle +Dart_GetObfuscationMap(uint8_t** buffer, intptr_t* buffer_length); + +/** + * Returns whether the VM only supports running from precompiled snapshots and + * not from any other kind of snapshot or from source (that is, the VM was + * compiled with DART_PRECOMPILED_RUNTIME). + */ +DART_EXPORT bool Dart_IsPrecompiledRuntime(); + +/** + * Print a native stack trace. Used for crash handling. + * + * If context is NULL, prints the current stack trace. Otherwise, context + * should be a CONTEXT* (Windows) or ucontext_t* (POSIX) from a signal handler + * running on the current thread. + */ +DART_EXPORT void Dart_DumpNativeStackTrace(void* context); + +/** + * Indicate that the process is about to abort, and the Dart VM should not + * attempt to cleanup resources. + */ +DART_EXPORT void Dart_PrepareToAbort(); + +#endif /* INCLUDE_DART_API_H_ */ /* NOLINT */ diff --git a/platform_channels/codelab_rebuild.yaml b/platform_channels/codelab_rebuild.yaml new file mode 100644 index 0000000..7b227fa --- /dev/null +++ b/platform_channels/codelab_rebuild.yaml @@ -0,0 +1,2720 @@ +# Run with tooling from https://github.com/flutter/codelabs/tree/main/tooling/codelab_rebuild +name: Animations rebuild script +steps: + - name: Remove runners + rmdirs: + - android + - ios + - name: Flutter recreate + flutter: create --platform android,ios --org dev.flutter . + - name: Patch android/app/build.gradle + path: android/app/build.gradle + patch-u: | + --- b/platform_channels/android/app/build.gradle + +++ a/platform_channels/android/app/build.gradle + @@ -64,4 +64,6 @@ flutter { + source '../..' + } + + -dependencies {} + +dependencies { + + implementation 'com.google.code.gson:gson:2.8.6' + +} + - name: Mkdir ios/Runner/Assets.xcassets/eat_new_orleans.imageset + mkdir: ios/Runner/Assets.xcassets/eat_new_orleans.imageset + - name: Add ios/Runner/Assets.xcassets/eat_new_orleans.imageset/Contents.json + path: ios/Runner/Assets.xcassets/eat_new_orleans.imageset/Contents.json + replace-contents: | + { + "images" : [ + { + "filename" : "eat_new_orleans.jpg", + "idiom" : "universal", + "scale" : "1x" + }, + { + "idiom" : "universal", + "scale" : "2x" + }, + { + "idiom" : "universal", + "scale" : "3x" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } + } + - name: Add ios/Runner/Assets.xcassets/eat_new_orleans.imageset/eat_new_orleans.jpg + path: ios/Runner/Assets.xcassets/eat_new_orleans.imageset/eat_new_orleans.jpg + base64-contents: | + /9j/4AAQSkZJRgABAQAA8ADwAAD/4QN6RXhpZgAATU0AKgAAAAgACgEGAAMAAAABAAIAAAEPAAIAAAAS + AAAAhgEQAAIAAAALAAAAmAESAAMAAAABAAEAAAEaAAUAAAABAAAApAEbAAUAAAABAAAArAEoAAMAAAAB + AAIAAAExAAIAAAARAAAAtAEyAAIAAAAUAAAAxodpAAQAAAABAAAA2gAAAABOSUtPTiBDT1JQT1JBVElP + TgBOSUtPTiBEODUwAAAAAADwAAAAAQAAAPAAAAABUGl4ZWxtYXRvciAzLjguNQAAMjAxOTowNzoxNyAx + MDowNzozNgAAKYKaAAUAAAABAAACzIKdAAUAAAABAAAC1IgiAAMAAAABAAEAAIgnAAMAAAABAfQAAIgw + AAMAAAABAAIAAIgyAAQAAAABAAAB9JAAAAcAAAAEMDIzMJADAAIAAAAUAAAC3JAEAAIAAAAUAAAC8JIB + AAoAAAABAAADBJICAAUAAAABAAADDJIEAAoAAAABAAADFJIFAAUAAAABAAADHJIHAAMAAAABAAUAAJII + AAMAAAABAAAAAJIJAAMAAAABAAAAAJIKAAUAAAABAAADJJKRAAIAAAADNTMAAJKSAAIAAAADNTMAAKAB + AAMAAAABAAEAAKACAAQAAAABAAAB9KADAAQAAAABAAAB9KIOAAUAAAABAAADLKIPAAUAAAABAAADNKIQ + AAMAAAABAAMAAKIXAAMAAAABAAIAAKMAAAcAAAABAwAAAKMBAAcAAAABAQAAAKQBAAMAAAABAAAAAKQC + AAMAAAABAAEAAKQDAAMAAAABAAEAAKQFAAMAAAABADIAAKQGAAMAAAABAAAAAKQHAAMAAAABAAAAAKQI + AAMAAAABAAAAAKQJAAMAAAABAAAAAKQKAAMAAAABAAAAAKQMAAMAAAABAAAAAKQxAAIAAAAIAAADPKQy + AAUAAAAEAAADRKQ0AAIAAAAOAAADZAAAAAAAAAABAAAAyAAAAAUAAAACMjAxODowOToyNiAxMDozNDo1 + MwAyMDE4OjA5OjI2IDEwOjM0OjUzAAAAZFsAAA0hAAKFeQAA9CQAAAACAAAAAwAAAAEAAAABAAAAMgAA + AAEAFtM1AAACigAW0zUAAAKKODgwNDAwNwAAAAAyAAAAAQAAADIAAAABAAAABwAAAAUAAAAHAAAABTUw + LjAgbW0gZi8xLjQA/+ELJ2h0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2lu + PSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJh + ZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPiA8cmRmOlJERiB4bWxuczpyZGY9 + Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0 + aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHht + bG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgeG1sbnM6ZGM9 + Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIiB4bWxuczphdXg9Imh0dHA6Ly9ucy5hZG9i + ZS5jb20vZXhpZi8xLjAvYXV4LyIgeG1wOk1vZGlmeURhdGU9IjIwMTktMDctMTdUMTA6MDc6MzYiIHht + cDpDcmVhdG9yVG9vbD0iUGl4ZWxtYXRvciAzLjguNSIgeG1wOkNyZWF0ZURhdGU9IjIwMTgtMDktMjZU + MTA6MzQ6NTMiIHBob3Rvc2hvcDpEYXRlQ3JlYXRlZD0iMjAxOC0wOS0yNlQxMDozNDo1MyIgYXV4Okxl + bnM9IjUwLjAgbW0gZi8xLjQiIGF1eDpJbWFnZU51bWJlcj0iNTQwNyIgYXV4OkxlbnNJRD0iMTYwIiBh + dXg6U2VyaWFsTnVtYmVyPSI4ODA0MDA3IiBhdXg6TGVuc0luZm89IjUwLzEgNTAvMSA3LzUgNy81Ij4g + PGRjOnN1YmplY3Q+IDxyZGY6QmFnLz4gPC9kYzpzdWJqZWN0PiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9y + ZGY6UkRGPiA8L3g6eG1wbWV0YT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSJ3Ij8+AP/tAHhQaG90b3No + b3AgMy4wADhCSU0EBAAAAAAAPxwBWgADGyVHHAIAAAIAAhwCPgAIMjAxODA5MjYcAj8ABjEwMzQ1MxwC + NwAIMjAxODA5MjYcAjwABjEwMzQ1MwA4QklNBCUAAAAAABBP7b/y1Vk/1NM2WgzC7tTm/8AAEQgB9AH0 + AwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQE + AAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5 + OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqy + s7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEB + AQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKB + CBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdo + aWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW + 19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/bAEMAAQEBAQEBAgEBAgMCAgIDBAMDAwMEBgQEBAQEBgcGBgYG + BgYHBwcHBwcHBwgICAgICAkJCQkJCwsLCwsLCwsLC//bAEMBAgICAwMDBQMDBQsIBggLCwsLCwsLCwsL + CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLC//dAAQAIP/aAAwDAQACEQMRAD8A + /Mj9p/XWWedHGTzgn0Nfjb488Qz/ANpsiknDcdulfpv+01qhmvJhuyM1+WHiuGO51Iv0JOcZq8MrRPmq + s4zqNs9b+EGrXd5eGKHIbjrX6zfArwTd63NAsSl2yK/KH4LwNBrUDbeCQD9M1/Tx+w38LLLWPs160e7I + B9u1RiYObSIwtdKo0j7G/Zz+C2qWllHLeocH8q/QfTPA0kFqqhcGvQfBHgu2stPjto1AAXjA717Zp/h1 + AACueMVtQw3Lod9Wu2rI+V18B3RjJK8+hrzXxZ8MbnVYnjKkD6V+iUHhi3kQkqBxWFqnh62ijIRfyH/6 + q7HTVjkUL7n4P/Gf9nC0vbKf7TFuLA81/PD+1n8ArjwpeSy2qNjcSOOMV/bn8S/CFpPYyFox846fWvw1 + /aw+EWm39jcO8YYgk5NcdTDJO5OJpLkutz+Vbw/4M1C7v/JniYHPcdq+s/CHwrVolIh647V9C2nw20qz + 17YsQ3bueMV9neCvhrp1xaIzxDp6YqHFRWh5XvTep+esHwtDzBfJ4zW3rvwrtbCx8149pxuGK/S+H4VW + huswwg8j8K5/4jfDKFdLZlXB2/lisajbRm6aV7n4465pkdnIYhgAdq861dbeS3dSoyORxX0J8VvDU2kX + kmzsSK+T9d1n7NG4lYg4IxmvCxWH5nc8qvHmTR4N4ouDFfPEemTx7157eXDNx29BWt4j1Azak7etcnPM + W5HA+lc1Khys6cHhuWKKN0/O49CKwJsE7sZ71rXDseDwOKyn3b8nn+VejBWPoKCsisx+U579cVSc5+Zf + pVx14IB6VnSt2HGOK6YnpQKMpypDcc/WsmV8nKH6kd6uyyHOfxrOb5jg8gV0QOiI9ZTkHP1qcSqT83Ws + 4HbgVIrgE1ZpY0Q+Op61MjAsNw5NZoc44OfetW2XOG7UmZuJs26OU3MMCrMoc5Awcd6bBHgZPenzKoOD + xUBGJnOxyQSRmpIJZEk9vWq07he2P/r02GUbgp9OlbKOho9D0zQ5CwGP/wBVeu6XGHhGRha8K0S5aKT1 + 9vSvbNAuxJGAeAawmtTGb0OwslXziW5we9Q6iVMmwcj6U+OURHe3c8VnTz/6TuJyCOhqIrU4asjW03w6 + LlhIq9Dj/OK9I03w1EkOGTn3ql4UEciBGAyR616nbiJBlT+PXrXRzNI8ObbkcBL4VinDbVwelfPfjfw8 + 1hO/GOc19kQsjbiBxnP4V4L8SfInWQt1FaQlc2oycZI+PLyTaWUH61hszIc5rZ1QbLlk6YOM+9Yxilc5 + RS30FM+hg1ZMtQTEdTx7c1tLNuCgZx2FYcVtMnOwgH2rRzsUAg5qb6lO3QguSCcdfasxogzAdqvSPzkc + D1qWCDceDnmtETKVjOS1YYb+ma9R8KeAPEXiHD2cLCM9GINe/wD7NP7NOu/GHWY7yWJk09HHJH32Ffvl + 8M/2H7CHTIobS1DbFA4HpWNerGC94zoQr4qTjQWi6/5H87U/wO8VRW/nKGJxxkeleN+IdD1bQLkwapEy + Nk4OODX9cWsfsWXCW2PsYIHAGK+Ivjn+w9b6zpNwgtNs0anGBzkVzU8XTk7HdVyrF0o87Vz+cuZGx0GK + qRyFWy3Oete7fFr4MeKPhlqctvf27+QpOGwcYz3rwxYirZweK7bdTkhNSWhr20+wfjW7b6i0ZHzcDp61 + yUchCnnn19KtRhmOWO0+lLmtuR9Xc3Y7N9XMuR0J5rJlvGdtobOKplo/x6cVRuWWHlc/SqVVNaD+oSg9 + jXa9ZfmWqk95gbs8Y71z/wBqy+7PFJJLuXdnn/GsZas7KdLlRXvLzktXNXcm5ua07pghJOPeuflYyMTV + widGiLlrISwFdhpkx3ZPPvXGwKQR3rqrAH7y8VcjNq529u4WIbcVP5h9vzrMhZWTlc4464/qKl+T+5/4 + 8f8AGsrC5T//0Pwa/aG1t45pWuGycE/Xivzl1LUTLqZY9M19bftH6xLPeSPnPJ/OvhK5u2W58w+tbxio + xR8lQi5uTPsX4KX1tJ4gto5DwWA9K/rp/YLms9M8N20mRlgpB9q/iq+G3itdO1q2kbjEgznuK/pi/Y4+ + PlnaWVrEZgF2qOT34q49zgv7LEWkf1X+DtSgnhUqccZPNe6aRJDIg3EevWvzA+FPxq0u8tI5BMO2ea+q + NI+LulRJzOAB3zXTDa560aqetz61aW3iUoSK5q+ubeTJzntXzfqXxu0qa4FvDOpPsetUrz4tafbWu6Sd + TgZznFVKSvqzel72qOl+IF3arZuznoD+dfiR+1x4mtLK2uSrAMQR+NfdPxZ+Pmk2ljK6zKdgIxmv56f2 + vf2iYdYuJ7SwlL8kEjp71yzrxvypjxqcKdzxWLxNZXnihVDDIbJ9OK+7/h3rdpd2sUZIHA/Gvxk8GeLH + fVWubiQbi3WvvT4d/EK1g8kbxn+dYyV2fNqvyLU/SxbjSrOz+0sw4A/z714R8TfGNtc2UkUAHAyMfyqP + T/EY1jTgpPUcCuJ8S6RLPBJJ0A55rCpJJBeU9j80/jdfyzyyvEvXJzX5q+PJb2Od9zH3r9cfij4RluvM + aFPX6V+ZvxR8MSxXcgcYwa8uvVSicU7wneR8p3JeWQs3f1qhImT/ACr0K40LHUdelY8um7M7sZrz4Vk2 + dkMRHocPLE+ORjisySPDbmP41111a7OvPp9awpbc59+1dsJHqUKlzn5UI+h/Cs+4HHyn35rZmjIJGMms + yePf0/wzXTE9Om9Dmrklcgc1mF8n2rYuoWOWb9KwZV27s10wOmJIW79jTNxY7M9fSoQ5PvTl5+bGT2rZ + I2ReiJzhutdBYBi+AetYcEfAbpXTWMS7c4yfSokM6G3QFOOg/nVe9iVRx6fnWlagbdzDp7Uy8jBXgY/n + ULcaRwt2WVi31qKCY+Zn09KsXy/MQeBVGEqZMD/PpXQhyWh6BpHze5NetaE5hbcOnvXkOiMDt9frXsmk + oDb4PUY/GspbnHUOrefevytnI61zV/f+Q+/gY61oOpVCUPA6/jXn2syOHJJPA60lE53BPQ9Y8LeM4ba4 + Vd2fXnpXtdn4ljukDFhj618G/b57ScMhIrv9H8ZyrCFySc8itdLann1sA780T7Fn8SW8cGAcA18++N/E + P2hXVTyx4rAk8ZvLD97JxgZrg5NQfUtWiikPBcZNKL7DpYSSfNI9Y+FPwYufiBq8bXKFg7DjnFfsr8EP + 2JdCkghkmskfOOGQGvMf2OvA2nXTWr7Ax4Nf0bfA/wCGlobCLKD7oxkV5OOzF03yQPsclySGJj7Wvqfl + T4n/AGJ/C39ksINMhDAddgz/ACr8pv2hf2VYPDole1thHtyQQuP6V/Zn4h+Gdq+mSBYh92vxp/a8+G0M + Vnct5fQHkCuOhmc+ZKTPVzDh2hGk5UlZrsfyMeKdCuNA1F7WcfKp4NdF8PfC934t8R2mh2aF/NcKfTFe + nftDaQmn61JHEnzF8fnX3D+wJ+z9eeIfF9hqE0G9SQScc19LBrl5j4mspNKkvieh+sP7KnwPPhvQ9I0+ + 2twowu7A7nvX7xfDH4d2cenxxxRgHAzx1rjPgd8CLfT7K0kaHBCqM49q+5dC8KPoIT93lF7V4uMhOUrv + Y+5yqlTw9JQicVP8LrK4syxjBJHcV84fEP4I6ffW8rCBS4GOlfpRanTnsDIuCTwFPXNYbeCV1GN5pE5f + 2rm9hquXc9H6wuVqWx/Lx+0z+xZbeKdOulktQxYE/dr+Y/8AaO/Zm8T/AAe1qadYGayDHoPu/wD1q/0q + vFXwLs9VtmWWEHdnORX49/tl/sDWPjHQLyW2s1ZyjdB35r26HNGPLLY+SzPBRnL21DSXbufwTIArAEY5 + 6+9b62j8KtfVfxx/Zc8S/Cz4lP4fu4GSGWQiMleOtev+D/gx4asLBWuIFnmwNzNzz7Vx4/GQo6Nnu8J8 + O4nMpP2cbW7n54tbPv3dB9Kr3sRZTuXOBX6Uax8KfDNwrBrOPpjAGCK+XviL8MofD5MtqmYn5B9PY1yU + MxhOSR9Vm/BeLwlF1JpWR8nNGA+R16AVKSAoGPmH45rXvNPa2cjqRkcVnGNRHhugH1r2Vrsfmc/ddmc9 + dNvZg3eqG3DEH9a0pwd2Dz9aoOvzcjjpW0UZcxat1XqOSDiujswF4Axiuft1K8niuhsiCwLdueO1N7C5 + jZTcF45z74p+X9P/AB4f4VEzIpwFz/n6im+Yv9z/AD+dQLnP/9H+ZD45R/aZ5WcngdK+H9WmWB2X+7mv + u74y26NNK3I6mvgXxXtjlZe/P5VcJ3R4GFpcrZFYa1PBMGiOMe9fdnwJ/aHvfDUsUDzFSuOSa/OeF8sB + 7YNegeHYL6WRZYQSKtTtuZZjgo1I3WjR/Sz8IP2x9RtrRI0uhtwOS1fQc/7b+oWkH7y9LY/hU9a/m78I + 3/iSyjVo5HUL+Ga9k0TxPqcs6i/dsipdZdGeDTo14u1z99fBv7Y2vXt60rylmc8DOcelex3f7TevXFkz + TOS2OMHNfip8OfE6xTRtES39a+rrLxA12oJPbkA8V5GJxE09GfYZXR933j174j/GHxRq1pIEk2K4OeeT + mvzR+Kct1eSyTMSxYknmvtPWpEmsCHIB7Yr5Z8b6dvVmcd6wwdRuV2dOa0lyWR8YDVtT0i5Pk888V694 + D8e66b9HYkBSBye4rkdS0+M3JjYck9a7nwnpMayKVAAr6KMtD88xlJN6bn6R/Cr4kr9lSO8bBwM5Ne9a + j4ns9QsdiMBkdq/PTTbxtMt1lhOAuCBXSWvxImH7kt7ZzXHiYO10dGErWjZnuniltPkgcZHIJ+lfnz8W + vDsVxcPMiAgeo719N6j4xtDbbp5OevWvmvx34lsp1cCQA+lfH5hXlG6RhjqiaPjrVNCZZTEBzz1riL7T + Ng2tyeua9o1SSGRjKckA15/qCqCdnQfyriwdWUnqeRQnNyPJb202np+fHvXKXUODtB7V6RqcSgEsf/rV + 5/qON3BwBX0dFOx9Lg76HLXEXLFuh71kzqSpx/OtiY4yIzwfWqEiOTnv0xiu6KPdpnPXCALlBz0rAurU + L1/EV3Mlvu6jj6VRurRCCpGc10RZvCepwDx4yFOamjXsRzWlJa+W2CKU2gLZ/l61spHUpXC2BLAHpXW2 + qAjB+tc1FbspGRXQ2zGIAnkHqKiWpR0SNtXjoO1VbuQMpH501JxySfzrLuZgCff0pJFxMa6CuWb1NZYI + WUZ5FaMrA5A7+neqUihSMDNboo7fQ3y6mvaNHcmLaewzXh+iHDDv0r2TSJVSMDg8VnJHDWR1YbfEyete + ea/wSeorsTdFgQfXH1FcRrcmSd3PpVROeO55vfuAxB65plpPIinHHr9KZdsctnjtRaAnr0qZM7opNG/9 + qmMXzHP0qvptxKupxM2ThvyqMsoQ54qpZs5vo9vTP41MdwlFcrP3m/Ya8W6fBNaW94wDcdelf1R/s9Xe + mX2nwGMg5Hr61/GN+y1qNzHfW8SKd2RwOa/pP/Z41DxGNOicJcIm0dN2OK+czOm41Oax9Vw3ik6Ps7n7 + D+K4rW20eZ8jlTX4V/tp6/Z2+n3WWG0q2ea+2PGniy+TTJEaV1IU5ySD/OvxV/au8Ry3Nnc+ZKz8N1PF + efRvUqpJWR7eYVlSw8tbn4OfGe9XWviLb2ajcklyo/Wv68P+Cbn7LsFr4S0/V3twWkRCCB1z3r+PTXEf + U/i5p0Iyd12nH/Aq/wBHb/gnR4X0+X4MaJI6qXFugP5CvvqdL9ykfmuEqJ4yUn0j+LbPsfwN8Po7Gyij + aLGB2rv9X8Mp9icqnIBxXtujaFCIBsXitLUtAge2bI4xiplSjJWZ68cTKMro/Oq21C6sPEP2e4fCh8Ae + 1fVvhF7LVEVI/wAfevD/AIjeA0ttZGoWYb5XJIA6V6P8MLO8huEL7lU8YPpXmYbDyp1HF7HrYrERqUlJ + bnt83h2CeIHb19q8L+IngS0vrCVZIwQQQTivqx0CoPLPb0rzbxTFHLbyIBjjvXquyR5FFuUkkfyv/wDB + RP8AZC0fxHps3ibTrVftVrudWA5yK/C+18BaxbQEeT8y5B5wc1/aN+05oWnt4bufPUNlWzmv579X8E6J + cX90tiqlPMbp25r814jzBUqqif1Z4TZAq1F1rdj8mdb0++s5DHIhGOvH4V89fFTT2l0CUtzgjr9a/Vr4 + kfDqzjt5JQgHBr8sfjDqFrJdPpFkwdUY7iOcmuTK8YpyTR+g8dcOuWClyLofAfiC32Oy7RgZrgpVGCOm + K9x8TaVuV8jpmvFNSge1kZCevt1r9DwVVTifxFxDgJ4as4tHMXRUEkcf1rL3HJ5zVy6lJJH+cVjmTDY/ + SvRSPAijYg5bJ6H9K6OzXOMnHpXH27EsF/Gut08MzDcc9KTKlojp49uwE4H1p/y+q1q28dq0Kl1yfrU3 + k2X9z9RRynI6x//S/mi+Ms4SSXB6ZJHrX56eLZi07A9Qev1r7r+Md3vkmVz0PWvhvULF7vUsY4zRTaUb + ni4fe4/wJ4S1DxRfrHEh2A9cV95+CPgzDFChdAxwM4FcX8GNHtbOBDGmDjrivvfwVYpMRuA57V81mWaz + jJxjselTwvtXqcBpvwqihtC2zt6Vz0/gQWsr5XA9q++9L0G3ltcbe3P415J410e2sYpW6gcnNcuCzGU5 + WZeIyuEI8x4X4VhfT2WMdSce9fSmh3xhtgHb3NfOekXqSXbp2U4FeyadJvjAjJGOx5r16sW1qThbR2PS + dT1EHTWfJzjmvEdfu/tFi/mdc8V39/OF0xiTk9BXgWu6v9mLwyNjd0pYaNmLMJXgedana/6WZscZNbGm + 6umnxhsgEetc/da1aSuYt2cVxeva5DFFhSBxnrXvU9j4nEwu2eo6v8UBZwbd/IHTPFec3fxdYHML4Yf1 + rwDxHr8ku4K3HfFeWXGtzoWwevJxVVWnFoyoZdKWtz6wvfi3ezny3nJGMYyfxrlZ/GFxqUu3fkZr5mi1 + iZ58sfbFdxpuqKi8Y5/OvlMfh+ZvQ0r5Y4q7PYLnVYzb/LnIH1ridQ1fd8gOSazLjVYihYtgmuRn1Ug8 + Hn0rlwmDUehx0cE1K9jUvJ5JhhmyPSuTvwWBweR0q1/aBZsgdfWsS8ldz1r2IQse3Qp8ph3MgjkPNNjK + upPGO1V58Nmo4pSPvdBzXQkdy2NqFFIAxjHrUdxa7lzjk9eKfatu2r+taRERIBq0EXqcLd2e1j6elZzR + fNgdTXYaiiBTyT6Y4rmWVgxbr71tE9Gm7j44V6g8Y9KsorZweh7VHGckYOfwqbgLjGfWqasbETMBwDk1 + nXUpCHHOP5VdY4BI+vpWPdszcHkGhDSKKzDJJP4VZJL7azBxJgL+tacQEgB5yK1TKa7G/pBCyZx0/nXq + elyMsJbpnvXlenLsmHvya9F0ybamG5qWjirm+9y6jaW7nNcvqcrSkqSM9vc1bublQCQa5+6nDElW47U0 + jBLU5a6YMSR1zVmx2mM54qCcoWK55qW1/djLdOmaiSOuDsaLI5GScCus+Hng7UPFvia3sLQcMwBboBXJ + xDedq9TxX6EfsgeCIdQ8U2csy9XXnFYynyLmYqrbXLHdn7f/ALD/AOyR4U8P6RaazqsAuLogElxkD8K/ + e/4beDLC2s0hhiVEAwRjA/Svm39m/wAA20Phy0EaA/KAcdq/Rvwn4RjhtFAHbOPevMdZ1JXZ9RhcJDD0 + lGK1PmT4xeALC98PzPbRBHCntX89X7UXhMyi7sphhlzgiv6p/G/hZZNNlRgSApr8Hf2s/AMf2y5eGMcg + /nXPVcYTUkjerB1aLjc/lxuvB72Hxh0+8Ix5Vwp5+tf6FP8AwTI1kX3wk0uJz/yyTjPbFfwz/Enwk1h4 + 8jkRMMsob9a/sf8A+CWfjaO4+HOm2gcAoirj6V9Dh8RzRimfJ4bD8tafp+TP6JtJtwIVVcE4rSubMSJt + xwOnFYXhi6S7s423ZyMV3Kr5mB7V1s21PENc8M20jM8iZP0rmNPtBplwURR14r3jUtLEoOOteWarossM + pYZ5JNZVZWVzejroy22rhYMSHFeXeLfE9tbxszsOBVfxPf3Gmws7dAK/PT44/Ha18LWs73EoUgHAz1rw + s1zaOHptyPseGcgljcRGMTzv9rn4mWdpoU0aSDLKwAzX4IavrF/HfTXFrM0ZkYkkCvYvjv8AtFjxZq0s + dxcYiXOBnivjHxR8UvDdnbPNNdpnbkKOv6V+N5liqmNxDmkf334c8MLL8vjBrVnknxv8W+IJLOSKa9lK + +gOBzX5peK5JWuJJJCW/GvpL4m/ESDXrtkgYlAeM180eILmOXMq8/wCNfT5XSlTikz2OKoUp4aVNPU8x + 1VRJESc56ZrwXxbCoLPwMdga9t1O6VYmDcdT6Zrw/wAUzCRjnH0r7jLG0z+EPETBQhXlY8tuHySvTnNZ + Bk+YnofetW5XAYuKyHJLHIPpX0iPyJI0bMqHwTmux02RSw9etcLA+1h9a6uwn2Pux26UnuKa0PSIGi8o + bzg/59qmzb/3v5/4Vz8N2fLGGA/DNSfbG/vj/vmrPOadz//T/l7+Lel3DzyPg9OM+9fL0enKl4Gde/ev + 0p+Ifg5L3zCFAb6V8beJ/B8llKZMDqTxS5XKGh8rTxijNxZ6V8L54Yggfp1r7n8EyQsqMhAJ5zX5seFt + Z/syRYpDgdq+pPCHxGjs0VpJQVGBXyOZYGUm2j6DA4uKep+jOk38cVkWc4wOv9e9fL3xV8cWhnksbY7j + k5xXm3iH49mSzNhp784wSD1rws63cateNcXDEkn17Usry2cHz1Drx2NVRckNj2nwzK9xP5qg/N/WvdtF + lCqCw+n0r548HTsHVE9MelfT2hRwSoGf72K96ojiobl7UYPO09vL9Mcdq+XvHVlcW9rLO/B7GvtkabE2 + n7ohyR+Ir5m+KumebbMgONo/nUUdzTGR9258DanrFzZXBZnOM9c1zGp+JWmUru6+tdB4zsjbTMMcH9a8 + I1a4lgz2Ir14T0PCeFU3c2L/AFBHcknrzXF6hcj7wPB6etZk2ouxxnGKzZ7sk7uaUnc9GjhuVG3bTkkN + 3FdFa6i0S/J9K4q1lUNluMV0NrtYhs8DmuGrBdRV6aN8XM9wvI49ac0MjNkDk88mrVlBuGR0NbiWYI4P + X9a4XUUXY8OvPlehzAhc8Hgdc1BcWqsNx5zXYfYVjXJ9e9Vbm1yMKMj+VWqlyadU88urdecDJrFfIO0j + PpXa3do24qQMfyrl72ARsTj8jXVTkd0JXC2uADgjk+1aazKwAPJ9+1cyJJFfH/6qupKSPQH8+K2NlB3J + rmbJOfTrWEzbWxnA6elXruVgpB4PXFZDtu4Jyc55rSB3U0SrIATk/TNXYyxHH+HFZKM2Mt2rVt33KMnH + erkdIjpgHvWRdxsVOBxXQOuVJA+tZNyn9449qzvqJHNlCG3Y6GtW1jYnY3NReWehBwenFaVjF82Fq1It + 7GpaxYceh/OuytW/dcccVzkMQHI6jtW/CxKkDjIqjiqorXM+0kkZrENwxJT9Ks3soVsLyD2rCEyb8E8+ + 3SgiMdCaVfm9c81Om7G0fdpFAI3d+OamUALkcj0pSKLNgGNwhPPP0r9eP2LdPVtStbhhyrLg/SvyLtVb + zk2jjIIr9h/2KZR59rHuycjiuDMHai2jTDa4iCZ/XX+ytrOm3OhW9tcYDBQOvFfpRodraxW2/cu3GQa/ + HT9nY3AsoDEcHA5FfpN4dS+mskM7sVx0zXzWGxzWjVz7yrhXKN0zqfHF/FNbSW9s2446jmvyV/aM8L+b + bXNzP1wT9c1+n2qQ7Y5BH0r4U+Ptsk2mT7hyQfrW9Wp7Rpk0qXJFo/mG+O+jCw8XG6IAxJn9a/bT/gl7 + 8UYbaW20WSUKRjaO1fkP+07aeTrMrsQuHOB7V7L+w54xudE8bWK28hQ7xxn3r2OZwpKR8th3fGuC6n97 + Hwy1g3emRENnIFe+2u4rwMZ5r4I/Zq8Yf2/o9qmcOqKTz7V986ayeWMHIAz6169GqpwUkTiabhUcWWng + kZQRj8q5LV7RJIySOntXoAZWQ5HvXOatHlC3HcVbMovU+JvjPJc2emTG3XOQc8V/Nr+2d4m1Szu7pZWY + jnGOlf07fFy3ibS5jJycGv5kf29ILXdcxjHKtyPWvzjiyi3JXeh+5eF017Zaan87Pxe+KOpSas9jFKRy + ckccfWvnPU/F97MhVmJFa/xNnDeKrlB/AxGK8suGyK4sLhYRhGyP69jm2IpYZUoSsrCXer3MjHJ4rmdR + 1GQRkVcceoxWDqgAjOelepRiro+QzHFVXCUnI43UbppCW74xXlmvNuHU/wD169CvTsPTnk15vrThwWPG + K+kwKsz+VuPqjnVk2efXIOSDzWI5+Y85rauCPvViMfmIB+te9E/JkTR1sQSlTkdawlOOa0YpGUYNJg0d + It3CVHmHml+12vr+v/16wPOlPKbse1HnT/7VIw5D/9T8TPHNyqRvg8sOc9ea+QPGTCNmboO/419J+N7q + aUyHHTnivj/xnq0lvJIpU9arD6o/PpTU5XR5nrEvlbpIux4xxXPR+JL9VCbyM8de3pVLWteV1O3pXK2l + ybi4/vDiqrQja9j3cDBtanvGhXjyRBpCScV3ul3J3AA455+leW+H5QVwoz/jXa2U7JIVP3fWvPe56rWh + 9E+FrvbsAPcfWvpnw1qJcLt6YHFfEugaxLFMqA5xX0P4a8SRxoGLfNWdQKLsz6/sNQhTTiBzxg+1fPHx + OuIZIX2nkg9q6qz8TgWJQHORyfavIvHGqrNExPX2NZ0l7x0Yifu2Pj3xqhed8jIr5v8AEabCxXjPPHvX + 0n4snEszFj78V87eIyWlODxzyK9OOx50NzymctHN6+1V3wThat3f+t288+1Vpcnn1/Cmd8XoJFNtcscY + HT3ro7KcsQvauOd9rZFX7S7w2xjwOtY1YXRFSN0epWV35ZCqfb2rq7CdZSFB/DrXk9neBnHOfSuv06/K + 8E9MfWvJrUjwcVhz0jyB5YB5NQvb7kLKOP5Vk2+o71BzyPX0q61+NhViPXmuaPMmeYqM09DmdShG5i34 + VxN4BuIbjPXjrXb6jPvy4ya4a8DMSScfhXfRbPRw6fU564TZkn6VCkp6CrFyVA+tZ2cd67oo9inDQJWJ + +ZuO9UjICdw+gqxIC3yn9Kg2Fjz07ZreKOqMbDo93OcHNa1sOcCqEULJ1APrWtASoPSh7FE7qNuTnFUZ + RngdK0W5HTAx0rMmcNwfrxWTQFDameOavWkYBBXHvVTILYHX1rStBuYZ4JpXHJnSQRFkOOv0qyoKKe+P + WrdnGGjG4/WpJoUMZOPbFWpHHNHE3rgFsHr/AFrnRIVcBPXmuh1FGLEd/bk1zyptlzjmm5FwibduQT61 + pRlBn35xVK3UMBV9cHA54qOYTiaFmnzrkZyR1r9XP2QJngvLYqQOV+vFfldZfNIvGcHrX6c/suXkVrcW + +4jjFcmYP9yy8JG+Igf1Ifs6a28VjD83QDFfpVoHiRhYrn0/lX4vfAjxvb21tCjN8oAr9CvDnxAtPsoQ + nPA5Jr89q4v2TZ+tYXAe1gj6U1TWvMidgw6HpXxP8atVL2crOecEV7NP4thkt2IOR7etfJfxi1h7qymE + HL4OK2w+P52jWtl3JF6H4YftRTb9ZmbqNxP1qf8AZSne38a2VyoOFkXJ9qv/AB+8I+ItTvJZIot24k9e + atfs4eHdZ0rWoUu4CAGHfNfYSq3wlz85jh+XMtup/ZD+xpqYe0jAfJMSkc1+qWjX6+WpPtmv58v2SviV + d+F2tvtRzGODn0r9ovCPxH0PU7JJYZRlsd62yrFwlT5G9UdmcYOcavPbRn0ut6rLkHmsDWL+NISxNeeT + +PtItY9zzqOP7w/xrxzxr8b/AA9ZwMouUOP9oda9WpXhBXbPKo4WpOSUUcp8cfE0dtpE4U8hSMV/M7+2 + BJdeI9RnsLRS7tlQPUmv1v8Aj9+0Fo32Ca3hl3EggAEGvyYeRvHnjCS5cfIp3D86/Pc8rrEVbRP3XgLD + vBQ9rNH5U6X+wM3jbVX1jxTdywLMxbZDgED6kGux8Q/8E0/htDpjS6bqF+k6jI3urKT7/Lmv2U0zwhBH + FuC42j0rA1bQn2Exr1zn6VywjUSWp+uR4qk9HI/la+M37POufC7UJIGDyQKTh2HOPwr5N1qOSEFCK/pH + /a08GWl3oLSSRoWKsOnpX88nxH04aZqktqgwNxwK9DCz5nZ7o9arj6eKwjmtJI8K1EjBPcdOK8x1x++e + n516TqTIIj/+uvKtbbLEdK+nwW5/MHHE71JHGzYOSxwKyjitCXvms9vRa9yJ+Wjk6jJ6VewFX/P86oxn + BAHIq6OmTyDSYAjyKMIWA9qf5s395/8AP41EAD6Uu0e3+fwrMD//1fxT8T6CL1WKkDr168V8TfE/QfId + wOM8cV+iPj7w5eaeHe0z3z7V8V/EjTHliZ36nJNa4KzifmOsLNH5/eIbeaGY4PHQYrN0gOsgbtnBr1Dx + HpCMTuXBz6VxtnZqk+2MZOausj7HL6t6aPSNEnZFGCAQK6H+0ZN2Afp2rlNNi8gbj6dBS3F9sYAdc/jX + A4anc5HpOma7LA4GAcc16fo/iqSPa0Tfd9/5185298rfMvGOldPY6ksRDZzntUypmd9T6w0/xs3lEMeo + x1rivE3iieZXy3B9K8zt9cQQAM2M8/nWDrms/Jw+R0pQp6jm29DH1/Vtxc5yT+NeO6xfCTK10OrXgkzg + k9a89vp1dywJxmuuMSYRObu5Cz/MMHNU5HYEkjFSXMuXBPbjNZsr8cnp602jritAaTKbQfxqmJmiPXrS + PMfu1Wbnv+dK1zSxvWuosmNpxx+FdHZaozYLNgfWvPNpzx+VXbV3Rwc1lOimZToxZ7Lb6oJFVN35VpJf + ttG45zXnen3WxMk9P51tJfAKegBrhlQ7HK8JE6G5usqWWuUu51IJ61M9yz5b0/WsW5Jkk+Y55ranSsEM + MoshlkLfKOc81AM4JPOaljjc4z6960Y7RmzkdO1bpWOqMUjFO5ydoz6VKqOBsIzz+VbYs5VbgACrUeny + lcgcfqavmKMKIEHkEH0q5GsoX5FrW/s1gxYgfUVet9PY/KRQ2K6OZkE5GCKyZ/OXgrjFepwaCxH7wc9v + rQ/hwuSxX8cU4q5hUxEYnkiMR+Fa1qzlxjnpXenwfPL0iPFMTwtcxNuCHFRNWJji4S6k+kkSxAZyB7Vs + XFviMgHjtS2GlyQKBggnFajRYTa45rHmG/e2POdQs/mLAf5Fce8JV8qOleoapAmwtjBHANcFLDsYnvT5 + jaESSBBsAf8AOrseM89qz45Ng+bJJ59atQEGTOfwqblyhodXpUDtLGQO457V9zfBzWW0maNm2jBGMdq+ + MdIUrEFQYxyDXrvhnXprAh1JGK5sYnOHKVgoqNTmZ+7/AMGPiJK6xR+YPlwODX6a/DrX7nUIFUscNivw + M/Zu8SyapPGiMcsQBz61/S7+yX8J01fToNR1Fd+QMZFfmecUuSfKfsmQ4iMqPMz0/wAMeENS1e2DpCSC + Op5zmt26/Z8udbgLSWvUdxxzX6Y/Df4W6TDZRosQHA7V73Z/DPTguEiGB6CuvLMtqSipo5MzzmEZOFj+ + dTxf+xKdXmMkliuCeDg9K5Dw/wDsfjwvqSztabADkYHWv6YpPhnpbj54x+Vef658IdJfL+UvB9K+glSr + xhyvY+cjXw8qnPy6n5AeGvCkvhiFI9hUL1+gr1y2+Js/hu1ys/k7Rzzx+tfRnxF+GcVlbyPap0B6dq/K + 74+6td6DaXEYJVuQK82VSVOWh7MIwrQ1PXviH+19BpVo32vVRGecgECvizXP2xtM1m8MNtfBxnHWvxh/ + ar+LniSz86K0uXXkjr1r4P8AAHxm8RPq3k3M7sGf1r04YedanztnkxzCNHEezjHQ/ol8Y/Gg6+dyzby3 + HB9a1fhDq8ra4JZzhZTjnivzR+GfjGbXp4zOxOMdea/RrwBYvcQxSxn5uOR7V5VSjyy1P0HL8Y50vdP0 + x0DQPt9iCpB3dMVa1f4dzfZC6DnFeQ/D/VvGmnqsNqBKi/8APQZ/rXuWoeKfiBcacY444IwVxuCHjP4m + vQjOjy6o5qmJxMZ+6z8nf2v7X7Lp0lggwyg5yc9a/m1+NelX0WsSXOw7MnJ71/UB+0R4M17W4p59Rk5O + TkKBX4c/Hb4eC0EwZc5z78VxUa8VV0Pucvx01hmpPofkxqjlA0bfnmvLtXbLMMdePevZ/HWnNpd7IqZC + 5rxzUYw2eOnWvsMF3Pxbi6spVJHGtExY988VVeAgVssi4DHFRtFn5sV7MWfnTkYgUg9OlWAAKstGq9qg + Ix9KJFJ3GMzKcD/P6Gk8xv8AP/6qd5LSfMBmj7M/9z9f/r1A7o//1vin4h+GLaGGRkX5Tk/WvzV+J0EM + FzLb4HJ/SvtH4sfGK0t4pYI3GTkD8a/OvxRrk/iPV98ZO1zxWWVN8t2fmdStGTtE8M17RRcu7KDgn864 + 638LSKcqh/Kvr3S/h9JewhmXIPfFbknw3kt0IEJwR3FdtXU97B1+WJ8hDQPLjy4xxXB6vaxwSEdCO9fV + ninw21krMy7evFfLXiVHjlkJOc1lCGp6ka3Nsc+sixHDHHoK1YdRdOrVw1zekdGwetUhqT/j9a05UbJM + 9Zj1TMZ5rDv9VyuJOAK4tdSl25LYqjc6gxyCelJQQ0i9d34wR1rlb26Zhls57e9RXF55hPOf6VkTXOO/ + Tk0cprGI2aXDbuee9UHYkkfpSTStyB+lSadYXeqXa21uuSTSsa7FULIz4Qc1qWvh/VLlcxRE56DFfYPw + n/Zy1PxD5TzQls8njNfo98Pv2LjcQIWt+T/s/wD1q83E5nRo6Nnbh8BXr604n4dDwPr7AbYSR9OtOTwV + 4hD7Wt2yT6Gv6O7f9hlfL3m1wO+V/wDrVPH+wwA+fs3H+7XJHPaDOqWSYyP2T+dqHwhr8bDdA2c9QK1Y + /CWvuOIGBBz0r+iRf2GrUD5rY59dtW4v2Gdw3G2/8doeb0CP7Hxj+yfztR+CtfcECBs/Sl/4V94idjmA + hj19a/o8tP2Hrdhj7LyD1xWkv7D8O/P2fn1x0o/tigilkeMeyP5x7X4ca6oH7g/StqH4ea4BuMJ/EV/R + xafsR2yN/wAeuf8AgNakn7Fdsx3LahRyPu9qzeeUb2N1w5jGrn83sfw410c+Q3txV5PhrrxAZYSPwr+j + uL9iq2ibi0HqeK04/wBim0kcH7KOOvFDzuggXDeMZ/Ns3w41wjmBsfStDTvh3rjyH/R3bAwBjvX9JMP7 + DdrKflt//Ha7DR/2D9Pi/efZeT/s1Dz2j2CfDGLtufzcWvw18Skc2rHPTivUfC/wO13VpVSe1dV69K/p + J0f9hrSw6lrQD1+UV734V/Yv0WBBvtVyPbmtYZ1B7I8qvwtiPtTP5uNM/Zo1G4hCrakDHJIp11+yzfKm + 8259/lr+q/Tf2R9BghGLVegzxUN5+yTpEi/LbBc/7PNayzaNtYnEuFKl/jP49/FX7Put6Vukt7cn8K+e + 9d+HniSycq9s4x7V/Z34j/Yw027D5t16ZHy//Wr528XfsHaZdxNttASM/wAPOa4aub046uJ6eG4bxK0U + rn8hF94U1wKSYHB+leeX+g6xEx/0ds/Sv6s9a/4J72ryExWvXP8ADXl2q/8ABO9Wk+a1Bz0+SsZZ/QS1 + PQhw5jPI/mIXRNbHIgc49qtWWh6w05Vrdj+Ff0pJ/wAE60JyLTGP9mrNn/wTwjikDm25z3Xriuf/AFmw + 97HT/qzjGtj+ffQvDutTRhRA35V2y+FNWt4tzwsMdOMV/QZZfsCLaDzhagf8B9K8u+If7Jq6VbMBb5Kj + j5af+sOHk7IdPhnFwvJnyd+wxo+p6/4vtvD9rC807yDZGoySfav7VP2W/CD6JpFto+peVDeeWD5BkXzC + B/sgmv5Vv2K/hjqHhv41vqcKmNdKtprkn3xsX8ctX6k+HPHXirwv4os/GkN5M13YziZWZzgBeo/EcV8D + xRmjjjoRhFOFk276n6Fw1lblgJc0rSu0tD+qLwPbRRQRg+nI969qtQgXjn+VfC37OP7Qfhb42fDzT/iH + 4dnUx3YZJkU8xzxnbIp9wRX1ZF4us44/vg/jX1mV5nQjSWuh8nmOCqyqPTU9GkEbAEdfpXL6yUCEgD2r + LXxVaOM7wfrXJ634ngEZYvnvXfWzSi46M46OAqJ6o8u+IKQ/ZZGbHIP41+Ev7ZzQQQTTRr1Jr9jviH4q + U2sgVtxwenWvxE/a+v5r6yuBtOADzivnalf2lVNbH02GouFJ3P5jf2qNaEupTR5IO4/LXxr4MCPrAkU9 + D29a+g/2rruS38RSKT36D1r5w+F8hu9VyM/er7LCxtQ0Pia0r4l+p+nHwHgkuJ4o15IIxX7dfAPwhJcx + w/agSAB+NflP+y/4GmnkiuJEPzYr92/g/pP9nWsRdOg4rwcXUXtLH6FlcpRoXPrjwR4LtfKjGwAeor02 + +8J2/wBnMZUc8cCuW8N68LNQrjOOK7a58QRtDuHX3onXpqJnL2rlc+Fvjp4Qtv7OmXZjg/pX8/8A+09o + McBmVBjGa/ow+OmuWZ06UOQGx61+BX7RKLrN9NDAM9RnFeHHER9voz6jC1ZrDu5+AHxltpRfPGq52kjj + mvnW60++KZ8pj+FfrpqH7PF74p1EFYSwdq9r8P8A7AdzrNojJC2SvTFfZYbNqFKKUmfm2eZfia0pShE/ + AVrC5xuEL8eq1CLedVyyH/69f0Q/8O675VIe2P4rmse+/wCCdFxtO21PrjbXqRzzDdz5B5Pjf5D+eie3 + lU7gpYEVQMEvHymv3o1L/gnrcqTttSD/ALvTFcnL+wNeRkr9l6Dn5acs6w38wllWLX/Ls/EQIwyCnf0p + drf3P5/4V+2K/sEXjDItD+K5p3/DA97/AM+n/jlR/buF/mF/ZmL/AOfbP//X/nD1rU77xPqRZn+Rj3z3 + rvvBPw8NxNHK6kn1NeJ+G9RM92shGc4Nfa3w2urfavmcY4qaXuKx+T0KLi7M9s8GfDe1WJFI7d/WvQNT + +HmnxWzAKOQf0rY8M6paw26v0Kip9c8YWMFnIzkA8n8Kacmz36U4qOp8I/F3wZFaRSiFccHHvX5c/ElT + YXrqpzjINfp38YfHdpMkihwo5r8t/ifqttdzSBDnrXdCHu3Zrha/NWSjseI3N+xclTxVEXxAAzg54rGu + Lk+ZtY9DVH7TjPv2rM+pUDo21Fs/Kc1E2oPjrnFc81xnB6Uzz+fSkVyGs90WXk1TedmbmqDTDvViztp9 + RuFtbcFmY4FA7FyxtLrVLtLO2Us7ccV+lf7L37LuoeJLuG7uoCd2D0qh+yr+y9feJ9QhvL2AsWYHketf + 1Ffsq/sp6ZodrbmSHBGO1fNZxnEaSdOm9T6DJslnipKdRe4eVfs9/sjWtnZ27SWoGADytfpr4M/Zx063 + iXFuAPpX138OvhJp9jbxqsQBHt0r6W0fwDbRINseOPT0r4lwrV5c0j76MqGGjyQWx8M2nwF03y+IB9MV + aPwD04HiFQPTFfe7eG7eDC4wf6VXfSIA2eMn0raODcdzCWNUj4RX4DaeSGaEfTHSrY+BOnIoHlA59sc/ + lX3Mmj2+/O0VJJotsUPy1r7JpEfWEz4Mf4JWUYKiFcfSiP4KWiMGaEN26V91r4ft3xhQfw707/hHbYEg + DB9BWU6ctzohXR8WJ8G7EgA2461D/wAKas04EAFfbn9h24Jzx+FB0CFvmwB36VkqbbNfbo+JB8ILRSSI + h78Vp2nwisR1iGfpX2GdBt2cKR9au2vhyBm6fWt1QkzN4pHy5ZfBmwcBREMY9K6m1+D1pEm1IgO3Svqq + x8PI23KgA111poEAA2gc100sE2cFfH2Pkq1+E8EZz5Qzj0rr7L4ewQYzGK+mBoUCgkAHFNXSIwcKMAiv + Rp4XkPKq4rnPErPwTATt2Z/CtJvAdt5Z+TOe3vXs0VjGoGR7VcFmpHOAOvFdPs01qcnO76Hzpd/Du2m+ + URj8q5e9+E1pKNpiB/CvrdNMQjgZqyuiRlgwHIrkq4LnOmni3A+HJ/gdpzZzABn0FYc/wI0yReYAOfSv + v46FFt+79agk8Pxf3etcFXKLo7aeatM/PQ/AfTgdsduOnpVdPgPZqCPIXPfiv0I/4R2BcybevWq//CPW + +BhBntXl1Mk1uejDOT4AufgjZLA2IF6ccV8l/F74B2t1BMqxZ47Cv2ivPD0JiIwDj2rw3xj4Dgvon+QH + Oa87FZdOmrxPRwmZRk7SP59PDvwjsfhho/iXxRIixy3TRWcWTzyS7fyFeaeK9Yj0fw1c3Y48uFmya+6/ + 2xNItvDo0rw1B8rSySXLgcegGa/MP9ofXIfDvws1zU5Dgpaui59SMV8ljJSrV2pb7fofVYXlhR5ltufT + f/BHvx34h0P4G+Idakmke31fxHdzwqxJVVQKh2jtkg9K/XHWPj7f6bEHdmwBX5a/8E6vAl54X/ZD8GrI + hR7+3e+bIwSbl2cH8iK+xfEdgZtNaKXg4I5ruzDDVXUnyNpX/LQ83AOk6VN1Fd2u/nqegz/tgXdtJ5a5 + Jz613Phj9ofUvFeFCsS9fn2vhiRr/Mh+UHI+lfWHwm0aC2cADnFPKcFWdRKcmVmM8PGF4RR7trmuXt7a + ncMZGTnqTXwB8fdKN3YTm6Tqp5FfopfWsa2+QO1fHvxr0sXWk3BAJ+U44r7mlh1BHy7rX2P44v27PDja + J4qluIxhHYjjpmvBP2ZtCXVtdV7hc7n4r7p/4KB+GLmVpZGjPD4HH1r52/Y+8L3La5BJIjHDjtX1dJ2w + u/Q+GqP/AGy3mfvd+zn4FeysYJigVcCv1R8GaVBHZo2MHAr4f+EsAj0yCNAcBRzivsTw/rE9pbhTkqAO + TXyFWfv6n6RSSVNJHp8+onTpASTxz+FY9149twpQNn+dfP3xF+IL2SyRoxzg4r57tviXdXVzn5s5rx8Z + Wn9k7MPCP2j0b41eLGntpiCcc1+e0vhk+KdTZ2G9WbnjrX0N421PU9Y3ooJDDr9a2/g/4Lkup18+Ik57 + 1wUFJNt7nrqrFR5USfC74BaZcTxSSQA5I7V+nHw6/Z+0f7JGgtlyMfw1d+F3w3gEUUhj54PSvvLwX4Sj + t4EBXGBXr4XDzqS1PFzLGwjGyPl2b9nfSdmTbqfwrDvP2dNH/wCfdfTGPzr9Fk0OJRgL1pknh6A5UKPW + vdWX6HzDzDU/LHUf2YdJmYt9nXOfSuIvP2V9LMjN9nHPtX67P4StnGHUetZ8ngu3Jzt/OsamWS3RrDM4 + 9T8ix+zBpseVW1GM+gp3/DMen/8APqPyFfrNJ4Ot4227F/4EMmo/+ERt/wC5H/3zXL/Zkzf+0oeR/9D+ + WTwvqiQsPmB96+k/CfjyKwjUO4G3rzX57WPi4RLuL4PpnmnzfEiSFMh8Dtk1fKj4WWX1G/dR+sFl8arS + 2BSSbGePpXE+MfjWJYWSB8g981+XUnxTvehlyueDnvVWf4oS3KlXcnjtXRBRQnleI2sfQHjzx5PqEkmJ + ODnivlLxLqgnZnzuPp71W1LxVLdE8/h/k1xN3evM2c4zVSkexl+X+y1ZmTkFyRyTVYk525qRjls1FnOM + Vke7FDGP401j69TxTicZ9Kt6Zp13q14llZrudzgYFJsom0nSNQ1u9TT9OjaSRyAABmv17/Y6/wCCeni/ + 4j39vqV/bMFcg5INdZ+wf+xXfeKdXtdT1K1LbyrHcK/sq/ZU/Zq0nwlpFrDHaqhUDtXzOa5w4v2NHc+h + yfJvbr29fSHTzPlT9mH/AIJy2/hSyt554hlQOCPSv1z8A/s9ReH4kSOMcdiK+n/Bvg2Czt0VEUYwDivX + LbTIoACBjFePRy/2vv1NWe9WzFUV7OlojxTRvBy6eg3J0rontdgGARivRLuBFBAGa5q5hBJ7Y4rt+qxp + rQ894qVR6nHXFo0nFZ39mgkgfyrsPLDHJ/Spo7XkHt3rCVJM2jWaOPTSifw544q2ujFlAPXrXVJajcc8 + ds1qW9ooHz04YdN2CWIaRx0Xhst82SKtf8Irx5m416JBbBm56DtWj5cf3cfjWzwMHujL67NbM8ik8OuC + cngUkejMrkP0r0+5hU8EYz6CqBiiB+6KiGAgpaI0ePm1ucaNCjLcLyeR6VqQeH42wduBXTR2ysQD1rZt + 7TnDYxXfDCQ7HHUxku5h2uiRLhe/8q2odO2/c6AVrwwpGo71oxIuNxxW8aEVscksRJnPNpoK54H0oOk7 + sHFdJmPOCOtOR4927H4d6r2SMvayOb/sV2bK+1SpozgYxzzXVREdAOtXFjTHzDpV+wiS68jkI9MkT60/ + 7EU53E9Oa610jx8nU1RdRncw/wD11MqKQ1WbMT7KQMGnG1Y4NbGxckDjPpyKbJg/dxj/AArN0ylNmM9n + jAB+X3qL7EWOFGR7VusqNyRj605EUY9euaydGN9TZV2jnZNIDL83YdDXL3/hhLgFgvXvXqQjGMY7/jUE + saEFmHAyc1nUwdOS1RpDFzT0Z/Nr+3ZfQz/HqbR1+WPTreOPA7M3J/nX4mftvaldSfDJtBsCTNqU8dui + 9y0jBRj61+q37UfiBtf+P3ifVnOYxeyIpB7R/L/Svzl8SeGF+KP7Vfwi+Fjp50Wq+J7HzE6gxwOJG/QG + vxTCr22Zxius/wBbn67i5Ohlc5PdQ/G1j+mz4Tfs2p4F+DHhfwhCu1tM0q0t2GMfMkSg/rUOv/CGWaMo + y+31r9JZdFgCCML8o4x9K5S78Lxu+7Z3x9K/V62RUpK6Wp+b0c6qRdr6H5kW3wHnln3iI5Jr2zwf8Drq + yljmCcDmvtKz8J2qtu2Diu2sNCgj2qqgdqnD5HGErjxOdzmrHy5L8IXnhA28mvHfHX7OL6vaywnOXU/S + v0mTSIVGCKoXuhRyLgAGvSnlsLaHnQzKae5/Kx+1B/wTM1L4gvLJajjJIGK+a/hN/wAE39f+G9+sk1tu + VGzkDtX9f2r+CrO6BSWMYPHIrzu++Genux2xD8hXlVsHiI+7GWh6NGvhpSVScFzH47eBvgFPp1qizRFd + ox7CvZ4/hFPHAERCTiv0Pi+HNpExVVx+FaSeB4Oix/XNeesBV6nrPMYW0Px/8Y/s8alrLMqoQWz16c1z + +g/sd3fnK7ggZyOOc1+0kXgC1ZtzRg49q37bwNaxYJiHHPFJZLOb1E86jHY/I21/Y0FygV+w9K9T8Hfs + kQ6NMJCB+Ar9QLfwtAjBSlasegwo2doP8666XD8FuctTiCpayPmPwj8KV0tEVRwor3XS/DYtUAK4x0ru + 4dKWLgLj14q75AjGNvA/Ovaw+XU6eyPFxOY1Kr1ZyK6WygdffFPTTuee/rXTui7/AMeMU1VycY989a61 + SXQ4nWkzFXTAwwF5xzirK6GDweua3o1wABz+laEW2P8AlW0aUXuZSqyRyyaAQMKM/UZp/wDYLf3B+Vdp + HKoHA/T/AOvT/OX0P5f/AF6r6vDsR7eZ/9H+Hy+luo3KZIFY0k8kv3jyPftXba7abGKiuFeN8c8A9OKc + tzjw804XRWllIGTWeSyng1Zl3A7TxiqRJyR1rWJqTCVzkDihnYgZNRgHHI4FO3DGKoQ3jGBUZzT2B55p + uSR64oKQsYZnCr3r7t/ZZ+HGm32uW95eoHbcD8wr4asiFuVY9jX6J/s4eJLbTryAM2NpB/KuPHSkqT5T + egk6kVLY/rQ/Yj0LQ9LsbVBCi/KvYV/QJ8MBYLaR+WFGAK/lt/Za+MtpZWsCmUDGO/Sv2g8D/tNaJoel + Ry3twu4qMDPJr85UpQrtyR+ockamGXIz9mNKu7WKBWUgY7Voz6tbIh52+1fkm37cGhwcrMCBwOQTihf2 + 3NCn+V5vbrXuQzGKVkeBPLJt3Z+pN5r1nuOWFc7ceIbQ/MSOK/NNv2t9BuBuS4Xkf3qxZv2ptDAybpcf + Xn+dZyx7exrHLbH6fDXrPPJBq5FrNo3TBr8t7f8Aaj0QJkXak9ue1blj+0/oki8XK/nWX1u/Q0+oeZ+n + keqWWwMWHP41bTWrNTkEV+Zv/DUeiohxdJj61zt7+1tpEWWivEOPet442y0RlLL23ufrTFrlqRlWHFWm + 1u0VeXGfrX57+DfHHj3xBpcXiHUCmkaXMA8c938ryoe8cf3mHoThT6130Xji6mhaTQ4rzUyg5YR7V+px + 0H4mvguKPF7Icjm8PXqOpXX/AC7prnmvWzSj/wBvNeRpQyKrW1prTv0+/wDyPrS78QWkeW3AGs0eI7Jp + AN3PYV8Xz+MPi9q3iI2/h+w+yxNFuJnARQMkZB/l3q7a+H/jNPbkf2tEskxI/j+XHfPfp71+bS+kbKTv + hcnqSXTmmo6fKMte6/FnqLhSVvfqxX4n2lHr1uMMSQOx6VqweIrRRtDjP1r80J9E/aR0bX5PDs2rW5R7 + fesjEgFXPYjnORjpXY6h4j+K+hafvufLv7hfvrGTnPsCMnjgc1vH6R/sZ8uNymcVez5aik18pQh+ZjU4 + Qm1eFVP8P8z9EItet+qEZ+tWW8SWycBhmvzm0f4v6lqsLw20hgvlJ/0WY7WPsCcc151qn7Vtto1/JpWs + S/ZLmE7Xil+VlPbINfrvCniVk3EVF1MtqXlH4oSVpx9Y9vNNxfRs8etkVWlLlmrM/VZvEdrngj86sQ6/ + ARkMD6V+RLftgaOrfLep16bqtW37ZGmlxsuUx25r6z+049jL+yJW0P2JttWt3wysPetQalHxtP61+TGg + /tf6ZJIEkuEPHrzXtGm/tOaLeKCky5xnrW8czpvc555RVT0R+gjX0W0dM9BVCa/hGCGzmvihP2iNJ2hj + Kv50f8L90+U4SYfnRPMaZMcrqrdH2kNQgxknHfFN+3whSxOK+OE+N1gRvMwA9SaJvjlpiqC0wOfesv7Q + gX/ZlRdD7DGpQj7zfSpI9SiBwSCPavhu6/aA0mLkzoMHGN1Vof2h9JDfLMv51lLM6aZtHKqjPv1L+DHW + qup6ta2Wm3F1IwAjjZjz6CviOD9oTSicLMh/GjxB8bbG/wDDeoIk4BFvKSc9AFNc+IzqlClN9Un+RtRy + Wq6kV0uj+fn4haiuseNdc1pT8tzfTMpJ4IZjXnX7EHhyLx3/AMFYfh/p8o8yDw3p2oas4PIVxGUQn8WF + ddrDxXK3V5wTJKzr6dT2rC/4JeeIbWw/4KEeO/Gl5gDSNASzQnsZpFJ/9Br8r4ZcXmMas9o3f6fqfo/E + cH/Z7pR3k0v1/Q/sQkubcn1P9azzcWxbGBXx7N+0JpsZwZl9OvemxfHnR2IJnUf8CFfsKzOlLY/L5ZVV + j0PtG1kgztGB710cRhxww9q+LrT44aSePOXtzmuvsPjfo+zc0w4963hjqXVnPPL6vY+tYjFtOTggU2Ux + EHOM18xj44aXtBMozVWf466Wg5lyD3q3mFFdTNZdXf2T6QufI+8Tj/69c9P9mBI4Pavm28+P+hoTulH5 + 1gXPx60RwMTj6ZFYTx9Hozpp5dX7H0+UttxYEVNFFasM5Ge1fK8Xxr0uZjGZ1P4ity2+MGmEAGYAcdDW + UcZSbNpYGsfTUMdsDycnpVxYrTJyev5V82x/FzSsbllBzx1pkvxk02EH94Pzrf65SSuc7wNZvRH01ttR + hj0Heo2nthnpk+lfKc/x10yMFvMGB71z9z8ftOHSZc/Ws3mVFdTRZXXfQ+yzf2+PvYqu19asu5jjvXxH + N+0FYrx5y5+uazZP2iLQLl5VwOnPFJ5pSH/Y9bsfb81/B94n/wCtmoF1C3Ugg8V8Jy/tF6aeRMo7Y3VJ + B8f9OmUbZhn1zxWLzSmWspqH3rFqMDDrxV4XcDnO75TXwXD8d7LdgSjr2NaLfH+zgwfMB/H/AOvVRzel + 1IllFV7H3A13ET8rbf0/rTftSf8APT9f/r18HSftK6UjFWlGfrimf8NL6R/z1H/fVX/a9Ij+x63Y/9L+ + PLxN4OMUxU5JHTPpXmuoeFTApdh+Qr768UeBZXR53Ta39K+ePEOgGKNlX3/St9HqfGYTHSilFs+UL/TP + LJOOM1zMyFGx3r2PW9O+ZuOBXnF9ajeT1p2PoqNbmVzCUcHPSncfw1a+yc4PU1L9iA4zzTsdF0Z2ecdK + Z2zmtL7Cx6HnrUJs2PIOaLDUkVoiPMye1eseC/HN1oNyj7iFU8V5aLZ1ODV+CFj0rOpG6szSLP0v+Hf7 + ZT+EIUw7FlHbpXrVx/wUd8RTcCdx0xyRivyQt42VQGBzVzYR2ryZ4ChzXcdT0oYuuo2U3Y/VX/h4jrC/ + L57+mQau23/BRfVlYLJcN165r8lnQgcjvVIqT8w4+tEcDQ/lE8VX/wCfjP2Ytv8Ago9qJGDcFfU5q9/w + 8ZvGGGuie+c1+La4GOamTJGRx6U3gaH8oLF4j/n4z9mU/wCCiuoIDm6O0991TR/8FHtSgOBdMc9w1fi6 + +DkZ/SqJTnK85oWAoP7IPGYhbTZ+28n/AAUg1ZkKre4B4J3dq/oX/wCCdvwU8W3vgvTf2pP2jY2I1KIX + Hh3w/cIdxR/9Xd3KNjO7hoYiOmHbqBX4Mf8ABFH/AIJs6X+0p40l/aj+Pmnmf4b+D7sR2ljMp2a1qseG + ER9beD5Wm/vsVj6F8f2+fDv4UeIfH+vL4z8QhUSIiS2s2GN6jp0AAA7V/OPi/wAc1Kdf/Vnh+fLWf8aa + 3imtKcH0nJO8mtYrRe89Ps+GcrnWj9dx0n7NbLv5vyO78GeBdS8TTJ4p8bu9zd7/ADDaH7qJjjdnqfQc + CvrbTvDc8OnCG3j2l4zhDgAN2yBUng/w7FJvyjRXK8MHOWOOgPA49DXpNhbiG6RpGI2HG3GcH3Nfn/Bn + B9HDU4znG3O7XXrZt31v3XfZbns5nmLb5Y9On5WseW654eglSysmVfMEbxOV79GHP4U628Mu1rAIgNql + sr/vHAx/WvTNRs4ZJVuJP4JCP++uKTTrcxTbPvfMAvPvX1eK4dwzxzTStK0dOiSjb8Y/NnBHHTVJNdLv + 56/5njGp+ErfUfEFwrJumi2xo55+UDJH0yTWZqfg3T7dBNerngncByD2x+Ve3W9rHHPLdMfnaZjz0IGR + /StGKK2i0+SS/UEBfTpnr+OazfCOBxLk3GN3zO7WiV7q/nbTuL+0qsLK76I+CvjN8HdPvfCT6tYuw1lA + JLQqACWB+6T3GOpJ61+Rn7UXwD+IXxq8Li60aY6R8QdOib7O058u31CNMkQyHorc/I/RTwfl6f0G+IdA + /tK+m1O4UKZE2qnVUX0I9cD86+bPH/ga38U6ZJZSp+/YZjkB/wBW3bH9a/Lc+w2K4dzSnmWUfu6kNuvM + uqmuql1j2tqmrr2qbhjcO6VV69+3p6H8A2sfto+LvCfiG98L+Kpp9P1HTLiS1u7acbJIZoSVdGB6MpGD + WvpX7e6xMPNv5G5yMNjNfUf/AAXS/Yg0vw/bR/tg+D4VtNQa8j03xVbLx5ssnyQXYA4BO0RSdN2UbqSa + /miBKNkHOOmK/sngfiHAcS5PSzTDxs3pOP8ALNfFH9U+sWn1sfm2Oji8HXlRnPVfiujP6E9E/wCChukW + uGa5YleRl/8A69ew6V/wU4s4VCxXIj4/vV/MjC0i5BJH4+tWmknJ3ByB9a+peW0H0Mo5nil9s/qJt/8A + gqFCQrPekn3ety3/AOCpESuNt7kdThq/lWe4uh9yRh07mlF1eqcJI/PoTSWV0BvNsX/Mf1nwf8FSrFo/ + mvcnB/iqle/8FR4JEKi8zz1zX8psV3qOBmZ8H/aNXBPflsLO+PXcayeVUDSObYv+Y/pk1P8A4KdFt2y9 + GP8AermJf+Cos8HEd5x/vV/NxM90TnzGPbqaypzOeQzE8d6FlVDqi/7Vxf8AMf07WH/BVQQgNLeZ+rVr + 6h/wVU07WNMl0q7vG8mZSrbZCpGfQjmv5Z2knzkyNgdcH0p8ckjAkueOn41nUyLCzVmjSOeY2Gqn+B/a + /wDBL4jaH8ZfhHZePdLlWVX8xJivaSI4I9jjk1+Vfw4/bCsfgD8YvG+utcbJdYuQgOefLjZq+g/+CYcV + z4d/YAuvEd9wHu9SniLHqFwM/mpr+dP4/wCrvqnxOv542PBxwe55P86+A4byqlLOMZQXwQbS+8+04hzS + sspwde9pys/w3/E/owk/4KmxXaiQXwB9d2KZbf8ABVKOP5ftZLHsG9K/lnaaVMYY4+tSx3VyDxK3Xnmv + 0aGTYeOyPgpZzjH9r8D+tXQ/+Cp8UzqZbzAxg5Ir1/Tv+CpOlbVRb0ZPYtX8b8Oo6kmFSeQD2Jq6Nb1l + R8t1ID7OaU8povYcM4xa6o/syH/BUnTI8It4PXO6sfUf+Cp2mNGSb/8A8eHNfx0DxBr44+2SnB/vEVC+ + ta0/37qQn3Y9az/saj3NVnmK8j+r3Wv+CqFqrkJe++d1cW//AAVYTd5ZvckH14r+WqXU9VlP72d2B9+K + qm/vlOVlbPXgmrWUUF0Iec4t/aR/V3pn/BVWDI/0zk/7Vej6T/wVUslI828B/wCBV/H8mp6gp2iZvzNX + 4da1VOUuXA7jdUSyel0No53ierR/Zhb/APBVLQygJvAMf7Qpk3/BU3RZ02C9Uf8AAvWv42B4i1lRkXco + PsxqB/EWtEblu5fpuqf7Hg1q2U88xC2SP7AL7/gqHpO44vsAcY3CuQvP+Coenn5ftqseT96v5HpvEGtM + SPtMmPQN61XGt6qP+XmT2+Y1ayOh3Mnn+L8j+tGT/gptp5UB7sZPq3JNZN3/AMFMrMgxi9A/4FX8ow1r + VT1uJOf9o0DWNRYfNM/Pqxp/2JQJee4t9Uf1B3//AAUyjXiO93enzVBp3/BUcwzATXXy98NX8wQv78j/ + AFrnOP4qPtl5uGJWORjrVvJ6G1jP+2MXe/Mf1s6J/wAFRNAmIM99yQO/Nd+P+Cj/AIa1G2ITUwGIPGa/ + joTUb2NjsmdfxP8AjV5PEetwjbHdSDjP3j3rB5DRvdM1jn2KW9j+uaT/AIKEeH0ch9SQ55+ZgKZ/w8L8 + O/8AQRi/77FfyNt4l19jk3cp/wCBE/1pv/CR69/z9Sfmf8aX9h0+4/7exPkf/9P8cfHvhK3s7B2aMA49 + K/Pzx7bJbyyKAMEnivvv4qfETTpbYlGwccj3r80fiF4rgup32HpnitKKe7PzWMuaooxPDfETp5jMh+te + TajIPNKk9D3rq9e1lHcsprz9pjM5d+vWtmz7DBU2opssKBngdxVsKMccGqaOOp69qsq/Oe386o7h4Tjn + mmMONp9/zp28DOKRmGOO5496BIgKckn1qWLbnPHHXio2IxuPFRGbByOv1qZIuLN6GTnzD2q08ydW+tcy + LruetSLe5PH4VhKmdEahuyyq4yD1rMfbkgcAVU+0lhk/X8aUyAnBrPksac9yQOMcj6k0ecq/Kf0qo7Yy + ufwNQGUKPftRyj5i8ZwRz/k10Xgzwlr/AMQfF+leBfCkJuNU1u8gsLOJRy89y6xoPxYiuLEh6HFfrX/w + RT+FkfxG/bv0PxTqCr9h8DWV34gkZ+QJolENv+InmRh/u5rx+Is0hlWV4rMpq6pQlO3flTaXzenzN8JR + devCivtNI/tt/ZL+BHhv4XeE/Bf7N3gyPboHhCxjtjtG3z5lBeeV8dWmlLOSe7V+w2l+Fngv7ZoZjCI0 + IAI4K8YUEd6+Gf2MFgt7jUPEGvxy7ZSFhkVCyscnI6enNfqJDcaDeWsc1vLGCo4wCmRj0NfxhwHkMMwp + VsdjMRGVeU+dpytJu92976u/4H6tm+IeGcMPSg+VK22mxyOq2khuUkVyknA3jghc9Ca2Ge64a+VST8u9 + TgN/ga0HsVlHmRbSMdFbmnJG0aNAxBjYcqR0PtX6JHANVKrndc1rPpdbXvv6rVea0PCda8YrexRVJjaz + xycsmGGfb/EVct0SItI4yVUt9cf/AK6vwTb2WG4PIztcj747g+9QXCxw2AldggdREQe5Jxx+VdDwsaaj + NSvyrrvZO+vn73zWq0ZnzOV01v8A1+hWs9Pk3RRq3L8kY6buTUOqj7TILS1P7iBvvf336cfT+dX7q5Fs + 0kEbEEjBI6gEdB7n1rLdYolD3siW0S9FY84HtXfGcIUnRoq/fWystEnJ6JdXrq7LuYuMnLnl/XyOR+x3 + MiPycFiMDtnuSf6Vy3iHwpIN115OAVwC78nA6gD+terNrHhZT+5L3DY/h6fnwK5DxJ4rMdg8VlaxeYR8 + nmMWfBHoBXy+MyDALDVKmKrKWmnL72v/AIC19zWvU9CjiazmlCLXrp+p+OH7e/wa8IeNfCN94d8T2zXW + i+K7OXTtRjYc/MuNwz/EvDqezAHtX+b58ZvhnrHwR+LviP4PeIpVlvvDWoT2Esi9JPKbCuPZ1ww9jX+n + H+0po2reNPDV1EshjubEGaJScAMOTgd+K+UdF/ZL/Z6/bd+BU3hT4+/CnQteS1lltZPEVpAtrrkMztv8 + wXcQEpZQwxv3KQMEHpUeBOeUsHnOMy1yapVI8yilf34tK6XS8XK/flXYy4uy2tUhRrUUnLZ3fLp62d32 + Tt6n+cJHJhsjn1qbz8DP9K/sF8af8Grvgbw1aX3ji5+PA0nw0J2MD3ekeZJBEx+VZpEmCbgOCwUKT2HS + vMdE/wCDen9iS8i+0T/tWQSgKznyNKQgBeD1n9a/rLmpaNzWp+dupUi3H2Urr0/zP5SGl3YwOtPR9pJH + X+Vf1r2//Buj+xRev5Vr+1GcgLu3aQgwG6ZJm4z2q3/xDYfsr3Mjmz/aktNi8jfpSZ2/+BA5ovSe1Rfe + L21T/n1L8P8AM/kqSQL159K0UugOeMj9a/q8H/BsZ8MNQiaTQP2m9GkJ/wBUJtMwDn1xcZrE1P8A4NX/ + ABrJOU8I/tCeD7tFxn7RbTQlc+u13o9nGW0196/Uf1zl+KnJf9ut/lc/lUnuyRhetZksg79etf0xeK/+ + DWn9tq0Z2+H3j7wJ4iiDYUrfy2rH8HiI/Wvm3xv/AMG2f/BWTwnBJdaf4M0vxBGnfStYtpmbPortGTVx + w76Nfev8xPMIdVJesJL8XE/CLevPoecd6aZEXBwMCv6SPBv/AAajf8FZPFnhtNf1fT/DOhSPgraXurbp + +RnnyY5FHp96vzp/bm/4I3ft+f8ABPNLDVv2i/CAi0LUp47aDWdKnW+sTNKcKjumGjY9g6LntmtHh2ld + /mv8zJZjSk+VX+cZJfe0l+J+yPw3s0+Fv/BMPw5pf+qluNDWZ+x33zmQ/wDodfyy/EPUBqHjXU7snObh + 8Y54U4r+qH9tTVbf4c/sraZ4Ri/di0trS1x0+W2hGf1Wv5I7y9+1XUlzLyXZmP4mvzPw+i68sXjH9ub/ + ABdz9H43aowwmDX2IL8EkTNL827FTxSjGcYPb2xWSJM9PX6U5JFPU1+lcp8BzG8kuVwcZPSp/NHfmsAT + lRlWwRSm63c9qhwK5jfE4HB700yg449zisE3OG2j6Uhu5Ac5o9mPnNtp1LHnp/Kq7Sg5BI71jyXG77va + m/aGbOTn1p+zFzmg8wX7tMW6YDv+FZhlBBJ69qYZR9arkFzm2LkdG7003IbAJ5/lWN5p246CozMBzmj2 + Yuc0jcb+T2qMSjduXgVSE4xgmo/OI6VSiHMaQmA4OKXzRuwvU81k+bmlM3GaOUXMbP2j04pyzpnbjpWO + LjnA70efuHJ60uQfMa73GTgden50wzZ47VmecM1GZeMn0/KjlDmNRrkKcbivtmm/ax/fP+fxrKMynrzS + ecnp+pp8gcx//9T+XDxT4p1G/QohZmAxkEn8fxr5w8TwX0zOzBsn1FfT1tfWiARjjHB4pl9o1rfwlwgO + fUVlPGKOlj5/A5HZ8x8CapptyWJIOTWEulzn5jxX2lqfgq383JjGDVdPAlpLH/qVAPtzUfXkfTU8ulY+ + ORYSg/N2qZdPkGc19az/AA/sgMtCoFZbeBLIli0QOM+1UschvL5HzF9ilH3cc/nTDYzdWzxX0jN4JtEP + yx//AFqybjwfaAkbccVaxqJeAkfPctnL/EOT6VSe2mXhh+Fe8zeDoVY4XrxVdvB9t6c0/rcSfqcjwd4p + G5HNR+VLxnOa90bwTEc4HBHFQjwLHyzZ/Cn9ZiT9WkjxhYpU5HIq2o6D05r0a/8ADcMC7e/rXHXdi0BL + dvan7RSD2bjuY0gI47D+dUXSUjcBxW7BbtM2PXiuks/Dq3A+Y8fpmjnSGoNnnojlB5/Kv6JP+Df7SBD4 + j+KnigqTKllpVgB/CEuJppDn3zEuK/Cq68LrEgfJGeenev3C/wCCE/jaDw78TfiX8KXcCfxBoVpqdqpY + KXfRrgNKqg9WEE8j467UPFfBeKGHni+FMwo0t+S+naLUmvmk0exw+lTzKi5bX/Q/vl+C2iPa+D9It1TC + tCHRY8YyeSzV9VaZGsMRgJLMvB+Xdj6kV85fs93tlq/gDSLyxkyrW2yVs5ZSCcg+nbFfW+nWZjtl+z5U + EdMdvev508OsslWoxq092rtvXovTr/lbqfdZ7iOSbT7/ANdzDMUMqMHjAK4wwBFLbbgpEVxIgHZvmH65 + rfe40y3Vvt0oCj+EYLE/TmuX1HXrm4Pk6bCLaPpuPLk+ntX2GY0qWF/e1qqc9rRXvPX+61b1bV/M8mjO + VT3Yxdu72/Ffkcl488XXnhjw7c6iqCdkQldiHcPcL1OOvHpXxv4K+Omu+JDeaFrN1JcRvJ8lyELFAw5O + 0cBR17nNfSHxWtriTRJNDtm/fTpiWTPIVugz79/aviL4cN4y8OXeoWvxU02300m5K2d5p8jXFvLb87RL + lEeOQZ+YFdh6hq/KM+ljamLlFy92KSa5rb9N0359u6Z9blqoxofDdvrb+v8Agn1L8OfG2tw209pqFzLc + w+awjnx+8IHA3dW+hr1W2mt7yXz4j5jE4LAlyPr3FeGaHe6ZYzjyZEMMxCu0Z3BT/C+f0NeijUHtrwx6 + ku2UdJo+GIH0/lSyurKNNQq1NE9L3aV/PdX6dN9UY4umnNyitzsrjUZ4W8uI/MrHGQRx9OvNRC3kvQ74 + Yuf4gMN+ua8f8dfGK80Gzkh02OG+ZSI0nmGPnP8ACMEbsdz0Fee/DD9oG21FbiTxnqFltjlZAViaCPYu + MkS5PAOQCU2nH3hX0FOjOtO7rc0F3dremrTfo230Mo4Wpyc6h+v6fmL8XraOytbqS43Bwr7i2CcYNeF/ + 8Es/EFzrM3xK8MM5e3s7yyYdcBpFlBA7dFHSva/jpPPqHh2+vPDen3d5JNavNB9nie4jkGMfJJEGR+vZ + jXln/BIrwD4k8MeEvH/jfx3ZT6Tca5rSQW8F9G0Exjs4zltkgVgCZcA45xXV4U5JjI8ZOvUpSjCKlq00 + vhkt2l3X4HFxPXh/ZkYp+9dH6hReHbKyt5bWeBZLSYFZIXQMkgbghgeCD3zX4qftd/8ABG6w+LGprrn7 + Jvi1fAvnXBlv9HmjM+nMZDl3hKkSRHP/ACzyY/TbX7zSiwmBjmuIMHsXHSrOn6RaXEyLYXdo5HYTKP0r + +vXQi/dsmj8yqT5vek2n3V1+X/DH84Fp/wAEVP2spfCcVncePtMub8sVlZYp4Y2jX7vQsSQOxqK7/wCC + IX7UFlaPb6F4+tVkETukkkUxBmbpuXdyB6gg+1f08JpPiixgMEsTSwnoY5ACB7Ef/qrwrx7efF7wvai7 + 8P3zXjSt8sEhUNtJ7SD5SR6HFZVMFQhHm5H8jSliK1SfJ7T7z+fC8/4JF/8ABQiw8LwTaH420U6xAgRl + EUohkwcFgWB2nHseaqX3/BKL/gpro9kbnwh480OXUsnMt+JfJwepKqmSR71+8dn8RPjxYzq/iWF4lUgi + EIcsD6tj+Ve6jxHrN94cg1rVo5A1w5jNrgowJ6bR1YdzSo4bDyu1Bq3dBXqYiFl7W99NGn/Xqfgv8B/+ + Cef7XGleM9KHx98eaTqGm26M97DpNk6+dLxgLLIcqo/iO3ntX7yfDnwnaeCtA/srw3ara2MA3MVUFnc/ + rz3qeyt1ula81LbbkEBFclcfhx+tehJc6Fp+nt9ufBlwfLBBOB6Adq3oYZQbkY1qzlFR3Z594l+JHhLw + XZf2j8QNch0eL5QrXV2lohJzgbpDznHQc46dK+bv2nfiR4I1Xw5pWueDBaeLP7LebUXWFl1C3BhjZQjK + PMUsS3y5xjGRXxl8V/A3jT9pf4vaxe+NoJYdJso5E0+Mx74WVm3JKuc53RhFJGPu4HfPx18Rv2f/ABH4 + H8RRT+HvtMSKGYXNqBbyFs4IUIV5XsBjjvnOfGxWZV5UpqEbLZPr6n1WDyHB+0h7Wd5W1jpy69P89T8V + fjJD4S+M/wC1D8Pfhp8QtHOvaHrOpzXeraSsrWzTW3LSRhkIaP5cgYI9K9Z+Nn/BBX/glj8b9Mj1/wDZ + s8e618KNRvgxgtdSlXVtNZ+yASFJ1x7SNX6M3OueO/D1/ZeK9W+yahd6OjyRXWrQQ311CnILq80bTJtH + LAOuc88GuUv/AIu+EfHHiX/hJ/F3h+Cxu5wIbjUtGv4zIqyrsaRILhpEUOpGVQx/KQoPevneG6s8tofV + Ya6ttuK1/NnucSZLHMsQsVfWySSk1a33J9T+S/8AbP8A+CF/7bH7Inh2X4l6VBY/ErwShyda8LyG58pe + xmtiPOTjkkBlHc1+MJlYEhs5HBz+tf6T/gfw0vw3uYvFfw+8eHxFpdxG0ayNayW0rODn7PcQkCJvl/uM + QdvGDiv5A/8AgtF8CvAvw5+M+k/ELwjBZ6deeKvthvbS0ZWR5LZkBuNqfKu8uUxwWKbiOa+0wmY+1nyT + jZ9LdT4fG5TPDx5k211urNfl+R+LvnkjHSgTknGetTCzbnI/w/lTksXHBr09DytRiu2flBqdC7nBq5HY + SYBxWnb2Dbs7enei6E20ZIgYHBHWpFQD6Dr3rpDYMQABVRrN41zjFF0YOozCkTnK96oSDj3rfngZQcis + WWIlsd/SguMmzOaQqOeKZ5hJqWWM78YqJomHLU9DWw3zCeBS7+efzoEbDkil8phx2oCzE396QEHpUgib + PTNSrATyRRcRBnPNSAevU1OIGXI6j+tL5R5qWxkB3ZpCcdeaslDjmoXQYytLmERYPt+NGD6j/P4U8wuf + T+VJ5D+35mnzIdz/1f5ctO0W6llwFwAfT0r0218Pypb73U9O4617RH4FtrA8r055q3qEFnZ2uHwCB27V + xV6Lb0N8FNJXZ81atpghwW+90rIh8uEAE9a6PxfqlkkhIYDHQV4xfeLLRGZS3Tkf4VzPDyPUji4Lqd5d + vCvTp0GeKyJGiPJ6V5nceN7durZx3zWd/wAJlbyZCv05OT1o9hIr61DuejzyQueSDWHJIjemfXFcNJ4s + gLYLgfXvWZN4pgH/AC0H4elNUZEPEQO+l8sj5uvFVAsbHIAPP4Vw/wDwkkBTAbORjOaaPEFuRhmziq9j + Ij20TvlhjPXA5zmmXcUIjBTHOa49dftlfO7g9qfNrsUiZU54GKapSJdWJT1nbg4wSM5rzHVdr5GcE9q6 + rU9SVwTu5xz6V5/qF2rnnt/WuylBnBVmizp8Xz7WFejaRp8rpkc9K880R0EmW659K9j0a6iRQOgrPESa + 2FTqFfUbSZLffIDgmu8/Zf8AjVc/s4ftIeEPjVAu6HQtRje8j5IlspcxXMfH9+B3X8azLt4ZbcrJzkYH + Y1474gh+zysU6da51CFenKjVV4yTTXdPRmzruElOO61P9Nn9hv422nh3VP8AhGbIprWm3WHs50f5ZIn+ + aOVDyMMpDD2Nfr0+vX+owebIPs8bHAVTjPbr1P6V/CJ/wRU/bITxR8N7P4V6xc7df8AlIo8nLT6U7/uX + 68mEnyTjouyv7iPh/wCMNO+IWgWfiDTMeWYhlE+bD4Gf8+9fynkU8VkmZYzhqvUa5Je5GySnFv4r6Nrl + 5Xa+t9Nbn6NjPZ4zD0cfCN7qzfZr/g6XsdJdJFGh8iIKByT3596qKq2qfa58sw4jX1PoP05roFs/MYCf + 7pPSse6ZbvU/s1rzHbBl3DpvPX8ulfQVsvlKqsRJatpRVlv3t2S17XWpwQqKzj82eV+JrOeaCVZTvkcl + 5D7/AP1hwK8kurlbG/nt5MblYkgkcive9XhZo3iTB2qfp/n3r5s+J+kyJqjyqPuBWx/vKCefrX53nWEd + L2mItfVf+3fefQ5fUU2qbfT/ACOa1PTNJ1G5k8m5+xTuNokUY/lj9c1Skg+M1jEs+iavp+qwwr8sd3EQ + do6DehB/PNeX+JvCfjHWFSDwhrH9nXEjADzohcRbu4IODz064qGPw5+0j4d2hLjRNUSRsbh5tu3Tg4ww + znPsK48qw8qi5+aNvPT81b8T1qsVFWuvmhsk+vXWtRvr+lT2z2cjYS2AuYjuHJG50YHnvnivZdG8LfDy + 60wxeJ5LSH7cCu29s2UDrw2Q/U5zjg18qJ8Y/H3hHUL+38YeGdR821kyZ4IRcRyM3cGMknjpgZrY8L/H + tvije3+g6JrujW13bxlorXVZGsX2lcgEzhRu9cdK/ScvyypJcksDGaezjJr8VK34HFiE2rqpypej/NM6 + Kx/ZM8R2/juCf4ErpWl6bPIGupbK+kgyqHGEhO1AOcjAH61+iHhb4N+PvCUccui39+ZIxkefP9riLHnJ + VmPPXoe9eGfDnwtcaxDH4kufEOluQvLafcRPGeAMDDdRj0zX014V0/XbWzfVbDWvOt4uWJlUghuBgg9j + X7Hwtk9HD01KVGcZPvU5rW7dUfG51j60vcjVTS/uv7nrZ/cdsbjxW2zTNe0ieclQHmSMPA3HzcEl157Y + +hqpp2haFFcNc2VjNa+WfmVA2wsP9lhz+BxVePUfiFqSRrYeJreCEHD+eiSE/kQRXKeLdL1O2086hb3O + n3V6y8SWsbRiVh7B+3rX2rmkuazdu9v+H/A+ZULvlckr9lL8b6fid7q2h+KPFmnXlho+p3OjQKuxJY4x + uyMEkDIIHbgnOa7mHxd4ntdGW2s3i1Hyo9jW92hVWYej4BH0YH61856R4ojWzRL+/SGQEiVXlAbPpt3E + 8Umq67qYUPp905iYcbUdt3uPWtVXja/X1M3hZJ8iWn+H+n+PobWp/tGazp8k8d34cv4TG3HlwPdLGR1y + qYdlx/dq94L+LMnxQtpdXt3mi8vdA8UsMlqwx3CSfMAfXkGvNNR1TxFdWUlrp5kSYqf3jwEqD+YNed6Z + oOjtdQxeOr2GVnTfI8azR5K5/jL7Vz7msJV6l1rp5tL+vuOqODouLfK0/JN/g/8AM+utP0rWLi3NtFC0 + ssbn5iNgKkkgkng8elQeNNO8d6T4Uuj4fjaW5uU8kQwyqGw4IY5zgcZHJHOK8i0//hTOmW0dwr2pEuFD + xuLgHcfu58w5P6ZrpfiF4t0A+ELmzsvEqaXBCdjRQQxyz4x91TnqfXoKc5RdKXM7adGv1SM40mq0ORN6 + /ai/yTf6epueAPA/9i2KSm3Fs4VR5bSqRGMY28E8j8qb4v0HQLhWW/aIheQQCxU+wANeO+AvHHw3iu21 + C88R+TCo3GF32ouBg5HUc9STWn44+J/wEkvpo38T2NzMgIMKTNPktgfdj3DPPpWcKlBULR5bebRtLD4l + 4htqTfdRf/BPn/4h+B/hdBcf2hJPJIsQO6A26jzF4z87uCo45ypHA4r5m1P4e/Du+eRvB/gHTrma6OHa + XdM53E87SYY8KRuOSQB7V913Gn+F7wyx+FtMvdUSWLCTQWwtYy/oZJ9pAHf5Tn61Y07wheaXZSvrMcUG + 0+ZHarJ529VHzCRyFB74CgKOvNec8JreKsvL/N3/AAPajj+SKU22/N6/crP7z89PG6anZeHIvCXhu1ud + SOnwyS/ZrSMQxb0IMiKAQvzMfvLkEnOcV/G5/wAF1PED+J/2gPBYk0b+wVXw204tGVUdTPdzZLqoGGOz + knrj8a/vuvdPt5tJF3Ij2126JI4R9pJIAKnjA6An/wCtX+f9/wAF6vE665/wUO1fTcANpOjabZttIbLF + Xm/D/WCs8FTaxSl5MeaV4ywUo26r77n4tLaRKTxnP5VILNAMgAGpTKPvHjNSeeAd3ftmvoeZnx/KiaK3 + jAIcY6VdjjiA4A/GqH2hQMMe3605bgdB0+lK7IlFGwBETtHY1HKsLJgH3rFa+aMc9x+NZk+pSHJHTt2q + lcwlSRevVi3EjmuemVCeBwPSmveMzH8Kg83ccDg1oio07DJIwxyBupPJXjOB/n1qweuR2pxaPv3p3NOV + Fb7OMjgH/Cn/AGYZ4H51ZDKBjrxUgePG5uD7UrsLIrrbISABzUhtAi5I/DFXbdTJjAJz6DrUslvNn5kY + Ck5MGjFeLGVAxVeWMjORitkpjqAD1FZ9wUHGfpSuQ0ZbDORQkYPBpSAenPPrQvJGf1oVyGiXylbknHtR + 5Cf3h+tSY3AEDH1o2H2p2ZVkf//W/IDxVpWpwkrAmMd/WvBvE+la2Y2dsZPFfZ2vajY3EuMgj17V5Nr0 + mnyoQAOeh61xTxljuhlqta5+dvjPTNY+dhHj9TXzJrNlrYmZBGev5V+lfiy2tWRxtA6/nXh934Vt7lmY + KMtntXNLMbG9PKOzPhY6dqzMSIyc8GnLpOoAEmMg/wBa+3IfAdkWG6PJ6citaP4e2mQxiBB4xWbzWx0R + yaT2Pg5tJ1HZuMbVQk0zURlfKPHNfoY3w9scAeUG7f5/Gs67+GtnIo2RjPcY4/pUrN12KeRzPz5Gm6kG + 2sjfWr0el35P3WznmvvSP4X6eUH7pTzg5FX4vhXpYP8AqVx2wO9Ws2iT/YtQ/P8A/s3UAQGVqsJYX0ZJ + bcMDsOtfoXB8IdPcAtCM9feoJvhNpqxtJ5I44zT/ALVj2JeTVD86dQtpwvy5B9a4u6Mgl+bNfbnjPwDY + 2isIIh3r5e8T6CbORsdOor0cPiFM8vE4Z03ZnP6VNKGyOlel6NHc3EqJuxgfoK5rwhpIvZgsgxzivtb4 + a/CnTNUZWmQn3HIrnxuIVO7ZjRw8qkrRPBp4bmOHk8fWvNfEvmLkck9enNfo74i+Dmk6fZ+bywA7V8je + NfBkMM7CHJ68GuXCYxTZtiMDUpfEed/Ar4p+O/gd8TNO+J3w7uTbajp0nAbJjlibh4pFz8yOOCPxGCAa + /vL/AOCaP/BU/wALfEHwhBe2mYgcLfaWzb5bOXOCD3MZ6o+OR1wQRX8Hek+G2ivAJBgGvsP4Gat4u+GX + iyDxp8P9Qk07UYVMYdOQ8b/eR1PDK3cH69cV8N4icF0c6jDG4aXs8ZSXuT7r+WXeN+urXTdp+5w7mdXC + ydKS5qUt4/qvM/1FvC37QXw+8d+Ra+FZjJeXeI4w44iJ6n8O3rXffZY7FBByEX3PXrk/U1/EH+zr/wAF + CNY8PXUCeJ8abdKQfMDn7O5HcHqmfRiR/tV/Qr8Lf+CrPw71PwlBH40RZpggUTq/ysfcjINfjUs6xuBq + yocQU3CS+GajeL7r3b3v3XZJpWPspYKhVipYJ+sW7P8AHsfq9cad/ojIq5LRHGf89q+ZPG7QXOpyEfOW + j6jsR/hXx38TP+CqPw3i0Z7LwxJHHMFKsyNvK54wPcngVjW/xK+LnxH1W3m8O+Hr+CMWcVyxvUNpGFZd + vLS7RksMAZ5NceY4+jmsFhMBTlJ6a8rs9Jfd8+h15fhJUJudeaXzXkfUI0m/sbFNVkiZbZy2xweCUIDE + e4JH51maz478M2FlCgmmuLiZmVFgjaRlKDLF9uQg9zivlD9oj9oXUfhbDafCvWrg3OsS6fLqca2yMFFp + KqkRxkA75PNJ5HXZjvXmHwr+EvxW8QyS+LfFQudHsZgf9Hkcx3NxuOMPD97Z1J3Yqsq4LxjqOiou6Sut + 7O3vXa0Sve3U9GrjaCipzmtdrdex9APf6l4t1ZRpLSJNFL5gEjEjBGGG3gAjHByRk19EeCPBmjXfh+S3 + 8WWEFwZlPmJcIs249s5GCcdqz/DmjiPyIQiQKqmNSOcYyevPevW7KMLthUcADjsc/wCNftnDuQ/2f5s+ + ZzLHe2Vo6HC2f7LH7OmpTJdL4SsYXQ5Uwp5IyeTgIRiuhuP2RPgXqkrFrW/hMsYTEWo3UagDpwJMcdjX + sGjwEo3mLyCG+hrppJ7pGWG2TapPO4c/Wv0Gnh6TjeUF9x8tPHYlStGrJfNng2g/sk/DPwTcyPpF5rbi + RNhjn1KeZBkg5+diQePyrs9P+BvgjRYhe2qXNywcsftFzLJgP1ADNgCu9i1BldrcPmQHBI5/P3rcmkZ4 + NrOOQOlaRw1HdQX3IyqY7FbSqv72ZvhbwtoWlxNa6NZxQAPltqDr65616iujq9usD4Klec9sf0rjvD+p + 2+nq0sKbXPLEnn8q6VfFJu7loWc7upb1H4muynypWPOre0lJv8TlrzwobacNbN5y5+YB+n61hyeHrNLr + dIAysADu5wfTHeuw1bUfIie6A688D8OK4sajGv8ApGoAZxkL0I98etTJRRrTlNrVnJeJfgX8JvFVoo1L + w9ZTShw+4xhG45PK4PNedN+xn8DWQg+Hmu0mwZI2vrgA5Pp5mPyr6An1aIWgkP7sOeST19K6jRPEUkcc + OoRHkj+LqfwPqKwdCjJ3cV9yOj65i4RSjUl97/zPGfCf7NnwP8IC4Gj+D7GzM8JhkzmXdGeqEszEg4GQ + Tg16N4V8A+AvDEflaFomn2Cn5v3FskeD+AHeuh1DV7uTZtXI6YHH5/8A16uPqOmiEQWE6SXRQFocFmQk + 4BI9M9TWsadKL91JfJHPUr16i9+Td/Ns1XntvJkypwwIPc4NfOvxhuFGgTNobmW4kVitswO+XGAAOPfJ + H0r3eK927d0e9ucYOF/EmvJfFctnqUhjldMswZcdhgBsEdz296jFyTpNXKwEWqyk1ex8/RefO1pqFwrN + EfLQxKB83mbVy2eu0HJ9hX+c3/wVmspPHH/BRP4paxpquUTVVtfctbQxxsf++lP4V/pT3Nxp0uhajqWk + OsUEEEv2d5DtKhEJ3exHpntX8CX7Q/wjufHPx78beMpYvMOo61ezKzAk7fNYLycn7oHevOwllX5m7+7+ + q/yO7OKk/qqjFa8y/BP/ADPwqbwNrSjdtP4VTk8Ka1HxsLfhX65x/s8XV1N5Qtjjg4x2NMvP2bLu2jyt + v1r1/aw7nzHNX7H5AN4c1uPhozg+3ehfDuut8yRH8RX67R/syTzqZZ7c4+lQj9m6bf5EdsRnvT9rAXtK + 38p+Rb+HNdkYoYzntwarf8Ijrhb/AFeDX7Fz/srTpAJEhx6cVJp/7LVxJGZJrfJ55xVe1h3J5638p+Pk + PgPWJBucY+lb1v8AC/Urg9GHviv2N0T9k26vLkKltlM+nQV7joP7H8ckqwiAfMckkVnLFU0aQp4ie0T8 + JrD4MarOu4RsQPWt60+CN/dOIY7ckjgnBr+gaf8AZKit1W0tbbOeBxXsWgfsY22laULy8tQHbnpzXJUz + CEVc66eAxMnyn83A/Zz1WFPMmiZfrVWb4S22mEGaLJX1Ffv78QvgVHpiOqwYCg9q+JNW+Deoa74hi0Ox + hy8r7RxnjvSp46M+oq2DrU99T4i8BfCCTxHMRb24CL3217Fqv7PkFpbbVi7elfsL4C/Zah8G6FDttx5r + KC5I5rO8Z/CPyIHxH17159bM1z2i9D0KOUVHT5prU/nZ+JHwuGklnhTYVOcgV8xX0b28jW8g5UkV+1Px + q+GjRQzEx7Sue1fkr468PNa6zJEqhRmvUwmIjUW551SjKnLlZ5acAdKi83awrf8A7KmwW2njtVd9MmPI + jPrXamjJoqLPuGc4p3m/7X8/8alFncJ8qJkfSl+zXf8Azy/8dFPQWp//1/0Sv/8Ag3Y8M3Tn7L451OGM + 54aKNv6CvO9a/wCDcqNWaW18f3jRgcKbZAfz/wDrV/X4LCBRgCqF5pkBQ8A5rxpZQ7fxZfh/kepHM9b8 + i/H/ADP4Vfi1/wAG9nxH0OJtR8I+MPtqqD+7uLba35q2P0r4L1r/AIJI/G/w7fm1vJhIAcFkU/5xX+iT + 4m0G0nQhlGa+XfEPwu0S+uJHliXJPp1NeRXy3FQfu1LrzSPbwmZYZr34W+bP4WIf+CVvxhhUB5d2RkfL + g1j3/wDwTS+OOnuVjAkQfxbea/ukHwf0Qp/qFI9SBVG6+Cnh6ZDG9ujDHpWay7FNayR2f2rhE7JP7z+C + fxF+w/8AGjw5btO1oZFQEnKn/wCvXgd18GPiRZTvC+mS5TrhTgV/oKa1+zl4Z1KNhPaptxx8or568Yfs + eeCpLWSWOxiH0XFc1TCYmndtXOynjsLUaUZNH8L8Pw08dvMbZdOff2GK9j8M/sv/ABY8QRK9pYlV9Cpz + X9UNt+xD4bk1Np0s0TJyvy19ZeBf2VtBsLVUNsqkAfwjtWMFXnK0YnTKeHgnKUz+NfUf2Wfi3oUHn3ll + hV9jk15Dr3w18c2cDrNpkyAE/NtO388V/dzqX7K/hW+yJ7VG9cjNeS+Kv2I/BusL5L2EbD02iuhUK8Xr + EweLw0lZTsf5/PjHwX4svJGt4NNnZjnopxXyt41+FHj6MmZtLmK5/umv9GY/8E7Ph3KrLLpkWW6nYK43 + xJ/wTL+H19FgadEBjgBOwr06WNq0bfuzwcVgKddu1Zfcf51vhnwL4ntLn9/p0y85yUNfavwzXU9N2LLA + 447qa/sb1H/glR8PLgEf2emPQLis/TP+CXfgTTHBSwUD/d5rnxeZuqrOkzXA5P7J3dVH8ruvTz3GllZ4 + mH1U4r5T8S6HqFzduUtZGB54U1/a9qX/AATp8J/ZzbpYKS3queK8nvv+CZnh2W4M0dmoz1G3Arnw2M9l + vBnZjctdX4aiP4oNT029tJNr2zrjrlcV6/8ADaTUppVhhgec9PlBJFf1g6x/wSj8KX7+Zc2ShR2Uda+j + Pg5/wS0+G+hmO5OnJlcfwiuqpj1Vjyxg7nBRymdGXNOasfy02fhnxTLYeYmlXGNvB2HmuP1DSfiHpqMd + Jgv7X1EO9Bz6gfWv7udM/YT8DQ6etoNNh2gf3BUFx+wH8PpF+bTYemR8grz/AKtWd+aldHpTq4drl9r+ + B/n3a/P8UIDFdak2ozJbSJJ5czSMh8shgCpPI4r/AE9vBVl4W8T+DtA8WXEcSPNplpqcSyqeJp1DCQq4 + IV0YjacblJ96/ODxF/wTg+F2r27QzaTDlhjhB3r9EdFh1DTPDdvbT7bb7JHBYB1JVyu0H5XxjaCuCmSe + +K9TLqajLldNRXboebXhFL93Uv6bni3jj4aeBPEvj2PxPrFhH/aPhywnt7OfcTBDAx3lolbJErsNpbJJ + UHpXPTeHlttQEaHfEoOQfvYPQ56nNfRa6TZW+uX8t8GxPbxSRMGZi5OVB69juByPeuD1vRpHvIrpXK4U + jpyVBzivQnh4Ru4xSu9bGNPENtK/TqeeQGP/AI9FYbiDwD1ArotI07Xf7RaKNVVQPlUZzx3P1rJtNHgt + dZDWJd8N5hzgn5uDj6elfSukaZZeXDe7oyzLzs7fX3q6OHjLXsFfEuGlty5ottHBYJHdRES9W9R71qzW + RkQMpHfbxVmWJJAGIIUcehNXliZEHGSRx/hXfGN9DyJztr1OWs9JjsJALZQufmYLxknrWm1tE8RjiGG6 + g9cVvRWaA/IMenNQXKCNAIwSeckcVfJYh1eZ+ZysmnTO+AAAeDgHH/1q577PcJrWyxtfPunAjQ8gAjkY + 69TxXoLXMsLgMvI5yKrS3dt5gvI3eCZWDKy8HNKxpGb2Mm91GaTT54L6PyrqFtrqvKoy9fy5rybRIL/V + ZxJePiNJCevJHoa9G1bTtQubORdKmR55AMednb1yegPqce9UrTR5bKxSzZ1RyfmYfLkjqcd6iUeY2hJQ + TON8TX93fTCxs0bbEwyff/AV3FlO8sCW8eQVwAR3FXIrKwt0Qnl8Yzj73uTWsgSFFAgU5wevzYNJU7Pc + U610kkV1lmjLpNIwJ7k5/I02C2EUAEOFZSSOBzznmtoLESSUAjx1x0NQ3MHlQC8LbUJwB3PsO/4VfKYK + fQo/2mwXcZFAyRyM445//X0xXmfiLWNGZmj+Vltwz9x8oXkg98A8YzzjFdJrCpaxC9/1ijGCTgKM9x0I + 559a+evHmp38lx5U0QSZG+cxuqvsZgeAeADySQTjj6V5mYVXGm0ezllBTqI888QeJbrQ7PUfCulwqtpJ + bNHCBlSC6A7QOTkAKD/dya/EK9/ZxF3dSSSQl3ldnYkZOWOSTX7SaHMmvePdO8LQz/aWunkyGIHGeSME + 5Gfl6+/evpk/s66AkvmJbgH2FeZl6c1Jp+X9feejm7hBwi15/p+h/Oha/stxwQ+c0GGPQYrMm/Znkupw + kUJI+lf0ox/ATRJFxJar+VTD4AeH40CpbLn/AHf5V6Ps5Hje0pWtY/m1m/Ztjt4fLaD5umNtW9L/AGXo + SvnywgD021/RDffs7+Hbk7ltlB6niobX4BaIqiNbdQOnSmqUxOrS7H89rfs1JczeWkI2j2qx/wAM0xoo + hSHPPYV/Q+v7P+hwKXSFenQCs25+C+jWh3C2Vs+2KfspCVWk9kfhvo/7MdvaW25IQGPtzXoug/s7W1mo + d4vm+lfrQvw602KZT5I4rq7H4b6TcbQ8IB6cCs5UGzWNaMVsfmJ4W/Z5tWuhe3UA2ryOK2PGvw4sLawK + rGMqMD0FfqxH8LbEwbEiA4PFef8Aib4KWl/CyNHwR1rlrYSdtDoo42Clqfzl/G3wtY2UMrKoHByK8T+C + PwhsP7VfxTqsQz/Du7V+7/xA/Y+0nxFcYkt92D6Vwkv7ICW9r9jtI/LwAPlHFcDpVYpqx1upRnNS6HxD + d2WlXkPlw7fkAGK8A+IOlWqxyfKAD6V+rOm/sZSIfnLZPII461X8RfsO2GpWrLMrFiO571x/VK172O94 + yja1z+Vn9ou703StPuZZsKADX4ieKng1fW5bhcbSxwa/sj/aR/4JbTePpG07TQ8a5O7rzXxjB/wQz81y + 7GUj05r2sFNU4+9ufO42hUqVLxWnqfzCjTYD1wc496JNKt2OD2zX9Pd3/wAEMHVflaQZHHXtXIXf/BEP + UEGS0g9uc16McZDuedPAV/5PxR/NO+m2gb5iAfrim/2dZ/3h+f8A9av6NZ/+CJeqF8BpOOOhNQ/8OSdV + /vSf98n/AArX63Dv+Bl9Trf8+/xR/9D+9KSeNAcmue1HVoo1K7uleY6p45RSyxtk+lcbdeJLy7JCnA6H + HpXPKuuhtGg+p03iHXVYsFOTXnLSyTPvOR9KuKWkGXOT2zTzEsZ3A/Wuabb1OqnFLQiwvQnOfzpMFkwB + 16U1pArYHJp6kBd7NxRGY3AjlWMJlgOK4zWUtp1K4+Ujpjqa2NT1EIu2M4PYVlWUD3D727msa07+6joo + w5feZh2Phu2ZsiMYP416HYaNFbQ4wPyqxZWSxKGxgfSr6yZGBx/hTo0ElcmtiG9CulhC4wwz6+tSnSbY + nG0Gr8Kjgdz1x1q8GUfWuhRRzObMP+yLbklB+VQXOj2rAgqOe9dA0gVcNx9Kzbif7ytj0/GrcEyFUknu + clc+HbZj8qA59qzG8MWm7aUzXZs2/I/CjYCSH5/Csnh49jdYidtzg5fC1gwJVBx7VC3g+w2D90pP0xXo + qwITleM9aufZARz+vrTeHh2F9amup4nc+CLLlmizk+nFdFomh2doNoQYHQAV297aYBBHOeTWLGggbAHt + n3pU8LCLukOpi5yjZs6S1toPLwuAOmKmNrE/GM8fSs+KUquc44zzUv2mTGDwD7V1KKOPmZJPZW4xwM9K + 8D8RXCWOt3Vnbxiad5lVFdflXvuUhcFlz0JHU89K97JGc+vWvmL4jQXtr47E9nKVdyuEHJGUwWwTzxxw + OfWufFe7FSS6nfl3v1JRb6G7pdzLJAl1qb+XHBuTcqEqcuWX5uucAkDlar3scN1/qnXcACOcHB6GsDU7 + nUVtDZ3rSSC7WOcs5y6lGIDDoCcbwR7+9UYrmC1kUykZIPXjgdO1YSq9Gd3sbvmRoWvhSeS6W5XbvCky + YPr346V6R4W0+fS7Sa2lAYB9+FGcZ9Pr1rldJ17zXFog+bgMDxww/rXp9tPbWoj+QoxAB5yCfzraiofZ + MMQ6m0jYgtXnuDM/KJjbnpuxyauzNKUKsOF6e3pVCymUFAhGMnPaukllEo5OCB/nrXbG1jyqjfNqZMAZ + EA5C/Xmq9xdvbDy0iEhc9+OlaElxFs2xHdk4JzTjIJmwQQF74/zmncSXkZ6W7ykzTKI2OcDtXH60kwm3 + R7cDkn0Pr+FdncwytEyAnnHI9K5W+jVZCOoIwQeQQKib0sbUI+9cq6TNFHDvkQNMoxnoFqIW8kV19qMe + 55QS7N8y8+np+FZHmXQ229ogEsjbstkfyB/pW9BYy3apJqKFZIsDAORkdxjtWXMzrnBLVl5YlkQiEb8D + nA4Ge1RblMPkum1ieM9cdOPxrpLYrEpCsNuc9O5qrKkDiRioHfnvWvQ429SGEKkPl5x7571TvY0nh8ly + CjcMD3Hfp0p8jhGDR/NjrisvVZrM2LSSybV74ODUyeg4J3OU8TMyx7EAkDEtJ7KoJ4Hck4AFfLusT6Xq + mgaxr2oxcNHtVXwSQScgZ44Az7GvQPjD8Q9O0iBtNjuxbmNC7yYztGCOePUivij4zeOpNA0Oa0juVuIX + 0wz21o8TP9pnfohjT5iz/dHUDd0r5XNsbFScVrbS3m9j7fJMDPkU3pf12W/6G7+w7rGk/FP48zeINOty + 1vpcl4kcqgGIjzDkBsA8MoGBx1x04/a99Pgzg45r8tv+CZXw2tdD8KWvjGVriW91iwF07XEm9wknzIOp + wMuxHfnFfqxMpX/Oa78jouGFXNu22eDxLiPaY1qOySRVisYDg4FOOnxqN3QnvUscg+4Pbmp2Y/w/pXtK + x4DuYs2nwhSR3rPFhbxHBH51uTKSDgdRyKwbnzUzgnn0q1FGfMyb7PbmPaK5TWbW22luB/8AXrdXzSMV + kX9sZMhuAabghqbPLp7WATZxgV0+lJAwG0gegpk+mFWz1A/GnxWz7gUyB/Wjkiae0kegWsEZTk81Lc2U + Dgqe9c3b3jxqdtJNqcqH9QM1m0tgTfcmuNEtpDggE9xVA+G7TeXZAfQVKurDbjdRJqw2570ezj2H7SXc + mj0GyyDtGamm8N2kuVKAg+1Z0esLjaTx71rx6qjIO3XrT5I9he0l3OIvfh/p1xL5vlru6dKgX4c6Sqhj + Cv1xXffbo2GCe/HpUP28Kp74zSVGHYp16nc4OX4f6SFO6JenpWDc/DTSJGJ8lMdM4r1R70P9361VkulB + +Wk6EOxSxFTueOP8JdILErbKw9dtM/4VJpX/AD6J/wB8168Ljdzv2/Sl87/pqf1pexh2K+s1e5//0f6/ + WJDYbv0qxbGQuC3IPaoI90hww2/rW1BG6LvYcCuClZbnfUv0LRjWMEr/ADqk8jqSM/hTJ7jDYPSmgs33 + hkGtZ2a0M4Jp6jD5oO9hxzWBqurraREk/SujnZY7YvJwK8p1VZNQuwg+7nFcNeXIrLc78PDmd3sZo1Se + 8uPMBO0nt3r0rQidoEnGBWNp3huNVDgdOM1vRQmNwqHAHGRUUKcviZpXqRtyo6kPuHPGOlAjHQ9+9MgX + 91mrgiyfmPWu5Hny3CJlj59e9WPOXJK5qFY3Lfzp4jZR8x5p2dx3Qkk+eevpWU8u45NXp0YDKjI7ms/a + 5YqR+NaJGLHxrg7s5x61OpDDJ6/zpI1wADSnJ4A59KdmJNE67cgqMVdWUFfl/KqIJyAeTUqY6+nXtUWZ + d0Q30qhOflJ5rFgtzLJsBqxqJkZiAeOlS6aoJy3T361pTRnUt0LIs8HKjpUy24GMj8e4rXUo5Ge3rVtY + 4jgetatGNzHEG4jIxzmvnH4v6Yf+Eos/Km2faPLB3AmNSnAY475IwMjd0r6p8gYwv6V8lftF3j6Prml3 + isypImzKnGcZ45BB7cEEVxY+SjSbe2h6OUxcsQordpnmTahFiJCrPPcpGZZZEwyhCVG1VyQuODwAMdzz + R5b26rcsvnrJu2FOhA44yP8AJrU0y72ECyYSwA45A5XkLyM5+6Tj255ro1SbVLrzGVVmkAAY/KPx/L2r + gjFS6ntzm4vY5fwr4w0+5upUS2mAiY73BBwEOznr3zzXtNpf2F0oubJGKuQuSc+v4dq5CPwvbS3R1Ix4 + lmVUcqME4OecdDz2/OofB2kSaJHJpSyTTC0kKKZGJ+VsMAD6DOK66cJR32OWrOE02tGe0wqoAt36Dqf8 + +9acV0y4jkO49s9/Wue+0i0k3QYjXH8R459a03uBMw3kBuwHT8K7VI8qdPqWLuArhcbBwRjpzUoupCCC + cY5HFVQQdzNjnqD7jtTEC4wzDnoB/WmyUW57kBBtJx7da5C5vlSQrIRuZgM9zWvMmECg8dM9hXLG2juL + 1jI21RwQPWsZyd7I7KFOKV2a0NxJMw+zryOpBHX2NdCIysCmQ/P3z0J9qoWaxWsgiCq5UZCr04960pHI + ++FBQ7Tt7Eep6GriZ1FroVg0ojKxcDpgilmd0iDOv5VYGWBGSCeARU/lzhUE+TuHHcce1VYwcrbowZhB + G/mJ3HAGea5bV4tliGZAipuY5P8ACOfzrsbzTp1cMCGXOPrn+tc/r9m+qaVc6TACJZECMzA4VSeTn1I4 + HvWU07M2pOPMtT8/td8AX2rW2q+J59l7Pr7iGGK4B8tIozvQdQQu9QWI618cfG3Uf+El1e18M+JPDmpX + dhq95b2cV3ARaQlDviaMyEBxJ90Bdyg+9fpx8SLwaFZB55RBDajbGxBZuyk4HP3S2cDpXyl8DfDF/wCM + 9BurDxCkVwsuptc2EIiEKRNH0mBYM7EsSQx5bg4GefjMbh4+1VJb/wBb79Wz77A4qbourJafp+GySP0N + /ZNsDp2mSWGAotLKCArxkEf7oA/IDPoK+uLtAwyPSvmT9mzSkjbXL/JAinW0UdQRGM5z68j6Yr6buAcf + WvrMDFqhE+CzSaeLnb+tDOjOM4H61dTDJjpWW7NG2D9amhuGLYzkVv1OM0GgDpvHaqc9mSOnHpV6GYEY + P5VZITkjkmtYsyaOVmiSNfYVg3U8Ijw+MdBXWajCxyBxXA3yOkpQjk1fMhKLInjikGMcfShrNANvfv8A + jUVuGWTJPXt2rQldUXntTurDs0ykttyNvOBVW508shHINatrKhfOcYrRcoy9c57CpQzgDYupwvNMaymk + Uqe/FdosSDI6c0fZkBGeh9KQHC/ZSgwvb1pkkskaiu1ubAbd4HUc1x95bOrnjHqaTZomQLcys3ynk+tW + UefOCT+FFpafMM9+eK30tUcbupFCkJpHPvLIpCgHFZzXMzTbc4rr7ixSQcd6wpLDbKH7/pU3KS7CRIxT + LFvyqTy/dvyH+FTosm35HI/Af1p22b/nofyH+NK47o//0v7EbZVByRitZEEkYC//AKqxo2kzwOOwNWUu + duB2rzo6npy0JWs1dzn9faqciCB/88Vox3AEZauW1zUU2eUjfM3WrlJRIhByehm63rC/6heg4rB0WKS8 + uvNfOwd6ZLZyXsoXPHXitaF1t08iEY7E4qKVHnnzz2NqlXkhyQ3OtkuFVPLiHFOtLSSSXeRxVTT0LqB1 + zXUxmOGPZ39a65OO0TjipbsmRFjGR2ojuFwCehqlJLn5EBNUJbiRB246e9Cj1Ic+h1cRjYZ7VXmnjT5Q + QK5+DUxt+bsO9Z19cyO2Qcj0HNXyolNnU7ldsHoab5cYG4ketcTFq80asB3/ACqU6u4QEjr2/wA/40Oy + GrnXhF6jkml8obsr2xnHc1kWupb8R9xW3bSGR/Ydapq5N7MsJGoIYAZApkmF4P8AjWkqIE5HtVeaNeS/ + 69KycWaKSZyt1l3x29aID5KBVzzVie9s1l2EZzyMVWm1WyjXlD9fSuiCikYS5m9C0Lx0Jz0NXo9UxhWU + krWOmqadKdqir0VzZEcjt69Kd4sjlkjW/tdeC2cn+tfJP7WF3v0XSb5CA0c7YJAI4w3I7jjkV9TSPZMu + Vzmvlv8Aaku7HT/AlrqMihlS7VcNjB3qf6Zrzs2S+qVPQ9bI3JY6lp1/NHkdprCGeCODBh2LsPCNk8tl + RwuCSOTyBn6eiRPqry7ovK84ZVARuVlOAASDnnH3gcDPtz4FperT37n7XdJJLhAzlcswYhiM9iowCDX0 + H4Ta0uLkRREJbJ0C4Ubc9PzrwsJWU9Ln1eOoOn71j0HRz4is7X+0HikuvPKBbaNggiXHPOcOQSTkqPl4 + 479qlvvlZZMBmH8I/mfX+YqGG8soImnlmWKKHDbt2AuOck+g79q01kefy5JgW3j77MCT6AAYB9sHnNfQ + U2lpc+Xqczd2rf1/Xn3G2thehFiuf9IfH+tYjgDgDaB2Heugi0SCKFVX5nI+YZzismLcMeczuAQdp46H + oDwevrXVRfMglRCPTI710U7HJWlJbGT/AGTL0Venaoxp1xuZGj2sewHFbSXFxHKctkegHOKkF3eF8rIX + x0GMYNVZGanJGX/YDSAFyrZHBB449KLPQ9LukKPKEK54I4/P3p0k08jhZWyO4z/nFMN3K0LNsX6Z7+tK + 8exV59zO1G1s7WYeQxJwVJ+6M9cD14HaqlraSL/pcaeUExtVsFc9yR71pTXCPt87BaNgw65XPcf5/Cr9 + 3d3qwKqSRPD1AK4PPuCeKmybNeaSVjEgktbL5ZmkIKsECjcNx/HgH17VbTUYCoWUdBgFe9Zc8keXVIgD + uBHYDPPB68U+eJWQEx/dG0en/wCupu09BuKerHzzCScSQuVRQQycBXPHOcZ47Vxut6hHaqbt2YlMsNpw + QB2PI4q9qEqLEqy8x7gcZycjpn2zXkHj/wAQQ2enzsgZxs3Mi9SwGcAHqMdfXpXFi8QoQcjuweGdSaij + 5M/aR+J4W8tLq0lghcylLaO4lihRpdpbYZJvkJbjsR2PU10fheC10/R7PT7+PypliCyQLIAFYcMoxgbB + nk56mvhrxR8Pbz46/F2DVpV87QtInF0GaXCY2lXVUXIO7ADhgDx15r7KggmtY5G1S2TanlrtfLgjG8jA + bGdg4AxzivgqeMlVnKrNdT9E+pxpwjSh0X9fmfo38AEjTwD9viQqbu4eZgeTzjg4AHHQY7CvcUl3t1ry + T4E20sXwr0uW4xmdXmAAA+WRyV9e2O9eqRja+1vXNfouGVqMF5L8j8ox0r4mo/N/mQ3lsMbl6/SsVRJC + 5yT6V1WAy4rHubQqCR/+utJRMozCKX5eDyKuic9eaxos5z/k1cUOfahX6CY66uEKluhHeuQ1G5jJKMOn + 866Wa23YOcZri9WtGjbcTV8txKVmMhk3ksvQ+lXngZl+7gVU0tTglq6mJkMZQ9Bz+NJKw3I4mYtA/HBN + WLeVpWx0IrR1BI2b5e9ZtviNyCBQC8zQYZBYnnsPrU9scLtx9MU0tGV3gilRyCHBpiL3leYhD4H86xLu + xBbbjkVom53Hk1bEiTLnjNAJnJpatF87DGKsiRVGTx6/jWnMFTJqp5Cv/DSsVcpvIO9Y91L8w5roJLRE + jIzxiuZuVaOfBHDHpWckaQZXKyHkNj60myX++KvqibQGXJ9cinbI/wC4PzFQUf/T/sSDnJycZ55561mX + MhV93XacmsuPUv3myU45zmm6hchrfZEclhzXnThKDPVpzhNElxqyRoXZuffkVzMP2jUJ/MY/M5wB6VTS + zuLi4VGJCLXouh6dDCDKRk/XtXPGMpSvI6ZuMY2iY50+aCHaep4z6VQSGQSbCM85NdtfTWar15rItUFz + MTHjANdvN0RyKNveZu2MKx24kXj/ABqG4kYvsTuec1pqqogj21GkcO/cx4HWritUYSejsVlYxR5xg9zW + HdySM25ifbFb899ZQEx5/E1AywOu4EEVq5N6IxUbas5yR2RQo6CmhhORuP1rXntY3Q7TyelV4rVYev8A + k1LdjSKuc3fJMJf3XAHP41o28YWDzGxkD9a6EWUckWXx19Kie0RVIjHQdKLsDnrK5bz2bqOor0DSXLxK + /cmuTt9OCnzgAvP4VtLfxWXytwD6VUZaGc1qdjLISPl4rMvW3x+WSeaxxqvn85OemKks5vPuth5FXyu1 + zPmS0MafTbyZtwFVZ9HvHi8tRzXr0NlH5SnocVBLZQD7vH400kCmzx+DRrtGHXNXH0+8C7uo/OvTjZR7 + MkVA1pEq5/pRYbm2eZfZ9RDDAOK+bP2ubPWLr4KXkNnAZbhriFI1AJJZiQMY5yM54r7gS3hYcen5V8+/ + tS2V03wL1xrCQxOiISy8HYWAdQR0JUkZ7VyY9J4aovJ/kd+VVHHG0Wv5l+Z+Xfh3WtEsTctqd41vEYiZ + Z2G2OFk2/M+dzFdoYHHI684NfR/hT4q6Pp9ougajaSRzeZ8k7xuBsZQQu7GCD1BFfn74TWOVxorA+WrB + hGG3qWBJLAjg5PHvX014T1UxbLefd5YAG/A2jB4x0AwOOn1r87oYycPgep+vYrAU6itUV/nY+rk+MVpa + 28IsYbiZnIBKw7htzyCDnt3r0iPxze2k4sptMuEE7eWrFQJNy9ATu3rgHqwHPTivn/QNW0+OUWLIZ55R + hoth2mN+OuNpJJxgHPfFem6XKmjxva6cj2ImXyyssTifZHldrBwcBjkZ3EjFe1hsZWd3KWny/rU+dxeX + YeOkaevnf79O3o7npWm+KdU1HUY7KysGQOTmWZmYgjrhf5YzXrtpqqXEAZtgdhlhG28A+mT39c14Bp98 + 8kyPFK1uVIZdspQnH8KtjIJ6V6XYXcU8e6EMqjk556njnv7mvcwOJk78zufOZlg4K3LG39ep3v2mNnMa + 4yR645+tXkDK3HUAfSuc0kxljsPPX65rUadmnABx7V60Xpc8CpBJ2RYvOFFxECAeo6VWiyyggbueOOcf + pUUyM+4SHhffNWkuPLtwWHXpn0pdQ5dC1LbweUJJ/lkfAOe4PoO/8qifTyE3pGTGDjIGBxz+eKx31QG4 + QFY9jtteWaXaIvcdsexIFTreajqMjG1SJrdANr28hZnDHpLtyAB6DGRS51t1NFRna/QeJbcFChZYyDgs + CM+5B7e1Zt7Z/apGTcBGFyck5JHPGKq3t/eSXi6enliJWcykg7iQMYUjpnHOQelYWpeJ5dIjG+VhHJlW + BG7I7ZIH5c1lOrFLXY2hh5trl3ZX1OcCGVRuC56ngHpkA+xP1r5z+IcrWtndyy5CwxM4fGT0I4FeuP4j + g1u/utHsLd7OW1dUEl9thimLqW/c5yzhQCWIXAFfl3+158a/iT4e03WNL0LUrO5txPFZW1zC8jQAzHaV + yBkOsmRkDkAivnc4xtOnTvL0+Z9TkuXVJ1LKytq/TTt/X3He/AKysNL+HVzd2ME88813IgYAHzJB/EB3 + Jz09Byepr0XxE1roWmW1kskMRV7idyxUp8keD8vRlXnueAfSvm79iC+8da18Bbfxh8Q1ik1K9u5ltEAe + 3jhsUcRlto/iYo0g7EkZODXqmrS6cmux29lZ4VI5SyMVTa848reYiWG0jnGeR0GeK+Wi/cpxsfWpe9Ul + fufrz8Mobqx+HWiWt6weZbOJnKgAFmUMcAcAZPAHFdqJ/m5NZ1jZfYdNtrPtDEiYxgYUAVMu4k7+eM1+ + pRhZJH4rUlzScu5fWbacnPNOlKMvPpzVGNyDtOKla4G0IuMU9CSg7BBwe/pU8VwH+U/T61A/zDLYqgt1 + HA+HBGPSpL3R0uAwIA/pXNapbecvOTWpHqEUoNMmuYwpDYP0q2QclbxPbgq/XsakN1tJzxgetLqM4VfM + iXtXKvNO83zA4xSRZty3qEbQapy/OfkO71qv9jkfBJ4z0rr7DSg0IOOPSnyi5jkoLhlJVvu/1q4Z2Vdp + P1z2q9f6a0WSvQnNYYSVWKHr6GlJdiotExlbhgc1diZl+c5qIRDyxJg9ADUqzxoTuIH1qbjaZbkVnXd1 + x/SqwufLkCtz3prXkQHlqd9Z00+5sx9KlspRudCsqSL5Tfh9KxNQtFPD/eXkGswam8bGNuoOM0+bUhIu + GPI7mplqUlZiROUUjpz61J5x9R+dYv8AaFm3M20mj7dp3oP0rPlZrdH/1P6trvUy975CjgdMV3uj2CSw + hp+hrN07wis4N9KPz61aErWcxhdvlHauJOVTVnqOMIaRNiWwQcQgcZNZ11fTWsZVeDQmuW0EoSSTrxWh + Oltcweah4681SXvcsibvl5onAyXGoXl+EwcV6LprQWIBl71m6XDFNKQOCp5rRvbZXkVYscUKMYy0FOUp + xSZ0dzc2ht9y4BOADWbDLbsDGDuNYNzMYXEOcL0xWtDDlRGnGa3jUTZySpSS1OI1xLme7LQEgA0+1uLl + I8gdK6iaCGDOTyeM1DGbYjgDFaOouhKpvqZKX83neW/bqela0cvmJuJ+8cVRlt4pJSyjOelTvNFCoDjp + 71jddTZLojZhkXjuR7U7yyw5HJ7VUt7yJl3VNHOOcn3NJSHKmTSOq9ScetY1yiO3zngUl5PL8sa9Cefp + VWKQSoWbAJ4FQ5a6GkaatqXYkjgTKnPf161taUCGViK5UbvN2Iep5rvtMtgIQ54ArSM29DGrBR1OiS6w + mxRilMm8g85zVUKV68ipQ2eB3PStOY5i8fukj8ayJ3lGWB64rSMiKu4YBqqxV3w3+fpTuBjpLKHKuK84 + +ONlZ6t8HPElvqEzQQrYyTPIg3MgiG/cB3IxketeqzQqULIOneuB+JVvJd/DbxBbxgbm065IB5XIjJGQ + eMcc8VlXV6covszow0uWtCSezX5n89Fp4/u7JLWX4aNZahNIwAa4QFktzIMusQyEYjBwysFVs85Ar6P0 + 7XvDMuoz2OiyG5ltdqXZjgaJI5z8wCbuWQqVb05xz0r478C3NmJLC4S7triS4hPmC3+Zo2LNgNwuM7cj + HHTvwPrXwvpuvXEfmaGzN9lIluCqeZmINyQeNvJHPPf1r8nhXfM4WP3upQioqd/0+/Q9r8L+ILXV7NYf + DMK6hp7BvL1WFxJbGRTtMBiYBiwIJz04I9M+0eErzQNEMWoT6lLdW8GFuru3tJHHmqPuqjfOSDhWxyDn + FfP2hW2raO0Om2V0lxDb2wbBnlW+SVydvmSZIBYDcGKFlzkZBxXuulz+IbeZdD1Vk8+GHe7yyzXNy7uA + x85FAVZeMKxUfKckAGvcw0tbrdW/r/h9dDwcXBNNX0d+17d9U/wVtdmejaT4k0qDdLbWOoFgpgZjsjHm + uP8AWLnOY8HnjPbrXoVg1sCqI7BoR/q5CAxJ6lQCcj8TXm2n2E+mWX9oa0pitsKVTKh5GcZUR7iNx4yR + nIGTit3SNajCIFt4ohnBCZb5c5yCTkHtn0HSvYw1Vx0qaHz2MoKabpa263v/AF8u56/p9wpiMjZQLjn3 + 96tQ3zGfJA5/irgF1hGARnAZvX/61aK6lIqAEjHc9a9mOJVkfO1MFK7dju5btNhKn5lzjjrWLcaizLtJ + Py5zXInWpuI3xz3A7VUuPEFmgLOw6YOPWpni49yqeXz7XN2NLrUbkWNunmmQ4CqN2QOTxW7aXCwMLi7/ + AHt+zH7OzIRHI+eMiIDaoUfxHqPWvKJJ5dUt32ySwbv4oGKMOf7y4I967i2+3W9m0c8zpBGm1THGUkHq + XkQ/OBg4Ay3saxpV+bVf1/Xc66uFUVZvXtb9fzWit8rXr65k0dJdSnt5bqZNpCOPLikZ+QFc5OMDqV/x + rknlmlsUMyQLNMcvGJBMQSMkY6nHQce/FTXWpHUkd9EgM0ODsmnZmDjnaVQEOG2jjcq89ttef63rpkDS + veXNxcyjZEpiSBraJRyCBtYEnkHLc9eOmVaulrfT+vmdGGwcm7W1+d/8l13t2MHWxpesX8Ol7Ibi6sla + SOOBYmuiRztTdKpBPXZtBbGe3P52ftI6VF8X/EOnfB65i8yzvobh9QuArR3FvZ+XtSXyZF3b1nMfCbsn + J6E19JfE7XDoWmXX2m6bS7aRNzzGKN5GLcD97yyqq53bRz1BBANeDfD3VtA8W/FGa90q5g8W2V1bF7bV + bSB98MakobeJLhVjIk3eYXAwv3QRjn5bGYqNSSp+avr92m/Tt9x9jhMHKnB1OlnbT79duu1/v2XpFlr/ + AIX8G+GdM+G3hfTr3Ph23t7A25gZWCxxLyzsETc0f7w4ODnkHIFZfhyK21f4g6NoWpwG5+03tqqyl1z+ + 9uAcOqAAsCoxkLtAPGSKXVNDXwfG/mywaRaWxkjtyN0MaxR5OZ3lbqp3ZkG1QD3rH/Zqs9Dv/wBpLS9M + 8MXEN/brf/2pNe2YBtZiUEjhQowCHJBYnnHy98c1Nyq4mnFKyul/XyNMSoUcHVkt+WT69F/n5/efu8q8 + nc2RQYxuyapJqtuT8pFWTdxMCVPSv1A/EyKa33A7O1Zz28u3JJBqy+obGwgyaaj3E/JGBSshmNcTOnBN + ZkqNMf3YOK7FdNVzmTvk4x3pJrOJVztpt6AtzjooJlOHOc1qxWu47s44zirohGM45qWFSFI71lzamjWh + iyWQ+6PWs6S3CD5xjH611xSNuZO3tVG6a28ojPOOKtvQlJmDCA6kLjPrWtY3TxN5Tnj1rlo7+Fbgwk9+ + 3StuGWFTuBw3ue1ClcUos6K4UTRHB6VgS2qA7OOa1ra5jkXHGOtRX28ZZe3amSYMisoIGRnvXF6/bXyw + F7cbm9h2r0OSNZl+Y8gVahs45kPmDPFZzjfY1hOzuzyXRoL87kmzg8giuiaykMeWHI6V0zWkVucAZGfz + pPMiD8Y4OCKlKy1Lcru5xkmkyPjcc5psugSGIrzx+NdlPIsakxjj261yV74lNtciAjKn9KTY0nucfNo9 + zHIVcH2wO1Rf2VL6N+X/ANau/wDtMM4D5HTHNG6L1H+fwpWHzH//1f7Cb/xBaWFvgsBgV5PqmtrdNuU/ + eIGBVPWNG1vWZQQxRSelb1p4QgigTIyTyTWVGEYayZ21Ztq0Ec6NEu7hxcxysQTx7V1Mt5c6ZZbJCcDv + XVRRWVlCPMIGPeuI1uSTXrgQ6fygPO2sK0oufOdVBS5OS2hveG7pjCbhzx796hm1PUHvC9uMqOPrUtlZ + nTbEwLkuau2hS0t/KlwZDyTUqN0E52d7EcFxLNIsl0mMdfSukfUo1j3cDsPpXPyXG+Mfnx7VjXl5KVEI + HpkVtFKxzTbb1Ohnuluef0qm1g6opzx9a4m48SW2nMomJHPJ7Vp6frx1px9gyygnJrWNGXK5dDKdSPMo + nUjesq81DcQs8+4n5elXNPtbuZiXxx1BFSTQSpujJ68e2KSp6ajdVKWg+CONYcg9OuKgWWQBto+97VYE + KoASTnHND3tuqGPAyP6UvZIPbMyz9qnu/LAPHHBq1NYSRRbx1qhaamn2koeSWz+Va+p6gsUOR9eKUqdn + YqNV2Mi3fybhSepPr3r1jTHAhDY5rw+IzXl4vk8heTXq2nXvkwBGHIXOaajbQzqO+p1Mrhe3FUmmIIHr + VeK7EoG7kZ6+tPZhI2T9aZnY1xmVdxz60scfynbzVYSA4j3c9MUPOsXy59/zpohotuqAHP5+1cv4m08a + r4X1SwXg3FnPH9C8bD+tWpr2R2Ma9AeKYJB9neNiCXBXA9wRTkk0ON000fyH/BvTdL0CWLVoIwk32oxX + L7tzs9uxCAk88JwOgGa/RfxZ4OtPEGrQX2hajc6Rd2G28029spDG8U7R4DEA7XUZBKMMHAr8sfDOvXum + nVdMjWIfY/E0sfkq3C7RwAfXC8A1+mfg3XbPU/B+lXtzNHE6IImeRxGoUE/MzHgYHUnAA61+LVHKFdu+ + tz+koU1OhF9Gj23w9qHxCk11dM1eOxvdMktFuZ9YdjHqE95gKUeJQI9rYLbhjHQA9a7SS08QaL4au9E0 + 3VpbPTplSFNQe+W3m0lZGJdonZWeYyc/6wsE7Y4rmdJuWtZzaSNG5jbYSjb149CuQfbmpda8O+HPFmqQ + ajqkMksllgptkZELI29d4BAYKwzg5FelQxUk7vf+vX+u255tTCRlZdN9v+Cv8rdGrp+uaOsVokV3bmWW + E5kUhixJkHJQE9WHHGOuK7OPUbDV3ln0aO4tYYpfLT7evkPuXGSQcADPrXhcUUZu4b+fJmjj8tXBIKo3 + UV1Okan4y1NJYviVqGlJ5kix28kcZtoVhQYTzmcndIx6twOn1rvo4lOPJ1/rr0/E4cRgXzc9+nn+XX8D + 0DUNY1axtmi0+5HnuvyvIgZUP6ZFdUuoeJlt4ZrhIx50auu/cuVPcexrgZvO1Fc2kfmlY1cmPkAZAz9M + nitiK1v9NgFr9oSEfMbi3GyRxIOgc8vGw/u/LkdR0rohWkru7scdTDQslZc3mtfw1/rpuaa+INTmMkUn + lqQxClAeF/E1bgikv2lEcbsygNgKzgEDnJ5wMAnJrkNTWz0i8e3mvoJ5UVSyQkyEStj5G4G1lByc8Cr1 + ndX9hq8+hSWyTyRGSKRIpS3mYGd8ZGRuPHGDkDitIVHzWqen9WuRPDpRvSVtL9tO+ttP8z0rwXa3h1b7 + PBEXjVHYqvCNj/ax0J4Hvin634ujjkXRbDUpLG5EoDXUMYxZucjpJuAbuVCEYJ71z7+LvAug2oZ72x1G + 8RB5lhDOs0sUpGQGwMxvjnn7uD1zx59rXxD1Aa39t8NraapZXQQvHKWSe0mXOJBKEG/b02cqSM5rueKh + RpqPOr/f/X5ryPOhgKtes5+zdraX0Ta9brbvZO272Pbde8TaNJpEcjvHNbhgks+923yqpBZQictkcb1G + A24V5vcatKdP+2XqSxJKzRWXmK8szFBlmkfc8W8kjjIJXBwTmuCt/F895dyaJ4dXUdNu0+a/vmWJ7a6h + Y58pMgkMf4mwCMcVy2u6h4Mu9SfVfD+u20l8IF+0LHdsY7RQTgypnZG3BywGcDGeK4sTmSmubR6en/Bd + vwfVndhsodP3Hda+v39Ffv1Wlk2eZ+OJPFXjWa8/4Ruxtri2szCl/v8A3hYMSQ2F3uqEKdxiU4AzxWd8 + K4P7K+1apo8kb2817NKsMXmeQscr7z5CELtO4kDcgAU5Ir5j8Y+P77VfHEWtWulzSPbB4bKK2v2tzGkw + Kyn7RGodlkciTY2cAACvt3wILzTtIbVNYlmuXhhRlE8vmEsRzgnAGTkkDgk5r5qOIpzk5Rld3d/+B2X5 + 76H0NTCzpx5XHT+t9Xd/cltra54F+0LaavrX9paXqmn6cljcypKLvJuZ3kUGMqQPLC4RPvNuIZsdgad/ + wTp0jVrr47X6LqH2nT7CxY+Vgb/NLONzkfxEkl+ByRxiuJ+Itx4dtNQ1HWVQR311J5tzKPvNj5VGecYH + HHrX0V/wS/skvdd8R65KjoUT5iVwu6Rhxk9TgE//AK67MkqOrmVNdE7/AHI8/iWn7DJ6z62t97SP1ot9 + HuppvvEc9O1dVpmmzW/yytn9as2yqXBJ5NWGmkjl29jxX6ufhWpfFhATvxk1YaNEXI4/pVWW7MceehFV + orl7iNlIxnsaQExYhsL29+1WS0bqM/xVHaxfNhx1q1LbKnzr25wKTGmZMsPVVPXkEdjTQinDEYIqzMWC + lu3aspjJndyOMGotY0TuQ31yltESp5x3ryS/up5LpthYY5znFemz26zOC44NV10e3kkBA6evvQuW+pV2 + loeJXf2+CX7Rk468099R1aeIC3JNesa/pCmzPkqMgdK4TQGjjc210uCpPB61pUSlG8RQk07M2vDs975S + /aTkmu/jlFxHt6MevvXP2k9lE+Oh6VcaRjMGg+7n9KlPQUlrcW4R4JfLz8jdDU0Uj221SPXNTzJ50ZkX + k4yK5+fWIrV/LuRz60JrZiab1Rp6o7+SW6N1ri5NSk3b14I4Iret/ENpeTC2/DNNvtPt4388AYPUetCg + m9x89uhSsrwTLsbnOeTXJ6/boJg6DDV0zWwRvNiIwaguLeO6Tn+H15rOUOhrGfU5CG+cIA43Ed84qX7d + /sf+PCtRtKjY5XkfhTf7IX2/So5ZF8yP/9b+wNjEPn6LnrXO6p4ktrWMlOQO46iqWsavHaIbSRtjevSn + 6Dp2iXFmxDGV8ZO6uD2kU1F7nr+yly81tDmorxvEMhhLHaTzjg4rpotPg0SLy7TlyK0Eg02xjLQKAw4H + amWtlc3Ns89020dRmtlGMnzPRIxlOUVyxepIly8OnteTAEqM8etcda6pd3UrSzIQB0HpWtoMbT2863Nx + 5hRiMH0+lY03n2MrPc4KsflA96pRTsyVLRrqaUc4ndmU/Mvb1rMtbXUbvUTM4IQHFa9lBGf3mcEjJz2r + pLSQpGY1G7HH51okkyJSdjndX8N6be2bLwGbqe+aw/D9kuiRLaWRD8/Mc55rs7uGONBGTgycVnWvhzTN + BkaezLbp+SCc8/jW3tfdszmVJ810dPZ3rKDFkZ70XcnmOAhyBySPSucugtk4SNj5klSXcl/p2mvJaRfa + JD/DnFTOTtccIamwoaeYyJ0Hanf2agUzEde1c5o97qNzF5LweU7HLe1btxcyxJ5RJYVKk+qLlFXumQ2m + m2wmMqnp0/GlubeKc8ngVppbk237snOKoNbuEYP94foKmU7scYtIj0S0T7SX6Kc44ruPsKiMsxwMZyKo + aPYJHbhjzxWlLcKiMtOJnPczdNmCSvGwrWmyfmTg81lWIyGcjv6dq1UYbQp/LtSiu4SfYagk3DccCor0 + OoznpWwIgoyef0rPv5E8sqoyc/WnYm5ixC4lkHOAeuaufZ3XDdRnNakUEZgBX71RR3FushiLAk+9NaBq + fxPeO/P8F/tA/GHw5qEhX+ydclmRQQSJPPYoCCOjA4B7Zr7Z8Fanb674FXw94gi+0wahE8dzARuDJKMO + DjHB9eOORXxP+2PqNj4L/bm+Nvh6VvKk1DUDKJX5BDbXHHsSRUXwa+MULeFra0eXEqkIvIYjtwc44PQ5 + 4r8TzpunialtLP8AQ/rDhXLZ4vLqE0r80b/1+B+q/wAMk0TwN4dtfC3hZWisbIFYlkdpWGSScuxZ2JJ5 + JJNex6R4nih3iedwC5Cjbxk8fzzgV+dfhv4x262zt5obYjYzx298GvRrH4rWLrGIpthH7vb91hnsMHHb + pgEn2rzY4+3U9ufDFR/ZPuu+10COJI7sTS8ncg4IHQE9sV0Nr4r8GS2C2HjPX9M8PK4YQ3WryKkDSoNy + LyCC2RwvfFfFWnfE+yuMiKcE/dx2Zl45JJxjuOR2qDxFqHw8+J9gfCnxF0+01yxR0mSC7VZIjLD91gD6 + Z9O/viuqhmcY1E57f15r80clfheq4cqTv30v+TX4M+6/D3inxn4p0sah8SNVstR1QvnztNthaW5hx+7K + KCcnHJOTknI4re1TxH4ks4ZLvwW1hpWpPFGj3jWYuDcKvDSTJI2JJSny7u3FfLlr8RtNhiSKEpGiKFVV + wAoXgAAdAOgrQh+JVs7FROCwHAJ5xXQs61cubV9epwS4UqbKmuXtZW9LWtbytY+nZ21Vbe01W7jYWtwz + xRzsQAXTG4Y69+a4K5+LGoeG/Ex0Hw3ZX0OsXFuz2Ot22xrazkHGZFbOWHUKRzXhs3iLQJdWfXtqm8li + ERkDEsUXJ2gZwP5mqGo+NXiaGaCRk2DDZGGA9/f60v7YjF80H/w/9bdUaQ4VnJclWN12tZfPV37Po+q6 + Hv0SxaNbS6hcGO51TUXSTUL4RrHLdzKuC8m0Dk4/Cm6Z4jS8udqnaSDkk8jHYV4tY/Eqy1SM2zyIJVBL + I3Af3HbP41Bc+LtOEi/Y5EikK5f5sMATjOPT34rKpmib5uY2hw5UScZQ1Pp251qKOMeVJtGOff1NeJav + e2PhWz1Cy8NaTY2qanuuL2dI9kzOedxC8MW5yW5H1rz5/iNHZf6HLLnZ90Ywf8eR06/jXB/En4jtPpjC + CSRdysjSKApcEdcZ3Y/2uh9zxWNbM04NpmM+H50VeS0/y2MLwbIura5JLJGpKySMSvJ2j7oIJ7AZ4A61 + 9P3HiRR4La6klKxQyAswOGAQZA/Ovz08CTyRZuJ7lXExlX5iG8sZx9RnGec8HNd/4k+J0Nh4T1HSvOTa + GRjhwcqv068kDtx2rlpYhQh5s1o5POtaS2Ob+PnjGbwz4QHiK7cx/bnIQjJJBzx0IHqM8e1fq3/wS48L + T2Pwdl1y/J+03YjMh3biGJYkE9z796/mo+NHxvsvFEek+D3jJYTxpPKjli4U4RQpyAAGJOM5JGcYr+rP + /gnHpc8X7N0WqyEs91du2GXG0IiDGecjPrX2HCVOTxsJSXST/T9T4DxJh7HLZQvvKK/X9D75W2baPLzn + rmqkguWbfggjjFa1pLMEyR2qxMgMJkHU9vpX6knc/Ajm7rVbiGMmdSFX0rmYviZpa3S6dErvIW2kheB+ + Ndo7WsqNG65/lU9joeiXK5WJA+fSpkm3oy1KKWqLUGr74xOwIJrae5EkO4D0rLS1s/N8rIJX07Vd2eV8 + vX2qyLEkAV0PTPTHSsySNVYqOvWtRrfC+YDtHWqUxjALofak1caZkCIsdvU5qaLkYPOPSo5oZDGWQ889 + e9Y1peXquYphyO9RYq/Y33VZR5bj8K43XvDAQ/bYPlK88cV2STgkMB83amtcpfRtaSckDFWvInU8+s7a + KdMqcsvNaqpKqblPH8q46/e70a/MMIO1jkelbf8AaFyIhvGDjtUKL3SNW1s2bQvGhOP8msTWLaPUQCv3 + u2RUtvepcDDY+tWYrTLmT+A/zqXG400mcxbafBC3mx/eH861F1OCUCGZvmxxVTVrOYN51pkdMiuO1OVX + XchKyA89sGs+ZrQ15U9Ten1R7KUhwTEeje9Y+r6lMkPm2jcHk4/nWppb297Y/ZLjlumfWsC7lSylNg3P + dfpUyk+5UIrscFc6v4g84kMBmq/9r+IP74rr579beQxRxjHuM1D/AGs3/PJf++RXM+b+Y6k1b4T/1/6s + LnS49aeS/smdipAUMOCa7WztZbS1EaIFfaATjvU1q62USRRH5Y14yOTW5AsN3ERKxbeOOK4Y0lKV7HrV + K8oQ5b+hza6Pcmf7VORtHOD0zWXqWvXEhWxtYy2TtJXpj61v6tqNnbyR6EWy7kZAPIHvUm+yt7hbKyA4 + GXyOmatSu9NloYWsve3epxlvBJFdlIAQrj5u2DRYaLqV1qL3V/J5kIOI1Hb/AOvXZrfWr6g0Ua7lUYJx + xmi6vo7Sxe9hAROigc5NbSlezZEI2bSIIdLZ5AFAKRg5qzYv51+Y0XEKdajh/wBF0k3Qb55emeOT/Ksy + RrzTtOKp888p2hQe56/lUu+vl+YK3ff8jWtpIdQ1GSUfcj4H4VVSNdavJJYW2pCeD2+lXLe1bTNHW3uc + CV/Xg5NZ1/G2lWItbT/WzEcD1NN6b9PzJT5r26/kXtN0wX0zXbhWCcD2xXSxWCrI0jHhRS2AW3so4yu1 + sc+5q1MolPkRk/N97nJxTJbb1Me6s2gha4/vcCuVjs52vgHJwOuRXVS214ZBFC/7pOufWtOOyjgxJK27 + J9Kb7ji7aHPxSNEpjbPHANV3M0qlkJG7pn37Vp6jG+9tnGewHas2cyrNb2R4aQ/p3rOdty4ts6+3YW1o + iMQGxUH2i2kBBwSaWSMSnyhitiGGzY7NhOBnGK0Wxzve7KMe8Rjbwp9qi863A+VwW9K1p5YkjKouRjtX + PSQQRxOTDyQcUbCWp0FlNDKm/PGKp3ccRYSgZArB0i+RY0gcbCSQM963bma2SMjp2xVRd1cJKzOMHjfQ + V1n+xnuFEuQNueas6fbW19qj3cbZVe9QReH/AA3dXP254kaYHIcr82f0qfSoAplt4xwr4B9qz5W375rz + RS93Q/hl/wCC01y/w4/b58f39rCI4782blwSN5kt4XJ/Nvavxwg+PWv+FbaO406f5AwWSNjlWB6elfsJ + /wAHEemnRv28Nau3Yj7doGmzj6pF5Z/9Ar+ZrW9bYiSEsTn14PHtXyeJymlWrT543uz9z4L46r5bQoqD + 0jG1ntqtfyP1D0b9s3XNP8mN8APEpIY4GSeeB0B9MV9DeGP2vluCwnn4KYYRuxHHJHUbhxgD5foK/CQ+ + Ip9kLSNuAQAfUE13uheK3hcOjkI3UA5/nXmVuFcM7uKsz9vyrxRw+ItTrUkttep/QJoX7YOn2Lrf3yW1 + 5GUfMNyheJkYEeW4VyTgHA2suWAPPStuH9rl4LWO7EqR9CQZSAp99i4IHI5A5wOlfgY3iLzkIllZsHIw + x69ulaieO9QDR2kUny9cg8j0xXDLhOlJctz6inxjlcZe0qQ7df0P3mi/bUurbz7iFpJra1kjjkmVSUR5 + NxVSfU7Wx64NdDYfthiSFtSiv4yqZMmN53EcsDvwVyMY9x0xX4cWmu6Y3w71LVZ/Ev2XU/7Qs4YtFMEj + tdQ7ZC8/nj92ghOBsPzNvyOBXrXwb+FHxM/aAg8T23w4v9Ojbw3o82s3MeoX8ViZbe3xvSDzSokl54jB + yw4HNc74NoJfF956j43yWpe9K1vxP1p0b9vG1jvntp33bxtibccqT0II5yPzrso/2pjOy3V/IbneuC0k + 2zjGOTwR69K/nS0/xrfW1zFdCUsANyn+X4129t8VdQMXmyysCMnknqaJ8HQiuWMtC/8AWnI8S/aU4cjP + 6AJf2rIdCzqVxNsRACcHJI7H3rNsv2zND8TQzeXbxfb04a5yfN8rP3QR2yAcDvX4J6t8R/Emr7LDSt0k + szLtjjUyPM/YbRkse3A7VQ8J/EbVLGGaYSNFOW29SOnY/jWb4OVvaNiXEmSpSw7V6j1T6I/ow8L/ALRC + eIb77LLqAjEDYlPOcAZx82QcdjzkenQfQ3ivxDpjeHf7SLFxswTzwoBIz7HOa/nL+Afi/WvFfxE0vw6L + twJLiPgnK+WrAtuwR8rLlPqR2r9d/jz46Xwn8NZYreUwt5I+UnIJxjv1/pXymeZf9Vr06Cd3I+az7EYe + vS58P8K3Oc1j446X4djkmgvsShmCwvtfKEAZ59PT8K+XvG/7ZsmkK1rIWktZyyylFZnG0ZGMZwpOOK/O + LXPibJeSXV3d3DCVZF8qIruV1OcnOcLjA4IOc+1eXat8QJbexkt0ch5gwbBBBX/9Yr6/CcMxaXPqfPS4 + vwOCwvJyq9rd/wDL8z728PfEOPxl4rsduSs8oZVfGcMQcd8e/GcV/oV/sEaVLpH7KvhZGXabqOedx6Fp + GGOPQCv8zT4CX17rPjnSbWByc3EMKrnrudeP51/qNfswaYulfs7eDLfy/Kb+yoJXTOcNMN55+rV9dkmC + VHEtrpG33tf5H86+IWfRx1GEaasue/4P/M90t9wk2Dp79qdI4kja3k4z3qaQxoqyLjp2qK5VmHmYyp4w + OtfVn5QYkdhHCqwWrBvXPNXgZoLgHPytWbaQk3v7pHQLzk9CK6Se3kOJCcj3oslsDK6JBDN55Y57+laj + 3CSoMcD9aovHDPFu25445pNOIVfLdeRng9RQvIH5l1rxdhRjxisVb+DzSkBzjrWiUTzyrA4x+FU7i1tI + 8mNcE8UmNWGJK3LE4GfxxVMRMZSIyMEd60IrQPa/JnJ9azXtmTDI54qH3LXYZuuoJCGxzXN6zdX9vcrd + adjcOq9OPSt4efcIULYb1rGvLC6RG+ysN5HGfWk72KVrnF+Kry9vIo5j+6k+nerug6VdanY5uLgg+x7V + Z1TS78acktwPNl68DHSud0nWXsbyO1dXHnnB4wFPvXQ7KneL1MtXOz2Orfw1cWkTGOYnngVFY3OowKUn + 56itLULbWRIos/mz3ziuCvovF0cxCAYGa56cZPU3k47G7JqdwkxZvutwc1zviS6i0maO/kAaGXCufr0N + XoNUgjtWbWnSMDvnuKZ5+heJbZrBJFkRh8pzUVLyT5d0aU1yu72LVm9sxWaEAZwcjmmeIbD7dbC4gH7x + P51iW+l3/haxk/tKQNbxHKsOoX3qa216zni862lDq+QBn+lQmpLXcduV3WxzKyRhcSD5u46c07zoPT9a + 69LWyuV80sqE9QfWnf2dZf8APRKLLsO77n//0P62LYQ6nrioJtrRR4cI3ADdiPwro702VhG92bvbDaIW + c+oA5zXg/wALfDj6fNL4h1eedru5PG44UoPlAI/vceteiX6WfiLxDJ4QiXelqkc98f4TuOUjz6nGSPSu + OTdOCiviZ6FozqOTfuom027tpoLnxTcR5JQy4b7wT+Hj3q7oUGqvo8eqarAsUkql255Ut0HT0ravBDea + vBoMcaGILvmPHyqOg/E/yq1fWN1cRrplrJlMlmfHQDoKuL/yIm/8zI+wJBpa29i26SVsb+/vWbqLCTUY + tKPzJAqlgP7xrW1CIK66pckLBbfcVeN7dM56Vz+jz3N5NLdp5c2wk8LhjIeoBz2qvaRUvyBQk4/n5dze + 1DzbnUbS0CsIVPzEDPPpXPxzed4i81UaRFJWIdFXb1atae41WxtDJfurTzErFGnVAeuT3NWfD+mW9lbi + SRSERCpQnOO5Jz+tJavT+mN6LX+kTW0rapffa7hf9Gg+4c5yR3qrp9pPqOvy65dhhbRjbbg8Z9Tiuq0d + LB7NJYgfLTkKowOfap/Nt5iZ/wCBGwAOmf61TgtLsyU3qkiFbW7ur5bhz+6UcL3JratrZoIzHKw3see+ + BUdtMmGnAyTwBnqfarsECk75TnjLkcjPYVSSWiJbe7HW8MTqX79B7Cs9kWQ5U5Ve1aDxEqzZPTp069BV + IwspKo/UcnsMd6LXJTM1UDTtIMgc968x1Hw3rmsfEey1K1vWit7CJjLB2ff0/EV7DFarsGW9Dj+X59a8 + 0+H2o2HiTU9c8R2quY4ryS1Ry2Vc2/yMVHpvyPqK5q9GFRxhLvf7tTpo15QUpR7W+89Igs2QFnfIH4Ve + twFG93+Y9KhK+Y53ggD8OlRgqL2JYzlcMTXZscd29TZigViQ3zFgaz5YVV1iUZB4qw823lGwQAfwNQwi + 5e5SdQSAD29TTEZFzpsSkTt+78tuPxqOMpPI8EoxsOBzyal17Sp9VtTaTlkXeGLRkg4B6ce9N0ezW3Xc + weR+WDMaaQNjXtYgN0UZbHUdxVHw3MZ4XlVcL5rKST6V0kqSpbvJGPmVCcDt71z3huS3TQoWbcBJukyR + gtu9qVnfQLo/ii/4OW/DzQfthaPqhQH7Z4RtzuA+95U06kfXkdq/kP16dftUhBGMnj2r+yv/AIOYtAe3 + +P3gDWyxUvo3yMWJ3LFLLvQA8AYwfrX8XPibzItQlV9wZ2J5HPJrzIq9Wdz3KNZ06cbPoZ8WqAwCNjwt + dHY6rhfmOM9a8wmlVHKoe5z9K3RqVr5g+zhlGBkMcnd37DjPStZ0j2sBm0ovWVj1S11mVwGzzV8amTcA + EkL1rzi1u0ndYo25YjvXsnh/wq08xM4P7sfMOuK4q0401eR+mcPUMVmclCjrZq76f1oRSX8jwliTtAzy + e9T2WtagIJBbuU3qUJB6qeCDXdnwvZvCqTArG+QGxwcdcV0Oh+FdOiZbW2cPnPzMO9cEsxpxjdo/S8Pw + Ji6uIj+8smrb63e2h5FZ3N/5JhIJ5x0wc1ekvbuDDuCFwCPSvpbTPhnCsa+ZtMjdW+tdPL4BfWpUk8SX + rXZiiS3j3c7IohtRB6BRwK8+pn9BNn2uC8IczdKMYvW3W1l66/kcx4a/ai0H4Vr8O/G37Pel33g/4h+D + 5bqTUvENtfs7XxmOIjHEy7YGjjLIWU/MDzyK+b/EHjzXfFWs3vinW5TPeajcS3VxKRhpJpmLux7ZLEk/ + Wvp5/wBn3wvpirq8LuzsDlG6c15j4g+HmmWW5bYYzz9KuhnWEqy/d3fmzy8x8LOIMBB1MW4pvW0XfS2j + v+nTpZHoX7JPiuSx8ffb5drEgoM9QO/09a+qP2sPjBDeacNGjuG2eWFKZ6k+36V+dvh++h8EXMlxA5ST + pnPP4V5b8SPiTd+IrpjLKW9ycnivLrZK8ZmkMX9iKPIzPMsHlHDro4id8Q29PmV9Y8UsbhxgEcj1rln1 + ie9kLyEZ4A9OP8/ia4WbVlDYTk89au6NdTS3yL1UZY5746V9xDDqKP5lzLOp1ZO8j9O/2GtNtNT+L3hy + K6AYi8W4I7YjwwHuc/hX+p/4C0saF4G0Lw7DGU+y6dbQgYwBsjUY/Sv8vr/gmyIpP2iPB+m3EIl+33ph + xxkDBJbn6AH61/qcfLDDEqg/uwFI+nFZ4KNq9V+S/U+azGrz0qafeX6EaG42sAhBHHapYjNJC0Z+96VO + 8qCUCPnd+dQCcxSnbzn5T7V6dzybFlG22wYr8w4NVp2lmtGUfMDwaWOUGR4pTg1AkzRMwAOxufpTvoTb + UfZbrZPIhAIHQHrg09fMWYy9C3v6VM3lJJHKnC9DzVuaLzo9iDlec+9LbRD31IJ/MeASyfKy0m4Sx7wu + 70+tK4la3LA/LjnPNRaaxa28puqkjFO9xNEdrPcrKYmjwOxJ4rFvv7Rt7toWRShOc5rpXDLIsn3c/nWT + rav9nNynX17Ut1YpPW5mPHdwHcApDcVRluJ1bYBx04rU8wPGoHJUDNZN7d21tAZpCcDOQOvFT1sWjOe4 + 1mBPNnlDRljhdvIFeU+OtV/4Ru8HiCUl7N+HB/hI7129v8SdCuL7+zo1JlPUMM9P0qpqdl4a8Uz/ANm6 + pErKPnw3qvf0rTkna0XZhzRTvJXRb8I+NrTxBpSTwtj+77itfVdQmS1eRF3MAcD1rkdNsbHRYsyhVETd + V+6ATxwD6V2EmyQxTWigxnlsHqD3qp0ny6szhVXNoj5Phs734g+LbnRNZaSxhgUsFXjfn39K8U8R6xqv + wc+NNv4Y+1SXWn6lbedEpBJjdGweewIPSvubxj4YtZrYasE2vG27cOCMfSvjbxf4X1XUvjvbTahEg0a7 + 08yQzncZFmUjK56bTwaxnUSUaTXzOumuaTqp6djvPFPxR8Q3N9DHb2U13ahVUALhfNPAJz2HevQfBmn6 + re5fXRH5kqkoI/lCf/Xq5okdskEFiI0m3HG89setdJPY28UoS1cRiQ7SV5Ix/KoTajYqdm7o8Wi+JExl + ntjpd07W8rws2BhihxkfN0NT/wDCxJv+gTc/kP8A4qs2xhl8LPc6Nr9ibiaO4kZZVJPmRudykk98HBq/ + /bek/wDQMf8AI1jGvor7+hq6Cu7Nn//R/rNhaGKAap5TFtgWNNvJbPAwemD1P+FS+HrEaClxqE4VLu7b + dIc5LOw9T6dB2qpYQ3Grt9v1ZlWNBkQpnC54ALHqfXgVv3kGnaZCl1fhQSwCI38LdgB6+px+lcfOpNya + /ryPRdNxSin8v8zUmNtoX+jwHzLq7cfe7kD/ANBUf5yaTWNRmtraLR7Ys7znaxi4YK3Vs9vQVj6VqNvA + l14ivld5LqRUj3fNuzhVVQeME4445OTWbrt+2gGIk77y8lJkkP3YYQPmPTgIpAXuWI9TSkun9en+ZMe/ + 9ev+RqvBBqsTNc/8elj8oB5VmXrnOc4HH51HpF7M1wdTdYhbuVjto1yp3N6gdSf0qlqlvBHo8GgW83lw + llPy8hlB3EdyQe+evPPNbF3YTTzLqb3KpBbqfLQDaARkO5P04HoM+taQi1b+vV/5BN7/ANen/BI7Kzv2 + 1KSS8YLLITsU4Koi9+M9f51nahaX2ualFpNheeVDES148fG4do+me+W/AVPaWIuZf+EmckOUWMbWOCiE + kAdBjJz0rW0XRjpVo+6RmlvZC5MqgONw6HGMnueBWlmkk9mZNq77k94l0LMafoDrGuCrSMclQBjjNX7a + z8mzW2tgRGgwM9frVmzsrezt1tYF2iMYY9eSasP9mAYBhiLmR1HBHYAc0WV7iu7WGySTRoDGoHHyDI/z + 1q6t5HhYmyhUdP7zf561mC7WC4CrtkDnCl/4c9v61ia9q66PYebDC880kogiEYz8zdWIz0Ucmi9rhyXO + racqx8qXnP3u3ufwqCSc9P73Ueg7D/gRrhb3V0LrBJMsZkRiGPaKMcsewBNauk6sBJ1ycIx3ckSSg7Qf + 90DNJyXRgoPexe8b+Ih4T8JajrgXdJa20kowRguikgAk+vAqr8INAl8M/DjRtDvWP2gWqSXBOCTNN+8k + PAA+8TXi/wAdptd13R9B8LeGUSV9Z17TbWYSMUX7HHKss/I5YmND8uRuJweK+qYzH9xDjjjHYE7RWMJO + VRt9EXUjywSXUPs7lVccdAeKsW1giRtLK2AQenHBNJId0e9GPB4OOR2+lR38kTaTLBcStGSjDPQDIx39 + 66kzk1IbYw3cck9ttKs5UZGeE4FaMLJCdsnyg4BHt1qlYzCK2ijlP7wqN46ncRk/lT53WONphy7AAHsc + /lSjsN72LDw+YpbzD8i56VRvB5NlvRsklU/76IFSx3DyIEjyQSMjofpSNNHcRhRtzvyocdCv9KsRzniS + 9hSMWNi4WacrH15wSFPHWquqW0dvNGtjE7TFfLUrwqAe3Tmuc0CxurPxtrF/rt49w80UEsEWFEVvGV5K + 4G4BnUk7mPPTAr1QWsUsn2iLknGD6g96zpylK9y5xjG1tT+UX/g5J+Fmu6l4R+GvxW+zkrpbX9pcyDk5 + ZNyDj33V/BR40SR75pXyCuVI96/1Bf8AgtnoVpq/7HWrapNCt0dGEt1PFL8qbBGzDB65LKAMc54r/Nf+ + IXgq41XR7PxppVjMlvqFtHcgeWQAsi5yD0K+449a872vLiZp7afke1Soe0wsHHdX0+Z8jztkkryM0iIZ + eFzxWlcwQwXDpJkAHmksBbCfMn3c9u9d7lpcxoUOaoot7mhYWd4PmXPP6V6HpGq61ZEG2dgMfMB3qtBq + WlwxhYowDjFatv4ltbaPghQO5GeK8+rJyVuU/V8kwOGwcoyWMs/J/wDDHWR+LfExiRWifYp43Agc9cdK + 9F8O+JtWSE3j258pWC7u2a861DxJY6xFCsOqRyqowd6iPYMehxmt5vFC6XoUFnpuoQXCmTe0SqrEFfUg + nIrx69Hnio8mr9f8j9eynNvYVpVfrjlCMbp3g7vS1ved1r0benrb6AX4o3traCKSArnjcetaNj8Tzne0 + eWPSvEIfGkevRBNa1XSreM9VMRSUH0yFI/HNVINWt5ZyLeZJFU8EHgj1rxpZXT1Uqdn8/wA7H6ZT4+xS + lGVDF80dlfkv80pSt8z6MvPizcz2a2vk4z0b6V454o8Z6lcxlkTBHJrSu9VuoPDCYuLNomk+4CDOrfTs + K861PULX7O0sk6Ajt60YLBUoyvGHUOJ+J8dXpKFbEv4U9kraeuvqeP6vr99e3LPcMfpXBahbzSsZnzg1 + 0t35S3JMZBUniula30NtF3blM2ejHBGK+vjJU0rI/lfGYGrmlSt7Wqrxu9XueHnIkwBjmuj0SZ1vVjj+ + 8y1BcrbmUrGQTn1rc8M6abvVobe2G+SU7EUDOScdBXdKa5dT8srYaUZuKdz9yv8Agjd4DTxn+2x4Bsbx + jmK53hVHQMCGP16Cv9NshrjzEiDHBOcn8a/hA/4IMfBvStJ+OmieJvEAC6jBMJVbGPKt4Rvdj/vEKo+t + f3MRarHZ3K20rsPNBJY9AR29f/1Vx5fUU3Um+9v6+8xzOi6fs4dbX+9/8A3GtkhnS6RnHGCvar8o3jec + AA5561TspPt+neZCdyMDggehq48EjwLI74yDjjmvTVmeS7phLGWmjlDbR3qpOl3GrNOyFC3yle496WeW + P7KqyuIySFXP8THoB7mi+0+6ltkNlMI8ckEbs+3tQrMHdGlKsbaft9RnA9RUtteW62aPIMbuMDqT7VkR + XMrQkMVB24OPUcYpumlLuJ7V8lonIznocZBH50drB3NPTHS8t5Il3RqWKgMMEYqpCI4rtRaNlTuUndkk + r/WrCJcxxtErhiehY5PHc15R4m8J+K7q+Mtndg2kqyKyY27PMQqG45JBOe1TJuK0VyoJSersdxrWtzWM + kX2iJ2EjEbFwWVR3JHFeBfET9qT4ReEdWi8GXOoG71mcjbYWY864UNgBnVM+Wp/vPgV5NN8NPiP4d+H1 + 18N7jVD9l3vLeX7yv9pljkPyiN8gqRj5jnpwMV3HwT/Ze8AeGdPOofZw81yR50jYMkpU5BZwMtzzknNc + ftK03aEbd7ncqVCnHmnLm7W/X/I+j/D+p22qadHdREFHHykHP+FSXtraAM9wo8s8k9APxpq22n6Tqf8A + ZNgyBVjBEYxkD3+tbawmWMkgMH7dfwrqTexxyXXuclJpem+UZbeJc4wD0JzToYdChnj08oGmaMs4xnAP + Tcf5etdFc2Txsrg5BH4Cs6wthb3jwwR4lZtwfg5B4Oc9cVV5X3E7W2PJPGXh1bXUvty3H2JI8MMDdGUx + /Ev9ao+BfFljc6tNpFyT+4UFWwQGXvtzwQOOnY16l470DUNZ04RwuqMCVfIwdp9CcfrXzfNYaxZ+IoNQ + swkUlsAgUAhnZeq8nGHHAP8AhVVKsrJPoFKnF3fc+mL25jkP2a1HmW8g6nnrXneveHZdZ8PG20oR/bdN + YtblhnA5wp9mGVNZnh7xHfa5bTRQIyLIdynIwFPXPfrxjHBrtvDQuxcs0m3dtxx/EPf3qJrnjdDi/Zys + fPnhnxNd3OqPpd3bCK5s2KTpwPLLDKg9evO09CK9ni02BrJ/PZVMy5UgenPrXkfxe8F3kHiqz+JFjPKt + tbRtb6rZRhcXFvnckuNu5mhbPAP3WOORXUeHvGek6zpLRWMgYQbWjYfMCh54wSOlY06l3Z7o6akNLx2O + 6ltYtRWOdo9zKgUkjnIqH+xYv+eI/Ko4PEM17H52l+W8YO08nIYdQcZqb+1tY/uR/m3+FU1DsZpzP//S + /rbtpLSSSO3s41EEJKsFcZSY5zvAJ55BH16enP61b6ReXkVxclWlybW2VySArEbyMZ+ZtuM9cfU0mtzJ + /aMfhTRJjaySp5m6MgCGPPLdMeY+cKT7ntW9fz6VokEKwRqZIwqRBf3pL9AATnnjk1yJwtddNvU9K07p + PeW/p/wS1Dp9s0r+aBbQaaQsJR9o+6C7HI6DOPTAOTyRXPaXa6Zf3dx4sW8a4a7CbUONqQRglBjrzkse + mc+wqv4o1OHTYbLwfpcf2m/uyHuQo2lYN2WLZ/vn5e+eeK6W/t3vbg2towX5hJKzjacDouB61m3Z3jqa + pXXvaX/Jf57mitnp9oPtKri4uQqPklm2rk4x2AHp3PNWbiGO6hex5SE4GVXjjsR6Y/WqNmq3l2dSmV2R + AUjHQY7kcc5Pp2rRvriK0RVOAX4y7YGSPbsK0jfcxkkQqJXvkhiSSOCFVZXXAQ4P3e/pzVqxnS7vH1Z3 + z5RaJDnOC33jj1yMeoprrHY6fBpcBSJ5PlUhcDeeRwO1a2nwm3ij0xQEITBAHBPVj3xk5OK0Vm7dDJ3S + u+pbjZoLdZpdq5yVxznPQ1TJHnpZImQPnkAHfPAOMY9a0NscMW8k7EwAQPTtmpZIpY7bEpDNL854I+Y9 + Prik2xRsjHmBdvMbGRlUIHTHU4rjtWtY73VraS4VpIwHVFHRSBlnPQDA7+prt7hVJWC2QbmIUAH9cmqP + 2J5ZpmztiP7qLnPyr949+p4p6y0bHdLU4C4ni1XUYdPe2c292N5ymFEMHzAtzwrMVVR1OT1Ga6v+z2ii + EUrBp8/vGXuWGWP4cAHrircTXNxdNJIjJG7fKV/55oOM+mT0rTVQJn35KhdpY9cnqc855P6U2gT2Pzy/ + aH/ab+CPwO/aQ8CW3xn8R2HhTSbG2v7v+0b6TZCbueMRRwMScIzozSqxU8DAPWvs74afH/4I/GnT47z4 + Q+L9J8Qq6B42sbuKYsvKrgA8gkN0zjBzX5i+F/g74R/aG+P/AMSvjb4m0qLWtOF1HoFvaTslym+x+RW2 + M2yMKzOZE27m2ITngD1fwT+xt8DvhT8RLT4sfBjw/pvh7xNoKsovl05ZHnhkiZJhgbcGTcxynzdO3FcN + D2sm5rZvt08ndLoehiKdFWpyvdLe+ifmrN9e5+ooljigAkBzwuM96yr3TrjUjI9zu8ssg2j07D8z+VM0 + W6vNTie41K3aBonXZu+6QYxuI74BZlyfSuhtrgFEmcZDMZB/uqPlI/Q16EX2PIlGzszKsdNh+03GpSfK + pkfac8hUAU4+pGaj1rU7e2vdM0ogtJeXaxLgHGEjaUknHomPqa1YY3+zLD0BkCnPTC5Zv5CuVtL4ah8R + FsxtaPT7TznbPSS4bCjH+4n6+9N7BGO7O1liVS7b8lZBk9ahb7JEY03bSxZhg9l//XVRtaEatJJGdsSN + JnH3t3v/ACqtc3K7TCwVD5e3PcZP+FDkSoHFeMpl0q0uNSd9z3Bt4I16ABMl/rhSzfhWzp/iKabQrW6s + 4ZH82NZMMdpC7RgH1/CsrxxqAuvCupf2XELxxHOI41G7cfLIwPqGx1rC0uS50nwNplvf486O3jRwMD95 + tGfpycCsJTcZX6WOmNJSilbW5+cH/BT/AMb32i/AbVA+jtqOn3dvjUIgqyNLFuw4UE4GFJKk8A4r+L3x + rb6B8P7nRrLwLNDd+FtTsYbeymXIt5baOQ7ztydjAt+9jb5kYMpGAM/2q/tmaHqXxA8F61pdtJA8Zs3j + kLEYiLKVHHQkNjOcdq/iF/aL+HvxD+Bfj+70/wAP6dJPocqfarvTbpQ0DucJ50IQlkcjILrgnvkV83Xr + qWKfNto18j67C0PZ4P3dG01p5nRfEH9hD9nz49/FSw8M+GbR/BOoa3qbWCPabnjlZhsSVI3JjZA4PmBd + meSMdK/MO5/YW+LNjNdf2R5V0lpdTWbh/wB0wkhYqRzkdvWv1O+Cn7TGhT6v4a8vV13aTdNLa2mpFYrq + 3d1wzRT4CNtJDAEgkjpya0fgV/wU6+LX7HXi/U/hp8atCg+IHhWXUrlpY7jaSCzkma2kZSMSLhtrAgn0 + Ne7RcqlOTpavTS/rff5Hy9HGSw9eCxUVbXVp2e1tU79+5+Lut/s4/FvQlYaxol1BAj7HuCm6Bc92kXKg + e5NYXh/4NeIPFCtBYFHkyQIt+HbHXC9T7etf2/8AwS1z/glv+31p10/womk8P69fWzLeaSUMEi7xg5hb + MbYPdDitvRf2HvC+h+OPDmgaj4d8P+PdH03Ule81DU4DDqsaH5Pl/d7GVBgj5uTzXBVrVbOMJJS81t8r + n6Flmd5JGrGWYYCc6b35Ki1XlePT5rv5/wARs/7L/wASNK0hdWktVjhuH8lDMxjO9uineoAJHOCenNco + n7PvxR03Wl02fSrtZsZAC7lIPTDLwc9sGv7yJP8AglV/wT+8QeJ/FdtZaXr2nPCrPcXtjPPHBIJTvBjQ + DYwyDgkZXGK5y0/4IK/sY+N7H+0bPxh4mgt5OEzqJUqo7YWJiCe3pXJTqZnzOLnBp36Nfr/w/kfZ1cw8 + N6lOFSNHE05xt7vNFru9VFu79Pd213P4VZ/gh49knJfS75JCxUq1vIvI6j7vaux0n4K/FW62R2djIN3Q + n5RgfXFf2V69/wAG9P7NMSG60b4keK3SJ9jQtqTkkgZyAbUnafXHtXm6/wDBBj4GaPY3Muoav47vI0xI + gstYgWZl6ZWKW0Xce5AfOBwDWlR45q3NG/o3+o8vzjgahP2koV9d7TUX+NN/efylJ+y78YdIsV1rW4TF + DdktEXccgdcewrzvXPAer6fKbJZBNL0Ow5UH3PAFf11+Cf8Agi98Cbu7u5PFy/FGa0V2WBb66srYIiZw + eAWbdjAIC/Ss7Sf+CQv7MOm+P5LTxL4PudV0+a3iMF1qOrsQsrdRIiPEM8hcDdzWeGhj+Z/WJxfpG35t + nfm/FvA8MMqWVUq1+8p33315FZ+qaP45NR0m5065NldsnmA8kMCM/UHB/CvSvBP7P/xg+K0qWHgHSLnV + PNwAbWGWTGfUquAPcnFf6Ffwe/4JcfsufC62XW9I8E+GtKihQYlktUnkXHO7fKGOT67q8Q/aO1f9l34d + a4uiaN4hiivfLCC0softGAchfKijwuSR06V1YnETpQT0v/XQ/OnnmXTlNUaE5RfeXKkuza3/AA+R/Jb8 + Mf8Agj98cdR8Maj8TfizeWfhjQNIiaaffKstywQbtoRTgEj1bNUfDvhv4XfDbxELDw5pjXVzLZpJBcXg + GQspJB3ZITK47Z/nX9TniP4b+PviF+z7qWk6toK+CfBWqQSpPrvimZLW4aKVcM9vaqRITj7uQAPXrX89 + H7XXxe/Zt/Z58d6d4H/Yx1ZPiDrsFnHA2uTW4e2iuigQLEHGGa3CnYcHDc84FeRQr46pWlHErrpHRaW3 + l1V9dz5jGVnUa+qRUIdWr232Td+b0TsfoR+zHe2njOU/CPRJ7zw3rNnpb6pc/wBlzRx3siRkyIkjSI6o + rNGrBcbsDPyk5r+2/wCHuoXPiDRNF1PxBLuvvsMD3G9QGaYxL5mR/vE8V/EN/wAEkf2fvGemeDtW+Jni + i4a48Sa7cTR332mQB5Y5FZcF3O7ALZr+zn4cX0VnZaORJuL20MJUgliwiGASOOmD717OAnGMpRj/AEzl + x9GUoQm+34fofU+n3arHKlvjCuRx2zVlbzFiG6Fcg/hXKaXc7RK0jHbnkYx+tbQkYpIoTcu7OAeucHiv + bT0ueFKOtiXy9Pu0jecRs8J3KTg7W6ZHoaWK5WWDBdcrnvz8tUrKws7UTJBCkTF9xCrjJPJJx3OTk96s + 2MVpHPOjRqmXySAOd3PPrSSsg01sZUGoWls9zaXDgFG83g8gOM9PrkVDpOq2a37yRPNslHRlbcCuQeMZ + 5zxTWi+z+KZI1KgXECuQwzkREjjnj7w7VbuJxDfRvwC2OCcHn0/KpTitC+V79zWN8sjrLArhNxJLDGSf + l6de3pXMeI/HXhXQpIdP1zVYtOmvJ1tbYXDBFknlBKxqTgFm6Bc8ngV1V0ftFu0qjG3oB3x/9cVy/jbw + D8P/AIr+EJfCvxL0a21nS7obZbW7jWaJtvQ4OeR1BHIPTkU3fpuSktLlybSrXxBpqJqKrtdAGSRMnPcH + Naeiae2mqYIpQy5DDKjAz14GOK5jwr4S0/wrpa+FvDLPFZWiqkEUkjSNHGo+VQWLMR2G4kgcZ6V0jJdf + aEikkYA559aWyvbUp6uyehV1dIINWhuGKgshQkDqc5HNVIL68WP7TbyLLFIcgbTuXnkY9jnIq34h00tZ + xyMpzHKjdM+39ayYEl0nVVtn4hvWLoFGdkwBLDPZXUZ9mB9RUOXvFxjeN0dTa3c06FZvL44Gc/y61Tup + GiZLuIfPCwOM4yO4z9KrSpsJdFAZTnkUy6kklcKqnOOTnj6VTkZpamldwX6KX06aN4biTMqTDcVRuuzB + GR7GvmLxQ11oupXa+Jkj1O8LboLVVZYzGgwrKBnLHrzx+Wa+kbeW9WF4LOJZJQPl3uUB5+h/lXj3xJ8I + a3qWfEGtXpaC3KBLGJvKQ4OfmkG1iWPGMhexBzSnNqPMlf8AI0pQXNaTsvxPNdEv10XWLVA+dO1zc9sU + JyJgNzxspwUJALqOhIf2z6ppUtza3kjSOS0Y3bc5Gwn04/OvnOHxHY/Efwjf6bPb3HheeNXS3nnjaKWJ + 4c+RPtIPKsobryvXg13vgnVLHxvodjqKOsc8TN9oijY7Y7iP5JVB643jPvSp1opLzNKtCWt+h75fwWl+ + qXQmTzB8y46hT3xz0NfAs2iaj8G/jy+kWLJDomv2s97YWhAIuLkHdPbIS4IdRmVBtI25HAHH1voKQLcN + ZWweRLWRmQ7sbQ2QyckkjngfT0rmfjZ8K3+LfgO40C3updJ1a1YT6dfxHbLa3kfzRSqecjIw68hlJU5B + rGtHVVEtjShK16be5R0fT9F1awTWNKvZWt7vEsbW7qUZWAweSOcVqf2Da/8AP5d/99L/APFV+eugeK/i + x8QNPOp+GPEcHhO8s5JLLWdKvLSOR4NUgYrPtBlTZG/yyRjBBVgwOGFbX9nftEf9FG03/wAAI/8A5IrZ + UpvWOq+RL5E7Sdn6P/I//9P+pb4d+H/EF091428V8z6lJuEIfKwwqMIo459SfUmvR9PtoUnm1W4jUQxj + EQI+7jq31NV7a5u2sUteA8hCrj+761neKNSeTytGXlj9/b0CjtXDBKnFNdNvXuerPmqzcZdd/JLoTaVK + urz3Gt3asgDDY3rEn3RkepzWrcaksaiEsuZSBgDJ3H19fasg3o06G309Pm+YMcdvTNaAewutR+1EeYIc + Pkf3vyqoPS73FUj72mx01sY0uobRWCeSm8qq5HPAHXiqsWoPe669uxAWFSSSAc+3NYyatFFZzajdqIjI + 3BJ5I7VftvMGlj7KpZ5hjeOTz6n0qlLS6IdN3szT06ZLvUpbuErKsQ2B1HAJ689K3ooZ40JdsjOQAMDP + qfWsvRbSHTreLT2kCdWbI5YmtqeVnkVVUFe/PGKpbmU3uUNLs0hHlZLKzmWTJ6k1r3U1uhfyx93+Edqp + RyrbEy7iXPYDio57mBf9lyMnIxwKp7EdbjBcqVb7MQGyI13Du3eoJWigz5Z3EAQJnqT3NYljf+aplxu2 + s789M9BWnaSFpQGUEwxcD/beknpoW466miNkjtMi7F3BQB6IK5Lxhq1r4Y8M6h4lvJAi2dvJPI7NhflU + nnGPQ9+9dPfQEBrSHpEoTI7luTXy9+1gmt6t8JrjwJ4enS31HXJobOCWXOxCXBJPthSOnepqTaTZpQgp + TjG+jf4f8MZf7KPwgtvBXwgtfLubiO41iWTVLuOSJbcJcXbb3VI0GFVSTjJZiPvMTX1fpPhzTLN2XBby + jnL8lifX/Pes7QbM2Wj2WnO/zWsSKzHuwAzXUrdghhIgHXB7GtadNQioo569eVScpN7mb4hs7XxBAnh+ + UyCGeUF/LJQ4jw3DKQR820cEV00u5pdykgIcDbxkJyR9DXLabrNnqGrzpaMsq6Z+6dkOf3z4JB+gx+dd + RFsabCtnbw3pjv8A4U1q7kSvFKL/AKv/AEio80rfJJu3Y28dmfk1zWixojX+rwx7Xu7goTjBIT92pP0C + 5rrb6+S3iMsuCXw239FFQCWK3RYVXk/PIe2Tz+FJq7HF6GTrXmyKLWNf9bIkLMcjCj5if0x+NQX8bPOZ + gDuDoAD0459OldSdVsVdy+FBADZ/vdgPeqlzqenu+ZWA2gg56DPPP0oaWtwUnZaHlnhm/lv/AA5aSeIY + VgupVeWaFX3qjZzgNhSeg7D6VgeJtRsrqzijtmEmUGB7nHPvWrr+jtqmo2es6PqctpFEG3RhVMc49WyN + 3HYgj8a+a/jD4U+IGvWCw+C/Ea6Nc4cCR4Fk4PQ8kYrlrPlpuzPRw8FOqnLT79Dyv42+HbK60zVI9O48 + 61aBkHQxsd2MjGMHPI596/nF/an+A/gDRvDPiT4i/EWa5tLOytzBCqSMJRGEC4X+9+8ztyMnnmv1p8S/ + Cj9scs7S/EWC9jJOGexVOACD8qnGBnPvX54/Hj4A/H7xtoUlrrXjC11KfCFFuIY1RJ4ySrqoXPHUZPav + j8VVbnzOXKrn3GFoxVJxS59PxP54/Gv7L4s9Ptbie+Om3t0PtCRXrKREt62Yo2D4O9UxuY5+b6V8n67Y + +LfALz2EGtpfxRMYDHIFlgZYsDhW3YyRjjFfrb8Svh14t8f+H4Ne8WK2p3yCXfJCVO4wMV4G3O0nleea + +P7n9mrVr+4fTXmK+YyiFSvDSNkgHCcnsa68Pi3C8qlRf157nBiMv9panTpNrz9O2xwHwD/aw074QNJb + yeHFtdSkBA1bQrtrG9QE5ztfzYn56DAr9n/2MP8Agob4JTxbbXXxT+Pmqw22FeS18S6c8m3+HYJbUvGA + OpLAGvyA8Q/sd+PdDTMKQQGKPzpfNI6dM8AfrXIaP+zzrT6mNN1h459w8x4YWCyMh7jitv7Xwsry9pF+ + tn+O/wCI4cJ4l8sXQnH/AAuUV92q/wDJWf3I/Bv9sn4A/EJL628L/EbwlrsYk8uIR61bW8svJztScRMM + Hpk49DX6AeC/iFe6toNmfDGs6ZeOWKyW88lpcmAdgXWRxk8cBq/zvLL9nL4DXmjNqWv6heWqxOVJEKOq + nkAYHft061Zg/Z7/AGbZHZdJ+Id3bXijiI27hj+IIA5/GtKWa0I3tG9uyen4s1q8JYhpc0rX7uLv+CP9 + Bnxl8bPHPg+0t1n8FnxBJIfKiGnRW7bsHkbTMNx7jGORjvXTS/GLxxc+CpNQbwNLoTMT5b31nHDOpB5U + 7mZDke/vX+ftB+zL8KodKOsWfxlkjlthu2LHcI65/u/Nn6le9Ymtfs/aRqV5a6fJ8WZtVglYMWurqdVi + 3nG4h3OPXPpRHMaEm/i+9r9BPhSsrWlH/wAAjf7+f9D+2z4h/tGePH0W+1LUfD2m6TaRqyRw6pq1vY20 + xQEAJ80vDH2GO9fPvhr/AIKA/sxeF/BFx4h+KvjHwZ4Z8RQwllsrK9j1PbKOR+8T5jg+ifjX8h3iT9n/ + AODPhwDTfEHipNaMfAe3uWnUMfr0rkIfgT8GdQgkbQ4LiZ4Y8s/m7cBeuVB5H45rJZnTSa1+5v8AG6NH + whV5ouc726Jxj+DUv0P6EPjL/wAFbv2FtY1BZPiR8TfE3iSxiVyln4fspIYZGYYwfNCA45xk496/Mrxb + /wAFg/hB8NvEtzq/7IHwtm1K9jQGDWvFcuZ0kI6pBCz7cHOP3ufpXwBa/AnwdrBe1srhWjQlhFG4Zh7Y + PP6muQ1f4Y3WhkW1jbxWwIwigjLdcMwyTmuili8O9Fv6W/Hf8ThxWS1oa8l15vm/DSP/AJKc58Xv2qf2 + xP2w9bvn+Kni671BpS0n2FJWitlBP3RGpwR/vZNes/shfso6n4m1K1bxNasxWYSqS+DjqCp6DnOa838G + fCnxvp1+8+kac5nlGRIq7uvQ5GP5V+o/wA0/40f8I9H4Gk8P3r3s6GNJjEAGGDjoO3v9TWeIrSScMMlZ + 2/4LFQwvPJSxblon008kfuP+x7+zd4A0232WeqG1khkicKoJ2kjkNkDJ6+1fsfonhSBdKSS21C4RlKoj + WzlH+UbQ3A6kcg9q/Kf9iL4AftPaAslzqtgt/wDaLSOSbz5U8yMFTjCqGOOgGSOa/dTwR8IL6LQLXUPE + lzFFJ8rMDIAB/s8ccV24HCTi9UrdzhzPGU2tG0+3UseBvEM+g3i6Pftd3JnGfOnbzSCvGCSTjP8AkV71 + o2u6VeXEiWkoYFQxXPKsOoP0rkLq+8O6Rt02EieaQZzE4AU/XGDVKR44LsRyBk39WxwRjPUc/WvUTjC6 + 5rngyTqauNj12OaFbvzY/wCNemeT2PSnu8K3rw7iu4AivJtF8V+Hz4g/s+xmZ5wdrYU7BnPG7pnjpXpQ + vra41JRnDICDkdelWpJ3MJwlG10ctDb+KU8XWtxqksRtn86NFQEuM4ZSzd84xgDHvW/qF09tAVuwpKTb + E9QBjaR74NQSa5Zancp5SsHhlyuVI3bTt9OnXvSeMb/RdN0u51XV22RwJ5hbGcMOBwASTmlaMbyb0/4B + V5Saglrt+P8AwS5dCLVbeKza6mtZZGOxrdtj/LyeoIIx1yDV7Srea0to7KW4ecw5BkfAdscAnaFH5AVB + ptra6nbW2ozKVZPmjPQjeOfzBqe0cLPIZGBxIcDqQDRFdSZPTl7EyRxHVftET7ldChGcDKn/AOuasSqk + DrJyAhUAnpgmsOW9jh8RJYxKFZgX+ueprA+JY1y40KfT/D1zDaTzjbHPNkqj8YOB19vem72YkrySvZHo + V+HnsJSMPwdvrntWGqvcvBIoOAec+hGDXJeE7LV9F81tWu/tUUzEqG5KqAAOeOuMn3NdBp2qxSK+Twrb + CMdCKzetmzRaXUXdGZc6wsF7cad5nmTQtlFOOUbkHj05Bq2NSt7W2e+v32RQj5mPT0rmvEd3bWN9Fq8M + AaSI7XK4GYmxn8uorNv77WNWd9Pt4FFtIPmZhz+WD/Ss0pXZq1FpfiekTSyJEJYDg9MntXltqdf1f7Tp + N7fRzJdhwiuSDGQcjGMHjr16V3unWU4txDJPkD7vykngeuf6VmQeDPD8l699IhS5JDNIh2EkDqccVpym + Kklc+U7aW9ufE81j4mjgt7izWTyBvPkSopAcFWG3cDx83JyPWuD1bx34A+H/AIim1WSb7FYak0f2wrAx + RLlysYkBjG1UKAbyR1Gc17x8ctQ+Gvwztj4y8dSix0y5cCe5MRmzMBhAwVWPzcY464q3e6T4Q+Jvw1ut + ItLdraHVYCyG4iwQSPlZgwHX3rnhF3cW9jvlNWjPldn1/wAtzzrW9XvvD9yupPdQS2ck6LHLHMSXgdTg + gDIyGHOexzXd+F/FuoP4gks79/3d9As1qWOV+T5XT65w3418i/DjS/FPh7wLqPw/8dCOGXTJ2ggkUptd + T92dVxhWK9sYyK+s/BvhLStJtrPW9Nt5LiQjCyyuGyjAZ6/d6A8AVrd/eZzSSs9Wup4p8av2R/hn8YvG + zeMvEEt/Z3bQpC4sLp4EfZnDMEIDPghdx52gDtXkv/DvP4Nf9BHXf/BjN/8AFV98XV7Z+cRPF8w/Hiq/ + 23Tf+eNcEsM22zqjjZKKVz//1P6sGluJ3EqyKnzYC5wQBVK0uoG1l3LMG6cjINcvoPiPTJdN+36id7zt + hR0K54q5qF3Y6JvumkX5kyAaweHbkk9LHoxxKinZXubP9qwW2ozAsXkcjJ6j8K1FLFBYQJsMp3MQea+W + ofiNpDat5ssw++SQrZxXrPh3x3a6je/a0mDK3yhQcVosPLotByqJLV6nvEUE+5EUqEjHIYbia6y3uIY7 + cCMD8DXm+l6mLy5MasRu/Ku9hmeB1WGMPWepnNWWppxPlBI5HB49qy9RvfscTzrzI3y8+vtTG1B2uBCh + CnqafAn9ozPM4UpCenv61K1diWuXUgea+t0htPMErPzuPYVDqUjzWUzBSrP8ila3pI4kjDxgM54/Corx + I/s+HAyowv19a1avoQpWscd4XLNYfZp02bX2Ak5OFrfjfbtaPq8ucgc4X+lZ0ZlijaNgCR0P1pIBI5Uo + 2zyxjHvURhoVKd2zp927Z5h+Y5kJ/wAa8A8aQ2Pib4r6LpdzlxpaPd8/dDHgH3r3JJFihafeDgck+1fM + 3gq5t73xzrnidpWuZLqVbeNSPljSPqB9c1nVkk0u5thoNqUr7L8z6itGL2nmv96Q7vSsqaSe3ScTOCiq + W29uK0Y5/LtIwFFV7+0lTT7hsj5lwA3HWup7HCviJPBttHZ6PErBRJcOZpMcctzXV3UjxwSNbYyRx9Sa + 4nSoLiC1SNyG4AGPSuhlmcRhYwD64qVsOfxXPl74u+I/H+keJdOvrV3k02K4UzQW0e9pFwRjGc/ex0r2 + Twt4s1/xJZpdXVg9j543BJsb8j1AJxS3sYuNdt0ZcmNt5UdMe9d8YkO3aANq9azo3jKTOjEVFOEI2tYy + tUeHy44rgbvMfe+0/wBwdq47UtRtJ9ONvGgV3O0gnkBz3/Cupv1VZ1lbKsoOe4r5v8eHUfCkd9r15dtL + aTyQlcAllIPPTtWdedouReFhzyUf6vc9i1e+RQbOzkIMciKoXn5R94YPasO+txLdycKY92G3Dn8K2bbU + rO7RZLPaSVVt3Y5rC1SRhLIychhng8ZFY1JXib0o2dj5+8aWdsmuXFtAu1UhYsAcDn0r8xPjB8Hdf1m0 + 127t7pY5ZreSSGSNdrHCEBc5r9W9fnWZp7u5jCIsZ3t2wK8B1qXwT46tGj0K7iuUSNo3MJzhj1Br5DMk + 03yH3GUz0XMfhX49+Dc9j8PLWfS/M+SygCeWAoYxYLbiex71zR+G0WpW9lq2l2wN0Ssw2oNmU64PTOO4 + r72+J2hadrWur8KIJTaZtTyrclQ3OB7im3SaPplpa6DYqitDEYV6bsAYzivksXUnKKTPvcvUIy0R+Zvj + 74Aa5rEeojU9U8uPUbcQthctEq9MD3HWvgmT9lO/0vWLm5e7N1bRghJgWWQgAZU+o4xmv3G1zwvqeouR + EvmRSvtbjueK5nUfhJcWFhaI8QLPIyEgdjWGGx9XDwkodfI9Wvg6OJlF1G7rbVn4o6r8PLbUPEFvdaRb + tp9vbRxObSIbxuhOSxPXBznmtX48/A7Sr62/tH4ZH/ibeUt07uAItrDLLwOCe3vX1VbfAj4mal468UXm + l3cc6QAw25lGAR1KnHXFez+Bfg9DrXhNbbXpEju442QhOj5BBGfau+tmE6XLUjJO1tPVdepz4fAU8RGd + KpFpO/4Pp27n48eDfgJ4xs9Yt9e8cGENNCRAkZyUJO4Enof1r26y/Zo+FvinxFBY+N5pnnAEhJBVXbuM + gAEGvqzwf8GfFWsA+EtMtDGlu7QvL944ByOT04r6P174Bwan4NjgtyV1K0yVc/e3L6VhmOa1JSXLUcXt + eOh6OU5NhqMXGdNTjvaWuv8AXkfAeufsu/BnwzdSrYGwjuplBiSSJip9uDwRXhuu/CvSPDGrSXCJYRef + KB+5V0JDHp83y4r9mtR/ZvPjr4bRLBtN5hXWXHdeta+ofsOWnjv4cCy1p43m2DbIpztZehrysLmsoW9r + VlLWz3Z7GNwOGmn7OlGNttEtT8NfFvw70XRZ3N1Mqo/zNFboFUnsBJg5684rjoIrHWdHi0W90ctd277z + cLFvHlkcL0/Wv3o0D9inRD4LtdH11YnFnIHSQ8k465qbWP2UdY0jUDDZXCW9i4ADxRKz7T7kV7FDiCk3 + y2bt1vY+Vx2RO7lCSV+lr/18j8jPhJrPi/w9rNnfeGNBluPsG3bHOheKcqf40OAR7V+qun+Jf2kPjd4T + j8K+KJI4rBCCyRFbUWyHqF2AHgccmu20r9lfwRbt9rbWLuZ48Mw3FcE/TpXoFh+zlJpN3ba14NvZX8zJ + cXDZV1H6V6lPHxqtcsfzPCrYGdFNzne3kj6a/ZavNE+BnhifQfC+sC+F0sYkSW8UxKUPJPOeSeSa++fD + /wAUdF1m2b7bc26QjCN5b7xnvyDxxXxV8JfD2kSWQ+0WljLC/BkjTDZ7gge9e3xaZPcyy6HDCsVvLkq0 + CAHA7ng17+Fc5a7o+Sx8aabvufXMXxL+G9vdxm81izVnVSibxuPsAepHtXptlqPhzxDex6ol4uIUKhN3 + Tdgng9zXwP4Y+EPg/wDtUXmoWjX09sdsbTDJXI7dq9VtPhXd3Hiq2utMdrRIFL3OTuBH8IAzwfevapt2 + 1sfNV6dNP3W156H1zJqnhDRdVjs3ntreeUebHHuVZHPThep59K9I00x/2gZ5HySAF9h3/Wvzh1L9mnwF + rfxr034nfEeJ9W1Wx2jSlaV1jtlTndtBxuJ55r7hiv5n1CCeZTEAuxjnINddOctXJHnV6UNFB30/qx6X + 4ivI7aGKC2ZY2kkVVIGSeelcv418a6Z4Z09pNeZgWUqoVCd2enIq5qW1rZJYGy0bBvyrkPHWsWL6DPmP + zZUjypI6N14+ldLlo7HFTgm4p7XOitPiVo1qbawWO4ZjGrZSFmXgdCwGPwPNQeEvGNx4xbUruximsmEv + kvFcxENlR9/r0I6VV8Pa5by6BAYgCJVUlh198019WitNYnjKOyzqpBXgAj1NJSdk7luCvKKWp2stnAbu + G8uEZpYPkWQdCpHOai8ZW0tzZKF6fwkrnHv9atySWV3YINzKAob5WxyKlsTNBbf6bN50LDILckZ7Vo5a + mCXU8q1/V10XRTqOozNiNfvdQCOmR3/KuE+B/wC0D4P+Jkl9Y6dMgurW5aKaFQTtKnGTkDGeuK9l1HSd + L1kNEDlQ3Q8D61yWnfDnwj4f16fVtLs4bWe5G53RArMw7nA5PvWTjrzXOmM4qLg1qevalb2c+myeYQFx + 7YrkLRpfsbW9uA8wHy54BrQ0q4u5bRodTi2qpIU/3vSvLPEOk3Vlqy6lpE0gyfmIbk/hUSWt7jgtOVnS + 6VrfxCtNRax1rTEa0P3J4JQSPqpwfyzXeWerW93lCJEkQ7SGUjn1Getc9oepXlxahrvLOOua6dr+JbVn + Ycr1+tVCSM6kXfYztbtry+XyL+Fbm2ODjAzkd8VQt7fS3kEbIEiOEA24xWzb6pNJItvsIXGdw6fnVWZ5 + jceSoU7jxntTvqRZ2sfI/wAf/hc+h6qPivoJmcxFPtcRO+NogfvbeSWXtiup8LeLJ447PTJ5GlhuhvDr + 8oAOMDA6V7H4mR7ixmsNRlDpKhTbnaoBr5K020uPD+p3fg6MIywL5tpKGycHnB+napp04c7VtTolUm6S + u9vy/wCAfU13aytLm1ICYGOM/wBaq/ZL7+8P++R/jXjelfEi/FpsvZhFIhKkbfStL/hY8v8Az9D/AL5H + +FDi+xNn3R//1f37m0/xf4WeNbh4ri3ibd1Ocfj/APrrotf8Q6dfW0N1qN0qREAEZxgn1roJtO0nx/o3 + 2iKZoZEGeDjpXmEXhvSVumsNWiWaMHksODj8a58pzL6x7mIjaa30O3G4P2L5qLumc79j8KXbSW9laxyu + +drp1JPf1rsfBPw313RiL++lIiJ3KgPQHp/npXeeGPCvg3SZFmWMKM/KOg4r2jFmIF2kBMZHP6c16dbE + RStA5adOd7yRN4XW5tLcMwyD1Y9q9Qe4hSwMme3UVx814BpgijQEDniqEmqXDaSTjaBn9K82ctzrjFyt + c2F1LTPszSxufPzjNdBBcpaaaoVtzSckeua8OS+i89YIpRliM/U12Q1MPMsG7Pl8/lWKqMudPzOr1PX0 + tZIrVDggZJqtHrSzOJJ5MhTwK8s1fWJJZnO0s3rVmzM5svOPBx34pKo9SnSSSOr1XxRbR3scUhKbvmB9 + qksvEEWqWkgtwVKHGe/1ry1kudfuisqkeWMAjrxXU+E/Dl1p6SRPJhWJPvTjUk9thzpQS13Ozt9d8rTJ + JLjlI1JOe4ryX4Z6npOt65d3fh/mISnfz/F3qL4jvd21pFoWlSES3bbCe4Br134b+BdL8L6NHDbxhZGA + Mj45J79KTUpTSWyHeEKcpPd7f8E9GSaO2WONl6c89OKyfFWo+Zp/2W3G1pGxz6Ct+7igeDY45FcHqMRc + CGMeYVPA9665PQ8+C1udfpNtHJCp3/MFxjNakKMgaQnp3rmbbzgoVAVyO/FWlv5ba3MR5PtS5kU4yY2w + s/OvZtQlPLHaPYCt6WaQxMG4wMe9c7b3zRxAx8EnJzWffavcooMpyzGpukh8rbNK4v4mGxACeh9qxdRs + LC9tWhmQSKP4CMj+vNUZJWuLre58tBTbvVbaxBAIJ/X+dZSkawh2PkDxd4V+I2mTanq3hPWJIZriUbLb + AKRoOuODg1qeHvHZ0zQ4B4ovC87SCLM2FLN+ma96leO5jlmWMDGSTXi9zo2h+Irf7LewhvLk3KcdDXl1 + 5JWUUe3h25Jupt8hl9rtle/a9Om2hWQgg9w1eLQaJb6LZmPRrOO0XLMQgA3Z6mr3jbRo9E1iK7sWf5wF + Zecfl0rtGaCDToXYh8jvXi4tN7nvYOSik4n5BfFTwH438HfHc/GrTUbUrR7Yw3ELuQIlGeVGMV2fgnSr + DV1i8aXDtJJdOXwx+6PTp2r7Q8faJY6np15Z7c+ajDHbpXiHgHwpplnoSafdw+WIXYAD0NfPYuCkttj6 + vA1XG7vueKfEH4iS6Fo1zbaDpcl7eZzEkSlgzjpz0FcNpvjLxNr2hWsHiSz+z3+czRxn/Vn37ivtmW28 + OaBi6gjQ8kktgkV8c+N9e03S/Htw2mSgLecspPftxXlexi00ke9SxMk076Hifw78O+MofEet2080Z0ee + RjD/AM9EduvPpXrPgLwTYeHlWzFwLmfLEFhzkn0rm/hZPLNqWpWrwb1aUtuJqP4l6r4l8Hyf2h4Tsmkk + XrkEg/yqZ4eU5OK8jtpYqEI8zb6nR6B4d13w54mv7aztjKt5J5ysvAFd5qmm3enxygwq9xMCEA6fN1rj + fhb8WtV8cXtvHq1m1jcqm1g3Gf617VatqEmpSwuomdfmXIriq4aV9Vqd9LHRaunocX8ONM1uLytJuAUV + NwZQcDnNe9eGNPubXQp7S3+UgsPmNeQ2VzeL4jEFyxtyc5HQZz2ruYtcsfD2mzx3c5ckEA5ycmsJYTW9 + ip45yTVzV0GxjXwpIl5IuWcjJOO9dDdXFhbaWLBWWWQx4UV8larqms3er2ltaTsLZXyUHevqTSvD6Xem + C4nwHKjBzXZSy63KzzMTj97s8W8QWMnhSOLU443vGv5QnlQqW2jPc46V7t4b8AyeIbVIbqc2lsiHch4b + mpvC2nvYW0t3dqDHCc/MOgqfwR4u0Lx3rGpW2jT+Z5OVYejCvfw8VCysfN4yvKfN7xtaJ8I9M+G2njV/ + DUzTGWXOyQltoJ7ZPFfSXhDTdTku7fVzMRAoAKY6V5/ZaZf3WhGJH+aPOMGu48G6hqQ0MxTffRsYHpX0 + GGk7nyeNWj1PbrBdPtLuSC3iDed824jvSX2n6lfWDNpx8u6iYNuBxkD1riJdZ1WC+triGMhG4+prvPDd + 8bu8lg1ABS2favYpaqzPArJx95HodpNDJo6Xl0itOFAPqDUs+pNHpGboEuxBBA6Y/GsnSgtvHJAhUp2H + Xir8F7bz6TPbAZIBxXfFt2R5kopNtrqOl8Rvc2zpaozgLk496xbrVYdX03yzHn5dh7fia2PCqJc6XIuC + H5Ga4KSzmtLmeF3IbJKj2rbmta5moptpdDoPCDLY276R8ysnK/SvQri1kSxhZWySeQa8Y0o3dprf2mR2 + ZWAU5HHNenata376d9qgumiGOAfenCbfu2Jqxs1K52WlwrLAy7uV6irmnXMNxK9i8ilkPCk9BX5cftef + HH9sT4IeDLrxV8CfD9p4oFvGWNvISJWx6YFfyXfEP/guJ/wUx8F/Fu78WePvCkmioitHHYCF1iAHfJHP + uRiplVnLSnG7Xmh+wpxXNVqJJ7aN/fp+tz/Qqi+zRXgO3O7vVzVYnaNbqMAbTX813/BGz/gof8Y/2vPD + eoeJPjDdsb8XRWK2SPYiR9q/pSs2N7Zjd/EOeacajldNWZFSkoWlF3Xcq+dNJCdi5LDiuDaYLrH2SQDa + 4zz613dsyFTAh+4SMZrjPEyJb3aXUS5YDrWUl1ZcHq0SW9xcWd1kn91noPeuplWOS3LR4O7nrXm6zTSk + tG45/SuisdQlZPIkkxj26URdn5BON0bNne3FveM9zgKeEA7VavDhxMhwT1rmr1pldWjII71rRurweZK4 + DCtFIylG1jK1/SrDX7VoLolSRgHNfHvxC+Fd3oeuxeLtLvZWltR0JO0r6Yr7KGwDazjvXL+JZo1tTO8I + mBGAuOprSNZxV0JU3ex8Xedb66BqOokNK/BJ+Xp7Uf2bpXov/fX/ANavMPFmi+KovEN04m+ziRy4TJGA + fpXO/wBmeKv+fz9W/wAKXtYvU6vYNaJn/9b9tdH17VLO3It5So9PrXa6TGLuyF1cEs7EZOeuTXmVj/x7 + n8P616joH/IJT6r/ADrk5UtUj3aWrsz1aSygfQ4JSMEkH8a7SAGWKCIkheOn0rlj/wAi9b/hXV2f/LD6 + D+VOXQmPX5ndt81goPpT5EWWL7O/3cZpn/LgP92pf4/+A1UNbHHL4Wc6NDsJdQhuiCGHOAcDNav2O3S5 + faOozn606L/XxfQ/zqw//Hy3+7/WqrJJKyIpSberOUS2hW4jOM7zzn8K665s7dYDlc8Dr7iuYH/HxB9T + /Suxu/8AUH6D+VRS2Kqt3Rz0djb2BZrYbeT+taMX7uRFHIYDOahuOjfWph/rYvoKlrU0Wx80+J/EGpXH + xitNHdh5CNkDHPavuKwcxRLsAHA/lXwF4g/5Ltb/AF/wr76tP9Uv+6P5VzYVvmn6nTj0uSn6FmaV3kZD + 0Cg/zqpZKpn8zGCeamf/AF7/AO6P61HY/f8Aw/pXoHldBJpnyzDjHFU7s4jA65PX8Knl/j+p/lVe9+4v + 1/pQwiZk8jiVYwcDA/Wsq9lkNwkWeM1pT/8AHwv/AAH+VZN5/wAfifX+lYs3p7oxtRv7gXgiBGCuTWdK + isxLjcQR15qTUf8AkIr/ALtNk6t9RTRZgyFreO6SM8LnA/OvN0mkhuNsXALkH8s16Pd9Lv8Az615m3/H + 0P8AfP8AI142LPbwnU868WXk0sr78ZAOD6YNYGk3lzLZ7ZW3bQSM/WtXxR/rX/3W/nWBov8Ax6n6H+de + LiT3cOtDkPFE8sWoPGp425rzqJ/KDbABkE/iK7/xZ/yE3/3K88H3W/3W/lXhVup9Dh+hzV8xm3JJyATg + V+XXxq1jUX+KdvEspRFyQq8Dj9a/US5++31b+VflR8Zv+SrQ/Q1GFSu/Q7sQ3yr5Gt8FviD4jX4g3mgq + 6+QSWzg7s/XNfdfid/Nt7PzAGzwc1+bvwX/5K3efQ1+j/iP/AI9rP61hiklLQ9LCO8NTldRsrW1uYru0 + QRSFQcrxWT8O/E+sz/Es2Msu6Mg8V0Gsf8sf9wfyrz/4bf8AJVj/ALprBK6dze/uoX9tXWNS8M+GTqWg + zNazscF04PNfL3wj1/XtfhtZtavZrpgqH942fvDJ9K+j/wBvL/kS/wDgY/kK+WvgZ/x6Wv8Aux/yrvoQ + j9Wcra3PPqTl7dK+lj7g8HN52pyGYB9hIXPbFfVGlux0pT/dLD8q+VfBX/ISm/3jX1PpX/IJ/wCBvXOt + wr7M6fw2Rc+baygeWVGV7HPrWb8MLCw03x9f2ljCkauCzbRgk81o+FP+PiT/AHR/Wofh7/yUi9/3D/Wu + 2m9jxsR9r0PcdPuZYp5II+ELEYptlfXEFxNFEdqlscVDZ/8AH6/+81RQf8fkn+//AIV7OG2R4OI3kd3f + atfRpaFX6NgfpXZQajcvfK+QCQMkceled6l/q7b/AHv8K7a1/wCPtPoP6V6uHb5jycSlyr5nTNeXNvMR + GxwcE/jWvod9ctNLGTwR/XFc9c/6/wDBa1tB/wCPmX6f1NepR3R5FfZnofhSeSPeq9N3T61xmm3txqPj + u6guyGWMcDFdZ4X+8/8AvCuI0D/koN99Kiu3zR9QopWm/I9Y1izt47HKLjHNef8Aiu/u5NKtbbeQryKp + xxwa9J1v/jw/A15V4n/48bL/AK6r/Ot5bmVLZHaG2hj0SGDG4MOd3Jrxr4kfsw/Ar4jWjf8ACZeHLS+a + RfmaSNSxz74r2yX/AJBVv9K0NQ/49l/3R/KiK1ZnJvQ+IPgz+zh8IvhB4ta2+HWlppcUrlmSHCgn14Ff + pZpRKW/kg8IBivkbQ/8Akc1/3jX1xpv3G+gqlvcK+yRBaIP7QmGTwcVj+IIwwEbch+tbdp/yEbj/AHhW + Pr/34/8APesJFQ+JHkV3fXFlL5UB49/evQ9ORZLYSMOSM15hq3/H1+A/rXqOlf8AHkv+6KiBvWWhJMPL + sy6cHrX5x/Ev46fEXwv42ubLS7tfJQHCOuR0P0r9Hbr/AI8T9K/IL42/8lAvPof5GufFSa2Z2ZfCMubm + Vz6y8PeL/EusXVhLfXkh89lLgHAORmvqm8vpke0tRgq4Gc9a+MvBX+u0v/gH/oNfYOof8fll9BWtN6HN + iklJfM8n8X6ZYHWnZowSQD1Pv6Vy/wDZmnf88R+Z/wAa7bxf/wAhlv8AdH9a5eraITdj/9k= + - name: Mkdir android/app/src/main/assets + mkdir: android/app/src/main/assets + - name: Add android/app/src/main/assets/eat_new_orleans.jpg + path: android/app/src/main/assets/eat_new_orleans.jpg + base64-contents: | + /9j/4AAQSkZJRgABAQAA8ADwAAD/4QN6RXhpZgAATU0AKgAAAAgACgEGAAMAAAABAAIAAAEPAAIAAAAS + AAAAhgEQAAIAAAALAAAAmAESAAMAAAABAAEAAAEaAAUAAAABAAAApAEbAAUAAAABAAAArAEoAAMAAAAB + AAIAAAExAAIAAAARAAAAtAEyAAIAAAAUAAAAxodpAAQAAAABAAAA2gAAAABOSUtPTiBDT1JQT1JBVElP + TgBOSUtPTiBEODUwAAAAAADwAAAAAQAAAPAAAAABUGl4ZWxtYXRvciAzLjguNQAAMjAxOTowNzoxNyAx + MDowNzozNgAAKYKaAAUAAAABAAACzIKdAAUAAAABAAAC1IgiAAMAAAABAAEAAIgnAAMAAAABAfQAAIgw + AAMAAAABAAIAAIgyAAQAAAABAAAB9JAAAAcAAAAEMDIzMJADAAIAAAAUAAAC3JAEAAIAAAAUAAAC8JIB + AAoAAAABAAADBJICAAUAAAABAAADDJIEAAoAAAABAAADFJIFAAUAAAABAAADHJIHAAMAAAABAAUAAJII + AAMAAAABAAAAAJIJAAMAAAABAAAAAJIKAAUAAAABAAADJJKRAAIAAAADNTMAAJKSAAIAAAADNTMAAKAB + AAMAAAABAAEAAKACAAQAAAABAAAB9KADAAQAAAABAAAB9KIOAAUAAAABAAADLKIPAAUAAAABAAADNKIQ + AAMAAAABAAMAAKIXAAMAAAABAAIAAKMAAAcAAAABAwAAAKMBAAcAAAABAQAAAKQBAAMAAAABAAAAAKQC + AAMAAAABAAEAAKQDAAMAAAABAAEAAKQFAAMAAAABADIAAKQGAAMAAAABAAAAAKQHAAMAAAABAAAAAKQI + AAMAAAABAAAAAKQJAAMAAAABAAAAAKQKAAMAAAABAAAAAKQMAAMAAAABAAAAAKQxAAIAAAAIAAADPKQy + AAUAAAAEAAADRKQ0AAIAAAAOAAADZAAAAAAAAAABAAAAyAAAAAUAAAACMjAxODowOToyNiAxMDozNDo1 + MwAyMDE4OjA5OjI2IDEwOjM0OjUzAAAAZFsAAA0hAAKFeQAA9CQAAAACAAAAAwAAAAEAAAABAAAAMgAA + AAEAFtM1AAACigAW0zUAAAKKODgwNDAwNwAAAAAyAAAAAQAAADIAAAABAAAABwAAAAUAAAAHAAAABTUw + LjAgbW0gZi8xLjQA/+ELJ2h0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2lu + PSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJh + ZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPiA8cmRmOlJERiB4bWxuczpyZGY9 + Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0 + aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHht + bG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgeG1sbnM6ZGM9 + Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIiB4bWxuczphdXg9Imh0dHA6Ly9ucy5hZG9i + ZS5jb20vZXhpZi8xLjAvYXV4LyIgeG1wOk1vZGlmeURhdGU9IjIwMTktMDctMTdUMTA6MDc6MzYiIHht + cDpDcmVhdG9yVG9vbD0iUGl4ZWxtYXRvciAzLjguNSIgeG1wOkNyZWF0ZURhdGU9IjIwMTgtMDktMjZU + MTA6MzQ6NTMiIHBob3Rvc2hvcDpEYXRlQ3JlYXRlZD0iMjAxOC0wOS0yNlQxMDozNDo1MyIgYXV4Okxl + bnM9IjUwLjAgbW0gZi8xLjQiIGF1eDpJbWFnZU51bWJlcj0iNTQwNyIgYXV4OkxlbnNJRD0iMTYwIiBh + dXg6U2VyaWFsTnVtYmVyPSI4ODA0MDA3IiBhdXg6TGVuc0luZm89IjUwLzEgNTAvMSA3LzUgNy81Ij4g + PGRjOnN1YmplY3Q+IDxyZGY6QmFnLz4gPC9kYzpzdWJqZWN0PiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9y + ZGY6UkRGPiA8L3g6eG1wbWV0YT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg + ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSJ3Ij8+AP/tAHhQaG90b3No + b3AgMy4wADhCSU0EBAAAAAAAPxwBWgADGyVHHAIAAAIAAhwCPgAIMjAxODA5MjYcAj8ABjEwMzQ1MxwC + NwAIMjAxODA5MjYcAjwABjEwMzQ1MwA4QklNBCUAAAAAABBP7b/y1Vk/1NM2WgzC7tTm/8AAEQgB9AH0 + AwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQE + AAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5 + OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqy + s7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEB + AQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKB + CBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdo + aWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW + 19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/bAEMAAQEBAQEBAgEBAgMCAgIDBAMDAwMEBgQEBAQEBgcGBgYG + BgYHBwcHBwcHBwgICAgICAkJCQkJCwsLCwsLCwsLC//bAEMBAgICAwMDBQMDBQsIBggLCwsLCwsLCwsL + CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLC//dAAQAIP/aAAwDAQACEQMRAD8A + /Mj9p/XWWedHGTzgn0Nfjb488Qz/ANpsiknDcdulfpv+01qhmvJhuyM1+WHiuGO51Iv0JOcZq8MrRPmq + s4zqNs9b+EGrXd5eGKHIbjrX6zfArwTd63NAsSl2yK/KH4LwNBrUDbeCQD9M1/Tx+w38LLLWPs160e7I + B9u1RiYObSIwtdKo0j7G/Zz+C2qWllHLeocH8q/QfTPA0kFqqhcGvQfBHgu2stPjto1AAXjA717Zp/h1 + AACueMVtQw3Lod9Wu2rI+V18B3RjJK8+hrzXxZ8MbnVYnjKkD6V+iUHhi3kQkqBxWFqnh62ijIRfyH/6 + q7HTVjkUL7n4P/Gf9nC0vbKf7TFuLA81/PD+1n8ArjwpeSy2qNjcSOOMV/bn8S/CFpPYyFox846fWvw1 + /aw+EWm39jcO8YYgk5NcdTDJO5OJpLkutz+Vbw/4M1C7v/JniYHPcdq+s/CHwrVolIh647V9C2nw20qz + 17YsQ3bueMV9neCvhrp1xaIzxDp6YqHFRWh5XvTep+esHwtDzBfJ4zW3rvwrtbCx8149pxuGK/S+H4VW + huswwg8j8K5/4jfDKFdLZlXB2/lisajbRm6aV7n4465pkdnIYhgAdq861dbeS3dSoyORxX0J8VvDU2kX + kmzsSK+T9d1n7NG4lYg4IxmvCxWH5nc8qvHmTR4N4ouDFfPEemTx7157eXDNx29BWt4j1Azak7etcnPM + W5HA+lc1Khys6cHhuWKKN0/O49CKwJsE7sZ71rXDseDwOKyn3b8nn+VejBWPoKCsisx+U579cVSc5+Zf + pVx14IB6VnSt2HGOK6YnpQKMpypDcc/WsmV8nKH6kd6uyyHOfxrOb5jg8gV0QOiI9ZTkHP1qcSqT83Ws + 4HbgVIrgE1ZpY0Q+Op61MjAsNw5NZoc44OfetW2XOG7UmZuJs26OU3MMCrMoc5Awcd6bBHgZPenzKoOD + xUBGJnOxyQSRmpIJZEk9vWq07he2P/r02GUbgp9OlbKOho9D0zQ5CwGP/wBVeu6XGHhGRha8K0S5aKT1 + 9vSvbNAuxJGAeAawmtTGb0OwslXziW5we9Q6iVMmwcj6U+OURHe3c8VnTz/6TuJyCOhqIrU4asjW03w6 + LlhIq9Dj/OK9I03w1EkOGTn3ql4UEciBGAyR616nbiJBlT+PXrXRzNI8ObbkcBL4VinDbVwelfPfjfw8 + 1hO/GOc19kQsjbiBxnP4V4L8SfInWQt1FaQlc2oycZI+PLyTaWUH61hszIc5rZ1QbLlk6YOM+9Yxilc5 + RS30FM+hg1ZMtQTEdTx7c1tLNuCgZx2FYcVtMnOwgH2rRzsUAg5qb6lO3QguSCcdfasxogzAdqvSPzkc + D1qWCDceDnmtETKVjOS1YYb+ma9R8KeAPEXiHD2cLCM9GINe/wD7NP7NOu/GHWY7yWJk09HHJH32Ffvl + 8M/2H7CHTIobS1DbFA4HpWNerGC94zoQr4qTjQWi6/5H87U/wO8VRW/nKGJxxkeleN+IdD1bQLkwapEy + Nk4OODX9cWsfsWXCW2PsYIHAGK+Ivjn+w9b6zpNwgtNs0anGBzkVzU8XTk7HdVyrF0o87Vz+cuZGx0GK + qRyFWy3Oete7fFr4MeKPhlqctvf27+QpOGwcYz3rwxYirZweK7bdTkhNSWhr20+wfjW7b6i0ZHzcDp61 + yUchCnnn19KtRhmOWO0+lLmtuR9Xc3Y7N9XMuR0J5rJlvGdtobOKplo/x6cVRuWWHlc/SqVVNaD+oSg9 + jXa9ZfmWqk95gbs8Y71z/wBqy+7PFJJLuXdnn/GsZas7KdLlRXvLzktXNXcm5ua07pghJOPeuflYyMTV + widGiLlrISwFdhpkx3ZPPvXGwKQR3rqrAH7y8VcjNq529u4WIbcVP5h9vzrMhZWTlc4464/qKl+T+5/4 + 8f8AGsrC5T//0Pwa/aG1t45pWuGycE/Xivzl1LUTLqZY9M19bftH6xLPeSPnPJ/OvhK5u2W58w+tbxio + xR8lQi5uTPsX4KX1tJ4gto5DwWA9K/rp/YLms9M8N20mRlgpB9q/iq+G3itdO1q2kbjEgznuK/pi/Y4+ + PlnaWVrEZgF2qOT34q49zgv7LEWkf1X+DtSgnhUqccZPNe6aRJDIg3EevWvzA+FPxq0u8tI5BMO2ea+q + NI+LulRJzOAB3zXTDa560aqetz61aW3iUoSK5q+ubeTJzntXzfqXxu0qa4FvDOpPsetUrz4tafbWu6Sd + TgZznFVKSvqzel72qOl+IF3arZuznoD+dfiR+1x4mtLK2uSrAMQR+NfdPxZ+Pmk2ljK6zKdgIxmv56f2 + vf2iYdYuJ7SwlL8kEjp71yzrxvypjxqcKdzxWLxNZXnihVDDIbJ9OK+7/h3rdpd2sUZIHA/Gvxk8GeLH + fVWubiQbi3WvvT4d/EK1g8kbxn+dYyV2fNqvyLU/SxbjSrOz+0sw4A/z714R8TfGNtc2UkUAHAyMfyqP + T/EY1jTgpPUcCuJ8S6RLPBJJ0A55rCpJJBeU9j80/jdfyzyyvEvXJzX5q+PJb2Od9zH3r9cfij4RluvM + aFPX6V+ZvxR8MSxXcgcYwa8uvVSicU7wneR8p3JeWQs3f1qhImT/ACr0K40LHUdelY8um7M7sZrz4Vk2 + dkMRHocPLE+ORjisySPDbmP41111a7OvPp9awpbc59+1dsJHqUKlzn5UI+h/Cs+4HHyn35rZmjIJGMms + yePf0/wzXTE9Om9Dmrklcgc1mF8n2rYuoWOWb9KwZV27s10wOmJIW79jTNxY7M9fSoQ5PvTl5+bGT2rZ + I2ReiJzhutdBYBi+AetYcEfAbpXTWMS7c4yfSokM6G3QFOOg/nVe9iVRx6fnWlagbdzDp7Uy8jBXgY/n + ULcaRwt2WVi31qKCY+Zn09KsXy/MQeBVGEqZMD/PpXQhyWh6BpHze5NetaE5hbcOnvXkOiMDt9frXsmk + oDb4PUY/GspbnHUOrefevytnI61zV/f+Q+/gY61oOpVCUPA6/jXn2syOHJJPA60lE53BPQ9Y8LeM4ba4 + Vd2fXnpXtdn4ljukDFhj618G/b57ScMhIrv9H8ZyrCFySc8itdLann1sA780T7Fn8SW8cGAcA18++N/E + P2hXVTyx4rAk8ZvLD97JxgZrg5NQfUtWiikPBcZNKL7DpYSSfNI9Y+FPwYufiBq8bXKFg7DjnFfsr8EP + 2JdCkghkmskfOOGQGvMf2OvA2nXTWr7Ax4Nf0bfA/wCGlobCLKD7oxkV5OOzF03yQPsclySGJj7Wvqfl + T4n/AGJ/C39ksINMhDAddgz/ACr8pv2hf2VYPDole1thHtyQQuP6V/Zn4h+Gdq+mSBYh92vxp/a8+G0M + Vnct5fQHkCuOhmc+ZKTPVzDh2hGk5UlZrsfyMeKdCuNA1F7WcfKp4NdF8PfC934t8R2mh2aF/NcKfTFe + nftDaQmn61JHEnzF8fnX3D+wJ+z9eeIfF9hqE0G9SQScc19LBrl5j4mspNKkvieh+sP7KnwPPhvQ9I0+ + 2twowu7A7nvX7xfDH4d2cenxxxRgHAzx1rjPgd8CLfT7K0kaHBCqM49q+5dC8KPoIT93lF7V4uMhOUrv + Y+5yqlTw9JQicVP8LrK4syxjBJHcV84fEP4I6ffW8rCBS4GOlfpRanTnsDIuCTwFPXNYbeCV1GN5pE5f + 2rm9hquXc9H6wuVqWx/Lx+0z+xZbeKdOulktQxYE/dr+Y/8AaO/Zm8T/AAe1qadYGayDHoPu/wD1q/0q + vFXwLs9VtmWWEHdnORX49/tl/sDWPjHQLyW2s1ZyjdB35r26HNGPLLY+SzPBRnL21DSXbufwTIArAEY5 + 6+9b62j8KtfVfxx/Zc8S/Cz4lP4fu4GSGWQiMleOtev+D/gx4asLBWuIFnmwNzNzz7Vx4/GQo6Nnu8J8 + O4nMpP2cbW7n54tbPv3dB9Kr3sRZTuXOBX6Uax8KfDNwrBrOPpjAGCK+XviL8MofD5MtqmYn5B9PY1yU + MxhOSR9Vm/BeLwlF1JpWR8nNGA+R16AVKSAoGPmH45rXvNPa2cjqRkcVnGNRHhugH1r2Vrsfmc/ddmc9 + dNvZg3eqG3DEH9a0pwd2Dz9aoOvzcjjpW0UZcxat1XqOSDiujswF4Axiuft1K8niuhsiCwLdueO1N7C5 + jZTcF45z74p+X9P/AB4f4VEzIpwFz/n6im+Yv9z/AD+dQLnP/9H+ZD45R/aZ5WcngdK+H9WmWB2X+7mv + u74y26NNK3I6mvgXxXtjlZe/P5VcJ3R4GFpcrZFYa1PBMGiOMe9fdnwJ/aHvfDUsUDzFSuOSa/OeF8sB + 7YNegeHYL6WRZYQSKtTtuZZjgo1I3WjR/Sz8IP2x9RtrRI0uhtwOS1fQc/7b+oWkH7y9LY/hU9a/m78I + 3/iSyjVo5HUL+Ga9k0TxPqcs6i/dsipdZdGeDTo14u1z99fBv7Y2vXt60rylmc8DOcelex3f7TevXFkz + TOS2OMHNfip8OfE6xTRtES39a+rrLxA12oJPbkA8V5GJxE09GfYZXR933j174j/GHxRq1pIEk2K4OeeT + mvzR+Kct1eSyTMSxYknmvtPWpEmsCHIB7Yr5Z8b6dvVmcd6wwdRuV2dOa0lyWR8YDVtT0i5Pk888V694 + D8e66b9HYkBSBye4rkdS0+M3JjYck9a7nwnpMayKVAAr6KMtD88xlJN6bn6R/Cr4kr9lSO8bBwM5Ne9a + j4ns9QsdiMBkdq/PTTbxtMt1lhOAuCBXSWvxImH7kt7ZzXHiYO10dGErWjZnuniltPkgcZHIJ+lfnz8W + vDsVxcPMiAgeo719N6j4xtDbbp5OevWvmvx34lsp1cCQA+lfH5hXlG6RhjqiaPjrVNCZZTEBzz1riL7T + Ng2tyeua9o1SSGRjKckA15/qCqCdnQfyriwdWUnqeRQnNyPJb202np+fHvXKXUODtB7V6RqcSgEsf/rV + 5/qON3BwBX0dFOx9Lg76HLXEXLFuh71kzqSpx/OtiY4yIzwfWqEiOTnv0xiu6KPdpnPXCALlBz0rAurU + L1/EV3Mlvu6jj6VRurRCCpGc10RZvCepwDx4yFOamjXsRzWlJa+W2CKU2gLZ/l61spHUpXC2BLAHpXW2 + qAjB+tc1FbspGRXQ2zGIAnkHqKiWpR0SNtXjoO1VbuQMpH501JxySfzrLuZgCff0pJFxMa6CuWb1NZYI + WUZ5FaMrA5A7+neqUihSMDNboo7fQ3y6mvaNHcmLaewzXh+iHDDv0r2TSJVSMDg8VnJHDWR1YbfEyete + ea/wSeorsTdFgQfXH1FcRrcmSd3PpVROeO55vfuAxB65plpPIinHHr9KZdsctnjtRaAnr0qZM7opNG/9 + qmMXzHP0qvptxKupxM2ThvyqMsoQ54qpZs5vo9vTP41MdwlFcrP3m/Ya8W6fBNaW94wDcdelf1R/s9Xe + mX2nwGMg5Hr61/GN+y1qNzHfW8SKd2RwOa/pP/Z41DxGNOicJcIm0dN2OK+czOm41Oax9Vw3ik6Ps7n7 + D+K4rW20eZ8jlTX4V/tp6/Z2+n3WWG0q2ea+2PGniy+TTJEaV1IU5ySD/OvxV/au8Ry3Nnc+ZKz8N1PF + efRvUqpJWR7eYVlSw8tbn4OfGe9XWviLb2ajcklyo/Wv68P+Cbn7LsFr4S0/V3twWkRCCB1z3r+PTXEf + U/i5p0Iyd12nH/Aq/wBHb/gnR4X0+X4MaJI6qXFugP5CvvqdL9ykfmuEqJ4yUn0j+LbPsfwN8Po7Gyij + aLGB2rv9X8Mp9icqnIBxXtujaFCIBsXitLUtAge2bI4xiplSjJWZ68cTKMro/Oq21C6sPEP2e4fCh8Ae + 1fVvhF7LVEVI/wAfevD/AIjeA0ttZGoWYb5XJIA6V6P8MLO8huEL7lU8YPpXmYbDyp1HF7HrYrERqUlJ + bnt83h2CeIHb19q8L+IngS0vrCVZIwQQQTivqx0CoPLPb0rzbxTFHLbyIBjjvXquyR5FFuUkkfyv/wDB + RP8AZC0fxHps3ibTrVftVrudWA5yK/C+18BaxbQEeT8y5B5wc1/aN+05oWnt4bufPUNlWzmv579X8E6J + cX90tiqlPMbp25r814jzBUqqif1Z4TZAq1F1rdj8mdb0++s5DHIhGOvH4V89fFTT2l0CUtzgjr9a/Vr4 + kfDqzjt5JQgHBr8sfjDqFrJdPpFkwdUY7iOcmuTK8YpyTR+g8dcOuWClyLofAfiC32Oy7RgZrgpVGCOm + K9x8TaVuV8jpmvFNSge1kZCevt1r9DwVVTifxFxDgJ4as4tHMXRUEkcf1rL3HJ5zVy6lJJH+cVjmTDY/ + SvRSPAijYg5bJ6H9K6OzXOMnHpXH27EsF/Gut08MzDcc9KTKlojp49uwE4H1p/y+q1q28dq0Kl1yfrU3 + k2X9z9RRynI6x//S/mi+Ms4SSXB6ZJHrX56eLZi07A9Qev1r7r+Md3vkmVz0PWvhvULF7vUsY4zRTaUb + ni4fe4/wJ4S1DxRfrHEh2A9cV95+CPgzDFChdAxwM4FcX8GNHtbOBDGmDjrivvfwVYpMRuA57V81mWaz + jJxjselTwvtXqcBpvwqihtC2zt6Vz0/gQWsr5XA9q++9L0G3ltcbe3P415J410e2sYpW6gcnNcuCzGU5 + WZeIyuEI8x4X4VhfT2WMdSce9fSmh3xhtgHb3NfOekXqSXbp2U4FeyadJvjAjJGOx5r16sW1qThbR2PS + dT1EHTWfJzjmvEdfu/tFi/mdc8V39/OF0xiTk9BXgWu6v9mLwyNjd0pYaNmLMJXgedana/6WZscZNbGm + 6umnxhsgEetc/da1aSuYt2cVxeva5DFFhSBxnrXvU9j4nEwu2eo6v8UBZwbd/IHTPFec3fxdYHML4Yf1 + rwDxHr8ku4K3HfFeWXGtzoWwevJxVVWnFoyoZdKWtz6wvfi3ezny3nJGMYyfxrlZ/GFxqUu3fkZr5mi1 + iZ58sfbFdxpuqKi8Y5/OvlMfh+ZvQ0r5Y4q7PYLnVYzb/LnIH1ridQ1fd8gOSazLjVYihYtgmuRn1Ug8 + Hn0rlwmDUehx0cE1K9jUvJ5JhhmyPSuTvwWBweR0q1/aBZsgdfWsS8ldz1r2IQse3Qp8ph3MgjkPNNjK + upPGO1V58Nmo4pSPvdBzXQkdy2NqFFIAxjHrUdxa7lzjk9eKfatu2r+taRERIBq0EXqcLd2e1j6elZzR + fNgdTXYaiiBTyT6Y4rmWVgxbr71tE9Gm7j44V6g8Y9KsorZweh7VHGckYOfwqbgLjGfWqasbETMBwDk1 + nXUpCHHOP5VdY4BI+vpWPdszcHkGhDSKKzDJJP4VZJL7azBxJgL+tacQEgB5yK1TKa7G/pBCyZx0/nXq + elyMsJbpnvXlenLsmHvya9F0ybamG5qWjirm+9y6jaW7nNcvqcrSkqSM9vc1bublQCQa5+6nDElW47U0 + jBLU5a6YMSR1zVmx2mM54qCcoWK55qW1/djLdOmaiSOuDsaLI5GScCus+Hng7UPFvia3sLQcMwBboBXJ + xDedq9TxX6EfsgeCIdQ8U2csy9XXnFYynyLmYqrbXLHdn7f/ALD/AOyR4U8P6RaazqsAuLogElxkD8K/ + e/4beDLC2s0hhiVEAwRjA/Svm39m/wAA20Phy0EaA/KAcdq/Rvwn4RjhtFAHbOPevMdZ1JXZ9RhcJDD0 + lGK1PmT4xeALC98PzPbRBHCntX89X7UXhMyi7sphhlzgiv6p/G/hZZNNlRgSApr8Hf2s/AMf2y5eGMcg + /nXPVcYTUkjerB1aLjc/lxuvB72Hxh0+8Ix5Vwp5+tf6FP8AwTI1kX3wk0uJz/yyTjPbFfwz/Enwk1h4 + 8jkRMMsob9a/sf8A+CWfjaO4+HOm2gcAoirj6V9Dh8RzRimfJ4bD8tafp+TP6JtJtwIVVcE4rSubMSJt + xwOnFYXhi6S7s423ZyMV3Kr5mB7V1s21PENc8M20jM8iZP0rmNPtBplwURR14r3jUtLEoOOteWarossM + pYZ5JNZVZWVzejroy22rhYMSHFeXeLfE9tbxszsOBVfxPf3Gmws7dAK/PT44/Ha18LWs73EoUgHAz1rw + s1zaOHptyPseGcgljcRGMTzv9rn4mWdpoU0aSDLKwAzX4IavrF/HfTXFrM0ZkYkkCvYvjv8AtFjxZq0s + dxcYiXOBnivjHxR8UvDdnbPNNdpnbkKOv6V+N5liqmNxDmkf334c8MLL8vjBrVnknxv8W+IJLOSKa9lK + +gOBzX5peK5JWuJJJCW/GvpL4m/ESDXrtkgYlAeM180eILmOXMq8/wCNfT5XSlTikz2OKoUp4aVNPU8x + 1VRJESc56ZrwXxbCoLPwMdga9t1O6VYmDcdT6Zrw/wAUzCRjnH0r7jLG0z+EPETBQhXlY8tuHySvTnNZ + Bk+YnofetW5XAYuKyHJLHIPpX0iPyJI0bMqHwTmux02RSw9etcLA+1h9a6uwn2Pux26UnuKa0PSIGi8o + bzg/59qmzb/3v5/4Vz8N2fLGGA/DNSfbG/vj/vmrPOadz//T/l7+Lel3DzyPg9OM+9fL0enKl4Gde/ev + 0p+Ifg5L3zCFAb6V8beJ/B8llKZMDqTxS5XKGh8rTxijNxZ6V8L54Yggfp1r7n8EyQsqMhAJ5zX5seFt + Z/syRYpDgdq+pPCHxGjs0VpJQVGBXyOZYGUm2j6DA4uKep+jOk38cVkWc4wOv9e9fL3xV8cWhnksbY7j + k5xXm3iH49mSzNhp784wSD1rws63cateNcXDEkn17Usry2cHz1Drx2NVRckNj2nwzK9xP5qg/N/WvdtF + lCqCw+n0r548HTsHVE9MelfT2hRwSoGf72K96ojiobl7UYPO09vL9Mcdq+XvHVlcW9rLO/B7GvtkabE2 + n7ohyR+Ir5m+KumebbMgONo/nUUdzTGR9258DanrFzZXBZnOM9c1zGp+JWmUru6+tdB4zsjbTMMcH9a8 + I1a4lgz2Ir14T0PCeFU3c2L/AFBHcknrzXF6hcj7wPB6etZk2ouxxnGKzZ7sk7uaUnc9GjhuVG3bTkkN + 3FdFa6i0S/J9K4q1lUNluMV0NrtYhs8DmuGrBdRV6aN8XM9wvI49ac0MjNkDk88mrVlBuGR0NbiWYI4P + X9a4XUUXY8OvPlehzAhc8Hgdc1BcWqsNx5zXYfYVjXJ9e9Vbm1yMKMj+VWqlyadU88urdecDJrFfIO0j + PpXa3do24qQMfyrl72ARsTj8jXVTkd0JXC2uADgjk+1aazKwAPJ9+1cyJJFfH/6qupKSPQH8+K2NlB3J + rmbJOfTrWEzbWxnA6elXruVgpB4PXFZDtu4Jyc55rSB3U0SrIATk/TNXYyxHH+HFZKM2Mt2rVt33KMnH + erkdIjpgHvWRdxsVOBxXQOuVJA+tZNyn9449qzvqJHNlCG3Y6GtW1jYnY3NReWehBwenFaVjF82Fq1It + 7GpaxYceh/OuytW/dcccVzkMQHI6jtW/CxKkDjIqjiqorXM+0kkZrENwxJT9Ks3soVsLyD2rCEyb8E8+ + 3SgiMdCaVfm9c81Om7G0fdpFAI3d+OamUALkcj0pSKLNgGNwhPPP0r9eP2LdPVtStbhhyrLg/SvyLtVb + zk2jjIIr9h/2KZR59rHuycjiuDMHai2jTDa4iCZ/XX+ytrOm3OhW9tcYDBQOvFfpRodraxW2/cu3GQa/ + HT9nY3AsoDEcHA5FfpN4dS+mskM7sVx0zXzWGxzWjVz7yrhXKN0zqfHF/FNbSW9s2446jmvyV/aM8L+b + bXNzP1wT9c1+n2qQ7Y5BH0r4U+Ptsk2mT7hyQfrW9Wp7Rpk0qXJFo/mG+O+jCw8XG6IAxJn9a/bT/gl7 + 8UYbaW20WSUKRjaO1fkP+07aeTrMrsQuHOB7V7L+w54xudE8bWK28hQ7xxn3r2OZwpKR8th3fGuC6n97 + Hwy1g3emRENnIFe+2u4rwMZ5r4I/Zq8Yf2/o9qmcOqKTz7V986ayeWMHIAz6169GqpwUkTiabhUcWWng + kZQRj8q5LV7RJIySOntXoAZWQ5HvXOatHlC3HcVbMovU+JvjPJc2emTG3XOQc8V/Nr+2d4m1Szu7pZWY + jnGOlf07fFy3ibS5jJycGv5kf29ILXdcxjHKtyPWvzjiyi3JXeh+5eF017Zaan87Pxe+KOpSas9jFKRy + ckccfWvnPU/F97MhVmJFa/xNnDeKrlB/AxGK8suGyK4sLhYRhGyP69jm2IpYZUoSsrCXer3MjHJ4rmdR + 1GQRkVcceoxWDqgAjOelepRiro+QzHFVXCUnI43UbppCW74xXlmvNuHU/wD169CvTsPTnk15vrThwWPG + K+kwKsz+VuPqjnVk2efXIOSDzWI5+Y85rauCPvViMfmIB+te9E/JkTR1sQSlTkdawlOOa0YpGUYNJg0d + It3CVHmHml+12vr+v/16wPOlPKbse1HnT/7VIw5D/9T8TPHNyqRvg8sOc9ea+QPGTCNmboO/419J+N7q + aUyHHTnivj/xnq0lvJIpU9arD6o/PpTU5XR5nrEvlbpIux4xxXPR+JL9VCbyM8de3pVLWteV1O3pXK2l + ybi4/vDiqrQja9j3cDBtanvGhXjyRBpCScV3ul3J3AA455+leW+H5QVwoz/jXa2U7JIVP3fWvPe56rWh + 9E+FrvbsAPcfWvpnw1qJcLt6YHFfEugaxLFMqA5xX0P4a8SRxoGLfNWdQKLsz6/sNQhTTiBzxg+1fPHx + OuIZIX2nkg9q6qz8TgWJQHORyfavIvHGqrNExPX2NZ0l7x0Yifu2Pj3xqhed8jIr5v8AEabCxXjPPHvX + 0n4snEszFj78V87eIyWlODxzyK9OOx50NzymctHN6+1V3wThat3f+t288+1Vpcnn1/Cmd8XoJFNtcscY + HT3ro7KcsQvauOd9rZFX7S7w2xjwOtY1YXRFSN0epWV35ZCqfb2rq7CdZSFB/DrXk9neBnHOfSuv06/K + 8E9MfWvJrUjwcVhz0jyB5YB5NQvb7kLKOP5Vk2+o71BzyPX0q61+NhViPXmuaPMmeYqM09DmdShG5i34 + VxN4BuIbjPXjrXb6jPvy4ya4a8DMSScfhXfRbPRw6fU564TZkn6VCkp6CrFyVA+tZ2cd67oo9inDQJWJ + +ZuO9UjICdw+gqxIC3yn9Kg2Fjz07ZreKOqMbDo93OcHNa1sOcCqEULJ1APrWtASoPSh7FE7qNuTnFUZ + RngdK0W5HTAx0rMmcNwfrxWTQFDameOavWkYBBXHvVTILYHX1rStBuYZ4JpXHJnSQRFkOOv0qyoKKe+P + WrdnGGjG4/WpJoUMZOPbFWpHHNHE3rgFsHr/AFrnRIVcBPXmuh1FGLEd/bk1zyptlzjmm5FwibduQT61 + pRlBn35xVK3UMBV9cHA54qOYTiaFmnzrkZyR1r9XP2QJngvLYqQOV+vFfldZfNIvGcHrX6c/suXkVrcW + +4jjFcmYP9yy8JG+Igf1Ifs6a28VjD83QDFfpVoHiRhYrn0/lX4vfAjxvb21tCjN8oAr9CvDnxAtPsoQ + nPA5Jr89q4v2TZ+tYXAe1gj6U1TWvMidgw6HpXxP8atVL2crOecEV7NP4thkt2IOR7etfJfxi1h7qymE + HL4OK2w+P52jWtl3JF6H4YftRTb9ZmbqNxP1qf8AZSne38a2VyoOFkXJ9qv/AB+8I+ItTvJZIot24k9e + atfs4eHdZ0rWoUu4CAGHfNfYSq3wlz85jh+XMtup/ZD+xpqYe0jAfJMSkc1+qWjX6+WpPtmv58v2SviV + d+F2tvtRzGODn0r9ovCPxH0PU7JJYZRlsd62yrFwlT5G9UdmcYOcavPbRn0ut6rLkHmsDWL+NISxNeeT + +PtItY9zzqOP7w/xrxzxr8b/AA9ZwMouUOP9oda9WpXhBXbPKo4WpOSUUcp8cfE0dtpE4U8hSMV/M7+2 + BJdeI9RnsLRS7tlQPUmv1v8Aj9+0Fo32Ca3hl3EggAEGvyYeRvHnjCS5cfIp3D86/Pc8rrEVbRP3XgLD + vBQ9rNH5U6X+wM3jbVX1jxTdywLMxbZDgED6kGux8Q/8E0/htDpjS6bqF+k6jI3urKT7/Lmv2U0zwhBH + FuC42j0rA1bQn2Exr1zn6VywjUSWp+uR4qk9HI/la+M37POufC7UJIGDyQKTh2HOPwr5N1qOSEFCK/pH + /a08GWl3oLSSRoWKsOnpX88nxH04aZqktqgwNxwK9DCz5nZ7o9arj6eKwjmtJI8K1EjBPcdOK8x1x++e + n516TqTIIj/+uvKtbbLEdK+nwW5/MHHE71JHGzYOSxwKyjitCXvms9vRa9yJ+Wjk6jJ6VewFX/P86oxn + BAHIq6OmTyDSYAjyKMIWA9qf5s395/8AP41EAD6Uu0e3+fwrMD//1fxT8T6CL1WKkDr168V8TfE/QfId + wOM8cV+iPj7w5eaeHe0z3z7V8V/EjTHliZ36nJNa4KzifmOsLNH5/eIbeaGY4PHQYrN0gOsgbtnBr1Dx + HpCMTuXBz6VxtnZqk+2MZOausj7HL6t6aPSNEnZFGCAQK6H+0ZN2Afp2rlNNi8gbj6dBS3F9sYAdc/jX + A4anc5HpOma7LA4GAcc16fo/iqSPa0Tfd9/5185298rfMvGOldPY6ksRDZzntUypmd9T6w0/xs3lEMeo + x1rivE3iieZXy3B9K8zt9cQQAM2M8/nWDrms/Jw+R0pQp6jm29DH1/Vtxc5yT+NeO6xfCTK10OrXgkzg + k9a89vp1dywJxmuuMSYRObu5Cz/MMHNU5HYEkjFSXMuXBPbjNZsr8cnp602jritAaTKbQfxqmJmiPXrS + PMfu1Wbnv+dK1zSxvWuosmNpxx+FdHZaozYLNgfWvPNpzx+VXbV3Rwc1lOimZToxZ7Lb6oJFVN35VpJf + ttG45zXnen3WxMk9P51tJfAKegBrhlQ7HK8JE6G5usqWWuUu51IJ61M9yz5b0/WsW5Jkk+Y55ranSsEM + MoshlkLfKOc81AM4JPOaljjc4z6960Y7RmzkdO1bpWOqMUjFO5ydoz6VKqOBsIzz+VbYs5VbgACrUeny + lcgcfqavmKMKIEHkEH0q5GsoX5FrW/s1gxYgfUVet9PY/KRQ2K6OZkE5GCKyZ/OXgrjFepwaCxH7wc9v + rQ/hwuSxX8cU4q5hUxEYnkiMR+Fa1qzlxjnpXenwfPL0iPFMTwtcxNuCHFRNWJji4S6k+kkSxAZyB7Vs + XFviMgHjtS2GlyQKBggnFajRYTa45rHmG/e2POdQs/mLAf5Fce8JV8qOleoapAmwtjBHANcFLDsYnvT5 + jaESSBBsAf8AOrseM89qz45Ng+bJJ59atQEGTOfwqblyhodXpUDtLGQO457V9zfBzWW0maNm2jBGMdq+ + MdIUrEFQYxyDXrvhnXprAh1JGK5sYnOHKVgoqNTmZ+7/AMGPiJK6xR+YPlwODX6a/DrX7nUIFUscNivw + M/Zu8SyapPGiMcsQBz61/S7+yX8J01fToNR1Fd+QMZFfmecUuSfKfsmQ4iMqPMz0/wAMeENS1e2DpCSC + Op5zmt26/Z8udbgLSWvUdxxzX6Y/Df4W6TDZRosQHA7V73Z/DPTguEiGB6CuvLMtqSipo5MzzmEZOFj+ + dTxf+xKdXmMkliuCeDg9K5Dw/wDsfjwvqSztabADkYHWv6YpPhnpbj54x+Vef658IdJfL+UvB9K+glSr + xhyvY+cjXw8qnPy6n5AeGvCkvhiFI9hUL1+gr1y2+Js/hu1ys/k7Rzzx+tfRnxF+GcVlbyPap0B6dq/K + 74+6td6DaXEYJVuQK82VSVOWh7MIwrQ1PXviH+19BpVo32vVRGecgECvizXP2xtM1m8MNtfBxnHWvxh/ + ar+LniSz86K0uXXkjr1r4P8AAHxm8RPq3k3M7sGf1r04YedanztnkxzCNHEezjHQ/ol8Y/Gg6+dyzby3 + HB9a1fhDq8ra4JZzhZTjnivzR+GfjGbXp4zOxOMdea/RrwBYvcQxSxn5uOR7V5VSjyy1P0HL8Y50vdP0 + x0DQPt9iCpB3dMVa1f4dzfZC6DnFeQ/D/VvGmnqsNqBKi/8APQZ/rXuWoeKfiBcacY444IwVxuCHjP4m + vQjOjy6o5qmJxMZ+6z8nf2v7X7Lp0lggwyg5yc9a/m1+NelX0WsSXOw7MnJ71/UB+0R4M17W4p59Rk5O + TkKBX4c/Hb4eC0EwZc5z78VxUa8VV0Pucvx01hmpPofkxqjlA0bfnmvLtXbLMMdePevZ/HWnNpd7IqZC + 5rxzUYw2eOnWvsMF3Pxbi6spVJHGtExY988VVeAgVssi4DHFRtFn5sV7MWfnTkYgUg9OlWAAKstGq9qg + Ix9KJFJ3GMzKcD/P6Gk8xv8AP/6qd5LSfMBmj7M/9z9f/r1A7o//1vin4h+GLaGGRkX5Tk/WvzV+J0EM + FzLb4HJ/SvtH4sfGK0t4pYI3GTkD8a/OvxRrk/iPV98ZO1zxWWVN8t2fmdStGTtE8M17RRcu7KDgn864 + 638LSKcqh/Kvr3S/h9JewhmXIPfFbknw3kt0IEJwR3FdtXU97B1+WJ8hDQPLjy4xxXB6vaxwSEdCO9fV + ninw21krMy7evFfLXiVHjlkJOc1lCGp6ka3Nsc+sixHDHHoK1YdRdOrVw1zekdGwetUhqT/j9a05UbJM + 9Zj1TMZ5rDv9VyuJOAK4tdSl25LYqjc6gxyCelJQQ0i9d34wR1rlb26Zhls57e9RXF55hPOf6VkTXOO/ + Tk0cprGI2aXDbuee9UHYkkfpSTStyB+lSadYXeqXa21uuSTSsa7FULIz4Qc1qWvh/VLlcxRE56DFfYPw + n/Zy1PxD5TzQls8njNfo98Pv2LjcQIWt+T/s/wD1q83E5nRo6Nnbh8BXr604n4dDwPr7AbYSR9OtOTwV + 4hD7Wt2yT6Gv6O7f9hlfL3m1wO+V/wDrVPH+wwA+fs3H+7XJHPaDOqWSYyP2T+dqHwhr8bDdA2c9QK1Y + /CWvuOIGBBz0r+iRf2GrUD5rY59dtW4v2Gdw3G2/8doeb0CP7Hxj+yfztR+CtfcECBs/Sl/4V94idjmA + hj19a/o8tP2Hrdhj7LyD1xWkv7D8O/P2fn1x0o/tigilkeMeyP5x7X4ca6oH7g/StqH4ea4BuMJ/EV/R + xafsR2yN/wAeuf8AgNakn7Fdsx3LahRyPu9qzeeUb2N1w5jGrn83sfw410c+Q3txV5PhrrxAZYSPwr+j + uL9iq2ibi0HqeK04/wBim0kcH7KOOvFDzuggXDeMZ/Ns3w41wjmBsfStDTvh3rjyH/R3bAwBjvX9JMP7 + DdrKflt//Ha7DR/2D9Pi/efZeT/s1Dz2j2CfDGLtufzcWvw18Skc2rHPTivUfC/wO13VpVSe1dV69K/p + J0f9hrSw6lrQD1+UV734V/Yv0WBBvtVyPbmtYZ1B7I8qvwtiPtTP5uNM/Zo1G4hCrakDHJIp11+yzfKm + 8259/lr+q/Tf2R9BghGLVegzxUN5+yTpEi/LbBc/7PNayzaNtYnEuFKl/jP49/FX7Put6Vukt7cn8K+e + 9d+HniSycq9s4x7V/Z34j/Yw027D5t16ZHy//Wr528XfsHaZdxNttASM/wAPOa4aub046uJ6eG4bxK0U + rn8hF94U1wKSYHB+leeX+g6xEx/0ds/Sv6s9a/4J72ryExWvXP8ADXl2q/8ABO9Wk+a1Bz0+SsZZ/QS1 + PQhw5jPI/mIXRNbHIgc49qtWWh6w05Vrdj+Ff0pJ/wAE60JyLTGP9mrNn/wTwjikDm25z3Xriuf/AFmw + 97HT/qzjGtj+ffQvDutTRhRA35V2y+FNWt4tzwsMdOMV/QZZfsCLaDzhagf8B9K8u+If7Jq6VbMBb5Kj + j5af+sOHk7IdPhnFwvJnyd+wxo+p6/4vtvD9rC807yDZGoySfav7VP2W/CD6JpFto+peVDeeWD5BkXzC + B/sgmv5Vv2K/hjqHhv41vqcKmNdKtprkn3xsX8ctX6k+HPHXirwv4os/GkN5M13YziZWZzgBeo/EcV8D + xRmjjjoRhFOFk276n6Fw1lblgJc0rSu0tD+qLwPbRRQRg+nI969qtQgXjn+VfC37OP7Qfhb42fDzT/iH + 4dnUx3YZJkU8xzxnbIp9wRX1ZF4us44/vg/jX1mV5nQjSWuh8nmOCqyqPTU9GkEbAEdfpXL6yUCEgD2r + LXxVaOM7wfrXJ634ngEZYvnvXfWzSi46M46OAqJ6o8u+IKQ/ZZGbHIP41+Ev7ZzQQQTTRr1Jr9jviH4q + U2sgVtxwenWvxE/a+v5r6yuBtOADzivnalf2lVNbH02GouFJ3P5jf2qNaEupTR5IO4/LXxr4MCPrAkU9 + D29a+g/2rruS38RSKT36D1r5w+F8hu9VyM/er7LCxtQ0Pia0r4l+p+nHwHgkuJ4o15IIxX7dfAPwhJcx + w/agSAB+NflP+y/4GmnkiuJEPzYr92/g/pP9nWsRdOg4rwcXUXtLH6FlcpRoXPrjwR4LtfKjGwAeor02 + +8J2/wBnMZUc8cCuW8N68LNQrjOOK7a58QRtDuHX3onXpqJnL2rlc+Fvjp4Qtv7OmXZjg/pX8/8A+09o + McBmVBjGa/ow+OmuWZ06UOQGx61+BX7RKLrN9NDAM9RnFeHHER9voz6jC1ZrDu5+AHxltpRfPGq52kjj + mvnW60++KZ8pj+FfrpqH7PF74p1EFYSwdq9r8P8A7AdzrNojJC2SvTFfZYbNqFKKUmfm2eZfia0pShE/ + AVrC5xuEL8eq1CLedVyyH/69f0Q/8O675VIe2P4rmse+/wCCdFxtO21PrjbXqRzzDdz5B5Pjf5D+eie3 + lU7gpYEVQMEvHymv3o1L/gnrcqTttSD/ALvTFcnL+wNeRkr9l6Dn5acs6w38wllWLX/Ls/EQIwyCnf0p + drf3P5/4V+2K/sEXjDItD+K5p3/DA97/AM+n/jlR/buF/mF/ZmL/AOfbP//X/nD1rU77xPqRZn+Rj3z3 + rvvBPw8NxNHK6kn1NeJ+G9RM92shGc4Nfa3w2urfavmcY4qaXuKx+T0KLi7M9s8GfDe1WJFI7d/WvQNT + +HmnxWzAKOQf0rY8M6paw26v0Kip9c8YWMFnIzkA8n8Kacmz36U4qOp8I/F3wZFaRSiFccHHvX5c/ElT + YXrqpzjINfp38YfHdpMkihwo5r8t/ifqttdzSBDnrXdCHu3Zrha/NWSjseI3N+xclTxVEXxAAzg54rGu + Lk+ZtY9DVH7TjPv2rM+pUDo21Fs/Kc1E2oPjrnFc81xnB6Uzz+fSkVyGs90WXk1TedmbmqDTDvViztp9 + RuFtbcFmY4FA7FyxtLrVLtLO2Us7ccV+lf7L37LuoeJLuG7uoCd2D0qh+yr+y9feJ9QhvL2AsWYHketf + 1Ffsq/sp6ZodrbmSHBGO1fNZxnEaSdOm9T6DJslnipKdRe4eVfs9/sjWtnZ27SWoGADytfpr4M/Zx063 + iXFuAPpX138OvhJp9jbxqsQBHt0r6W0fwDbRINseOPT0r4lwrV5c0j76MqGGjyQWx8M2nwF03y+IB9MV + aPwD04HiFQPTFfe7eG7eDC4wf6VXfSIA2eMn0raODcdzCWNUj4RX4DaeSGaEfTHSrY+BOnIoHlA59sc/ + lX3Mmj2+/O0VJJotsUPy1r7JpEfWEz4Mf4JWUYKiFcfSiP4KWiMGaEN26V91r4ft3xhQfw707/hHbYEg + DB9BWU6ctzohXR8WJ8G7EgA2461D/wAKas04EAFfbn9h24Jzx+FB0CFvmwB36VkqbbNfbo+JB8ILRSSI + h78Vp2nwisR1iGfpX2GdBt2cKR9au2vhyBm6fWt1QkzN4pHy5ZfBmwcBREMY9K6m1+D1pEm1IgO3Svqq + x8PI23KgA111poEAA2gc100sE2cFfH2Pkq1+E8EZz5Qzj0rr7L4ewQYzGK+mBoUCgkAHFNXSIwcKMAiv + Rp4XkPKq4rnPErPwTATt2Z/CtJvAdt5Z+TOe3vXs0VjGoGR7VcFmpHOAOvFdPs01qcnO76Hzpd/Du2m+ + URj8q5e9+E1pKNpiB/CvrdNMQjgZqyuiRlgwHIrkq4LnOmni3A+HJ/gdpzZzABn0FYc/wI0yReYAOfSv + v46FFt+79agk8Pxf3etcFXKLo7aeatM/PQ/AfTgdsduOnpVdPgPZqCPIXPfiv0I/4R2BcybevWq//CPW + +BhBntXl1Mk1uejDOT4AufgjZLA2IF6ccV8l/F74B2t1BMqxZ47Cv2ivPD0JiIwDj2rw3xj4Dgvon+QH + Oa87FZdOmrxPRwmZRk7SP59PDvwjsfhho/iXxRIixy3TRWcWTzyS7fyFeaeK9Yj0fw1c3Y48uFmya+6/ + 2xNItvDo0rw1B8rSySXLgcegGa/MP9ofXIfDvws1zU5Dgpaui59SMV8ljJSrV2pb7fofVYXlhR5ltufT + f/BHvx34h0P4G+Idakmke31fxHdzwqxJVVQKh2jtkg9K/XHWPj7f6bEHdmwBX5a/8E6vAl54X/ZD8GrI + hR7+3e+bIwSbl2cH8iK+xfEdgZtNaKXg4I5ruzDDVXUnyNpX/LQ83AOk6VN1Fd2u/nqegz/tgXdtJ5a5 + Jz613Phj9ofUvFeFCsS9fn2vhiRr/Mh+UHI+lfWHwm0aC2cADnFPKcFWdRKcmVmM8PGF4RR7trmuXt7a + ncMZGTnqTXwB8fdKN3YTm6Tqp5FfopfWsa2+QO1fHvxr0sXWk3BAJ+U44r7mlh1BHy7rX2P44v27PDja + J4qluIxhHYjjpmvBP2ZtCXVtdV7hc7n4r7p/4KB+GLmVpZGjPD4HH1r52/Y+8L3La5BJIjHDjtX1dJ2w + u/Q+GqP/AGy3mfvd+zn4FeysYJigVcCv1R8GaVBHZo2MHAr4f+EsAj0yCNAcBRzivsTw/rE9pbhTkqAO + TXyFWfv6n6RSSVNJHp8+onTpASTxz+FY9149twpQNn+dfP3xF+IL2SyRoxzg4r57tviXdXVzn5s5rx8Z + Wn9k7MPCP2j0b41eLGntpiCcc1+e0vhk+KdTZ2G9WbnjrX0N421PU9Y3ooJDDr9a2/g/4Lkup18+Ik57 + 1wUFJNt7nrqrFR5USfC74BaZcTxSSQA5I7V+nHw6/Z+0f7JGgtlyMfw1d+F3w3gEUUhj54PSvvLwX4Sj + t4EBXGBXr4XDzqS1PFzLGwjGyPl2b9nfSdmTbqfwrDvP2dNH/wCfdfTGPzr9Fk0OJRgL1pknh6A5UKPW + vdWX6HzDzDU/LHUf2YdJmYt9nXOfSuIvP2V9LMjN9nHPtX67P4StnGHUetZ8ngu3Jzt/OsamWS3RrDM4 + 9T8ix+zBpseVW1GM+gp3/DMen/8APqPyFfrNJ4Ot4227F/4EMmo/+ERt/wC5H/3zXL/Zkzf+0oeR/9D+ + WTwvqiQsPmB96+k/CfjyKwjUO4G3rzX57WPi4RLuL4PpnmnzfEiSFMh8Dtk1fKj4WWX1G/dR+sFl8arS + 2BSSbGePpXE+MfjWJYWSB8g981+XUnxTvehlyueDnvVWf4oS3KlXcnjtXRBRQnleI2sfQHjzx5PqEkmJ + ODnivlLxLqgnZnzuPp71W1LxVLdE8/h/k1xN3evM2c4zVSkexl+X+y1ZmTkFyRyTVYk525qRjls1FnOM + Vke7FDGP401j69TxTicZ9Kt6Zp13q14llZrudzgYFJsom0nSNQ1u9TT9OjaSRyAABmv17/Y6/wCCeni/ + 4j39vqV/bMFcg5INdZ+wf+xXfeKdXtdT1K1LbyrHcK/sq/ZU/Zq0nwlpFrDHaqhUDtXzOa5w4v2NHc+h + yfJvbr29fSHTzPlT9mH/AIJy2/hSyt554hlQOCPSv1z8A/s9ReH4kSOMcdiK+n/Bvg2Czt0VEUYwDivX + LbTIoACBjFePRy/2vv1NWe9WzFUV7OlojxTRvBy6eg3J0rontdgGARivRLuBFBAGa5q5hBJ7Y4rt+qxp + rQ894qVR6nHXFo0nFZ39mgkgfyrsPLDHJ/Spo7XkHt3rCVJM2jWaOPTSifw544q2ujFlAPXrXVJajcc8 + ds1qW9ooHz04YdN2CWIaRx0Xhst82SKtf8Irx5m416JBbBm56DtWj5cf3cfjWzwMHujL67NbM8ik8OuC + cngUkejMrkP0r0+5hU8EYz6CqBiiB+6KiGAgpaI0ePm1ucaNCjLcLyeR6VqQeH42wduBXTR2ysQD1rZt + 7TnDYxXfDCQ7HHUxku5h2uiRLhe/8q2odO2/c6AVrwwpGo71oxIuNxxW8aEVscksRJnPNpoK54H0oOk7 + sHFdJmPOCOtOR4927H4d6r2SMvayOb/sV2bK+1SpozgYxzzXVREdAOtXFjTHzDpV+wiS68jkI9MkT60/ + 7EU53E9Oa610jx8nU1RdRncw/wD11MqKQ1WbMT7KQMGnG1Y4NbGxckDjPpyKbJg/dxj/AArN0ylNmM9n + jAB+X3qL7EWOFGR7VusqNyRj605EUY9euaydGN9TZV2jnZNIDL83YdDXL3/hhLgFgvXvXqQjGMY7/jUE + saEFmHAyc1nUwdOS1RpDFzT0Z/Nr+3ZfQz/HqbR1+WPTreOPA7M3J/nX4mftvaldSfDJtBsCTNqU8dui + 9y0jBRj61+q37UfiBtf+P3ifVnOYxeyIpB7R/L/Svzl8SeGF+KP7Vfwi+Fjp50Wq+J7HzE6gxwOJG/QG + vxTCr22Zxius/wBbn67i5Ohlc5PdQ/G1j+mz4Tfs2p4F+DHhfwhCu1tM0q0t2GMfMkSg/rUOv/CGWaMo + y+31r9JZdFgCCML8o4x9K5S78Lxu+7Z3x9K/V62RUpK6Wp+b0c6qRdr6H5kW3wHnln3iI5Jr2zwf8Drq + yljmCcDmvtKz8J2qtu2Diu2sNCgj2qqgdqnD5HGErjxOdzmrHy5L8IXnhA28mvHfHX7OL6vaywnOXU/S + v0mTSIVGCKoXuhRyLgAGvSnlsLaHnQzKae5/Kx+1B/wTM1L4gvLJajjJIGK+a/hN/wAE39f+G9+sk1tu + VGzkDtX9f2r+CrO6BSWMYPHIrzu++Genux2xD8hXlVsHiI+7GWh6NGvhpSVScFzH47eBvgFPp1qizRFd + ox7CvZ4/hFPHAERCTiv0Pi+HNpExVVx+FaSeB4Oix/XNeesBV6nrPMYW0Px/8Y/s8alrLMqoQWz16c1z + +g/sd3fnK7ggZyOOc1+0kXgC1ZtzRg49q37bwNaxYJiHHPFJZLOb1E86jHY/I21/Y0FygV+w9K9T8Hfs + kQ6NMJCB+Ar9QLfwtAjBSlasegwo2doP8666XD8FuctTiCpayPmPwj8KV0tEVRwor3XS/DYtUAK4x0ru + 4dKWLgLj14q75AjGNvA/Ovaw+XU6eyPFxOY1Kr1ZyK6WygdffFPTTuee/rXTui7/AMeMU1VycY989a61 + SXQ4nWkzFXTAwwF5xzirK6GDweua3o1wABz+laEW2P8AlW0aUXuZSqyRyyaAQMKM/UZp/wDYLf3B+Vdp + HKoHA/T/AOvT/OX0P5f/AF6r6vDsR7eZ/9H+Hy+luo3KZIFY0k8kv3jyPftXba7abGKiuFeN8c8A9OKc + tzjw804XRWllIGTWeSyng1Zl3A7TxiqRJyR1rWJqTCVzkDihnYgZNRgHHI4FO3DGKoQ3jGBUZzT2B55p + uSR64oKQsYZnCr3r7t/ZZ+HGm32uW95eoHbcD8wr4asiFuVY9jX6J/s4eJLbTryAM2NpB/KuPHSkqT5T + egk6kVLY/rQ/Yj0LQ9LsbVBCi/KvYV/QJ8MBYLaR+WFGAK/lt/Za+MtpZWsCmUDGO/Sv2g8D/tNaJoel + Ry3twu4qMDPJr85UpQrtyR+ockamGXIz9mNKu7WKBWUgY7Voz6tbIh52+1fkm37cGhwcrMCBwOQTihf2 + 3NCn+V5vbrXuQzGKVkeBPLJt3Z+pN5r1nuOWFc7ceIbQ/MSOK/NNv2t9BuBuS4Xkf3qxZv2ptDAybpcf + Xn+dZyx7exrHLbH6fDXrPPJBq5FrNo3TBr8t7f8Aaj0QJkXak9ue1blj+0/oki8XK/nWX1u/Q0+oeZ+n + keqWWwMWHP41bTWrNTkEV+Zv/DUeiohxdJj61zt7+1tpEWWivEOPet442y0RlLL23ufrTFrlqRlWHFWm + 1u0VeXGfrX57+DfHHj3xBpcXiHUCmkaXMA8c938ryoe8cf3mHoThT6130Xji6mhaTQ4rzUyg5YR7V+px + 0H4mvguKPF7Icjm8PXqOpXX/AC7prnmvWzSj/wBvNeRpQyKrW1prTv0+/wDyPrS78QWkeW3AGs0eI7Jp + AN3PYV8Xz+MPi9q3iI2/h+w+yxNFuJnARQMkZB/l3q7a+H/jNPbkf2tEskxI/j+XHfPfp71+bS+kbKTv + hcnqSXTmmo6fKMte6/FnqLhSVvfqxX4n2lHr1uMMSQOx6VqweIrRRtDjP1r80J9E/aR0bX5PDs2rW5R7 + fesjEgFXPYjnORjpXY6h4j+K+hafvufLv7hfvrGTnPsCMnjgc1vH6R/sZ8uNymcVez5aik18pQh+ZjU4 + Qm1eFVP8P8z9EItet+qEZ+tWW8SWycBhmvzm0f4v6lqsLw20hgvlJ/0WY7WPsCcc151qn7Vtto1/JpWs + S/ZLmE7Xil+VlPbINfrvCniVk3EVF1MtqXlH4oSVpx9Y9vNNxfRs8etkVWlLlmrM/VZvEdrngj86sQ6/ + ARkMD6V+RLftgaOrfLep16bqtW37ZGmlxsuUx25r6z+049jL+yJW0P2JttWt3wysPetQalHxtP61+TGg + /tf6ZJIEkuEPHrzXtGm/tOaLeKCky5xnrW8czpvc555RVT0R+gjX0W0dM9BVCa/hGCGzmvihP2iNJ2hj + Kv50f8L90+U4SYfnRPMaZMcrqrdH2kNQgxknHfFN+3whSxOK+OE+N1gRvMwA9SaJvjlpiqC0wOfesv7Q + gX/ZlRdD7DGpQj7zfSpI9SiBwSCPavhu6/aA0mLkzoMHGN1Vof2h9JDfLMv51lLM6aZtHKqjPv1L+DHW + qup6ta2Wm3F1IwAjjZjz6CviOD9oTSicLMh/GjxB8bbG/wDDeoIk4BFvKSc9AFNc+IzqlClN9Un+RtRy + Wq6kV0uj+fn4haiuseNdc1pT8tzfTMpJ4IZjXnX7EHhyLx3/AMFYfh/p8o8yDw3p2oas4PIVxGUQn8WF + ddrDxXK3V5wTJKzr6dT2rC/4JeeIbWw/4KEeO/Gl5gDSNASzQnsZpFJ/9Br8r4ZcXmMas9o3f6fqfo/E + cH/Z7pR3k0v1/Q/sQkubcn1P9azzcWxbGBXx7N+0JpsZwZl9OvemxfHnR2IJnUf8CFfsKzOlLY/L5ZVV + j0PtG1kgztGB710cRhxww9q+LrT44aSePOXtzmuvsPjfo+zc0w4963hjqXVnPPL6vY+tYjFtOTggU2Ux + EHOM18xj44aXtBMozVWf466Wg5lyD3q3mFFdTNZdXf2T6QufI+8Tj/69c9P9mBI4Pavm28+P+hoTulH5 + 1gXPx60RwMTj6ZFYTx9Hozpp5dX7H0+UttxYEVNFFasM5Ge1fK8Xxr0uZjGZ1P4ity2+MGmEAGYAcdDW + UcZSbNpYGsfTUMdsDycnpVxYrTJyev5V82x/FzSsbllBzx1pkvxk02EH94Pzrf65SSuc7wNZvRH01ttR + hj0Heo2nthnpk+lfKc/x10yMFvMGB71z9z8ftOHSZc/Ws3mVFdTRZXXfQ+yzf2+PvYqu19asu5jjvXxH + N+0FYrx5y5+uazZP2iLQLl5VwOnPFJ5pSH/Y9bsfb81/B94n/wCtmoF1C3Ugg8V8Jy/tF6aeRMo7Y3VJ + B8f9OmUbZhn1zxWLzSmWspqH3rFqMDDrxV4XcDnO75TXwXD8d7LdgSjr2NaLfH+zgwfMB/H/AOvVRzel + 1IllFV7H3A13ET8rbf0/rTftSf8APT9f/r18HSftK6UjFWlGfrimf8NL6R/z1H/fVX/a9Ij+x63Y/9L+ + PLxN4OMUxU5JHTPpXmuoeFTApdh+Qr768UeBZXR53Ta39K+ePEOgGKNlX3/St9HqfGYTHSilFs+UL/TP + LJOOM1zMyFGx3r2PW9O+ZuOBXnF9ajeT1p2PoqNbmVzCUcHPSncfw1a+yc4PU1L9iA4zzTsdF0Z2ecdK + Z2zmtL7Cx6HnrUJs2PIOaLDUkVoiPMye1eseC/HN1oNyj7iFU8V5aLZ1ODV+CFj0rOpG6szSLP0v+Hf7 + ZT+EIUw7FlHbpXrVx/wUd8RTcCdx0xyRivyQt42VQGBzVzYR2ryZ4ChzXcdT0oYuuo2U3Y/VX/h4jrC/ + L57+mQau23/BRfVlYLJcN165r8lnQgcjvVIqT8w4+tEcDQ/lE8VX/wCfjP2Ytv8Ago9qJGDcFfU5q9/w + 8ZvGGGuie+c1+La4GOamTJGRx6U3gaH8oLF4j/n4z9mU/wCCiuoIDm6O0991TR/8FHtSgOBdMc9w1fi6 + +DkZ/SqJTnK85oWAoP7IPGYhbTZ+28n/AAUg1ZkKre4B4J3dq/oX/wCCdvwU8W3vgvTf2pP2jY2I1KIX + Hh3w/cIdxR/9Xd3KNjO7hoYiOmHbqBX4Mf8ABFH/AIJs6X+0p40l/aj+Pmnmf4b+D7sR2ljMp2a1qseG + ER9beD5Wm/vsVj6F8f2+fDv4UeIfH+vL4z8QhUSIiS2s2GN6jp0AAA7V/OPi/wAc1Kdf/Vnh+fLWf8aa + 3imtKcH0nJO8mtYrRe89Ps+GcrnWj9dx0n7NbLv5vyO78GeBdS8TTJ4p8bu9zd7/ADDaH7qJjjdnqfQc + CvrbTvDc8OnCG3j2l4zhDgAN2yBUng/w7FJvyjRXK8MHOWOOgPA49DXpNhbiG6RpGI2HG3GcH3Nfn/Bn + B9HDU4znG3O7XXrZt31v3XfZbns5nmLb5Y9On5WseW654eglSysmVfMEbxOV79GHP4U628Mu1rAIgNql + sr/vHAx/WvTNRs4ZJVuJP4JCP++uKTTrcxTbPvfMAvPvX1eK4dwzxzTStK0dOiSjb8Y/NnBHHTVJNdLv + 56/5njGp+ErfUfEFwrJumi2xo55+UDJH0yTWZqfg3T7dBNerngncByD2x+Ve3W9rHHPLdMfnaZjz0IGR + /StGKK2i0+SS/UEBfTpnr+OazfCOBxLk3GN3zO7WiV7q/nbTuL+0qsLK76I+CvjN8HdPvfCT6tYuw1lA + JLQqACWB+6T3GOpJ61+Rn7UXwD+IXxq8Li60aY6R8QdOib7O058u31CNMkQyHorc/I/RTwfl6f0G+IdA + /tK+m1O4UKZE2qnVUX0I9cD86+bPH/ga38U6ZJZSp+/YZjkB/wBW3bH9a/Lc+w2K4dzSnmWUfu6kNuvM + uqmuql1j2tqmrr2qbhjcO6VV69+3p6H8A2sfto+LvCfiG98L+Kpp9P1HTLiS1u7acbJIZoSVdGB6MpGD + WvpX7e6xMPNv5G5yMNjNfUf/AAXS/Yg0vw/bR/tg+D4VtNQa8j03xVbLx5ssnyQXYA4BO0RSdN2UbqSa + /miBKNkHOOmK/sngfiHAcS5PSzTDxs3pOP8ALNfFH9U+sWn1sfm2Oji8HXlRnPVfiujP6E9E/wCChukW + uGa5YleRl/8A69ew6V/wU4s4VCxXIj4/vV/MjC0i5BJH4+tWmknJ3ByB9a+peW0H0Mo5nil9s/qJt/8A + gqFCQrPekn3ety3/AOCpESuNt7kdThq/lWe4uh9yRh07mlF1eqcJI/PoTSWV0BvNsX/Mf1nwf8FSrFo/ + mvcnB/iqle/8FR4JEKi8zz1zX8psV3qOBmZ8H/aNXBPflsLO+PXcayeVUDSObYv+Y/pk1P8A4KdFt2y9 + GP8AermJf+Cos8HEd5x/vV/NxM90TnzGPbqaypzOeQzE8d6FlVDqi/7Vxf8AMf07WH/BVQQgNLeZ+rVr + 6h/wVU07WNMl0q7vG8mZSrbZCpGfQjmv5Z2knzkyNgdcH0p8ckjAkueOn41nUyLCzVmjSOeY2Gqn+B/a + /wDBL4jaH8ZfhHZePdLlWVX8xJivaSI4I9jjk1+Vfw4/bCsfgD8YvG+utcbJdYuQgOefLjZq+g/+CYcV + z4d/YAuvEd9wHu9SniLHqFwM/mpr+dP4/wCrvqnxOv542PBxwe55P86+A4byqlLOMZQXwQbS+8+04hzS + sspwde9pys/w3/E/owk/4KmxXaiQXwB9d2KZbf8ABVKOP5ftZLHsG9K/lnaaVMYY4+tSx3VyDxK3Xnmv + 0aGTYeOyPgpZzjH9r8D+tXQ/+Cp8UzqZbzAxg5Ir1/Tv+CpOlbVRb0ZPYtX8b8Oo6kmFSeQD2Jq6Nb1l + R8t1ID7OaU8povYcM4xa6o/syH/BUnTI8It4PXO6sfUf+Cp2mNGSb/8A8eHNfx0DxBr44+2SnB/vEVC+ + ta0/37qQn3Y9az/saj3NVnmK8j+r3Wv+CqFqrkJe++d1cW//AAVYTd5ZvckH14r+WqXU9VlP72d2B9+K + qm/vlOVlbPXgmrWUUF0Iec4t/aR/V3pn/BVWDI/0zk/7Vej6T/wVUslI828B/wCBV/H8mp6gp2iZvzNX + 4da1VOUuXA7jdUSyel0No53ierR/Zhb/APBVLQygJvAMf7Qpk3/BU3RZ02C9Uf8AAvWv42B4i1lRkXco + PsxqB/EWtEblu5fpuqf7Hg1q2U88xC2SP7AL7/gqHpO44vsAcY3CuQvP+Coenn5ftqseT96v5HpvEGtM + SPtMmPQN61XGt6qP+XmT2+Y1ayOh3Mnn+L8j+tGT/gptp5UB7sZPq3JNZN3/AMFMrMgxi9A/4FX8ow1r + VT1uJOf9o0DWNRYfNM/Pqxp/2JQJee4t9Uf1B3//AAUyjXiO93enzVBp3/BUcwzATXXy98NX8wQv78j/ + AFrnOP4qPtl5uGJWORjrVvJ6G1jP+2MXe/Mf1s6J/wAFRNAmIM99yQO/Nd+P+Cj/AIa1G2ITUwGIPGa/ + joTUb2NjsmdfxP8AjV5PEetwjbHdSDjP3j3rB5DRvdM1jn2KW9j+uaT/AIKEeH0ch9SQ55+ZgKZ/w8L8 + O/8AQRi/77FfyNt4l19jk3cp/wCBE/1pv/CR69/z9Sfmf8aX9h0+4/7exPkf/9P8cfHvhK3s7B2aMA49 + K/Pzx7bJbyyKAMEnivvv4qfETTpbYlGwccj3r80fiF4rgup32HpnitKKe7PzWMuaooxPDfETp5jMh+te + TajIPNKk9D3rq9e1lHcsprz9pjM5d+vWtmz7DBU2opssKBngdxVsKMccGqaOOp69qsq/Oe386o7h4Tjn + mmMONp9/zp28DOKRmGOO5496BIgKckn1qWLbnPHHXio2IxuPFRGbByOv1qZIuLN6GTnzD2q08ydW+tcy + LruetSLe5PH4VhKmdEahuyyq4yD1rMfbkgcAVU+0lhk/X8aUyAnBrPksac9yQOMcj6k0ecq/Kf0qo7Yy + ufwNQGUKPftRyj5i8ZwRz/k10Xgzwlr/AMQfF+leBfCkJuNU1u8gsLOJRy89y6xoPxYiuLEh6HFfrX/w + RT+FkfxG/bv0PxTqCr9h8DWV34gkZ+QJolENv+InmRh/u5rx+Is0hlWV4rMpq6pQlO3flTaXzenzN8JR + devCivtNI/tt/ZL+BHhv4XeE/Bf7N3gyPboHhCxjtjtG3z5lBeeV8dWmlLOSe7V+w2l+Fngv7ZoZjCI0 + IAI4K8YUEd6+Gf2MFgt7jUPEGvxy7ZSFhkVCyscnI6enNfqJDcaDeWsc1vLGCo4wCmRj0NfxhwHkMMwp + VsdjMRGVeU+dpytJu92976u/4H6tm+IeGcMPSg+VK22mxyOq2khuUkVyknA3jghc9Ca2Ge64a+VST8u9 + TgN/ga0HsVlHmRbSMdFbmnJG0aNAxBjYcqR0PtX6JHANVKrndc1rPpdbXvv6rVea0PCda8YrexRVJjaz + xycsmGGfb/EVct0SItI4yVUt9cf/AK6vwTb2WG4PIztcj747g+9QXCxw2AldggdREQe5Jxx+VdDwsaaj + NSvyrrvZO+vn73zWq0ZnzOV01v8A1+hWs9Pk3RRq3L8kY6buTUOqj7TILS1P7iBvvf336cfT+dX7q5Fs + 0kEbEEjBI6gEdB7n1rLdYolD3siW0S9FY84HtXfGcIUnRoq/fWystEnJ6JdXrq7LuYuMnLnl/XyOR+x3 + MiPycFiMDtnuSf6Vy3iHwpIN115OAVwC78nA6gD+terNrHhZT+5L3DY/h6fnwK5DxJ4rMdg8VlaxeYR8 + nmMWfBHoBXy+MyDALDVKmKrKWmnL72v/AIC19zWvU9CjiazmlCLXrp+p+OH7e/wa8IeNfCN94d8T2zXW + i+K7OXTtRjYc/MuNwz/EvDqezAHtX+b58ZvhnrHwR+LviP4PeIpVlvvDWoT2Esi9JPKbCuPZ1ww9jX+n + H+0po2reNPDV1EshjubEGaJScAMOTgd+K+UdF/ZL/Z6/bd+BU3hT4+/CnQteS1lltZPEVpAtrrkMztv8 + wXcQEpZQwxv3KQMEHpUeBOeUsHnOMy1yapVI8yilf34tK6XS8XK/flXYy4uy2tUhRrUUnLZ3fLp62d32 + Tt6n+cJHJhsjn1qbz8DP9K/sF8af8Grvgbw1aX3ji5+PA0nw0J2MD3ekeZJBEx+VZpEmCbgOCwUKT2HS + vMdE/wCDen9iS8i+0T/tWQSgKznyNKQgBeD1n9a/rLmpaNzWp+dupUi3H2Urr0/zP5SGl3YwOtPR9pJH + X+Vf1r2//Buj+xRev5Vr+1GcgLu3aQgwG6ZJm4z2q3/xDYfsr3Mjmz/aktNi8jfpSZ2/+BA5ovSe1Rfe + L21T/n1L8P8AM/kqSQL159K0UugOeMj9a/q8H/BsZ8MNQiaTQP2m9GkJ/wBUJtMwDn1xcZrE1P8A4NX/ + ABrJOU8I/tCeD7tFxn7RbTQlc+u13o9nGW0196/Uf1zl+KnJf9ut/lc/lUnuyRhetZksg79etf0xeK/+ + DWn9tq0Z2+H3j7wJ4iiDYUrfy2rH8HiI/Wvm3xv/AMG2f/BWTwnBJdaf4M0vxBGnfStYtpmbPortGTVx + w76Nfev8xPMIdVJesJL8XE/CLevPoecd6aZEXBwMCv6SPBv/AAajf8FZPFnhtNf1fT/DOhSPgraXurbp + +RnnyY5FHp96vzp/bm/4I3ft+f8ABPNLDVv2i/CAi0LUp47aDWdKnW+sTNKcKjumGjY9g6LntmtHh2ld + /mv8zJZjSk+VX+cZJfe0l+J+yPw3s0+Fv/BMPw5pf+qluNDWZ+x33zmQ/wDodfyy/EPUBqHjXU7snObh + 8Y54U4r+qH9tTVbf4c/sraZ4Ri/di0trS1x0+W2hGf1Wv5I7y9+1XUlzLyXZmP4mvzPw+i68sXjH9ub/ + ABdz9H43aowwmDX2IL8EkTNL827FTxSjGcYPb2xWSJM9PX6U5JFPU1+lcp8BzG8kuVwcZPSp/NHfmsAT + lRlWwRSm63c9qhwK5jfE4HB700yg449zisE3OG2j6Uhu5Ac5o9mPnNtp1LHnp/Kq7Sg5BI71jyXG77va + m/aGbOTn1p+zFzmg8wX7tMW6YDv+FZhlBBJ69qYZR9arkFzm2LkdG7003IbAJ5/lWN5p246CozMBzmj2 + Yuc0jcb+T2qMSjduXgVSE4xgmo/OI6VSiHMaQmA4OKXzRuwvU81k+bmlM3GaOUXMbP2j04pyzpnbjpWO + LjnA70efuHJ60uQfMa73GTgden50wzZ47VmecM1GZeMn0/KjlDmNRrkKcbivtmm/ax/fP+fxrKMynrzS + ecnp+pp8gcx//9T+XDxT4p1G/QohZmAxkEn8fxr5w8TwX0zOzBsn1FfT1tfWiARjjHB4pl9o1rfwlwgO + fUVlPGKOlj5/A5HZ8x8CapptyWJIOTWEulzn5jxX2lqfgq383JjGDVdPAlpLH/qVAPtzUfXkfTU8ulY+ + ORYSg/N2qZdPkGc19az/AA/sgMtCoFZbeBLIli0QOM+1UschvL5HzF9ilH3cc/nTDYzdWzxX0jN4JtEP + yx//AFqybjwfaAkbccVaxqJeAkfPctnL/EOT6VSe2mXhh+Fe8zeDoVY4XrxVdvB9t6c0/rcSfqcjwd4p + G5HNR+VLxnOa90bwTEc4HBHFQjwLHyzZ/Cn9ZiT9WkjxhYpU5HIq2o6D05r0a/8ADcMC7e/rXHXdi0BL + dvan7RSD2bjuY0gI47D+dUXSUjcBxW7BbtM2PXiuks/Dq3A+Y8fpmjnSGoNnnojlB5/Kv6JP+Df7SBD4 + j+KnigqTKllpVgB/CEuJppDn3zEuK/Cq68LrEgfJGeenev3C/wCCE/jaDw78TfiX8KXcCfxBoVpqdqpY + KXfRrgNKqg9WEE8j467UPFfBeKGHni+FMwo0t+S+naLUmvmk0exw+lTzKi5bX/Q/vl+C2iPa+D9It1TC + tCHRY8YyeSzV9VaZGsMRgJLMvB+Xdj6kV85fs93tlq/gDSLyxkyrW2yVs5ZSCcg+nbFfW+nWZjtl+z5U + EdMdvev508OsslWoxq092rtvXovTr/lbqfdZ7iOSbT7/ANdzDMUMqMHjAK4wwBFLbbgpEVxIgHZvmH65 + rfe40y3Vvt0oCj+EYLE/TmuX1HXrm4Pk6bCLaPpuPLk+ntX2GY0qWF/e1qqc9rRXvPX+61b1bV/M8mjO + VT3Yxdu72/Ffkcl488XXnhjw7c6iqCdkQldiHcPcL1OOvHpXxv4K+Omu+JDeaFrN1JcRvJ8lyELFAw5O + 0cBR17nNfSHxWtriTRJNDtm/fTpiWTPIVugz79/aviL4cN4y8OXeoWvxU02300m5K2d5p8jXFvLb87RL + lEeOQZ+YFdh6hq/KM+ljamLlFy92KSa5rb9N0359u6Z9blqoxofDdvrb+v8Agn1L8OfG2tw209pqFzLc + w+awjnx+8IHA3dW+hr1W2mt7yXz4j5jE4LAlyPr3FeGaHe6ZYzjyZEMMxCu0Z3BT/C+f0NeijUHtrwx6 + ku2UdJo+GIH0/lSyurKNNQq1NE9L3aV/PdX6dN9UY4umnNyitzsrjUZ4W8uI/MrHGQRx9OvNRC3kvQ74 + Yuf4gMN+ua8f8dfGK80Gzkh02OG+ZSI0nmGPnP8ACMEbsdz0Fee/DD9oG21FbiTxnqFltjlZAViaCPYu + MkS5PAOQCU2nH3hX0FOjOtO7rc0F3dremrTfo230Mo4Wpyc6h+v6fmL8XraOytbqS43Bwr7i2CcYNeF/ + 8Es/EFzrM3xK8MM5e3s7yyYdcBpFlBA7dFHSva/jpPPqHh2+vPDen3d5JNavNB9nie4jkGMfJJEGR+vZ + jXln/BIrwD4k8MeEvH/jfx3ZT6Tca5rSQW8F9G0Exjs4zltkgVgCZcA45xXV4U5JjI8ZOvUpSjCKlq00 + vhkt2l3X4HFxPXh/ZkYp+9dH6hReHbKyt5bWeBZLSYFZIXQMkgbghgeCD3zX4qftd/8ABG6w+LGprrn7 + Jvi1fAvnXBlv9HmjM+nMZDl3hKkSRHP/ACzyY/TbX7zSiwmBjmuIMHsXHSrOn6RaXEyLYXdo5HYTKP0r + +vXQi/dsmj8yqT5vek2n3V1+X/DH84Fp/wAEVP2spfCcVncePtMub8sVlZYp4Y2jX7vQsSQOxqK7/wCC + IX7UFlaPb6F4+tVkETukkkUxBmbpuXdyB6gg+1f08JpPiixgMEsTSwnoY5ACB7Ef/qrwrx7efF7wvai7 + 8P3zXjSt8sEhUNtJ7SD5SR6HFZVMFQhHm5H8jSliK1SfJ7T7z+fC8/4JF/8ABQiw8LwTaH420U6xAgRl + EUohkwcFgWB2nHseaqX3/BKL/gpro9kbnwh480OXUsnMt+JfJwepKqmSR71+8dn8RPjxYzq/iWF4lUgi + EIcsD6tj+Ve6jxHrN94cg1rVo5A1w5jNrgowJ6bR1YdzSo4bDyu1Bq3dBXqYiFl7W99NGn/Xqfgv8B/+ + Cef7XGleM9KHx98eaTqGm26M97DpNk6+dLxgLLIcqo/iO3ntX7yfDnwnaeCtA/srw3ara2MA3MVUFnc/ + rz3qeyt1ula81LbbkEBFclcfhx+tehJc6Fp+nt9ufBlwfLBBOB6Adq3oYZQbkY1qzlFR3Z594l+JHhLw + XZf2j8QNch0eL5QrXV2lohJzgbpDznHQc46dK+bv2nfiR4I1Xw5pWueDBaeLP7LebUXWFl1C3BhjZQjK + PMUsS3y5xjGRXxl8V/A3jT9pf4vaxe+NoJYdJso5E0+Mx74WVm3JKuc53RhFJGPu4HfPx18Rv2f/ABH4 + H8RRT+HvtMSKGYXNqBbyFs4IUIV5XsBjjvnOfGxWZV5UpqEbLZPr6n1WDyHB+0h7Wd5W1jpy69P89T8V + fjJD4S+M/wC1D8Pfhp8QtHOvaHrOpzXeraSsrWzTW3LSRhkIaP5cgYI9K9Z+Nn/BBX/glj8b9Mj1/wDZ + s8e618KNRvgxgtdSlXVtNZ+yASFJ1x7SNX6M3OueO/D1/ZeK9W+yahd6OjyRXWrQQ311CnILq80bTJtH + LAOuc88GuUv/AIu+EfHHiX/hJ/F3h+Cxu5wIbjUtGv4zIqyrsaRILhpEUOpGVQx/KQoPevneG6s8tofV + Ya6ttuK1/NnucSZLHMsQsVfWySSk1a33J9T+S/8AbP8A+CF/7bH7Inh2X4l6VBY/ErwShyda8LyG58pe + xmtiPOTjkkBlHc1+MJlYEhs5HBz+tf6T/gfw0vw3uYvFfw+8eHxFpdxG0ayNayW0rODn7PcQkCJvl/uM + QdvGDiv5A/8AgtF8CvAvw5+M+k/ELwjBZ6deeKvthvbS0ZWR5LZkBuNqfKu8uUxwWKbiOa+0wmY+1nyT + jZ9LdT4fG5TPDx5k211urNfl+R+LvnkjHSgTknGetTCzbnI/w/lTksXHBr09DytRiu2flBqdC7nBq5HY + SYBxWnb2Dbs7enei6E20ZIgYHBHWpFQD6Dr3rpDYMQABVRrN41zjFF0YOozCkTnK96oSDj3rfngZQcis + WWIlsd/SguMmzOaQqOeKZ5hJqWWM78YqJomHLU9DWw3zCeBS7+efzoEbDkil8phx2oCzE396QEHpUgib + PTNSrATyRRcRBnPNSAevU1OIGXI6j+tL5R5qWxkB3ZpCcdeaslDjmoXQYytLmERYPt+NGD6j/P4U8wuf + T+VJ5D+35mnzIdz/1f5ctO0W6llwFwAfT0r0218Pypb73U9O4617RH4FtrA8r055q3qEFnZ2uHwCB27V + xV6Lb0N8FNJXZ81atpghwW+90rIh8uEAE9a6PxfqlkkhIYDHQV4xfeLLRGZS3Tkf4VzPDyPUji4Lqd5d + vCvTp0GeKyJGiPJ6V5nceN7durZx3zWd/wAJlbyZCv05OT1o9hIr61DuejzyQueSDWHJIjemfXFcNJ4s + gLYLgfXvWZN4pgH/AC0H4elNUZEPEQO+l8sj5uvFVAsbHIAPP4Vw/wDwkkBTAbORjOaaPEFuRhmziq9j + Ij20TvlhjPXA5zmmXcUIjBTHOa49dftlfO7g9qfNrsUiZU54GKapSJdWJT1nbg4wSM5rzHVdr5GcE9q6 + rU9SVwTu5xz6V5/qF2rnnt/WuylBnBVmizp8Xz7WFejaRp8rpkc9K880R0EmW659K9j0a6iRQOgrPESa + 2FTqFfUbSZLffIDgmu8/Zf8AjVc/s4ftIeEPjVAu6HQtRje8j5IlspcxXMfH9+B3X8azLt4ZbcrJzkYH + Y1474gh+zysU6da51CFenKjVV4yTTXdPRmzruElOO61P9Nn9hv422nh3VP8AhGbIprWm3WHs50f5ZIn+ + aOVDyMMpDD2Nfr0+vX+owebIPs8bHAVTjPbr1P6V/CJ/wRU/bITxR8N7P4V6xc7df8AlIo8nLT6U7/uX + 68mEnyTjouyv7iPh/wCMNO+IWgWfiDTMeWYhlE+bD4Gf8+9fynkU8VkmZYzhqvUa5Je5GySnFv4r6Nrl + 5Xa+t9Nbn6NjPZ4zD0cfCN7qzfZr/g6XsdJdJFGh8iIKByT3596qKq2qfa58sw4jX1PoP05roFs/MYCf + 7pPSse6ZbvU/s1rzHbBl3DpvPX8ulfQVsvlKqsRJatpRVlv3t2S17XWpwQqKzj82eV+JrOeaCVZTvkcl + 5D7/AP1hwK8kurlbG/nt5MblYkgkcive9XhZo3iTB2qfp/n3r5s+J+kyJqjyqPuBWx/vKCefrX53nWEd + L2mItfVf+3fefQ5fUU2qbfT/ACOa1PTNJ1G5k8m5+xTuNokUY/lj9c1Skg+M1jEs+iavp+qwwr8sd3EQ + do6DehB/PNeX+JvCfjHWFSDwhrH9nXEjADzohcRbu4IODz064qGPw5+0j4d2hLjRNUSRsbh5tu3Tg4ww + znPsK48qw8qi5+aNvPT81b8T1qsVFWuvmhsk+vXWtRvr+lT2z2cjYS2AuYjuHJG50YHnvnivZdG8LfDy + 60wxeJ5LSH7cCu29s2UDrw2Q/U5zjg18qJ8Y/H3hHUL+38YeGdR821kyZ4IRcRyM3cGMknjpgZrY8L/H + tvije3+g6JrujW13bxlorXVZGsX2lcgEzhRu9cdK/ScvyypJcksDGaezjJr8VK34HFiE2rqpypej/NM6 + Kx/ZM8R2/juCf4ErpWl6bPIGupbK+kgyqHGEhO1AOcjAH61+iHhb4N+PvCUccui39+ZIxkefP9riLHnJ + VmPPXoe9eGfDnwtcaxDH4kufEOluQvLafcRPGeAMDDdRj0zX014V0/XbWzfVbDWvOt4uWJlUghuBgg9j + X7Hwtk9HD01KVGcZPvU5rW7dUfG51j60vcjVTS/uv7nrZ/cdsbjxW2zTNe0ieclQHmSMPA3HzcEl157Y + +hqpp2haFFcNc2VjNa+WfmVA2wsP9lhz+BxVePUfiFqSRrYeJreCEHD+eiSE/kQRXKeLdL1O2086hb3O + n3V6y8SWsbRiVh7B+3rX2rmkuazdu9v+H/A+ZULvlckr9lL8b6fid7q2h+KPFmnXlho+p3OjQKuxJY4x + uyMEkDIIHbgnOa7mHxd4ntdGW2s3i1Hyo9jW92hVWYej4BH0YH61856R4ojWzRL+/SGQEiVXlAbPpt3E + 8Umq67qYUPp905iYcbUdt3uPWtVXja/X1M3hZJ8iWn+H+n+PobWp/tGazp8k8d34cv4TG3HlwPdLGR1y + qYdlx/dq94L+LMnxQtpdXt3mi8vdA8UsMlqwx3CSfMAfXkGvNNR1TxFdWUlrp5kSYqf3jwEqD+YNed6Z + oOjtdQxeOr2GVnTfI8azR5K5/jL7Vz7msJV6l1rp5tL+vuOqODouLfK0/JN/g/8AM+utP0rWLi3NtFC0 + ssbn5iNgKkkgkng8elQeNNO8d6T4Uuj4fjaW5uU8kQwyqGw4IY5zgcZHJHOK8i0//hTOmW0dwr2pEuFD + xuLgHcfu58w5P6ZrpfiF4t0A+ELmzsvEqaXBCdjRQQxyz4x91TnqfXoKc5RdKXM7adGv1SM40mq0ORN6 + /ai/yTf6epueAPA/9i2KSm3Fs4VR5bSqRGMY28E8j8qb4v0HQLhWW/aIheQQCxU+wANeO+AvHHw3iu21 + C88R+TCo3GF32ouBg5HUc9STWn44+J/wEkvpo38T2NzMgIMKTNPktgfdj3DPPpWcKlBULR5bebRtLD4l + 4htqTfdRf/BPn/4h+B/hdBcf2hJPJIsQO6A26jzF4z87uCo45ypHA4r5m1P4e/Du+eRvB/gHTrma6OHa + XdM53E87SYY8KRuOSQB7V913Gn+F7wyx+FtMvdUSWLCTQWwtYy/oZJ9pAHf5Tn61Y07wheaXZSvrMcUG + 0+ZHarJ529VHzCRyFB74CgKOvNec8JreKsvL/N3/AAPajj+SKU22/N6/crP7z89PG6anZeHIvCXhu1ud + SOnwyS/ZrSMQxb0IMiKAQvzMfvLkEnOcV/G5/wAF1PED+J/2gPBYk0b+wVXw204tGVUdTPdzZLqoGGOz + knrj8a/vuvdPt5tJF3Ij2126JI4R9pJIAKnjA6An/wCtX+f9/wAF6vE665/wUO1fTcANpOjabZttIbLF + Xm/D/WCs8FTaxSl5MeaV4ywUo26r77n4tLaRKTxnP5VILNAMgAGpTKPvHjNSeeAd3ftmvoeZnx/KiaK3 + jAIcY6VdjjiA4A/GqH2hQMMe3605bgdB0+lK7IlFGwBETtHY1HKsLJgH3rFa+aMc9x+NZk+pSHJHTt2q + lcwlSRevVi3EjmuemVCeBwPSmveMzH8Kg83ccDg1oio07DJIwxyBupPJXjOB/n1qweuR2pxaPv3p3NOV + Fb7OMjgH/Cn/AGYZ4H51ZDKBjrxUgePG5uD7UrsLIrrbISABzUhtAi5I/DFXbdTJjAJz6DrUslvNn5kY + Ck5MGjFeLGVAxVeWMjORitkpjqAD1FZ9wUHGfpSuQ0ZbDORQkYPBpSAenPPrQvJGf1oVyGiXylbknHtR + 5Cf3h+tSY3AEDH1o2H2p2ZVkf//W/IDxVpWpwkrAmMd/WvBvE+la2Y2dsZPFfZ2vajY3EuMgj17V5Nr0 + mnyoQAOeh61xTxljuhlqta5+dvjPTNY+dhHj9TXzJrNlrYmZBGev5V+lfiy2tWRxtA6/nXh934Vt7lmY + KMtntXNLMbG9PKOzPhY6dqzMSIyc8GnLpOoAEmMg/wBa+3IfAdkWG6PJ6citaP4e2mQxiBB4xWbzWx0R + yaT2Pg5tJ1HZuMbVQk0zURlfKPHNfoY3w9scAeUG7f5/Gs67+GtnIo2RjPcY4/pUrN12KeRzPz5Gm6kG + 2sjfWr0el35P3WznmvvSP4X6eUH7pTzg5FX4vhXpYP8AqVx2wO9Ws2iT/YtQ/P8A/s3UAQGVqsJYX0ZJ + bcMDsOtfoXB8IdPcAtCM9feoJvhNpqxtJ5I44zT/ALVj2JeTVD86dQtpwvy5B9a4u6Mgl+bNfbnjPwDY + 2isIIh3r5e8T6CbORsdOor0cPiFM8vE4Z03ZnP6VNKGyOlel6NHc3EqJuxgfoK5rwhpIvZgsgxzivtb4 + a/CnTNUZWmQn3HIrnxuIVO7ZjRw8qkrRPBp4bmOHk8fWvNfEvmLkck9enNfo74i+Dmk6fZ+bywA7V8je + NfBkMM7CHJ68GuXCYxTZtiMDUpfEed/Ar4p+O/gd8TNO+J3w7uTbajp0nAbJjlibh4pFz8yOOCPxGCAa + /vL/AOCaP/BU/wALfEHwhBe2mYgcLfaWzb5bOXOCD3MZ6o+OR1wQRX8Hek+G2ivAJBgGvsP4Gat4u+GX + iyDxp8P9Qk07UYVMYdOQ8b/eR1PDK3cH69cV8N4icF0c6jDG4aXs8ZSXuT7r+WXeN+urXTdp+5w7mdXC + ydKS5qUt4/qvM/1FvC37QXw+8d+Ra+FZjJeXeI4w44iJ6n8O3rXffZY7FBByEX3PXrk/U1/EH+zr/wAF + CNY8PXUCeJ8abdKQfMDn7O5HcHqmfRiR/tV/Qr8Lf+CrPw71PwlBH40RZpggUTq/ysfcjINfjUs6xuBq + yocQU3CS+GajeL7r3b3v3XZJpWPspYKhVipYJ+sW7P8AHsfq9cad/ojIq5LRHGf89q+ZPG7QXOpyEfOW + j6jsR/hXx38TP+CqPw3i0Z7LwxJHHMFKsyNvK54wPcngVjW/xK+LnxH1W3m8O+Hr+CMWcVyxvUNpGFZd + vLS7RksMAZ5NceY4+jmsFhMBTlJ6a8rs9Jfd8+h15fhJUJudeaXzXkfUI0m/sbFNVkiZbZy2xweCUIDE + e4JH51maz478M2FlCgmmuLiZmVFgjaRlKDLF9uQg9zivlD9oj9oXUfhbDafCvWrg3OsS6fLqca2yMFFp + KqkRxkA75PNJ5HXZjvXmHwr+EvxW8QyS+LfFQudHsZgf9Hkcx3NxuOMPD97Z1J3Yqsq4LxjqOiou6Sut + 7O3vXa0Sve3U9GrjaCipzmtdrdex9APf6l4t1ZRpLSJNFL5gEjEjBGGG3gAjHByRk19EeCPBmjXfh+S3 + 8WWEFwZlPmJcIs249s5GCcdqz/DmjiPyIQiQKqmNSOcYyevPevW7KMLthUcADjsc/wCNftnDuQ/2f5s+ + ZzLHe2Vo6HC2f7LH7OmpTJdL4SsYXQ5Uwp5IyeTgIRiuhuP2RPgXqkrFrW/hMsYTEWo3UagDpwJMcdjX + sGjwEo3mLyCG+hrppJ7pGWG2TapPO4c/Wv0Gnh6TjeUF9x8tPHYlStGrJfNng2g/sk/DPwTcyPpF5rbi + RNhjn1KeZBkg5+diQePyrs9P+BvgjRYhe2qXNywcsftFzLJgP1ADNgCu9i1BldrcPmQHBI5/P3rcmkZ4 + NrOOQOlaRw1HdQX3IyqY7FbSqv72ZvhbwtoWlxNa6NZxQAPltqDr65616iujq9usD4Klec9sf0rjvD+p + 2+nq0sKbXPLEnn8q6VfFJu7loWc7upb1H4muynypWPOre0lJv8TlrzwobacNbN5y5+YB+n61hyeHrNLr + dIAysADu5wfTHeuw1bUfIie6A688D8OK4sajGv8ApGoAZxkL0I98etTJRRrTlNrVnJeJfgX8JvFVoo1L + w9ZTShw+4xhG45PK4PNedN+xn8DWQg+Hmu0mwZI2vrgA5Pp5mPyr6An1aIWgkP7sOeST19K6jRPEUkcc + OoRHkj+LqfwPqKwdCjJ3cV9yOj65i4RSjUl97/zPGfCf7NnwP8IC4Gj+D7GzM8JhkzmXdGeqEszEg4GQ + Tg16N4V8A+AvDEflaFomn2Cn5v3FskeD+AHeuh1DV7uTZtXI6YHH5/8A16uPqOmiEQWE6SXRQFocFmQk + 4BI9M9TWsadKL91JfJHPUr16i9+Td/Ns1XntvJkypwwIPc4NfOvxhuFGgTNobmW4kVitswO+XGAAOPfJ + H0r3eK927d0e9ucYOF/EmvJfFctnqUhjldMswZcdhgBsEdz296jFyTpNXKwEWqyk1ex8/RefO1pqFwrN + EfLQxKB83mbVy2eu0HJ9hX+c3/wVmspPHH/BRP4paxpquUTVVtfctbQxxsf++lP4V/pT3Nxp0uhajqWk + OsUEEEv2d5DtKhEJ3exHpntX8CX7Q/wjufHPx78beMpYvMOo61ezKzAk7fNYLycn7oHevOwllX5m7+7+ + q/yO7OKk/qqjFa8y/BP/ADPwqbwNrSjdtP4VTk8Ka1HxsLfhX65x/s8XV1N5Qtjjg4x2NMvP2bLu2jyt + v1r1/aw7nzHNX7H5AN4c1uPhozg+3ehfDuut8yRH8RX67R/syTzqZZ7c4+lQj9m6bf5EdsRnvT9rAXtK + 38p+Rb+HNdkYoYzntwarf8Ijrhb/AFeDX7Fz/srTpAJEhx6cVJp/7LVxJGZJrfJ55xVe1h3J5638p+Pk + PgPWJBucY+lb1v8AC/Urg9GHviv2N0T9k26vLkKltlM+nQV7joP7H8ckqwiAfMckkVnLFU0aQp4ie0T8 + JrD4MarOu4RsQPWt60+CN/dOIY7ckjgnBr+gaf8AZKit1W0tbbOeBxXsWgfsY22laULy8tQHbnpzXJUz + CEVc66eAxMnyn83A/Zz1WFPMmiZfrVWb4S22mEGaLJX1Ffv78QvgVHpiOqwYCg9q+JNW+Deoa74hi0Ox + hy8r7RxnjvSp46M+oq2DrU99T4i8BfCCTxHMRb24CL3217Fqv7PkFpbbVi7elfsL4C/Zah8G6FDttx5r + KC5I5rO8Z/CPyIHxH17159bM1z2i9D0KOUVHT5prU/nZ+JHwuGklnhTYVOcgV8xX0b28jW8g5UkV+1Px + q+GjRQzEx7Sue1fkr468PNa6zJEqhRmvUwmIjUW551SjKnLlZ5acAdKi83awrf8A7KmwW2njtVd9MmPI + jPrXamjJoqLPuGc4p3m/7X8/8alFncJ8qJkfSl+zXf8Azy/8dFPQWp//1/0Sv/8Ag3Y8M3Tn7L451OGM + 54aKNv6CvO9a/wCDcqNWaW18f3jRgcKbZAfz/wDrV/X4LCBRgCqF5pkBQ8A5rxpZQ7fxZfh/kepHM9b8 + i/H/ADP4Vfi1/wAG9nxH0OJtR8I+MPtqqD+7uLba35q2P0r4L1r/AIJI/G/w7fm1vJhIAcFkU/5xX+iT + 4m0G0nQhlGa+XfEPwu0S+uJHliXJPp1NeRXy3FQfu1LrzSPbwmZYZr34W+bP4WIf+CVvxhhUB5d2RkfL + g1j3/wDwTS+OOnuVjAkQfxbea/ukHwf0Qp/qFI9SBVG6+Cnh6ZDG9ujDHpWay7FNayR2f2rhE7JP7z+C + fxF+w/8AGjw5btO1oZFQEnKn/wCvXgd18GPiRZTvC+mS5TrhTgV/oKa1+zl4Z1KNhPaptxx8or568Yfs + eeCpLWSWOxiH0XFc1TCYmndtXOynjsLUaUZNH8L8Pw08dvMbZdOff2GK9j8M/sv/ABY8QRK9pYlV9Cpz + X9UNt+xD4bk1Np0s0TJyvy19ZeBf2VtBsLVUNsqkAfwjtWMFXnK0YnTKeHgnKUz+NfUf2Wfi3oUHn3ll + hV9jk15Dr3w18c2cDrNpkyAE/NtO388V/dzqX7K/hW+yJ7VG9cjNeS+Kv2I/BusL5L2EbD02iuhUK8Xr + EweLw0lZTsf5/PjHwX4svJGt4NNnZjnopxXyt41+FHj6MmZtLmK5/umv9GY/8E7Ph3KrLLpkWW6nYK43 + xJ/wTL+H19FgadEBjgBOwr06WNq0bfuzwcVgKddu1Zfcf51vhnwL4ntLn9/p0y85yUNfavwzXU9N2LLA + 447qa/sb1H/glR8PLgEf2emPQLis/TP+CXfgTTHBSwUD/d5rnxeZuqrOkzXA5P7J3dVH8ruvTz3GllZ4 + mH1U4r5T8S6HqFzduUtZGB54U1/a9qX/AATp8J/ZzbpYKS3queK8nvv+CZnh2W4M0dmoz1G3Arnw2M9l + vBnZjctdX4aiP4oNT029tJNr2zrjrlcV6/8ADaTUppVhhgec9PlBJFf1g6x/wSj8KX7+Zc2ShR2Uda+j + Pg5/wS0+G+hmO5OnJlcfwiuqpj1Vjyxg7nBRymdGXNOasfy02fhnxTLYeYmlXGNvB2HmuP1DSfiHpqMd + Jgv7X1EO9Bz6gfWv7udM/YT8DQ6etoNNh2gf3BUFx+wH8PpF+bTYemR8grz/AKtWd+aldHpTq4drl9r+ + B/n3a/P8UIDFdak2ozJbSJJ5czSMh8shgCpPI4r/AE9vBVl4W8T+DtA8WXEcSPNplpqcSyqeJp1DCQq4 + IV0YjacblJ96/ODxF/wTg+F2r27QzaTDlhjhB3r9EdFh1DTPDdvbT7bb7JHBYB1JVyu0H5XxjaCuCmSe + +K9TLqajLldNRXboebXhFL93Uv6bni3jj4aeBPEvj2PxPrFhH/aPhywnt7OfcTBDAx3lolbJErsNpbJJ + UHpXPTeHlttQEaHfEoOQfvYPQ56nNfRa6TZW+uX8t8GxPbxSRMGZi5OVB69juByPeuD1vRpHvIrpXK4U + jpyVBzivQnh4Ru4xSu9bGNPENtK/TqeeQGP/AI9FYbiDwD1ArotI07Xf7RaKNVVQPlUZzx3P1rJtNHgt + dZDWJd8N5hzgn5uDj6elfSukaZZeXDe7oyzLzs7fX3q6OHjLXsFfEuGlty5ottHBYJHdRES9W9R71qzW + RkQMpHfbxVmWJJAGIIUcehNXliZEHGSRx/hXfGN9DyJztr1OWs9JjsJALZQufmYLxknrWm1tE8RjiGG6 + g9cVvRWaA/IMenNQXKCNAIwSeckcVfJYh1eZ+ZysmnTO+AAAeDgHH/1q577PcJrWyxtfPunAjQ8gAjkY + 69TxXoLXMsLgMvI5yKrS3dt5gvI3eCZWDKy8HNKxpGb2Mm91GaTT54L6PyrqFtrqvKoy9fy5rybRIL/V + ZxJePiNJCevJHoa9G1bTtQubORdKmR55AMednb1yegPqce9UrTR5bKxSzZ1RyfmYfLkjqcd6iUeY2hJQ + TON8TX93fTCxs0bbEwyff/AV3FlO8sCW8eQVwAR3FXIrKwt0Qnl8Yzj73uTWsgSFFAgU5wevzYNJU7Pc + U610kkV1lmjLpNIwJ7k5/I02C2EUAEOFZSSOBzznmtoLESSUAjx1x0NQ3MHlQC8LbUJwB3PsO/4VfKYK + fQo/2mwXcZFAyRyM445//X0xXmfiLWNGZmj+Vltwz9x8oXkg98A8YzzjFdJrCpaxC9/1ijGCTgKM9x0I + 559a+evHmp38lx5U0QSZG+cxuqvsZgeAeADySQTjj6V5mYVXGm0ezllBTqI888QeJbrQ7PUfCulwqtpJ + bNHCBlSC6A7QOTkAKD/dya/EK9/ZxF3dSSSQl3ldnYkZOWOSTX7SaHMmvePdO8LQz/aWunkyGIHGeSME + 5Gfl6+/evpk/s66AkvmJbgH2FeZl6c1Jp+X9feejm7hBwi15/p+h/Oha/stxwQ+c0GGPQYrMm/Znkupw + kUJI+lf0ox/ATRJFxJar+VTD4AeH40CpbLn/AHf5V6Ps5Hje0pWtY/m1m/Ztjt4fLaD5umNtW9L/AGXo + SvnywgD021/RDffs7+Hbk7ltlB6niobX4BaIqiNbdQOnSmqUxOrS7H89rfs1JczeWkI2j2qx/wAM0xoo + hSHPPYV/Q+v7P+hwKXSFenQCs25+C+jWh3C2Vs+2KfspCVWk9kfhvo/7MdvaW25IQGPtzXoug/s7W1mo + d4vm+lfrQvw602KZT5I4rq7H4b6TcbQ8IB6cCs5UGzWNaMVsfmJ4W/Z5tWuhe3UA2ryOK2PGvw4sLawK + rGMqMD0FfqxH8LbEwbEiA4PFef8Aib4KWl/CyNHwR1rlrYSdtDoo42Clqfzl/G3wtY2UMrKoHByK8T+C + PwhsP7VfxTqsQz/Du7V+7/xA/Y+0nxFcYkt92D6Vwkv7ICW9r9jtI/LwAPlHFcDpVYpqx1upRnNS6HxD + d2WlXkPlw7fkAGK8A+IOlWqxyfKAD6V+rOm/sZSIfnLZPII461X8RfsO2GpWrLMrFiO571x/VK172O94 + yja1z+Vn9ou703StPuZZsKADX4ieKng1fW5bhcbSxwa/sj/aR/4JbTePpG07TQ8a5O7rzXxjB/wQz81y + 7GUj05r2sFNU4+9ufO42hUqVLxWnqfzCjTYD1wc496JNKt2OD2zX9Pd3/wAEMHVflaQZHHXtXIXf/BEP + UEGS0g9uc16McZDuedPAV/5PxR/NO+m2gb5iAfrim/2dZ/3h+f8A9av6NZ/+CJeqF8BpOOOhNQ/8OSdV + /vSf98n/AArX63Dv+Bl9Trf8+/xR/9D+9KSeNAcmue1HVoo1K7uleY6p45RSyxtk+lcbdeJLy7JCnA6H + HpXPKuuhtGg+p03iHXVYsFOTXnLSyTPvOR9KuKWkGXOT2zTzEsZ3A/Wuabb1OqnFLQiwvQnOfzpMFkwB + 16U1pArYHJp6kBd7NxRGY3AjlWMJlgOK4zWUtp1K4+Ujpjqa2NT1EIu2M4PYVlWUD3D727msa07+6joo + w5feZh2Phu2ZsiMYP416HYaNFbQ4wPyqxZWSxKGxgfSr6yZGBx/hTo0ElcmtiG9CulhC4wwz6+tSnSbY + nG0Gr8Kjgdz1x1q8GUfWuhRRzObMP+yLbklB+VQXOj2rAgqOe9dA0gVcNx9Kzbif7ytj0/GrcEyFUknu + clc+HbZj8qA59qzG8MWm7aUzXZs2/I/CjYCSH5/Csnh49jdYidtzg5fC1gwJVBx7VC3g+w2D90pP0xXo + qwITleM9aufZARz+vrTeHh2F9amup4nc+CLLlmizk+nFdFomh2doNoQYHQAV297aYBBHOeTWLGggbAHt + n3pU8LCLukOpi5yjZs6S1toPLwuAOmKmNrE/GM8fSs+KUquc44zzUv2mTGDwD7V1KKOPmZJPZW4xwM9K + 8D8RXCWOt3Vnbxiad5lVFdflXvuUhcFlz0JHU89K97JGc+vWvmL4jQXtr47E9nKVdyuEHJGUwWwTzxxw + OfWufFe7FSS6nfl3v1JRb6G7pdzLJAl1qb+XHBuTcqEqcuWX5uucAkDlar3scN1/qnXcACOcHB6GsDU7 + nUVtDZ3rSSC7WOcs5y6lGIDDoCcbwR7+9UYrmC1kUykZIPXjgdO1YSq9Gd3sbvmRoWvhSeS6W5XbvCky + YPr346V6R4W0+fS7Sa2lAYB9+FGcZ9Pr1rldJ17zXFog+bgMDxww/rXp9tPbWoj+QoxAB5yCfzraiofZ + MMQ6m0jYgtXnuDM/KJjbnpuxyauzNKUKsOF6e3pVCymUFAhGMnPaukllEo5OCB/nrXbG1jyqjfNqZMAZ + EA5C/Xmq9xdvbDy0iEhc9+OlaElxFs2xHdk4JzTjIJmwQQF74/zmncSXkZ6W7ykzTKI2OcDtXH60kwm3 + R7cDkn0Pr+FdncwytEyAnnHI9K5W+jVZCOoIwQeQQKib0sbUI+9cq6TNFHDvkQNMoxnoFqIW8kV19qMe + 55QS7N8y8+np+FZHmXQ229ogEsjbstkfyB/pW9BYy3apJqKFZIsDAORkdxjtWXMzrnBLVl5YlkQiEb8D + nA4Ge1RblMPkum1ieM9cdOPxrpLYrEpCsNuc9O5qrKkDiRioHfnvWvQ429SGEKkPl5x7571TvY0nh8ly + CjcMD3Hfp0p8jhGDR/NjrisvVZrM2LSSybV74ODUyeg4J3OU8TMyx7EAkDEtJ7KoJ4Hck4AFfLusT6Xq + mgaxr2oxcNHtVXwSQScgZ44Az7GvQPjD8Q9O0iBtNjuxbmNC7yYztGCOePUivij4zeOpNA0Oa0juVuIX + 0wz21o8TP9pnfohjT5iz/dHUDd0r5XNsbFScVrbS3m9j7fJMDPkU3pf12W/6G7+w7rGk/FP48zeINOty + 1vpcl4kcqgGIjzDkBsA8MoGBx1x04/a99Pgzg45r8tv+CZXw2tdD8KWvjGVriW91iwF07XEm9wknzIOp + wMuxHfnFfqxMpX/Oa78jouGFXNu22eDxLiPaY1qOySRVisYDg4FOOnxqN3QnvUscg+4Pbmp2Y/w/pXtK + x4DuYs2nwhSR3rPFhbxHBH51uTKSDgdRyKwbnzUzgnn0q1FGfMyb7PbmPaK5TWbW22luB/8AXrdXzSMV + kX9sZMhuAabghqbPLp7WATZxgV0+lJAwG0gegpk+mFWz1A/GnxWz7gUyB/Wjkiae0kegWsEZTk81Lc2U + Dgqe9c3b3jxqdtJNqcqH9QM1m0tgTfcmuNEtpDggE9xVA+G7TeXZAfQVKurDbjdRJqw2570ezj2H7SXc + mj0GyyDtGamm8N2kuVKAg+1Z0esLjaTx71rx6qjIO3XrT5I9he0l3OIvfh/p1xL5vlru6dKgX4c6Sqhj + Cv1xXffbo2GCe/HpUP28Kp74zSVGHYp16nc4OX4f6SFO6JenpWDc/DTSJGJ8lMdM4r1R70P9361VkulB + +Wk6EOxSxFTueOP8JdILErbKw9dtM/4VJpX/AD6J/wB8168Ljdzv2/Sl87/pqf1pexh2K+s1e5//0f6/ + WJDYbv0qxbGQuC3IPaoI90hww2/rW1BG6LvYcCuClZbnfUv0LRjWMEr/ADqk8jqSM/hTJ7jDYPSmgs33 + hkGtZ2a0M4Jp6jD5oO9hxzWBqurraREk/SujnZY7YvJwK8p1VZNQuwg+7nFcNeXIrLc78PDmd3sZo1Se + 8uPMBO0nt3r0rQidoEnGBWNp3huNVDgdOM1vRQmNwqHAHGRUUKcviZpXqRtyo6kPuHPGOlAjHQ9+9MgX + 91mrgiyfmPWu5Hny3CJlj59e9WPOXJK5qFY3Lfzp4jZR8x5p2dx3Qkk+eevpWU8u45NXp0YDKjI7ms/a + 5YqR+NaJGLHxrg7s5x61OpDDJ6/zpI1wADSnJ4A59KdmJNE67cgqMVdWUFfl/KqIJyAeTUqY6+nXtUWZ + d0Q30qhOflJ5rFgtzLJsBqxqJkZiAeOlS6aoJy3T361pTRnUt0LIs8HKjpUy24GMj8e4rXUo5Ge3rVtY + 4jgetatGNzHEG4jIxzmvnH4v6Yf+Eos/Km2faPLB3AmNSnAY475IwMjd0r6p8gYwv6V8lftF3j6Prml3 + isypImzKnGcZ45BB7cEEVxY+SjSbe2h6OUxcsQordpnmTahFiJCrPPcpGZZZEwyhCVG1VyQuODwAMdzz + R5b26rcsvnrJu2FOhA44yP8AJrU0y72ECyYSwA45A5XkLyM5+6Tj255ro1SbVLrzGVVmkAAY/KPx/L2r + gjFS6ntzm4vY5fwr4w0+5upUS2mAiY73BBwEOznr3zzXtNpf2F0oubJGKuQuSc+v4dq5CPwvbS3R1Ix4 + lmVUcqME4OecdDz2/OofB2kSaJHJpSyTTC0kKKZGJ+VsMAD6DOK66cJR32OWrOE02tGe0wqoAt36Dqf8 + +9acV0y4jkO49s9/Wue+0i0k3QYjXH8R459a03uBMw3kBuwHT8K7VI8qdPqWLuArhcbBwRjpzUoupCCC + cY5HFVQQdzNjnqD7jtTEC4wzDnoB/WmyUW57kBBtJx7da5C5vlSQrIRuZgM9zWvMmECg8dM9hXLG2juL + 1jI21RwQPWsZyd7I7KFOKV2a0NxJMw+zryOpBHX2NdCIysCmQ/P3z0J9qoWaxWsgiCq5UZCr04960pHI + ++FBQ7Tt7Eep6GriZ1FroVg0ojKxcDpgilmd0iDOv5VYGWBGSCeARU/lzhUE+TuHHcce1VYwcrbowZhB + G/mJ3HAGea5bV4tliGZAipuY5P8ACOfzrsbzTp1cMCGXOPrn+tc/r9m+qaVc6TACJZECMzA4VSeTn1I4 + HvWU07M2pOPMtT8/td8AX2rW2q+J59l7Pr7iGGK4B8tIozvQdQQu9QWI618cfG3Uf+El1e18M+JPDmpX + dhq95b2cV3ARaQlDviaMyEBxJ90Bdyg+9fpx8SLwaFZB55RBDajbGxBZuyk4HP3S2cDpXyl8DfDF/wCM + 9BurDxCkVwsuptc2EIiEKRNH0mBYM7EsSQx5bg4GefjMbh4+1VJb/wBb79Wz77A4qbourJafp+GySP0N + /ZNsDp2mSWGAotLKCArxkEf7oA/IDPoK+uLtAwyPSvmT9mzSkjbXL/JAinW0UdQRGM5z68j6Yr6buAcf + WvrMDFqhE+CzSaeLnb+tDOjOM4H61dTDJjpWW7NG2D9amhuGLYzkVv1OM0GgDpvHaqc9mSOnHpV6GYEY + P5VZITkjkmtYsyaOVmiSNfYVg3U8Ijw+MdBXWajCxyBxXA3yOkpQjk1fMhKLInjikGMcfShrNANvfv8A + jUVuGWTJPXt2rQldUXntTurDs0ykttyNvOBVW508shHINatrKhfOcYrRcoy9c57CpQzgDYupwvNMaymk + Uqe/FdosSDI6c0fZkBGeh9KQHC/ZSgwvb1pkkskaiu1ubAbd4HUc1x95bOrnjHqaTZomQLcys3ynk+tW + UefOCT+FFpafMM9+eK30tUcbupFCkJpHPvLIpCgHFZzXMzTbc4rr7ixSQcd6wpLDbKH7/pU3KS7CRIxT + LFvyqTy/dvyH+FTosm35HI/Af1p22b/nofyH+NK47o//0v7EbZVByRitZEEkYC//AKqxo2kzwOOwNWUu + duB2rzo6npy0JWs1dzn9faqciCB/88Vox3AEZauW1zUU2eUjfM3WrlJRIhByehm63rC/6heg4rB0WKS8 + uvNfOwd6ZLZyXsoXPHXitaF1t08iEY7E4qKVHnnzz2NqlXkhyQ3OtkuFVPLiHFOtLSSSXeRxVTT0LqB1 + zXUxmOGPZ39a65OO0TjipbsmRFjGR2ojuFwCehqlJLn5EBNUJbiRB246e9Cj1Ic+h1cRjYZ7VXmnjT5Q + QK5+DUxt+bsO9Z19cyO2Qcj0HNXyolNnU7ldsHoab5cYG4ketcTFq80asB3/ACqU6u4QEjr2/wA/40Oy + GrnXhF6jkml8obsr2xnHc1kWupb8R9xW3bSGR/Ydapq5N7MsJGoIYAZApkmF4P8AjWkqIE5HtVeaNeS/ + 69KycWaKSZyt1l3x29aID5KBVzzVie9s1l2EZzyMVWm1WyjXlD9fSuiCikYS5m9C0Lx0Jz0NXo9UxhWU + krWOmqadKdqir0VzZEcjt69Kd4sjlkjW/tdeC2cn+tfJP7WF3v0XSb5CA0c7YJAI4w3I7jjkV9TSPZMu + Vzmvlv8Aaku7HT/AlrqMihlS7VcNjB3qf6Zrzs2S+qVPQ9bI3JY6lp1/NHkdprCGeCODBh2LsPCNk8tl + RwuCSOTyBn6eiRPqry7ovK84ZVARuVlOAASDnnH3gcDPtz4FperT37n7XdJJLhAzlcswYhiM9iowCDX0 + H4Ta0uLkRREJbJ0C4Ubc9PzrwsJWU9Ln1eOoOn71j0HRz4is7X+0HikuvPKBbaNggiXHPOcOQSTkqPl4 + 479qlvvlZZMBmH8I/mfX+YqGG8soImnlmWKKHDbt2AuOck+g79q01kefy5JgW3j77MCT6AAYB9sHnNfQ + U2lpc+Xqczd2rf1/Xn3G2thehFiuf9IfH+tYjgDgDaB2Heugi0SCKFVX5nI+YZzismLcMeczuAQdp46H + oDwevrXVRfMglRCPTI710U7HJWlJbGT/AGTL0Venaoxp1xuZGj2sewHFbSXFxHKctkegHOKkF3eF8rIX + x0GMYNVZGanJGX/YDSAFyrZHBB449KLPQ9LukKPKEK54I4/P3p0k08jhZWyO4z/nFMN3K0LNsX6Z7+tK + 8exV59zO1G1s7WYeQxJwVJ+6M9cD14HaqlraSL/pcaeUExtVsFc9yR71pTXCPt87BaNgw65XPcf5/Cr9 + 3d3qwKqSRPD1AK4PPuCeKmybNeaSVjEgktbL5ZmkIKsECjcNx/HgH17VbTUYCoWUdBgFe9Zc8keXVIgD + uBHYDPPB68U+eJWQEx/dG0en/wCupu09BuKerHzzCScSQuVRQQycBXPHOcZ47Vxut6hHaqbt2YlMsNpw + QB2PI4q9qEqLEqy8x7gcZycjpn2zXkHj/wAQQ2enzsgZxs3Mi9SwGcAHqMdfXpXFi8QoQcjuweGdSaij + 5M/aR+J4W8tLq0lghcylLaO4lihRpdpbYZJvkJbjsR2PU10fheC10/R7PT7+PypliCyQLIAFYcMoxgbB + nk56mvhrxR8Pbz46/F2DVpV87QtInF0GaXCY2lXVUXIO7ADhgDx15r7KggmtY5G1S2TanlrtfLgjG8jA + bGdg4AxzivgqeMlVnKrNdT9E+pxpwjSh0X9fmfo38AEjTwD9viQqbu4eZgeTzjg4AHHQY7CvcUl3t1ry + T4E20sXwr0uW4xmdXmAAA+WRyV9e2O9eqRja+1vXNfouGVqMF5L8j8ox0r4mo/N/mQ3lsMbl6/SsVRJC + 5yT6V1WAy4rHubQqCR/+utJRMozCKX5eDyKuic9eaxos5z/k1cUOfahX6CY66uEKluhHeuQ1G5jJKMOn + 866Wa23YOcZri9WtGjbcTV8txKVmMhk3ksvQ+lXngZl+7gVU0tTglq6mJkMZQ9Bz+NJKw3I4mYtA/HBN + WLeVpWx0IrR1BI2b5e9ZtviNyCBQC8zQYZBYnnsPrU9scLtx9MU0tGV3gilRyCHBpiL3leYhD4H86xLu + xBbbjkVom53Hk1bEiTLnjNAJnJpatF87DGKsiRVGTx6/jWnMFTJqp5Cv/DSsVcpvIO9Y91L8w5roJLRE + jIzxiuZuVaOfBHDHpWckaQZXKyHkNj60myX++KvqibQGXJ9cinbI/wC4PzFQUf/T/sSDnJycZ55561mX + MhV93XacmsuPUv3myU45zmm6hchrfZEclhzXnThKDPVpzhNElxqyRoXZuffkVzMP2jUJ/MY/M5wB6VTS + zuLi4VGJCLXouh6dDCDKRk/XtXPGMpSvI6ZuMY2iY50+aCHaep4z6VQSGQSbCM85NdtfTWar15rItUFz + MTHjANdvN0RyKNveZu2MKx24kXj/ABqG4kYvsTuec1pqqogj21GkcO/cx4HWritUYSejsVlYxR5xg9zW + HdySM25ifbFb899ZQEx5/E1AywOu4EEVq5N6IxUbas5yR2RQo6CmhhORuP1rXntY3Q7TyelV4rVYev8A + k1LdjSKuc3fJMJf3XAHP41o28YWDzGxkD9a6EWUckWXx19Kie0RVIjHQdKLsDnrK5bz2bqOor0DSXLxK + /cmuTt9OCnzgAvP4VtLfxWXytwD6VUZaGc1qdjLISPl4rMvW3x+WSeaxxqvn85OemKks5vPuth5FXyu1 + zPmS0MafTbyZtwFVZ9HvHi8tRzXr0NlH5SnocVBLZQD7vH400kCmzx+DRrtGHXNXH0+8C7uo/OvTjZR7 + MkVA1pEq5/pRYbm2eZfZ9RDDAOK+bP2ubPWLr4KXkNnAZbhriFI1AJJZiQMY5yM54r7gS3hYcen5V8+/ + tS2V03wL1xrCQxOiISy8HYWAdQR0JUkZ7VyY9J4aovJ/kd+VVHHG0Wv5l+Z+Xfh3WtEsTctqd41vEYiZ + Z2G2OFk2/M+dzFdoYHHI684NfR/hT4q6Pp9ougajaSRzeZ8k7xuBsZQQu7GCD1BFfn74TWOVxorA+WrB + hGG3qWBJLAjg5PHvX014T1UxbLefd5YAG/A2jB4x0AwOOn1r87oYycPgep+vYrAU6itUV/nY+rk+MVpa + 28IsYbiZnIBKw7htzyCDnt3r0iPxze2k4sptMuEE7eWrFQJNy9ATu3rgHqwHPTivn/QNW0+OUWLIZ55R + hoth2mN+OuNpJJxgHPfFem6XKmjxva6cj2ImXyyssTifZHldrBwcBjkZ3EjFe1hsZWd3KWny/rU+dxeX + YeOkaevnf79O3o7npWm+KdU1HUY7KysGQOTmWZmYgjrhf5YzXrtpqqXEAZtgdhlhG28A+mT39c14Bp98 + 8kyPFK1uVIZdspQnH8KtjIJ6V6XYXcU8e6EMqjk556njnv7mvcwOJk78zufOZlg4K3LG39ep3v2mNnMa + 4yR645+tXkDK3HUAfSuc0kxljsPPX65rUadmnABx7V60Xpc8CpBJ2RYvOFFxECAeo6VWiyyggbueOOcf + pUUyM+4SHhffNWkuPLtwWHXpn0pdQ5dC1LbweUJJ/lkfAOe4PoO/8qifTyE3pGTGDjIGBxz+eKx31QG4 + QFY9jtteWaXaIvcdsexIFTreajqMjG1SJrdANr28hZnDHpLtyAB6DGRS51t1NFRna/QeJbcFChZYyDgs + CM+5B7e1Zt7Z/apGTcBGFyck5JHPGKq3t/eSXi6enliJWcykg7iQMYUjpnHOQelYWpeJ5dIjG+VhHJlW + BG7I7ZIH5c1lOrFLXY2hh5trl3ZX1OcCGVRuC56ngHpkA+xP1r5z+IcrWtndyy5CwxM4fGT0I4FeuP4j + g1u/utHsLd7OW1dUEl9thimLqW/c5yzhQCWIXAFfl3+158a/iT4e03WNL0LUrO5txPFZW1zC8jQAzHaV + yBkOsmRkDkAivnc4xtOnTvL0+Z9TkuXVJ1LKytq/TTt/X3He/AKysNL+HVzd2ME88813IgYAHzJB/EB3 + Jz09Byepr0XxE1roWmW1kskMRV7idyxUp8keD8vRlXnueAfSvm79iC+8da18Bbfxh8Q1ik1K9u5ltEAe + 3jhsUcRlto/iYo0g7EkZODXqmrS6cmux29lZ4VI5SyMVTa848reYiWG0jnGeR0GeK+Wi/cpxsfWpe9Ul + fufrz8Mobqx+HWiWt6weZbOJnKgAFmUMcAcAZPAHFdqJ/m5NZ1jZfYdNtrPtDEiYxgYUAVMu4k7+eM1+ + pRhZJH4rUlzScu5fWbacnPNOlKMvPpzVGNyDtOKla4G0IuMU9CSg7BBwe/pU8VwH+U/T61A/zDLYqgt1 + HA+HBGPSpL3R0uAwIA/pXNapbecvOTWpHqEUoNMmuYwpDYP0q2QclbxPbgq/XsakN1tJzxgetLqM4VfM + iXtXKvNO83zA4xSRZty3qEbQapy/OfkO71qv9jkfBJ4z0rr7DSg0IOOPSnyi5jkoLhlJVvu/1q4Z2Vdp + P1z2q9f6a0WSvQnNYYSVWKHr6GlJdiotExlbhgc1diZl+c5qIRDyxJg9ADUqzxoTuIH1qbjaZbkVnXd1 + x/SqwufLkCtz3prXkQHlqd9Z00+5sx9KlspRudCsqSL5Tfh9KxNQtFPD/eXkGswam8bGNuoOM0+bUhIu + GPI7mplqUlZiROUUjpz61J5x9R+dYv8AaFm3M20mj7dp3oP0rPlZrdH/1P6trvUy975CjgdMV3uj2CSw + hp+hrN07wis4N9KPz61aErWcxhdvlHauJOVTVnqOMIaRNiWwQcQgcZNZ11fTWsZVeDQmuW0EoSSTrxWh + Oltcweah4681SXvcsibvl5onAyXGoXl+EwcV6LprQWIBl71m6XDFNKQOCp5rRvbZXkVYscUKMYy0FOUp + xSZ0dzc2ht9y4BOADWbDLbsDGDuNYNzMYXEOcL0xWtDDlRGnGa3jUTZySpSS1OI1xLme7LQEgA0+1uLl + I8gdK6iaCGDOTyeM1DGbYjgDFaOouhKpvqZKX83neW/bqela0cvmJuJ+8cVRlt4pJSyjOelTvNFCoDjp + 71jddTZLojZhkXjuR7U7yyw5HJ7VUt7yJl3VNHOOcn3NJSHKmTSOq9ScetY1yiO3zngUl5PL8sa9Cefp + VWKQSoWbAJ4FQ5a6GkaatqXYkjgTKnPf161taUCGViK5UbvN2Iep5rvtMtgIQ54ArSM29DGrBR1OiS6w + mxRilMm8g85zVUKV68ipQ2eB3PStOY5i8fukj8ayJ3lGWB64rSMiKu4YBqqxV3w3+fpTuBjpLKHKuK84 + +ONlZ6t8HPElvqEzQQrYyTPIg3MgiG/cB3IxketeqzQqULIOneuB+JVvJd/DbxBbxgbm065IB5XIjJGQ + eMcc8VlXV6covszow0uWtCSezX5n89Fp4/u7JLWX4aNZahNIwAa4QFktzIMusQyEYjBwysFVs85Ar6P0 + 7XvDMuoz2OiyG5ltdqXZjgaJI5z8wCbuWQqVb05xz0r478C3NmJLC4S7triS4hPmC3+Zo2LNgNwuM7cj + HHTvwPrXwvpuvXEfmaGzN9lIluCqeZmINyQeNvJHPPf1r8nhXfM4WP3upQioqd/0+/Q9r8L+ILXV7NYf + DMK6hp7BvL1WFxJbGRTtMBiYBiwIJz04I9M+0eErzQNEMWoT6lLdW8GFuru3tJHHmqPuqjfOSDhWxyDn + FfP2hW2raO0Om2V0lxDb2wbBnlW+SVydvmSZIBYDcGKFlzkZBxXuulz+IbeZdD1Vk8+GHe7yyzXNy7uA + x85FAVZeMKxUfKckAGvcw0tbrdW/r/h9dDwcXBNNX0d+17d9U/wVtdmejaT4k0qDdLbWOoFgpgZjsjHm + uP8AWLnOY8HnjPbrXoVg1sCqI7BoR/q5CAxJ6lQCcj8TXm2n2E+mWX9oa0pitsKVTKh5GcZUR7iNx4yR + nIGTit3SNajCIFt4ohnBCZb5c5yCTkHtn0HSvYw1Vx0qaHz2MoKabpa263v/AF8u56/p9wpiMjZQLjn3 + 96tQ3zGfJA5/irgF1hGARnAZvX/61aK6lIqAEjHc9a9mOJVkfO1MFK7dju5btNhKn5lzjjrWLcaizLtJ + Py5zXInWpuI3xz3A7VUuPEFmgLOw6YOPWpni49yqeXz7XN2NLrUbkWNunmmQ4CqN2QOTxW7aXCwMLi7/ + AHt+zH7OzIRHI+eMiIDaoUfxHqPWvKJJ5dUt32ySwbv4oGKMOf7y4I967i2+3W9m0c8zpBGm1THGUkHq + XkQ/OBg4Ay3saxpV+bVf1/Xc66uFUVZvXtb9fzWit8rXr65k0dJdSnt5bqZNpCOPLikZ+QFc5OMDqV/x + rknlmlsUMyQLNMcvGJBMQSMkY6nHQce/FTXWpHUkd9EgM0ODsmnZmDjnaVQEOG2jjcq89ttef63rpkDS + veXNxcyjZEpiSBraJRyCBtYEnkHLc9eOmVaulrfT+vmdGGwcm7W1+d/8l13t2MHWxpesX8Ol7Ibi6sla + SOOBYmuiRztTdKpBPXZtBbGe3P52ftI6VF8X/EOnfB65i8yzvobh9QuArR3FvZ+XtSXyZF3b1nMfCbsn + J6E19JfE7XDoWmXX2m6bS7aRNzzGKN5GLcD97yyqq53bRz1BBANeDfD3VtA8W/FGa90q5g8W2V1bF7bV + bSB98MakobeJLhVjIk3eYXAwv3QRjn5bGYqNSSp+avr92m/Tt9x9jhMHKnB1OlnbT79duu1/v2XpFlr/ + AIX8G+GdM+G3hfTr3Ph23t7A25gZWCxxLyzsETc0f7w4ODnkHIFZfhyK21f4g6NoWpwG5+03tqqyl1z+ + 9uAcOqAAsCoxkLtAPGSKXVNDXwfG/mywaRaWxkjtyN0MaxR5OZ3lbqp3ZkG1QD3rH/Zqs9Dv/wBpLS9M + 8MXEN/brf/2pNe2YBtZiUEjhQowCHJBYnnHy98c1Nyq4mnFKyul/XyNMSoUcHVkt+WT69F/n5/efu8q8 + nc2RQYxuyapJqtuT8pFWTdxMCVPSv1A/EyKa33A7O1Zz28u3JJBqy+obGwgyaaj3E/JGBSshmNcTOnBN + ZkqNMf3YOK7FdNVzmTvk4x3pJrOJVztpt6AtzjooJlOHOc1qxWu47s44zirohGM45qWFSFI71lzamjWh + iyWQ+6PWs6S3CD5xjH611xSNuZO3tVG6a28ojPOOKtvQlJmDCA6kLjPrWtY3TxN5Tnj1rlo7+Fbgwk9+ + 3StuGWFTuBw3ue1ClcUos6K4UTRHB6VgS2qA7OOa1ra5jkXHGOtRX28ZZe3amSYMisoIGRnvXF6/bXyw + F7cbm9h2r0OSNZl+Y8gVahs45kPmDPFZzjfY1hOzuzyXRoL87kmzg8giuiaykMeWHI6V0zWkVucAZGfz + pPMiD8Y4OCKlKy1Lcru5xkmkyPjcc5psugSGIrzx+NdlPIsakxjj261yV74lNtciAjKn9KTY0nucfNo9 + zHIVcH2wO1Rf2VL6N+X/ANau/wDtMM4D5HTHNG6L1H+fwpWHzH//1f7Cb/xBaWFvgsBgV5PqmtrdNuU/ + eIGBVPWNG1vWZQQxRSelb1p4QgigTIyTyTWVGEYayZ21Ztq0Ec6NEu7hxcxysQTx7V1Mt5c6ZZbJCcDv + XVRRWVlCPMIGPeuI1uSTXrgQ6fygPO2sK0oufOdVBS5OS2hveG7pjCbhzx796hm1PUHvC9uMqOPrUtlZ + nTbEwLkuau2hS0t/KlwZDyTUqN0E52d7EcFxLNIsl0mMdfSukfUo1j3cDsPpXPyXG+Mfnx7VjXl5KVEI + HpkVtFKxzTbb1Ohnuluef0qm1g6opzx9a4m48SW2nMomJHPJ7Vp6frx1px9gyygnJrWNGXK5dDKdSPMo + nUjesq81DcQs8+4n5elXNPtbuZiXxx1BFSTQSpujJ68e2KSp6ajdVKWg+CONYcg9OuKgWWQBto+97VYE + KoASTnHND3tuqGPAyP6UvZIPbMyz9qnu/LAPHHBq1NYSRRbx1qhaamn2koeSWz+Va+p6gsUOR9eKUqdn + YqNV2Mi3fybhSepPr3r1jTHAhDY5rw+IzXl4vk8heTXq2nXvkwBGHIXOaajbQzqO+p1Mrhe3FUmmIIHr + VeK7EoG7kZ6+tPZhI2T9aZnY1xmVdxz60scfynbzVYSA4j3c9MUPOsXy59/zpohotuqAHP5+1cv4m08a + r4X1SwXg3FnPH9C8bD+tWpr2R2Ma9AeKYJB9neNiCXBXA9wRTkk0ON000fyH/BvTdL0CWLVoIwk32oxX + L7tzs9uxCAk88JwOgGa/RfxZ4OtPEGrQX2hajc6Rd2G28029spDG8U7R4DEA7XUZBKMMHAr8sfDOvXum + nVdMjWIfY/E0sfkq3C7RwAfXC8A1+mfg3XbPU/B+lXtzNHE6IImeRxGoUE/MzHgYHUnAA61+LVHKFdu+ + tz+koU1OhF9Gj23w9qHxCk11dM1eOxvdMktFuZ9YdjHqE95gKUeJQI9rYLbhjHQA9a7SS08QaL4au9E0 + 3VpbPTplSFNQe+W3m0lZGJdonZWeYyc/6wsE7Y4rmdJuWtZzaSNG5jbYSjb149CuQfbmpda8O+HPFmqQ + ajqkMksllgptkZELI29d4BAYKwzg5FelQxUk7vf+vX+u255tTCRlZdN9v+Cv8rdGrp+uaOsVokV3bmWW + E5kUhixJkHJQE9WHHGOuK7OPUbDV3ln0aO4tYYpfLT7evkPuXGSQcADPrXhcUUZu4b+fJmjj8tXBIKo3 + UV1Okan4y1NJYviVqGlJ5kix28kcZtoVhQYTzmcndIx6twOn1rvo4lOPJ1/rr0/E4cRgXzc9+nn+XX8D + 0DUNY1axtmi0+5HnuvyvIgZUP6ZFdUuoeJlt4ZrhIx50auu/cuVPcexrgZvO1Fc2kfmlY1cmPkAZAz9M + nitiK1v9NgFr9oSEfMbi3GyRxIOgc8vGw/u/LkdR0rohWkru7scdTDQslZc3mtfw1/rpuaa+INTmMkUn + lqQxClAeF/E1bgikv2lEcbsygNgKzgEDnJ5wMAnJrkNTWz0i8e3mvoJ5UVSyQkyEStj5G4G1lByc8Cr1 + ndX9hq8+hSWyTyRGSKRIpS3mYGd8ZGRuPHGDkDitIVHzWqen9WuRPDpRvSVtL9tO+ttP8z0rwXa3h1b7 + PBEXjVHYqvCNj/ax0J4Hvin634ujjkXRbDUpLG5EoDXUMYxZucjpJuAbuVCEYJ71z7+LvAug2oZ72x1G + 8RB5lhDOs0sUpGQGwMxvjnn7uD1zx59rXxD1Aa39t8NraapZXQQvHKWSe0mXOJBKEG/b02cqSM5rueKh + RpqPOr/f/X5ryPOhgKtes5+zdraX0Ta9brbvZO272Pbde8TaNJpEcjvHNbhgks+923yqpBZQictkcb1G + A24V5vcatKdP+2XqSxJKzRWXmK8szFBlmkfc8W8kjjIJXBwTmuCt/F895dyaJ4dXUdNu0+a/vmWJ7a6h + Y58pMgkMf4mwCMcVy2u6h4Mu9SfVfD+u20l8IF+0LHdsY7RQTgypnZG3BywGcDGeK4sTmSmubR6en/Bd + vwfVndhsodP3Hda+v39Ffv1Wlk2eZ+OJPFXjWa8/4Ruxtri2szCl/v8A3hYMSQ2F3uqEKdxiU4AzxWd8 + K4P7K+1apo8kb2817NKsMXmeQscr7z5CELtO4kDcgAU5Ir5j8Y+P77VfHEWtWulzSPbB4bKK2v2tzGkw + Kyn7RGodlkciTY2cAACvt3wILzTtIbVNYlmuXhhRlE8vmEsRzgnAGTkkDgk5r5qOIpzk5Rld3d/+B2X5 + 76H0NTCzpx5XHT+t9Xd/cltra54F+0LaavrX9paXqmn6cljcypKLvJuZ3kUGMqQPLC4RPvNuIZsdgad/ + wTp0jVrr47X6LqH2nT7CxY+Vgb/NLONzkfxEkl+ByRxiuJ+Itx4dtNQ1HWVQR311J5tzKPvNj5VGecYH + HHrX0V/wS/skvdd8R65KjoUT5iVwu6Rhxk9TgE//AK67MkqOrmVNdE7/AHI8/iWn7DJ6z62t97SP1ot9 + HuppvvEc9O1dVpmmzW/yytn9as2yqXBJ5NWGmkjl29jxX6ufhWpfFhATvxk1YaNEXI4/pVWW7MceehFV + orl7iNlIxnsaQExYhsL29+1WS0bqM/xVHaxfNhx1q1LbKnzr25wKTGmZMsPVVPXkEdjTQinDEYIqzMWC + lu3aspjJndyOMGotY0TuQ31yltESp5x3ryS/up5LpthYY5znFemz26zOC44NV10e3kkBA6evvQuW+pV2 + loeJXf2+CX7Rk468099R1aeIC3JNesa/pCmzPkqMgdK4TQGjjc210uCpPB61pUSlG8RQk07M2vDs975S + /aTkmu/jlFxHt6MevvXP2k9lE+Oh6VcaRjMGg+7n9KlPQUlrcW4R4JfLz8jdDU0Uj221SPXNTzJ50ZkX + k4yK5+fWIrV/LuRz60JrZiab1Rp6o7+SW6N1ri5NSk3b14I4Iret/ENpeTC2/DNNvtPt4388AYPUetCg + m9x89uhSsrwTLsbnOeTXJ6/boJg6DDV0zWwRvNiIwaguLeO6Tn+H15rOUOhrGfU5CG+cIA43Ed84qX7d + /sf+PCtRtKjY5XkfhTf7IX2/So5ZF8yP/9b+wNjEPn6LnrXO6p4ktrWMlOQO46iqWsavHaIbSRtjevSn + 6Dp2iXFmxDGV8ZO6uD2kU1F7nr+yly81tDmorxvEMhhLHaTzjg4rpotPg0SLy7TlyK0Eg02xjLQKAw4H + amWtlc3Ns89020dRmtlGMnzPRIxlOUVyxepIly8OnteTAEqM8etcda6pd3UrSzIQB0HpWtoMbT2863Nx + 5hRiMH0+lY03n2MrPc4KsflA96pRTsyVLRrqaUc4ndmU/Mvb1rMtbXUbvUTM4IQHFa9lBGf3mcEjJz2r + pLSQpGY1G7HH51okkyJSdjndX8N6be2bLwGbqe+aw/D9kuiRLaWRD8/Mc55rs7uGONBGTgycVnWvhzTN + BkaezLbp+SCc8/jW3tfdszmVJ810dPZ3rKDFkZ70XcnmOAhyBySPSucugtk4SNj5klSXcl/p2mvJaRfa + JD/DnFTOTtccIamwoaeYyJ0Hanf2agUzEde1c5o97qNzF5LweU7HLe1btxcyxJ5RJYVKk+qLlFXumQ2m + m2wmMqnp0/GlubeKc8ngVppbk237snOKoNbuEYP94foKmU7scYtIj0S0T7SX6Kc44ruPsKiMsxwMZyKo + aPYJHbhjzxWlLcKiMtOJnPczdNmCSvGwrWmyfmTg81lWIyGcjv6dq1UYbQp/LtSiu4SfYagk3DccCor0 + OoznpWwIgoyef0rPv5E8sqoyc/WnYm5ixC4lkHOAeuaufZ3XDdRnNakUEZgBX71RR3FushiLAk+9NaBq + fxPeO/P8F/tA/GHw5qEhX+ydclmRQQSJPPYoCCOjA4B7Zr7Z8Fanb674FXw94gi+0wahE8dzARuDJKMO + DjHB9eOORXxP+2PqNj4L/bm+Nvh6VvKk1DUDKJX5BDbXHHsSRUXwa+MULeFra0eXEqkIvIYjtwc44PQ5 + 4r8TzpunialtLP8AQ/rDhXLZ4vLqE0r80b/1+B+q/wAMk0TwN4dtfC3hZWisbIFYlkdpWGSScuxZ2JJ5 + JJNex6R4nih3iedwC5Cjbxk8fzzgV+dfhv4x262zt5obYjYzx298GvRrH4rWLrGIpthH7vb91hnsMHHb + pgEn2rzY4+3U9ufDFR/ZPuu+10COJI7sTS8ncg4IHQE9sV0Nr4r8GS2C2HjPX9M8PK4YQ3WryKkDSoNy + LyCC2RwvfFfFWnfE+yuMiKcE/dx2Zl45JJxjuOR2qDxFqHw8+J9gfCnxF0+01yxR0mSC7VZIjLD91gD6 + Z9O/viuqhmcY1E57f15r80clfheq4cqTv30v+TX4M+6/D3inxn4p0sah8SNVstR1QvnztNthaW5hx+7K + KCcnHJOTknI4re1TxH4ks4ZLvwW1hpWpPFGj3jWYuDcKvDSTJI2JJSny7u3FfLlr8RtNhiSKEpGiKFVV + wAoXgAAdAOgrQh+JVs7FROCwHAJ5xXQs61cubV9epwS4UqbKmuXtZW9LWtbytY+nZ21Vbe01W7jYWtwz + xRzsQAXTG4Y69+a4K5+LGoeG/Ex0Hw3ZX0OsXFuz2Ot22xrazkHGZFbOWHUKRzXhs3iLQJdWfXtqm8li + ERkDEsUXJ2gZwP5mqGo+NXiaGaCRk2DDZGGA9/f60v7YjF80H/w/9bdUaQ4VnJclWN12tZfPV37Po+q6 + Hv0SxaNbS6hcGO51TUXSTUL4RrHLdzKuC8m0Dk4/Cm6Z4jS8udqnaSDkk8jHYV4tY/Eqy1SM2zyIJVBL + I3Af3HbP41Bc+LtOEi/Y5EikK5f5sMATjOPT34rKpmib5uY2hw5UScZQ1Pp251qKOMeVJtGOff1NeJav + e2PhWz1Cy8NaTY2qanuuL2dI9kzOedxC8MW5yW5H1rz5/iNHZf6HLLnZ90Ywf8eR06/jXB/En4jtPpjC + CSRdysjSKApcEdcZ3Y/2uh9zxWNbM04NpmM+H50VeS0/y2MLwbIura5JLJGpKySMSvJ2j7oIJ7AZ4A61 + 9P3HiRR4La6klKxQyAswOGAQZA/Ovz08CTyRZuJ7lXExlX5iG8sZx9RnGec8HNd/4k+J0Nh4T1HSvOTa + GRjhwcqv068kDtx2rlpYhQh5s1o5POtaS2Ob+PnjGbwz4QHiK7cx/bnIQjJJBzx0IHqM8e1fq3/wS48L + T2Pwdl1y/J+03YjMh3biGJYkE9z796/mo+NHxvsvFEek+D3jJYTxpPKjli4U4RQpyAAGJOM5JGcYr+rP + /gnHpc8X7N0WqyEs91du2GXG0IiDGecjPrX2HCVOTxsJSXST/T9T4DxJh7HLZQvvKK/X9D75W2baPLzn + rmqkguWbfggjjFa1pLMEyR2qxMgMJkHU9vpX6knc/Ajm7rVbiGMmdSFX0rmYviZpa3S6dErvIW2kheB+ + Ndo7WsqNG65/lU9joeiXK5WJA+fSpkm3oy1KKWqLUGr74xOwIJrae5EkO4D0rLS1s/N8rIJX07Vd2eV8 + vX2qyLEkAV0PTPTHSsySNVYqOvWtRrfC+YDtHWqUxjALofak1caZkCIsdvU5qaLkYPOPSo5oZDGWQ889 + e9Y1peXquYphyO9RYq/Y33VZR5bj8K43XvDAQ/bYPlK88cV2STgkMB83amtcpfRtaSckDFWvInU8+s7a + KdMqcsvNaqpKqblPH8q46/e70a/MMIO1jkelbf8AaFyIhvGDjtUKL3SNW1s2bQvGhOP8msTWLaPUQCv3 + u2RUtvepcDDY+tWYrTLmT+A/zqXG400mcxbafBC3mx/eH861F1OCUCGZvmxxVTVrOYN51pkdMiuO1OVX + XchKyA89sGs+ZrQ15U9Ten1R7KUhwTEeje9Y+r6lMkPm2jcHk4/nWppb297Y/ZLjlumfWsC7lSylNg3P + dfpUyk+5UIrscFc6v4g84kMBmq/9r+IP74rr579beQxRxjHuM1D/AGs3/PJf++RXM+b+Y6k1b4T/1/6s + LnS49aeS/smdipAUMOCa7WztZbS1EaIFfaATjvU1q62USRRH5Y14yOTW5AsN3ERKxbeOOK4Y0lKV7HrV + K8oQ5b+hza6Pcmf7VORtHOD0zWXqWvXEhWxtYy2TtJXpj61v6tqNnbyR6EWy7kZAPIHvUm+yt7hbKyA4 + GXyOmatSu9NloYWsve3epxlvBJFdlIAQrj5u2DRYaLqV1qL3V/J5kIOI1Hb/AOvXZrfWr6g0Ua7lUYJx + xmi6vo7Sxe9hAROigc5NbSlezZEI2bSIIdLZ5AFAKRg5qzYv51+Y0XEKdajh/wBF0k3Qb55emeOT/Ksy + RrzTtOKp888p2hQe56/lUu+vl+YK3ff8jWtpIdQ1GSUfcj4H4VVSNdavJJYW2pCeD2+lXLe1bTNHW3uc + CV/Xg5NZ1/G2lWItbT/WzEcD1NN6b9PzJT5r26/kXtN0wX0zXbhWCcD2xXSxWCrI0jHhRS2AW3so4yu1 + sc+5q1MolPkRk/N97nJxTJbb1Me6s2gha4/vcCuVjs52vgHJwOuRXVS214ZBFC/7pOufWtOOyjgxJK27 + J9Kb7ji7aHPxSNEpjbPHANV3M0qlkJG7pn37Vp6jG+9tnGewHas2cyrNb2R4aQ/p3rOdty4ts6+3YW1o + iMQGxUH2i2kBBwSaWSMSnyhitiGGzY7NhOBnGK0Wxzve7KMe8Rjbwp9qi863A+VwW9K1p5YkjKouRjtX + PSQQRxOTDyQcUbCWp0FlNDKm/PGKp3ccRYSgZArB0i+RY0gcbCSQM963bma2SMjp2xVRd1cJKzOMHjfQ + V1n+xnuFEuQNueas6fbW19qj3cbZVe9QReH/AA3dXP254kaYHIcr82f0qfSoAplt4xwr4B9qz5W375rz + RS93Q/hl/wCC01y/w4/b58f39rCI4782blwSN5kt4XJ/Nvavxwg+PWv+FbaO406f5AwWSNjlWB6elfsJ + /wAHEemnRv28Nau3Yj7doGmzj6pF5Z/9Ar+ZrW9bYiSEsTn14PHtXyeJymlWrT543uz9z4L46r5bQoqD + 0jG1ntqtfyP1D0b9s3XNP8mN8APEpIY4GSeeB0B9MV9DeGP2vluCwnn4KYYRuxHHJHUbhxgD5foK/CQ+ + Ip9kLSNuAQAfUE13uheK3hcOjkI3UA5/nXmVuFcM7uKsz9vyrxRw+ItTrUkttep/QJoX7YOn2Lrf3yW1 + 5GUfMNyheJkYEeW4VyTgHA2suWAPPStuH9rl4LWO7EqR9CQZSAp99i4IHI5A5wOlfgY3iLzkIllZsHIw + x69ulaieO9QDR2kUny9cg8j0xXDLhOlJctz6inxjlcZe0qQ7df0P3mi/bUurbz7iFpJra1kjjkmVSUR5 + NxVSfU7Wx64NdDYfthiSFtSiv4yqZMmN53EcsDvwVyMY9x0xX4cWmu6Y3w71LVZ/Ev2XU/7Qs4YtFMEj + tdQ7ZC8/nj92ghOBsPzNvyOBXrXwb+FHxM/aAg8T23w4v9Ojbw3o82s3MeoX8ViZbe3xvSDzSokl54jB + yw4HNc74NoJfF956j43yWpe9K1vxP1p0b9vG1jvntp33bxtibccqT0II5yPzrso/2pjOy3V/IbneuC0k + 2zjGOTwR69K/nS0/xrfW1zFdCUsANyn+X4129t8VdQMXmyysCMnknqaJ8HQiuWMtC/8AWnI8S/aU4cjP + 6AJf2rIdCzqVxNsRACcHJI7H3rNsv2zND8TQzeXbxfb04a5yfN8rP3QR2yAcDvX4J6t8R/Emr7LDSt0k + szLtjjUyPM/YbRkse3A7VQ8J/EbVLGGaYSNFOW29SOnY/jWb4OVvaNiXEmSpSw7V6j1T6I/ow8L/ALRC + eIb77LLqAjEDYlPOcAZx82QcdjzkenQfQ3ivxDpjeHf7SLFxswTzwoBIz7HOa/nL+Afi/WvFfxE0vw6L + twJLiPgnK+WrAtuwR8rLlPqR2r9d/jz46Xwn8NZYreUwt5I+UnIJxjv1/pXymeZf9Vr06Cd3I+az7EYe + vS58P8K3Oc1j446X4djkmgvsShmCwvtfKEAZ59PT8K+XvG/7ZsmkK1rIWktZyyylFZnG0ZGMZwpOOK/O + LXPibJeSXV3d3DCVZF8qIruV1OcnOcLjA4IOc+1eXat8QJbexkt0ch5gwbBBBX/9Yr6/CcMxaXPqfPS4 + vwOCwvJyq9rd/wDL8z728PfEOPxl4rsduSs8oZVfGcMQcd8e/GcV/oV/sEaVLpH7KvhZGXabqOedx6Fp + GGOPQCv8zT4CX17rPjnSbWByc3EMKrnrudeP51/qNfswaYulfs7eDLfy/Kb+yoJXTOcNMN55+rV9dkmC + VHEtrpG33tf5H86+IWfRx1GEaasue/4P/M90t9wk2Dp79qdI4kja3k4z3qaQxoqyLjp2qK5VmHmYyp4w + OtfVn5QYkdhHCqwWrBvXPNXgZoLgHPytWbaQk3v7pHQLzk9CK6Se3kOJCcj3oslsDK6JBDN55Y57+laj + 3CSoMcD9aovHDPFu25445pNOIVfLdeRng9RQvIH5l1rxdhRjxisVb+DzSkBzjrWiUTzyrA4x+FU7i1tI + 8mNcE8UmNWGJK3LE4GfxxVMRMZSIyMEd60IrQPa/JnJ9azXtmTDI54qH3LXYZuuoJCGxzXN6zdX9vcrd + adjcOq9OPSt4efcIULYb1rGvLC6RG+ysN5HGfWk72KVrnF+Kry9vIo5j+6k+nerug6VdanY5uLgg+x7V + Z1TS78acktwPNl68DHSud0nWXsbyO1dXHnnB4wFPvXQ7KneL1MtXOz2Orfw1cWkTGOYnngVFY3OowKUn + 56itLULbWRIos/mz3ziuCvovF0cxCAYGa56cZPU3k47G7JqdwkxZvutwc1zviS6i0maO/kAaGXCufr0N + XoNUgjtWbWnSMDvnuKZ5+heJbZrBJFkRh8pzUVLyT5d0aU1yu72LVm9sxWaEAZwcjmmeIbD7dbC4gH7x + P51iW+l3/haxk/tKQNbxHKsOoX3qa216zni862lDq+QBn+lQmpLXcduV3WxzKyRhcSD5u46c07zoPT9a + 69LWyuV80sqE9QfWnf2dZf8APRKLLsO77n//0P62LYQ6nrioJtrRR4cI3ADdiPwro702VhG92bvbDaIW + c+oA5zXg/wALfDj6fNL4h1eedru5PG44UoPlAI/vceteiX6WfiLxDJ4QiXelqkc98f4TuOUjz6nGSPSu + OTdOCiviZ6FozqOTfuom027tpoLnxTcR5JQy4b7wT+Hj3q7oUGqvo8eqarAsUkql255Ut0HT0ravBDea + vBoMcaGILvmPHyqOg/E/yq1fWN1cRrplrJlMlmfHQDoKuL/yIm/8zI+wJBpa29i26SVsb+/vWbqLCTUY + tKPzJAqlgP7xrW1CIK66pckLBbfcVeN7dM56Vz+jz3N5NLdp5c2wk8LhjIeoBz2qvaRUvyBQk4/n5dze + 1DzbnUbS0CsIVPzEDPPpXPxzed4i81UaRFJWIdFXb1atae41WxtDJfurTzErFGnVAeuT3NWfD+mW9lbi + SRSERCpQnOO5Jz+tJavT+mN6LX+kTW0rapffa7hf9Gg+4c5yR3qrp9pPqOvy65dhhbRjbbg8Z9Tiuq0d + LB7NJYgfLTkKowOfap/Nt5iZ/wCBGwAOmf61TgtLsyU3qkiFbW7ur5bhz+6UcL3JratrZoIzHKw3see+ + BUdtMmGnAyTwBnqfarsECk75TnjLkcjPYVSSWiJbe7HW8MTqX79B7Cs9kWQ5U5Ve1aDxEqzZPTp069BV + IwspKo/UcnsMd6LXJTM1UDTtIMgc968x1Hw3rmsfEey1K1vWit7CJjLB2ff0/EV7DFarsGW9Dj+X59a8 + 0+H2o2HiTU9c8R2quY4ryS1Ry2Vc2/yMVHpvyPqK5q9GFRxhLvf7tTpo15QUpR7W+89Igs2QFnfIH4Ve + twFG93+Y9KhK+Y53ggD8OlRgqL2JYzlcMTXZscd29TZigViQ3zFgaz5YVV1iUZB4qw823lGwQAfwNQwi + 5e5SdQSAD29TTEZFzpsSkTt+78tuPxqOMpPI8EoxsOBzyal17Sp9VtTaTlkXeGLRkg4B6ce9N0ezW3Xc + weR+WDMaaQNjXtYgN0UZbHUdxVHw3MZ4XlVcL5rKST6V0kqSpbvJGPmVCcDt71z3huS3TQoWbcBJukyR + gtu9qVnfQLo/ii/4OW/DzQfthaPqhQH7Z4RtzuA+95U06kfXkdq/kP16dftUhBGMnj2r+yv/AIOYtAe3 + +P3gDWyxUvo3yMWJ3LFLLvQA8AYwfrX8XPibzItQlV9wZ2J5HPJrzIq9Wdz3KNZ06cbPoZ8WqAwCNjwt + dHY6rhfmOM9a8wmlVHKoe5z9K3RqVr5g+zhlGBkMcnd37DjPStZ0j2sBm0ovWVj1S11mVwGzzV8amTcA + EkL1rzi1u0ndYo25YjvXsnh/wq08xM4P7sfMOuK4q0401eR+mcPUMVmclCjrZq76f1oRSX8jwliTtAzy + e9T2WtagIJBbuU3qUJB6qeCDXdnwvZvCqTArG+QGxwcdcV0Oh+FdOiZbW2cPnPzMO9cEsxpxjdo/S8Pw + Ji6uIj+8smrb63e2h5FZ3N/5JhIJ5x0wc1ekvbuDDuCFwCPSvpbTPhnCsa+ZtMjdW+tdPL4BfWpUk8SX + rXZiiS3j3c7IohtRB6BRwK8+pn9BNn2uC8IczdKMYvW3W1l66/kcx4a/ai0H4Vr8O/G37Pel33g/4h+D + 5bqTUvENtfs7XxmOIjHEy7YGjjLIWU/MDzyK+b/EHjzXfFWs3vinW5TPeajcS3VxKRhpJpmLux7ZLEk/ + Wvp5/wBn3wvpirq8LuzsDlG6c15j4g+HmmWW5bYYzz9KuhnWEqy/d3fmzy8x8LOIMBB1MW4pvW0XfS2j + v+nTpZHoX7JPiuSx8ffb5drEgoM9QO/09a+qP2sPjBDeacNGjuG2eWFKZ6k+36V+dvh++h8EXMlxA5ST + pnPP4V5b8SPiTd+IrpjLKW9ycnivLrZK8ZmkMX9iKPIzPMsHlHDro4id8Q29PmV9Y8UsbhxgEcj1rln1 + ie9kLyEZ4A9OP8/ia4WbVlDYTk89au6NdTS3yL1UZY5746V9xDDqKP5lzLOp1ZO8j9O/2GtNtNT+L3hy + K6AYi8W4I7YjwwHuc/hX+p/4C0saF4G0Lw7DGU+y6dbQgYwBsjUY/Sv8vr/gmyIpP2iPB+m3EIl+33ph + xxkDBJbn6AH61/qcfLDDEqg/uwFI+nFZ4KNq9V+S/U+azGrz0qafeX6EaG42sAhBHHapYjNJC0Z+96VO + 8qCUCPnd+dQCcxSnbzn5T7V6dzybFlG22wYr8w4NVp2lmtGUfMDwaWOUGR4pTg1AkzRMwAOxufpTvoTb + UfZbrZPIhAIHQHrg09fMWYy9C3v6VM3lJJHKnC9DzVuaLzo9iDlec+9LbRD31IJ/MeASyfKy0m4Sx7wu + 70+tK4la3LA/LjnPNRaaxa28puqkjFO9xNEdrPcrKYmjwOxJ4rFvv7Rt7toWRShOc5rpXDLIsn3c/nWT + rav9nNynX17Ut1YpPW5mPHdwHcApDcVRluJ1bYBx04rU8wPGoHJUDNZN7d21tAZpCcDOQOvFT1sWjOe4 + 1mBPNnlDRljhdvIFeU+OtV/4Ru8HiCUl7N+HB/hI7129v8SdCuL7+zo1JlPUMM9P0qpqdl4a8Uz/ANm6 + pErKPnw3qvf0rTkna0XZhzRTvJXRb8I+NrTxBpSTwtj+77itfVdQmS1eRF3MAcD1rkdNsbHRYsyhVETd + V+6ATxwD6V2EmyQxTWigxnlsHqD3qp0ny6szhVXNoj5Phs734g+LbnRNZaSxhgUsFXjfn39K8U8R6xqv + wc+NNv4Y+1SXWn6lbedEpBJjdGweewIPSvubxj4YtZrYasE2vG27cOCMfSvjbxf4X1XUvjvbTahEg0a7 + 08yQzncZFmUjK56bTwaxnUSUaTXzOumuaTqp6djvPFPxR8Q3N9DHb2U13ahVUALhfNPAJz2HevQfBmn6 + re5fXRH5kqkoI/lCf/Xq5okdskEFiI0m3HG89setdJPY28UoS1cRiQ7SV5Ix/KoTajYqdm7o8Wi+JExl + ntjpd07W8rws2BhihxkfN0NT/wDCxJv+gTc/kP8A4qs2xhl8LPc6Nr9ibiaO4kZZVJPmRudykk98HBq/ + /bek/wDQMf8AI1jGvor7+hq6Cu7Nn//R/rNhaGKAap5TFtgWNNvJbPAwemD1P+FS+HrEaClxqE4VLu7b + dIc5LOw9T6dB2qpYQ3Grt9v1ZlWNBkQpnC54ALHqfXgVv3kGnaZCl1fhQSwCI38LdgB6+px+lcfOpNya + /ryPRdNxSin8v8zUmNtoX+jwHzLq7cfe7kD/ANBUf5yaTWNRmtraLR7Ys7znaxi4YK3Vs9vQVj6VqNvA + l14ivld5LqRUj3fNuzhVVQeME4445OTWbrt+2gGIk77y8lJkkP3YYQPmPTgIpAXuWI9TSkun9en+ZMe/ + 9ev+RqvBBqsTNc/8elj8oB5VmXrnOc4HH51HpF7M1wdTdYhbuVjto1yp3N6gdSf0qlqlvBHo8GgW83lw + llPy8hlB3EdyQe+evPPNbF3YTTzLqb3KpBbqfLQDaARkO5P04HoM+taQi1b+vV/5BN7/ANen/BI7Kzv2 + 1KSS8YLLITsU4Koi9+M9f51nahaX2ualFpNheeVDES148fG4do+me+W/AVPaWIuZf+EmckOUWMbWOCiE + kAdBjJz0rW0XRjpVo+6RmlvZC5MqgONw6HGMnueBWlmkk9mZNq77k94l0LMafoDrGuCrSMclQBjjNX7a + z8mzW2tgRGgwM9frVmzsrezt1tYF2iMYY9eSasP9mAYBhiLmR1HBHYAc0WV7iu7WGySTRoDGoHHyDI/z + 1q6t5HhYmyhUdP7zf561mC7WC4CrtkDnCl/4c9v61ia9q66PYebDC880kogiEYz8zdWIz0Ucmi9rhyXO + racqx8qXnP3u3ufwqCSc9P73Ueg7D/gRrhb3V0LrBJMsZkRiGPaKMcsewBNauk6sBJ1ycIx3ckSSg7Qf + 90DNJyXRgoPexe8b+Ih4T8JajrgXdJa20kowRguikgAk+vAqr8INAl8M/DjRtDvWP2gWqSXBOCTNN+8k + PAA+8TXi/wAdptd13R9B8LeGUSV9Z17TbWYSMUX7HHKss/I5YmND8uRuJweK+qYzH9xDjjjHYE7RWMJO + VRt9EXUjywSXUPs7lVccdAeKsW1giRtLK2AQenHBNJId0e9GPB4OOR2+lR38kTaTLBcStGSjDPQDIx39 + 66kzk1IbYw3cck9ttKs5UZGeE4FaMLJCdsnyg4BHt1qlYzCK2ijlP7wqN46ncRk/lT53WONphy7AAHsc + /lSjsN72LDw+YpbzD8i56VRvB5NlvRsklU/76IFSx3DyIEjyQSMjofpSNNHcRhRtzvyocdCv9KsRzniS + 9hSMWNi4WacrH15wSFPHWquqW0dvNGtjE7TFfLUrwqAe3Tmuc0CxurPxtrF/rt49w80UEsEWFEVvGV5K + 4G4BnUk7mPPTAr1QWsUsn2iLknGD6g96zpylK9y5xjG1tT+UX/g5J+Fmu6l4R+GvxW+zkrpbX9pcyDk5 + ZNyDj33V/BR40SR75pXyCuVI96/1Bf8AgtnoVpq/7HWrapNCt0dGEt1PFL8qbBGzDB65LKAMc54r/Nf+ + IXgq41XR7PxppVjMlvqFtHcgeWQAsi5yD0K+449a872vLiZp7afke1Soe0wsHHdX0+Z8jztkkryM0iIZ + eFzxWlcwQwXDpJkAHmksBbCfMn3c9u9d7lpcxoUOaoot7mhYWd4PmXPP6V6HpGq61ZEG2dgMfMB3qtBq + WlwxhYowDjFatv4ltbaPghQO5GeK8+rJyVuU/V8kwOGwcoyWMs/J/wDDHWR+LfExiRWifYp43Agc9cdK + 9F8O+JtWSE3j258pWC7u2a861DxJY6xFCsOqRyqowd6iPYMehxmt5vFC6XoUFnpuoQXCmTe0SqrEFfUg + nIrx69Hnio8mr9f8j9eynNvYVpVfrjlCMbp3g7vS1ved1r0benrb6AX4o3traCKSArnjcetaNj8Tzne0 + eWPSvEIfGkevRBNa1XSreM9VMRSUH0yFI/HNVINWt5ZyLeZJFU8EHgj1rxpZXT1Uqdn8/wA7H6ZT4+xS + lGVDF80dlfkv80pSt8z6MvPizcz2a2vk4z0b6V454o8Z6lcxlkTBHJrSu9VuoPDCYuLNomk+4CDOrfTs + K861PULX7O0sk6Ajt60YLBUoyvGHUOJ+J8dXpKFbEv4U9kraeuvqeP6vr99e3LPcMfpXBahbzSsZnzg1 + 0t35S3JMZBUniula30NtF3blM2ejHBGK+vjJU0rI/lfGYGrmlSt7Wqrxu9XueHnIkwBjmuj0SZ1vVjj+ + 8y1BcrbmUrGQTn1rc8M6abvVobe2G+SU7EUDOScdBXdKa5dT8srYaUZuKdz9yv8Agjd4DTxn+2x4Bsbx + jmK53hVHQMCGP16Cv9NshrjzEiDHBOcn8a/hA/4IMfBvStJ+OmieJvEAC6jBMJVbGPKt4Rvdj/vEKo+t + f3MRarHZ3K20rsPNBJY9AR29f/1Vx5fUU3Um+9v6+8xzOi6fs4dbX+9/8A3GtkhnS6RnHGCvar8o3jec + AA5561TspPt+neZCdyMDggehq48EjwLI74yDjjmvTVmeS7phLGWmjlDbR3qpOl3GrNOyFC3yle496WeW + P7KqyuIySFXP8THoB7mi+0+6ltkNlMI8ckEbs+3tQrMHdGlKsbaft9RnA9RUtteW62aPIMbuMDqT7VkR + XMrQkMVB24OPUcYpumlLuJ7V8lonIznocZBH50drB3NPTHS8t5Il3RqWKgMMEYqpCI4rtRaNlTuUndkk + r/WrCJcxxtErhiehY5PHc15R4m8J+K7q+Mtndg2kqyKyY27PMQqG45JBOe1TJuK0VyoJSersdxrWtzWM + kX2iJ2EjEbFwWVR3JHFeBfET9qT4ReEdWi8GXOoG71mcjbYWY864UNgBnVM+Wp/vPgV5NN8NPiP4d+H1 + 18N7jVD9l3vLeX7yv9pljkPyiN8gqRj5jnpwMV3HwT/Ze8AeGdPOofZw81yR50jYMkpU5BZwMtzzknNc + ftK03aEbd7ncqVCnHmnLm7W/X/I+j/D+p22qadHdREFHHykHP+FSXtraAM9wo8s8k9APxpq22n6Tqf8A + ZNgyBVjBEYxkD3+tbawmWMkgMH7dfwrqTexxyXXuclJpem+UZbeJc4wD0JzToYdChnj08oGmaMs4xnAP + Tcf5etdFc2Txsrg5BH4Cs6wthb3jwwR4lZtwfg5B4Oc9cVV5X3E7W2PJPGXh1bXUvty3H2JI8MMDdGUx + /Ev9ao+BfFljc6tNpFyT+4UFWwQGXvtzwQOOnY16l470DUNZ04RwuqMCVfIwdp9CcfrXzfNYaxZ+IoNQ + swkUlsAgUAhnZeq8nGHHAP8AhVVKsrJPoFKnF3fc+mL25jkP2a1HmW8g6nnrXneveHZdZ8PG20oR/bdN + YtblhnA5wp9mGVNZnh7xHfa5bTRQIyLIdynIwFPXPfrxjHBrtvDQuxcs0m3dtxx/EPf3qJrnjdDi/Zys + fPnhnxNd3OqPpd3bCK5s2KTpwPLLDKg9evO09CK9ni02BrJ/PZVMy5UgenPrXkfxe8F3kHiqz+JFjPKt + tbRtb6rZRhcXFvnckuNu5mhbPAP3WOORXUeHvGek6zpLRWMgYQbWjYfMCh54wSOlY06l3Z7o6akNLx2O + 6ltYtRWOdo9zKgUkjnIqH+xYv+eI/Ko4PEM17H52l+W8YO08nIYdQcZqb+1tY/uR/m3+FU1DsZpzP//S + /rbtpLSSSO3s41EEJKsFcZSY5zvAJ55BH16enP61b6ReXkVxclWlybW2VySArEbyMZ+ZtuM9cfU0mtzJ + /aMfhTRJjaySp5m6MgCGPPLdMeY+cKT7ntW9fz6VokEKwRqZIwqRBf3pL9AATnnjk1yJwtddNvU9K07p + PeW/p/wS1Dp9s0r+aBbQaaQsJR9o+6C7HI6DOPTAOTyRXPaXa6Zf3dx4sW8a4a7CbUONqQRglBjrzkse + mc+wqv4o1OHTYbLwfpcf2m/uyHuQo2lYN2WLZ/vn5e+eeK6W/t3vbg2towX5hJKzjacDouB61m3Z3jqa + pXXvaX/Jf57mitnp9oPtKri4uQqPklm2rk4x2AHp3PNWbiGO6hex5SE4GVXjjsR6Y/WqNmq3l2dSmV2R + AUjHQY7kcc5Pp2rRvriK0RVOAX4y7YGSPbsK0jfcxkkQqJXvkhiSSOCFVZXXAQ4P3e/pzVqxnS7vH1Z3 + z5RaJDnOC33jj1yMeoprrHY6fBpcBSJ5PlUhcDeeRwO1a2nwm3ij0xQEITBAHBPVj3xk5OK0Vm7dDJ3S + u+pbjZoLdZpdq5yVxznPQ1TJHnpZImQPnkAHfPAOMY9a0NscMW8k7EwAQPTtmpZIpY7bEpDNL854I+Y9 + Prik2xRsjHmBdvMbGRlUIHTHU4rjtWtY73VraS4VpIwHVFHRSBlnPQDA7+prt7hVJWC2QbmIUAH9cmqP + 2J5ZpmztiP7qLnPyr949+p4p6y0bHdLU4C4ni1XUYdPe2c292N5ymFEMHzAtzwrMVVR1OT1Ga6v+z2ii + EUrBp8/vGXuWGWP4cAHrircTXNxdNJIjJG7fKV/55oOM+mT0rTVQJn35KhdpY9cnqc855P6U2gT2Pzy/ + aH/ab+CPwO/aQ8CW3xn8R2HhTSbG2v7v+0b6TZCbueMRRwMScIzozSqxU8DAPWvs74afH/4I/GnT47z4 + Q+L9J8Qq6B42sbuKYsvKrgA8gkN0zjBzX5i+F/g74R/aG+P/AMSvjb4m0qLWtOF1HoFvaTslym+x+RW2 + M2yMKzOZE27m2ITngD1fwT+xt8DvhT8RLT4sfBjw/pvh7xNoKsovl05ZHnhkiZJhgbcGTcxynzdO3FcN + D2sm5rZvt08ndLoehiKdFWpyvdLe+ifmrN9e5+ooljigAkBzwuM96yr3TrjUjI9zu8ssg2j07D8z+VM0 + W6vNTie41K3aBonXZu+6QYxuI74BZlyfSuhtrgFEmcZDMZB/uqPlI/Q16EX2PIlGzszKsdNh+03GpSfK + pkfac8hUAU4+pGaj1rU7e2vdM0ogtJeXaxLgHGEjaUknHomPqa1YY3+zLD0BkCnPTC5Zv5CuVtL4ah8R + FsxtaPT7TznbPSS4bCjH+4n6+9N7BGO7O1liVS7b8lZBk9ahb7JEY03bSxZhg9l//XVRtaEatJJGdsSN + JnH3t3v/ACqtc3K7TCwVD5e3PcZP+FDkSoHFeMpl0q0uNSd9z3Bt4I16ABMl/rhSzfhWzp/iKabQrW6s + 4ZH82NZMMdpC7RgH1/CsrxxqAuvCupf2XELxxHOI41G7cfLIwPqGx1rC0uS50nwNplvf486O3jRwMD95 + tGfpycCsJTcZX6WOmNJSilbW5+cH/BT/AMb32i/AbVA+jtqOn3dvjUIgqyNLFuw4UE4GFJKk8A4r+L3x + rb6B8P7nRrLwLNDd+FtTsYbeymXIt5baOQ7ztydjAt+9jb5kYMpGAM/2q/tmaHqXxA8F61pdtJA8Zs3j + kLEYiLKVHHQkNjOcdq/iF/aL+HvxD+Bfj+70/wAP6dJPocqfarvTbpQ0DucJ50IQlkcjILrgnvkV83Xr + qWKfNto18j67C0PZ4P3dG01p5nRfEH9hD9nz49/FSw8M+GbR/BOoa3qbWCPabnjlZhsSVI3JjZA4PmBd + meSMdK/MO5/YW+LNjNdf2R5V0lpdTWbh/wB0wkhYqRzkdvWv1O+Cn7TGhT6v4a8vV13aTdNLa2mpFYrq + 3d1wzRT4CNtJDAEgkjpya0fgV/wU6+LX7HXi/U/hp8atCg+IHhWXUrlpY7jaSCzkma2kZSMSLhtrAgn0 + Ne7RcqlOTpavTS/rff5Hy9HGSw9eCxUVbXVp2e1tU79+5+Lut/s4/FvQlYaxol1BAj7HuCm6Bc92kXKg + e5NYXh/4NeIPFCtBYFHkyQIt+HbHXC9T7etf2/8AwS1z/glv+31p10/womk8P69fWzLeaSUMEi7xg5hb + MbYPdDitvRf2HvC+h+OPDmgaj4d8P+PdH03Ule81DU4DDqsaH5Pl/d7GVBgj5uTzXBVrVbOMJJS81t8r + n6Flmd5JGrGWYYCc6b35Ki1XlePT5rv5/wARs/7L/wASNK0hdWktVjhuH8lDMxjO9uineoAJHOCenNco + n7PvxR03Wl02fSrtZsZAC7lIPTDLwc9sGv7yJP8AglV/wT+8QeJ/FdtZaXr2nPCrPcXtjPPHBIJTvBjQ + DYwyDgkZXGK5y0/4IK/sY+N7H+0bPxh4mgt5OEzqJUqo7YWJiCe3pXJTqZnzOLnBp36Nfr/w/kfZ1cw8 + N6lOFSNHE05xt7vNFru9VFu79Pd213P4VZ/gh49knJfS75JCxUq1vIvI6j7vaux0n4K/FW62R2djIN3Q + n5RgfXFf2V69/wAG9P7NMSG60b4keK3SJ9jQtqTkkgZyAbUnafXHtXm6/wDBBj4GaPY3Muoav47vI0xI + gstYgWZl6ZWKW0Xce5AfOBwDWlR45q3NG/o3+o8vzjgahP2koV9d7TUX+NN/efylJ+y78YdIsV1rW4TF + DdktEXccgdcewrzvXPAer6fKbJZBNL0Ow5UH3PAFf11+Cf8Agi98Cbu7u5PFy/FGa0V2WBb66srYIiZw + eAWbdjAIC/Ss7Sf+CQv7MOm+P5LTxL4PudV0+a3iMF1qOrsQsrdRIiPEM8hcDdzWeGhj+Z/WJxfpG35t + nfm/FvA8MMqWVUq1+8p33315FZ+qaP45NR0m5065NldsnmA8kMCM/UHB/CvSvBP7P/xg+K0qWHgHSLnV + PNwAbWGWTGfUquAPcnFf6Ffwe/4JcfsufC62XW9I8E+GtKihQYlktUnkXHO7fKGOT67q8Q/aO1f9l34d + a4uiaN4hiivfLCC0softGAchfKijwuSR06V1YnETpQT0v/XQ/OnnmXTlNUaE5RfeXKkuza3/AA+R/Jb8 + Mf8Agj98cdR8Maj8TfizeWfhjQNIiaaffKstywQbtoRTgEj1bNUfDvhv4XfDbxELDw5pjXVzLZpJBcXg + GQspJB3ZITK47Z/nX9TniP4b+PviF+z7qWk6toK+CfBWqQSpPrvimZLW4aKVcM9vaqRITj7uQAPXrX89 + H7XXxe/Zt/Z58d6d4H/Yx1ZPiDrsFnHA2uTW4e2iuigQLEHGGa3CnYcHDc84FeRQr46pWlHErrpHRaW3 + l1V9dz5jGVnUa+qRUIdWr232Td+b0TsfoR+zHe2njOU/CPRJ7zw3rNnpb6pc/wBlzRx3siRkyIkjSI6o + rNGrBcbsDPyk5r+2/wCHuoXPiDRNF1PxBLuvvsMD3G9QGaYxL5mR/vE8V/EN/wAEkf2fvGemeDtW+Jni + i4a48Sa7cTR332mQB5Y5FZcF3O7ALZr+zn4cX0VnZaORJuL20MJUgliwiGASOOmD717OAnGMpRj/AEzl + x9GUoQm+34fofU+n3arHKlvjCuRx2zVlbzFiG6Fcg/hXKaXc7RK0jHbnkYx+tbQkYpIoTcu7OAeucHiv + bT0ueFKOtiXy9Pu0jecRs8J3KTg7W6ZHoaWK5WWDBdcrnvz8tUrKws7UTJBCkTF9xCrjJPJJx3OTk96s + 2MVpHPOjRqmXySAOd3PPrSSsg01sZUGoWls9zaXDgFG83g8gOM9PrkVDpOq2a37yRPNslHRlbcCuQeMZ + 5zxTWi+z+KZI1KgXECuQwzkREjjnj7w7VbuJxDfRvwC2OCcHn0/KpTitC+V79zWN8sjrLArhNxJLDGSf + l6de3pXMeI/HXhXQpIdP1zVYtOmvJ1tbYXDBFknlBKxqTgFm6Bc8ngV1V0ftFu0qjG3oB3x/9cVy/jbw + D8P/AIr+EJfCvxL0a21nS7obZbW7jWaJtvQ4OeR1BHIPTkU3fpuSktLlybSrXxBpqJqKrtdAGSRMnPcH + Naeiae2mqYIpQy5DDKjAz14GOK5jwr4S0/wrpa+FvDLPFZWiqkEUkjSNHGo+VQWLMR2G4kgcZ6V0jJdf + aEikkYA559aWyvbUp6uyehV1dIINWhuGKgshQkDqc5HNVIL68WP7TbyLLFIcgbTuXnkY9jnIq34h00tZ + xyMpzHKjdM+39ayYEl0nVVtn4hvWLoFGdkwBLDPZXUZ9mB9RUOXvFxjeN0dTa3c06FZvL44Gc/y61Tup + GiZLuIfPCwOM4yO4z9KrSpsJdFAZTnkUy6kklcKqnOOTnj6VTkZpamldwX6KX06aN4biTMqTDcVRuuzB + GR7GvmLxQ11oupXa+Jkj1O8LboLVVZYzGgwrKBnLHrzx+Wa+kbeW9WF4LOJZJQPl3uUB5+h/lXj3xJ8I + a3qWfEGtXpaC3KBLGJvKQ4OfmkG1iWPGMhexBzSnNqPMlf8AI0pQXNaTsvxPNdEv10XWLVA+dO1zc9sU + JyJgNzxspwUJALqOhIf2z6ppUtza3kjSOS0Y3bc5Gwn04/OvnOHxHY/Efwjf6bPb3HheeNXS3nnjaKWJ + 4c+RPtIPKsobryvXg13vgnVLHxvodjqKOsc8TN9oijY7Y7iP5JVB643jPvSp1opLzNKtCWt+h75fwWl+ + qXQmTzB8y46hT3xz0NfAs2iaj8G/jy+kWLJDomv2s97YWhAIuLkHdPbIS4IdRmVBtI25HAHH1voKQLcN + ZWweRLWRmQ7sbQ2QyckkjngfT0rmfjZ8K3+LfgO40C3updJ1a1YT6dfxHbLa3kfzRSqecjIw68hlJU5B + rGtHVVEtjShK16be5R0fT9F1awTWNKvZWt7vEsbW7qUZWAweSOcVqf2Da/8AP5d/99L/APFV+eugeK/i + x8QNPOp+GPEcHhO8s5JLLWdKvLSOR4NUgYrPtBlTZG/yyRjBBVgwOGFbX9nftEf9FG03/wAAI/8A5IrZ + UpvWOq+RL5E7Sdn6P/I//9P+pb4d+H/EF091428V8z6lJuEIfKwwqMIo459SfUmvR9PtoUnm1W4jUQxj + EQI+7jq31NV7a5u2sUteA8hCrj+761neKNSeTytGXlj9/b0CjtXDBKnFNdNvXuerPmqzcZdd/JLoTaVK + urz3Gt3asgDDY3rEn3RkepzWrcaksaiEsuZSBgDJ3H19fasg3o06G309Pm+YMcdvTNaAewutR+1EeYIc + Pkf3vyqoPS73FUj72mx01sY0uobRWCeSm8qq5HPAHXiqsWoPe669uxAWFSSSAc+3NYyatFFZzajdqIjI + 3BJ5I7VftvMGlj7KpZ5hjeOTz6n0qlLS6IdN3szT06ZLvUpbuErKsQ2B1HAJ689K3ooZ40JdsjOQAMDP + qfWsvRbSHTreLT2kCdWbI5YmtqeVnkVVUFe/PGKpbmU3uUNLs0hHlZLKzmWTJ6k1r3U1uhfyx93+Edqp + RyrbEy7iXPYDio57mBf9lyMnIxwKp7EdbjBcqVb7MQGyI13Du3eoJWigz5Z3EAQJnqT3NYljf+aplxu2 + s789M9BWnaSFpQGUEwxcD/beknpoW466miNkjtMi7F3BQB6IK5Lxhq1r4Y8M6h4lvJAi2dvJPI7NhflU + nnGPQ9+9dPfQEBrSHpEoTI7luTXy9+1gmt6t8JrjwJ4enS31HXJobOCWXOxCXBJPthSOnepqTaTZpQgp + TjG+jf4f8MZf7KPwgtvBXwgtfLubiO41iWTVLuOSJbcJcXbb3VI0GFVSTjJZiPvMTX1fpPhzTLN2XBby + jnL8lifX/Pes7QbM2Wj2WnO/zWsSKzHuwAzXUrdghhIgHXB7GtadNQioo569eVScpN7mb4hs7XxBAnh+ + UyCGeUF/LJQ4jw3DKQR820cEV00u5pdykgIcDbxkJyR9DXLabrNnqGrzpaMsq6Z+6dkOf3z4JB+gx+dd + RFsabCtnbw3pjv8A4U1q7kSvFKL/AKv/AEio80rfJJu3Y28dmfk1zWixojX+rwx7Xu7goTjBIT92pP0C + 5rrb6+S3iMsuCXw239FFQCWK3RYVXk/PIe2Tz+FJq7HF6GTrXmyKLWNf9bIkLMcjCj5if0x+NQX8bPOZ + gDuDoAD0459OldSdVsVdy+FBADZ/vdgPeqlzqenu+ZWA2gg56DPPP0oaWtwUnZaHlnhm/lv/AA5aSeIY + VgupVeWaFX3qjZzgNhSeg7D6VgeJtRsrqzijtmEmUGB7nHPvWrr+jtqmo2es6PqctpFEG3RhVMc49WyN + 3HYgj8a+a/jD4U+IGvWCw+C/Ea6Nc4cCR4Fk4PQ8kYrlrPlpuzPRw8FOqnLT79Dyv42+HbK60zVI9O48 + 61aBkHQxsd2MjGMHPI596/nF/an+A/gDRvDPiT4i/EWa5tLOytzBCqSMJRGEC4X+9+8ztyMnnmv1p8S/ + Cj9scs7S/EWC9jJOGexVOACD8qnGBnPvX54/Hj4A/H7xtoUlrrXjC11KfCFFuIY1RJ4ySrqoXPHUZPav + j8VVbnzOXKrn3GFoxVJxS59PxP54/Gv7L4s9Ptbie+Om3t0PtCRXrKREt62Yo2D4O9UxuY5+b6V8n67Y + +LfALz2EGtpfxRMYDHIFlgZYsDhW3YyRjjFfrb8Svh14t8f+H4Ne8WK2p3yCXfJCVO4wMV4G3O0nleea + +P7n9mrVr+4fTXmK+YyiFSvDSNkgHCcnsa68Pi3C8qlRf157nBiMv9panTpNrz9O2xwHwD/aw074QNJb + yeHFtdSkBA1bQrtrG9QE5ztfzYn56DAr9n/2MP8Agob4JTxbbXXxT+Pmqw22FeS18S6c8m3+HYJbUvGA + OpLAGvyA8Q/sd+PdDTMKQQGKPzpfNI6dM8AfrXIaP+zzrT6mNN1h459w8x4YWCyMh7jitv7Xwsry9pF+ + tn+O/wCI4cJ4l8sXQnH/AAuUV92q/wDJWf3I/Bv9sn4A/EJL628L/EbwlrsYk8uIR61bW8svJztScRMM + Hpk49DX6AeC/iFe6toNmfDGs6ZeOWKyW88lpcmAdgXWRxk8cBq/zvLL9nL4DXmjNqWv6heWqxOVJEKOq + nkAYHft061Zg/Z7/AGbZHZdJ+Id3bXijiI27hj+IIA5/GtKWa0I3tG9uyen4s1q8JYhpc0rX7uLv+CP9 + Bnxl8bPHPg+0t1n8FnxBJIfKiGnRW7bsHkbTMNx7jGORjvXTS/GLxxc+CpNQbwNLoTMT5b31nHDOpB5U + 7mZDke/vX+ftB+zL8KodKOsWfxlkjlthu2LHcI65/u/Nn6le9Ymtfs/aRqV5a6fJ8WZtVglYMWurqdVi + 3nG4h3OPXPpRHMaEm/i+9r9BPhSsrWlH/wAAjf7+f9D+2z4h/tGePH0W+1LUfD2m6TaRqyRw6pq1vY20 + xQEAJ80vDH2GO9fPvhr/AIKA/sxeF/BFx4h+KvjHwZ4Z8RQwllsrK9j1PbKOR+8T5jg+ifjX8h3iT9n/ + AODPhwDTfEHipNaMfAe3uWnUMfr0rkIfgT8GdQgkbQ4LiZ4Y8s/m7cBeuVB5H45rJZnTSa1+5v8AG6NH + whV5ouc726Jxj+DUv0P6EPjL/wAFbv2FtY1BZPiR8TfE3iSxiVyln4fspIYZGYYwfNCA45xk496/Mrxb + /wAFg/hB8NvEtzq/7IHwtm1K9jQGDWvFcuZ0kI6pBCz7cHOP3ufpXwBa/AnwdrBe1srhWjQlhFG4Zh7Y + PP6muQ1f4Y3WhkW1jbxWwIwigjLdcMwyTmuili8O9Fv6W/Hf8ThxWS1oa8l15vm/DSP/AJKc58Xv2qf2 + xP2w9bvn+Kni671BpS0n2FJWitlBP3RGpwR/vZNes/shfso6n4m1K1bxNasxWYSqS+DjqCp6DnOa838G + fCnxvp1+8+kac5nlGRIq7uvQ5GP5V+o/wA0/40f8I9H4Gk8P3r3s6GNJjEAGGDjoO3v9TWeIrSScMMlZ + 2/4LFQwvPJSxblon008kfuP+x7+zd4A0232WeqG1khkicKoJ2kjkNkDJ6+1fsfonhSBdKSS21C4RlKoj + WzlH+UbQ3A6kcg9q/Kf9iL4AftPaAslzqtgt/wDaLSOSbz5U8yMFTjCqGOOgGSOa/dTwR8IL6LQLXUPE + lzFFJ8rMDIAB/s8ccV24HCTi9UrdzhzPGU2tG0+3UseBvEM+g3i6Pftd3JnGfOnbzSCvGCSTjP8AkV71 + o2u6VeXEiWkoYFQxXPKsOoP0rkLq+8O6Rt02EieaQZzE4AU/XGDVKR44LsRyBk39WxwRjPUc/WvUTjC6 + 5rngyTqauNj12OaFbvzY/wCNemeT2PSnu8K3rw7iu4AivJtF8V+Hz4g/s+xmZ5wdrYU7BnPG7pnjpXpQ + vra41JRnDICDkdelWpJ3MJwlG10ctDb+KU8XWtxqksRtn86NFQEuM4ZSzd84xgDHvW/qF09tAVuwpKTb + E9QBjaR74NQSa5Zancp5SsHhlyuVI3bTt9OnXvSeMb/RdN0u51XV22RwJ5hbGcMOBwASTmlaMbyb0/4B + V5Saglrt+P8AwS5dCLVbeKza6mtZZGOxrdtj/LyeoIIx1yDV7Srea0to7KW4ecw5BkfAdscAnaFH5AVB + ptra6nbW2ozKVZPmjPQjeOfzBqe0cLPIZGBxIcDqQDRFdSZPTl7EyRxHVftET7ldChGcDKn/AOuasSqk + DrJyAhUAnpgmsOW9jh8RJYxKFZgX+ueprA+JY1y40KfT/D1zDaTzjbHPNkqj8YOB19vem72YkrySvZHo + V+HnsJSMPwdvrntWGqvcvBIoOAec+hGDXJeE7LV9F81tWu/tUUzEqG5KqAAOeOuMn3NdBp2qxSK+Twrb + CMdCKzetmzRaXUXdGZc6wsF7cad5nmTQtlFOOUbkHj05Bq2NSt7W2e+v32RQj5mPT0rmvEd3bWN9Fq8M + AaSI7XK4GYmxn8uorNv77WNWd9Pt4FFtIPmZhz+WD/Ss0pXZq1FpfiekTSyJEJYDg9MntXltqdf1f7Tp + N7fRzJdhwiuSDGQcjGMHjr16V3unWU4txDJPkD7vykngeuf6VmQeDPD8l699IhS5JDNIh2EkDqccVpym + Kklc+U7aW9ufE81j4mjgt7izWTyBvPkSopAcFWG3cDx83JyPWuD1bx34A+H/AIim1WSb7FYak0f2wrAx + RLlysYkBjG1UKAbyR1Gc17x8ctQ+Gvwztj4y8dSix0y5cCe5MRmzMBhAwVWPzcY464q3e6T4Q+Jvw1ut + ItLdraHVYCyG4iwQSPlZgwHX3rnhF3cW9jvlNWjPldn1/wAtzzrW9XvvD9yupPdQS2ck6LHLHMSXgdTg + gDIyGHOexzXd+F/FuoP4gks79/3d9As1qWOV+T5XT65w3418i/DjS/FPh7wLqPw/8dCOGXTJ2ggkUptd + T92dVxhWK9sYyK+s/BvhLStJtrPW9Nt5LiQjCyyuGyjAZ6/d6A8AVrd/eZzSSs9Wup4p8av2R/hn8YvG + zeMvEEt/Z3bQpC4sLp4EfZnDMEIDPghdx52gDtXkv/DvP4Nf9BHXf/BjN/8AFV98XV7Z+cRPF8w/Hiq/ + 23Tf+eNcEsM22zqjjZKKVz//1P6sGluJ3EqyKnzYC5wQBVK0uoG1l3LMG6cjINcvoPiPTJdN+36id7zt + hR0K54q5qF3Y6JvumkX5kyAaweHbkk9LHoxxKinZXubP9qwW2ozAsXkcjJ6j8K1FLFBYQJsMp3MQea+W + ofiNpDat5ssw++SQrZxXrPh3x3a6je/a0mDK3yhQcVosPLotByqJLV6nvEUE+5EUqEjHIYbia6y3uIY7 + cCMD8DXm+l6mLy5MasRu/Ku9hmeB1WGMPWepnNWWppxPlBI5HB49qy9RvfscTzrzI3y8+vtTG1B2uBCh + CnqafAn9ozPM4UpCenv61K1diWuXUgea+t0htPMErPzuPYVDqUjzWUzBSrP8ila3pI4kjDxgM54/Corx + I/s+HAyowv19a1avoQpWscd4XLNYfZp02bX2Ak5OFrfjfbtaPq8ucgc4X+lZ0ZlijaNgCR0P1pIBI5Uo + 2zyxjHvURhoVKd2zp927Z5h+Y5kJ/wAa8A8aQ2Pib4r6LpdzlxpaPd8/dDHgH3r3JJFihafeDgck+1fM + 3gq5t73xzrnidpWuZLqVbeNSPljSPqB9c1nVkk0u5thoNqUr7L8z6itGL2nmv96Q7vSsqaSe3ScTOCiq + W29uK0Y5/LtIwFFV7+0lTT7hsj5lwA3HWup7HCviJPBttHZ6PErBRJcOZpMcctzXV3UjxwSNbYyRx9Sa + 4nSoLiC1SNyG4AGPSuhlmcRhYwD64qVsOfxXPl74u+I/H+keJdOvrV3k02K4UzQW0e9pFwRjGc/ex0r2 + Twt4s1/xJZpdXVg9j543BJsb8j1AJxS3sYuNdt0ZcmNt5UdMe9d8YkO3aANq9azo3jKTOjEVFOEI2tYy + tUeHy44rgbvMfe+0/wBwdq47UtRtJ9ONvGgV3O0gnkBz3/Cupv1VZ1lbKsoOe4r5v8eHUfCkd9r15dtL + aTyQlcAllIPPTtWdedouReFhzyUf6vc9i1e+RQbOzkIMciKoXn5R94YPasO+txLdycKY92G3Dn8K2bbU + rO7RZLPaSVVt3Y5rC1SRhLIychhng8ZFY1JXib0o2dj5+8aWdsmuXFtAu1UhYsAcDn0r8xPjB8Hdf1m0 + 127t7pY5ZreSSGSNdrHCEBc5r9W9fnWZp7u5jCIsZ3t2wK8B1qXwT46tGj0K7iuUSNo3MJzhj1Br5DMk + 03yH3GUz0XMfhX49+Dc9j8PLWfS/M+SygCeWAoYxYLbiex71zR+G0WpW9lq2l2wN0Ssw2oNmU64PTOO4 + r72+J2hadrWur8KIJTaZtTyrclQ3OB7im3SaPplpa6DYqitDEYV6bsAYzivksXUnKKTPvcvUIy0R+Zvj + 74Aa5rEeojU9U8uPUbcQthctEq9MD3HWvgmT9lO/0vWLm5e7N1bRghJgWWQgAZU+o4xmv3G1zwvqeouR + EvmRSvtbjueK5nUfhJcWFhaI8QLPIyEgdjWGGx9XDwkodfI9Wvg6OJlF1G7rbVn4o6r8PLbUPEFvdaRb + tp9vbRxObSIbxuhOSxPXBznmtX48/A7Sr62/tH4ZH/ibeUt07uAItrDLLwOCe3vX1VbfAj4mal468UXm + l3cc6QAw25lGAR1KnHXFez+Bfg9DrXhNbbXpEju442QhOj5BBGfau+tmE6XLUjJO1tPVdepz4fAU8RGd + KpFpO/4Pp27n48eDfgJ4xs9Yt9e8cGENNCRAkZyUJO4Enof1r26y/Zo+FvinxFBY+N5pnnAEhJBVXbuM + gAEGvqzwf8GfFWsA+EtMtDGlu7QvL944ByOT04r6P174Bwan4NjgtyV1K0yVc/e3L6VhmOa1JSXLUcXt + eOh6OU5NhqMXGdNTjvaWuv8AXkfAeufsu/BnwzdSrYGwjuplBiSSJip9uDwRXhuu/CvSPDGrSXCJYRef + KB+5V0JDHp83y4r9mtR/ZvPjr4bRLBtN5hXWXHdeta+ofsOWnjv4cCy1p43m2DbIpztZehrysLmsoW9r + VlLWz3Z7GNwOGmn7OlGNttEtT8NfFvw70XRZ3N1Mqo/zNFboFUnsBJg5684rjoIrHWdHi0W90ctd277z + cLFvHlkcL0/Wv3o0D9inRD4LtdH11YnFnIHSQ8k465qbWP2UdY0jUDDZXCW9i4ADxRKz7T7kV7FDiCk3 + y2bt1vY+Vx2RO7lCSV+lr/18j8jPhJrPi/w9rNnfeGNBluPsG3bHOheKcqf40OAR7V+qun+Jf2kPjd4T + j8K+KJI4rBCCyRFbUWyHqF2AHgccmu20r9lfwRbt9rbWLuZ48Mw3FcE/TpXoFh+zlJpN3ba14NvZX8zJ + cXDZV1H6V6lPHxqtcsfzPCrYGdFNzne3kj6a/ZavNE+BnhifQfC+sC+F0sYkSW8UxKUPJPOeSeSa++fD + /wAUdF1m2b7bc26QjCN5b7xnvyDxxXxV8JfD2kSWQ+0WljLC/BkjTDZ7gge9e3xaZPcyy6HDCsVvLkq0 + CAHA7ng17+Fc5a7o+Sx8aabvufXMXxL+G9vdxm81izVnVSibxuPsAepHtXptlqPhzxDex6ol4uIUKhN3 + Tdgng9zXwP4Y+EPg/wDtUXmoWjX09sdsbTDJXI7dq9VtPhXd3Hiq2utMdrRIFL3OTuBH8IAzwfevapt2 + 1sfNV6dNP3W156H1zJqnhDRdVjs3ntreeUebHHuVZHPThep59K9I00x/2gZ5HySAF9h3/Wvzh1L9mnwF + rfxr034nfEeJ9W1Wx2jSlaV1jtlTndtBxuJ55r7hiv5n1CCeZTEAuxjnINddOctXJHnV6UNFB30/qx6X + 4ivI7aGKC2ZY2kkVVIGSeelcv418a6Z4Z09pNeZgWUqoVCd2enIq5qW1rZJYGy0bBvyrkPHWsWL6DPmP + zZUjypI6N14+ldLlo7HFTgm4p7XOitPiVo1qbawWO4ZjGrZSFmXgdCwGPwPNQeEvGNx4xbUruximsmEv + kvFcxENlR9/r0I6VV8Pa5by6BAYgCJVUlh198019WitNYnjKOyzqpBXgAj1NJSdk7luCvKKWp2stnAbu + G8uEZpYPkWQdCpHOai8ZW0tzZKF6fwkrnHv9atySWV3YINzKAob5WxyKlsTNBbf6bN50LDILckZ7Vo5a + mCXU8q1/V10XRTqOozNiNfvdQCOmR3/KuE+B/wC0D4P+Jkl9Y6dMgurW5aKaFQTtKnGTkDGeuK9l1HSd + L1kNEDlQ3Q8D61yWnfDnwj4f16fVtLs4bWe5G53RArMw7nA5PvWTjrzXOmM4qLg1qevalb2c+myeYQFx + 7YrkLRpfsbW9uA8wHy54BrQ0q4u5bRodTi2qpIU/3vSvLPEOk3Vlqy6lpE0gyfmIbk/hUSWt7jgtOVnS + 6VrfxCtNRax1rTEa0P3J4JQSPqpwfyzXeWerW93lCJEkQ7SGUjn1Getc9oepXlxahrvLOOua6dr+JbVn + Ycr1+tVCSM6kXfYztbtry+XyL+Fbm2ODjAzkd8VQt7fS3kEbIEiOEA24xWzb6pNJItvsIXGdw6fnVWZ5 + jceSoU7jxntTvqRZ2sfI/wAf/hc+h6qPivoJmcxFPtcRO+NogfvbeSWXtiup8LeLJ447PTJ5GlhuhvDr + 8oAOMDA6V7H4mR7ixmsNRlDpKhTbnaoBr5K020uPD+p3fg6MIywL5tpKGycHnB+napp04c7VtTolUm6S + u9vy/wCAfU13aytLm1ICYGOM/wBaq/ZL7+8P++R/jXjelfEi/FpsvZhFIhKkbfStL/hY8v8Az9D/AL5H + +FDi+xNn3R//1f37m0/xf4WeNbh4ri3ibd1Ocfj/APrrotf8Q6dfW0N1qN0qREAEZxgn1roJtO0nx/o3 + 2iKZoZEGeDjpXmEXhvSVumsNWiWaMHksODj8a58pzL6x7mIjaa30O3G4P2L5qLumc79j8KXbSW9laxyu + +drp1JPf1rsfBPw313RiL++lIiJ3KgPQHp/npXeeGPCvg3SZFmWMKM/KOg4r2jFmIF2kBMZHP6c16dbE + RStA5adOd7yRN4XW5tLcMwyD1Y9q9Qe4hSwMme3UVx814BpgijQEDniqEmqXDaSTjaBn9K82ctzrjFyt + c2F1LTPszSxufPzjNdBBcpaaaoVtzSckeua8OS+i89YIpRliM/U12Q1MPMsG7Pl8/lWKqMudPzOr1PX0 + tZIrVDggZJqtHrSzOJJ5MhTwK8s1fWJJZnO0s3rVmzM5svOPBx34pKo9SnSSSOr1XxRbR3scUhKbvmB9 + qksvEEWqWkgtwVKHGe/1ry1kudfuisqkeWMAjrxXU+E/Dl1p6SRPJhWJPvTjUk9thzpQS13Ozt9d8rTJ + JLjlI1JOe4ryX4Z6npOt65d3fh/mISnfz/F3qL4jvd21pFoWlSES3bbCe4Br134b+BdL8L6NHDbxhZGA + Mj45J79KTUpTSWyHeEKcpPd7f8E9GSaO2WONl6c89OKyfFWo+Zp/2W3G1pGxz6Ct+7igeDY45FcHqMRc + CGMeYVPA9665PQ8+C1udfpNtHJCp3/MFxjNakKMgaQnp3rmbbzgoVAVyO/FWlv5ba3MR5PtS5kU4yY2w + s/OvZtQlPLHaPYCt6WaQxMG4wMe9c7b3zRxAx8EnJzWffavcooMpyzGpukh8rbNK4v4mGxACeh9qxdRs + LC9tWhmQSKP4CMj+vNUZJWuLre58tBTbvVbaxBAIJ/X+dZSkawh2PkDxd4V+I2mTanq3hPWJIZriUbLb + AKRoOuODg1qeHvHZ0zQ4B4ovC87SCLM2FLN+ma96leO5jlmWMDGSTXi9zo2h+Irf7LewhvLk3KcdDXl1 + 5JWUUe3h25Jupt8hl9rtle/a9Om2hWQgg9w1eLQaJb6LZmPRrOO0XLMQgA3Z6mr3jbRo9E1iK7sWf5wF + Zecfl0rtGaCDToXYh8jvXi4tN7nvYOSik4n5BfFTwH438HfHc/GrTUbUrR7Yw3ELuQIlGeVGMV2fgnSr + DV1i8aXDtJJdOXwx+6PTp2r7Q8faJY6np15Z7c+ajDHbpXiHgHwpplnoSafdw+WIXYAD0NfPYuCkttj6 + vA1XG7vueKfEH4iS6Fo1zbaDpcl7eZzEkSlgzjpz0FcNpvjLxNr2hWsHiSz+z3+czRxn/Vn37ivtmW28 + OaBi6gjQ8kktgkV8c+N9e03S/Htw2mSgLecspPftxXlexi00ke9SxMk076Hifw78O+MofEet2080Z0ee + RjD/AM9EduvPpXrPgLwTYeHlWzFwLmfLEFhzkn0rm/hZPLNqWpWrwb1aUtuJqP4l6r4l8Hyf2h4Tsmkk + XrkEg/yqZ4eU5OK8jtpYqEI8zb6nR6B4d13w54mv7aztjKt5J5ysvAFd5qmm3enxygwq9xMCEA6fN1rj + fhb8WtV8cXtvHq1m1jcqm1g3Gf617VatqEmpSwuomdfmXIriq4aV9Vqd9LHRaunocX8ONM1uLytJuAUV + NwZQcDnNe9eGNPubXQp7S3+UgsPmNeQ2VzeL4jEFyxtyc5HQZz2ruYtcsfD2mzx3c5ckEA5ycmsJYTW9 + ip45yTVzV0GxjXwpIl5IuWcjJOO9dDdXFhbaWLBWWWQx4UV8larqms3er2ltaTsLZXyUHevqTSvD6Xem + C4nwHKjBzXZSy63KzzMTj97s8W8QWMnhSOLU443vGv5QnlQqW2jPc46V7t4b8AyeIbVIbqc2lsiHch4b + mpvC2nvYW0t3dqDHCc/MOgqfwR4u0Lx3rGpW2jT+Z5OVYejCvfw8VCysfN4yvKfN7xtaJ8I9M+G2njV/ + DUzTGWXOyQltoJ7ZPFfSXhDTdTku7fVzMRAoAKY6V5/ZaZf3WhGJH+aPOMGu48G6hqQ0MxTffRsYHpX0 + GGk7nyeNWj1PbrBdPtLuSC3iDed824jvSX2n6lfWDNpx8u6iYNuBxkD1riJdZ1WC+triGMhG4+prvPDd + 8bu8lg1ABS2favYpaqzPArJx95HodpNDJo6Xl0itOFAPqDUs+pNHpGboEuxBBA6Y/GsnSgtvHJAhUp2H + Xir8F7bz6TPbAZIBxXfFt2R5kopNtrqOl8Rvc2zpaozgLk496xbrVYdX03yzHn5dh7fia2PCqJc6XIuC + H5Ga4KSzmtLmeF3IbJKj2rbmta5moptpdDoPCDLY276R8ysnK/SvQri1kSxhZWySeQa8Y0o3dprf2mR2 + ZWAU5HHNenata376d9qgumiGOAfenCbfu2Jqxs1K52WlwrLAy7uV6irmnXMNxK9i8ilkPCk9BX5cftef + HH9sT4IeDLrxV8CfD9p4oFvGWNvISJWx6YFfyXfEP/guJ/wUx8F/Fu78WePvCkmioitHHYCF1iAHfJHP + uRiplVnLSnG7Xmh+wpxXNVqJJ7aN/fp+tz/Qqi+zRXgO3O7vVzVYnaNbqMAbTX813/BGz/gof8Y/2vPD + eoeJPjDdsb8XRWK2SPYiR9q/pSs2N7Zjd/EOeacajldNWZFSkoWlF3Xcq+dNJCdi5LDiuDaYLrH2SQDa + 4zz613dsyFTAh+4SMZrjPEyJb3aXUS5YDrWUl1ZcHq0SW9xcWd1kn91noPeuplWOS3LR4O7nrXm6zTSk + tG45/SuisdQlZPIkkxj26URdn5BON0bNne3FveM9zgKeEA7VavDhxMhwT1rmr1pldWjII71rRurweZK4 + DCtFIylG1jK1/SrDX7VoLolSRgHNfHvxC+Fd3oeuxeLtLvZWltR0JO0r6Yr7KGwDazjvXL+JZo1tTO8I + mBGAuOprSNZxV0JU3ex8Xedb66BqOokNK/BJ+Xp7Uf2bpXov/fX/ANavMPFmi+KovEN04m+ziRy4TJGA + fpXO/wBmeKv+fz9W/wAKXtYvU6vYNaJn/9b9tdH17VLO3It5So9PrXa6TGLuyF1cEs7EZOeuTXmVj/x7 + n8P616joH/IJT6r/ADrk5UtUj3aWrsz1aSygfQ4JSMEkH8a7SAGWKCIkheOn0rlj/wAi9b/hXV2f/LD6 + D+VOXQmPX5ndt81goPpT5EWWL7O/3cZpn/LgP92pf4/+A1UNbHHL4Wc6NDsJdQhuiCGHOAcDNav2O3S5 + faOozn606L/XxfQ/zqw//Hy3+7/WqrJJKyIpSberOUS2hW4jOM7zzn8K665s7dYDlc8Dr7iuYH/HxB9T + /Suxu/8AUH6D+VRS2Kqt3Rz0djb2BZrYbeT+taMX7uRFHIYDOahuOjfWph/rYvoKlrU0Wx80+J/EGpXH + xitNHdh5CNkDHPavuKwcxRLsAHA/lXwF4g/5Ltb/AF/wr76tP9Uv+6P5VzYVvmn6nTj0uSn6FmaV3kZD + 0Cg/zqpZKpn8zGCeamf/AF7/AO6P61HY/f8Aw/pXoHldBJpnyzDjHFU7s4jA65PX8Knl/j+p/lVe9+4v + 1/pQwiZk8jiVYwcDA/Wsq9lkNwkWeM1pT/8AHwv/AAH+VZN5/wAfifX+lYs3p7oxtRv7gXgiBGCuTWdK + isxLjcQR15qTUf8AkIr/ALtNk6t9RTRZgyFreO6SM8LnA/OvN0mkhuNsXALkH8s16Pd9Lv8Az615m3/H + 0P8AfP8AI142LPbwnU868WXk0sr78ZAOD6YNYGk3lzLZ7ZW3bQSM/WtXxR/rX/3W/nWBov8Ax6n6H+de + LiT3cOtDkPFE8sWoPGp425rzqJ/KDbABkE/iK7/xZ/yE3/3K88H3W/3W/lXhVup9Dh+hzV8xm3JJyATg + V+XXxq1jUX+KdvEspRFyQq8Dj9a/US5++31b+VflR8Zv+SrQ/Q1GFSu/Q7sQ3yr5Gt8FviD4jX4g3mgq + 6+QSWzg7s/XNfdfid/Nt7PzAGzwc1+bvwX/5K3efQ1+j/iP/AI9rP61hiklLQ9LCO8NTldRsrW1uYru0 + QRSFQcrxWT8O/E+sz/Es2Msu6Mg8V0Gsf8sf9wfyrz/4bf8AJVj/ALprBK6dze/uoX9tXWNS8M+GTqWg + zNazscF04PNfL3wj1/XtfhtZtavZrpgqH942fvDJ9K+j/wBvL/kS/wDgY/kK+WvgZ/x6Wv8Aux/yrvoQ + j9Wcra3PPqTl7dK+lj7g8HN52pyGYB9hIXPbFfVGlux0pT/dLD8q+VfBX/ISm/3jX1PpX/IJ/wCBvXOt + wr7M6fw2Rc+baygeWVGV7HPrWb8MLCw03x9f2ljCkauCzbRgk81o+FP+PiT/AHR/Wofh7/yUi9/3D/Wu + 2m9jxsR9r0PcdPuZYp5II+ELEYptlfXEFxNFEdqlscVDZ/8AH6/+81RQf8fkn+//AIV7OG2R4OI3kd3f + atfRpaFX6NgfpXZQajcvfK+QCQMkceled6l/q7b/AHv8K7a1/wCPtPoP6V6uHb5jycSlyr5nTNeXNvMR + GxwcE/jWvod9ctNLGTwR/XFc9c/6/wDBa1tB/wCPmX6f1NepR3R5FfZnofhSeSPeq9N3T61xmm3txqPj + u6guyGWMcDFdZ4X+8/8AvCuI0D/koN99Kiu3zR9QopWm/I9Y1izt47HKLjHNef8Aiu/u5NKtbbeQryKp + xxwa9J1v/jw/A15V4n/48bL/AK6r/Ot5bmVLZHaG2hj0SGDG4MOd3Jrxr4kfsw/Ar4jWjf8ACZeHLS+a + RfmaSNSxz74r2yX/AJBVv9K0NQ/49l/3R/KiK1ZnJvQ+IPgz+zh8IvhB4ta2+HWlppcUrlmSHCgn14Ff + pZpRKW/kg8IBivkbQ/8Akc1/3jX1xpv3G+gqlvcK+yRBaIP7QmGTwcVj+IIwwEbch+tbdp/yEbj/AHhW + Pr/34/8APesJFQ+JHkV3fXFlL5UB49/evQ9ORZLYSMOSM15hq3/H1+A/rXqOlf8AHkv+6KiBvWWhJMPL + sy6cHrX5x/Ev46fEXwv42ubLS7tfJQHCOuR0P0r9Hbr/AI8T9K/IL42/8lAvPof5GufFSa2Z2ZfCMubm + Vz6y8PeL/EusXVhLfXkh89lLgHAORmvqm8vpke0tRgq4Gc9a+MvBX+u0v/gH/oNfYOof8fll9BWtN6HN + iklJfM8n8X6ZYHWnZowSQD1Pv6Vy/wDZmnf88R+Z/wAa7bxf/wAhlv8AdH9a5eraITdj/9k= + - name: Remove widget_test.dart + rm: test/widget_test.dart + - name: Add android/app/src/main/kotlin/dev/flutter/platform_channels/AccelerometerStreamHandler.kt + path: android/app/src/main/kotlin/dev/flutter/platform_channels/AccelerometerStreamHandler.kt + replace-contents: | + // Copyright 2020 The Flutter team. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + + package dev.flutter.platform_channels + + import android.hardware.Sensor + import android.hardware.SensorEvent + import android.hardware.SensorEventListener + import android.hardware.SensorManager + import io.flutter.plugin.common.EventChannel + + class AccelerometerStreamHandler(sManager: SensorManager, s: Sensor) : EventChannel.StreamHandler, SensorEventListener { + private val sensorManager: SensorManager = sManager + private val accelerometerSensor: Sensor = s + private lateinit var eventSink: EventChannel.EventSink + + override fun onListen(arguments: Any?, events: EventChannel.EventSink?) { + if (events != null) { + eventSink = events + sensorManager.registerListener(this, accelerometerSensor, SensorManager.SENSOR_DELAY_UI) + } + } + + override fun onCancel(arguments: Any?) { + sensorManager.unregisterListener(this) + } + + override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {} + + override fun onSensorChanged(sensorEvent: SensorEvent?) { + if (sensorEvent != null) { + val axisValues = listOf(sensorEvent.values[0], sensorEvent.values[1], sensorEvent.values[2]) + eventSink.success(axisValues) + } else { + eventSink.error("DATA_UNAVAILABLE", "Cannot get accelerometer data", null) + } + } + } + - name: Replace android/app/src/main/kotlin/dev/flutter/platform_channels/MainActivity.kt + path: android/app/src/main/kotlin/dev/flutter/platform_channels/MainActivity.kt + replace-contents: | + // Copyright 2020 The Flutter team. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + + package dev.flutter.platform_channels + + import android.content.Context + import android.hardware.Sensor + import android.hardware.SensorManager + import com.google.gson.Gson + import com.google.gson.reflect.TypeToken + import io.flutter.embedding.android.FlutterActivity + import io.flutter.embedding.engine.FlutterEngine + import io.flutter.plugin.common.* + import java.io.InputStream + import java.nio.ByteBuffer + + class MainActivity : FlutterActivity() { + override fun configureFlutterEngine(flutterEngine: FlutterEngine) { + // Creates a MethodChannel as soon as the FlutterEngine is attached to + // the Activity, and registers a MethodCallHandler. The Method.setMethodCallHandler + // is responsible to register a MethodCallHandler to handle the incoming calls. + + // The call parameter of MethodCallHandler has information about the incoming call, + // like method name, and arguments. The result parameter of MethodCallHandler is + // responsible to send the results of the call. + MethodChannel(flutterEngine.dartExecutor, "methodChannelDemo") + .setMethodCallHandler { call, result -> + val count: Int? = call.argument("count") + + if (count == null) { + result.error("INVALID ARGUMENT", "Value of count cannot be null", null) + } else { + when (call.method) { + "increment" -> result.success(count + 1) + "decrement" -> result.success(count - 1) + else -> result.notImplemented() + } + } + } + + val sensorManger: SensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager + val accelerometerSensor: Sensor = sensorManger.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) + EventChannel(flutterEngine.dartExecutor, "eventChannelDemo") + .setStreamHandler(AccelerometerStreamHandler(sensorManger, accelerometerSensor)) + + // Registers a MessageHandler for BasicMessageChannel to receive a message from Dart and send + // image data in reply. + BasicMessageChannel(flutterEngine.dartExecutor, "platformImageDemo", StandardMessageCodec()) + .setMessageHandler { message, reply -> + if (message == "getImage") { + val inputStream: InputStream = assets.open("eat_new_orleans.jpg") + reply.reply(inputStream.readBytes()) + } + } + + val petList = mutableListOf>() + val gson = Gson() + + // A BasicMessageChannel for sending petList to Dart. + val stringCodecChannel = BasicMessageChannel(flutterEngine.dartExecutor, "stringCodecDemo", StringCodec.INSTANCE) + + // Registers a MessageHandler for BasicMessageChannel to receive pet details to be + // added in petList and send the it back to Dart using stringCodecChannel. + BasicMessageChannel(flutterEngine.dartExecutor, "jsonMessageCodecDemo", JSONMessageCodec.INSTANCE) + .setMessageHandler { message, reply -> + petList.add(0, gson.fromJson(message.toString(), object : TypeToken>() {}.type)) + stringCodecChannel.send(gson.toJson(mapOf("petList" to petList))) + } + + // Registers a MessageHandler for BasicMessageChannel to receive the index of pet + // details to be removed from the petList and send the petList back to Dart using + // stringCodecChannel. If the index is not in the range of petList, we send null + // back to Dart. + BasicMessageChannel(flutterEngine.dartExecutor, "binaryCodecDemo", BinaryCodec.INSTANCE) + .setMessageHandler { message, reply -> + val index = String(message!!.array()).toInt() + if (index >= 0 && index < petList.size) { + petList.removeAt(index) + val replyMessage = "Removed Successfully" + reply.reply(ByteBuffer.allocateDirect(replyMessage.toByteArray().size).put(replyMessage.toByteArray())) + stringCodecChannel.send(gson.toJson(mapOf("petList" to petList))) + } else { + reply.reply(null) + } + } + } + } + - name: Add ios/Runner/AccelerometerStreamHandler.swift + path: ios/Runner/AccelerometerStreamHandler.swift + replace-contents: | + // Copyright 2020 The Flutter team. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + + import CoreMotion + + class AccelerometerStreamHandler: NSObject, FlutterStreamHandler { + + var motionManager: CMMotionManager; + + override init() { + motionManager = CMMotionManager() + } + + func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? { + + if !motionManager.isAccelerometerAvailable { + events(FlutterError(code: "SENSOR_UNAVAILABLE", message: "Accelerometer is not available", details: nil)) + } + + motionManager.accelerometerUpdateInterval = 0.1 + + motionManager.startAccelerometerUpdates(to: OperationQueue.main) {(data, error) in + guard let accelerationData = data?.acceleration else { + events(FlutterError(code: "DATA_UNAVAILABLE", message: "Cannot get accelerometer data", details: nil )) + return + } + + events([accelerationData.x, accelerationData.y, accelerationData.z]) + } + + return nil + } + + func onCancel(withArguments arguments: Any?) -> FlutterError? { + return nil + } + } + - name: Add AccelerometerStreamHandler.swift to Xcode project + xcode-project-path: ios/Runner.xcodeproj + xcode-add-file: AccelerometerStreamHandler.swift + - name: Replace ios/Runner/AppDelegate.swift + path: ios/Runner/AppDelegate.swift + replace-contents: | + // Copyright 2020 The Flutter team. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + + import UIKit + import Flutter + + @UIApplicationMain + @objc class AppDelegate: FlutterAppDelegate { + override func application( + _ application: UIApplication, + didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? + ) -> Bool { + let flutterViewController = window.rootViewController as! FlutterViewController + FlutterMethodChannel(name: "methodChannelDemo", binaryMessenger: flutterViewController.binaryMessenger).setMethodCallHandler({ + (call: FlutterMethodCall, result: FlutterResult) -> Void in + + guard let count = (call.arguments as? NSDictionary)?["count"] as? Int else { + result(FlutterError(code: "INVALID_ARGUMENT", message: "Value of count cannot be null", details: nil)) + return + } + + switch call.method { + case "increment": + result(count + 1) + case "decrement": + result(count - 1) + default: + result(FlutterMethodNotImplemented) + } + }) + + FlutterBasicMessageChannel(name: "platformImageDemo", binaryMessenger: flutterViewController.binaryMessenger, codec: FlutterStandardMessageCodec.sharedInstance()).setMessageHandler{ + (message: Any?, reply: FlutterReply) -> Void in + + if(message as! String == "getImage") { + guard let image = UIImage(named: "eat_new_orleans.jpg") else { + reply(nil) + return + } + + reply(FlutterStandardTypedData(bytes: image.jpegData(compressionQuality: 1)!)) + } + } + + FlutterEventChannel(name: "eventChannelDemo", binaryMessenger: flutterViewController.binaryMessenger).setStreamHandler(AccelerometerStreamHandler()) + + var petList : [[String:String]] = [] + + // A FlutterBasicMessageChannel for sending petList to Dart. + let stringCodecChannel = FlutterBasicMessageChannel(name: "stringCodecDemo", binaryMessenger: flutterViewController.binaryMessenger, codec: FlutterStringCodec.sharedInstance()) + + // Registers a MessageHandler for FlutterBasicMessageChannel to receive pet details. + FlutterBasicMessageChannel(name: "jsonMessageCodecDemo", binaryMessenger: flutterViewController.binaryMessenger, codec: FlutterJSONMessageCodec.sharedInstance()) + .setMessageHandler{(message: Any?, reply: FlutterReply) -> Void in + petList.insert(message! as! [String: String], at: 0) + stringCodecChannel.sendMessage(self.convertPetListToJson(petList: petList)) + } + + // Registers a MessageHandler for FlutterBasicMessageHandler to receive indices of detail records to remove from the petList. + FlutterBasicMessageChannel(name: "binaryCodecDemo", binaryMessenger: flutterViewController.binaryMessenger, codec: FlutterBinaryCodec.sharedInstance()).setMessageHandler{ + (message: Any?, reply: FlutterReply) -> Void in + + guard let index = Int.init(String.init(data: message! as! Data, encoding: String.Encoding.utf8)!) else { + reply(nil) + return + } + + if (index >= 0 && index < petList.count) { + petList.remove(at: index) + reply("Removed Successfully".data(using: .utf8)!) + stringCodecChannel.sendMessage(self.convertPetListToJson(petList: petList)) + } else { + reply(nil) + } + } + + GeneratedPluginRegistrant.register(with: self) + return super.application(application, didFinishLaunchingWithOptions: launchOptions) + } + + // Function to convert petList to json string. + func convertPetListToJson(petList: [[String: String]]) -> String? { + guard let data = try? JSONSerialization.data(withJSONObject: ["petList": petList], options: .prettyPrinted) else { + return nil + } + return String(data: data, encoding: String.Encoding.utf8) + } + } + - name: Add ios/Runner/Assets.xcassets/Contents.json + path: ios/Runner/Assets.xcassets/Contents.json + replace-contents: | + { + "info" : { + "author" : "xcode", + "version" : 1 + } + }